Changeset 6412


Ignore:
Timestamp:
10/25/10 08:57:04 (15 years ago)
Author:
Mathieu Morlighem
Message:

moved ISSMERROR to _error_, ISSMASSERT to _assert_ and ISSMPRINTF to _printf_

Location:
issm/trunk/src
Files:
241 edited

Legend:

Unmodified
Added
Removed

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

    r6411 r6412  
    123123         * because this is a nasty error: */
    124124        if (marshalled_dataset!=old_marshalled_dataset){
    125                 ISSMERROR("final marshalled dataset is different from initial one!");
     125                _error_("final marshalled dataset is different from initial one!");
    126126                abort();
    127127        }
    … …  
    355355                                break;
    356356                        default:
    357                                 ISSMERROR("could not recognize enum type: %i (%s)",enum_type,EnumToString(enum_type));
     357                                _error_("could not recognize enum type: %i (%s)",enum_type,EnumToString(enum_type));
    358358                }
    359359
    … …  
    408408        vector<Object*>::iterator object;
    409409
    410         if(this==NULL)ISSMERROR(" trying to echo a NULL dataset");
    411 
    412         _printf_("DataSet echo: %i objects\n",objects.size());
     410        if(this==NULL)_error_(" trying to echo a NULL dataset");
     411
     412        _printf_(true,"DataSet echo: %i objects\n",objects.size());
    413413
    414414        for ( object=objects.begin() ; object < objects.end(); object++ ){
    … …  
    426426        vector<Object*>::iterator object;
    427427
    428         if(this==NULL)ISSMERROR(" trying to echo a NULL dataset");
    429 
    430         _printf_("DataSet echo: %i objects\n",objects.size());
     428        if(this==NULL)_error_(" trying to echo a NULL dataset");
     429
     430        _printf_(true,"DataSet echo: %i objects\n",objects.size());
    431431
    432432        for ( object=objects.begin() ; object < objects.end(); object++ ){
    … …  
    455455
    456456        /*Check index in debugging mode*/
    457         ISSMASSERT(offset<this->Size());
     457        _assert_(offset<this->Size());
    458458
    459459        return objects[offset];
    … …  
    468468        int i;
    469469
    470         if(!sorted)ISSMERROR(" trying to binary search on a non-sorted dataset!");
     470        if(!sorted)_error_(" trying to binary search on a non-sorted dataset!");
    471471
    472472        /*Carry out a binary search on the sorted_ids: */
    473473        if(!binary_search(&id_offset,eid, sorted_ids,objects.size())){
    474                 ISSMERROR("could not find object with id %i in DataSet %s",eid,EnumToString(enum_type));
     474                _error_("could not find object with id %i in DataSet %s",eid,EnumToString(enum_type));
    475475        }
    476476
    … …  
    532532        /*Only sort if we are not already sorted: */
    533533        if(!sorted){
    534                 ISSMERROR(" not implemented yet!");
    535         }
    536 }
    537 /*}}}*/
     534                _error_(" not implemented yet!");
     535        }
     536}
     537/*}}}*/

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

    r5749 r6412  
    6363                /*we could not find an input with the correct enum type. No defaults values were provided,
    6464                 * error out: */
    65                 ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
     65                _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
    6666        }
    6767
    … …  
    9191                /*we could not find an input with the correct enum type. No defaults values were provided,
    9292                 * error out: */
    93                 ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
     93                _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
    9494        }
    9595
    … …  
    119119                /*we could not find an input with the correct enum type. No defaults values were provided,
    120120                 * error out: */
    121                 ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
     121                _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
    122122        }
    123123
    … …  
    147147                /*we could not find an input with the correct enum type. No defaults values were provided,
    148148                 * error out: */
    149                 ISSMERROR("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
     149                _error_("could not find input with enum type %i (%s)",enum_type,EnumToString(enum_type));
    150150        }
    151151
    … …  
    165165
    166166        /*In debugging mode, check that the input is not a NULL pointer*/
    167         ISSMASSERT(in_input);
     167        _assert_(in_input);
    168168
    169169        for ( object=objects.begin() ; object < objects.end(); object++ ){
    … …  
    219219
    220220        /*some checks: */
    221         if(!constrain_input) ISSMERROR(" input %s could not be found!",EnumToString(constrain_enum));
     221        if(!constrain_input) _error_(" input %s could not be found!",EnumToString(constrain_enum));
    222222
    223223        /*Apply ContrainMin: */
    … …  
    260260        }
    261261        else{
    262                 ISSMERROR("Input %s not found",EnumToString(enumtype));
     262                _error_("Input %s not found",EnumToString(enumtype));
    263263        }
    264264
    … …  
    281281        }
    282282        else{
    283                 ISSMERROR("Input %s not found",EnumToString(enumtype));
     283                _error_("Input %s not found",EnumToString(enumtype));
    284284        }
    285285
    … …  
    302302        }
    303303        else{
    304                 ISSMERROR("Input %s not found",EnumToString(enumtype));
     304                _error_("Input %s not found",EnumToString(enumtype));
    305305        }
    306306
    … …  
    323323        }
    324324        else{
    325                 ISSMERROR("Input %s not found",EnumToString(enumtype));
     325                _error_("Input %s not found",EnumToString(enumtype));
    326326        }
    327327
    … …  
    375375        /*Make a copy of the original input: */
    376376        original=(Input*)this->GetInput(original_enum);
    377         if(!original)ISSMERROR("could not find input with enum: %s",EnumToString(original_enum));
     377        if(!original)_error_("could not find input with enum: %s",EnumToString(original_enum));
    378378        copy=(Input*)original->copy();
    379379
    … …  
    422422
    423423        /*some checks: */
    424         if(!xinput) ISSMERROR(" input %s could not be found!",EnumToString(XEnum));
    425         if(!yinput) ISSMERROR(" input %s could not be found!",EnumToString(YEnum));
     424        if(!xinput) _error_(" input %s could not be found!",EnumToString(XEnum));
     425        if(!yinput) _error_(" input %s could not be found!",EnumToString(YEnum));
    426426
    427427        /*Apply AXPY: */

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

    r6411 r6412  
    7474
    7575        /*some check: */
    76         if ((setenum!=GsetEnum) && (setenum!=FsetEnum) && (setenum!=SsetEnum))ISSMERROR("%s%s%s"," dof distribution for set of enum type ",EnumToString(setenum)," not supported yet!");
     76        if ((setenum!=GsetEnum) && (setenum!=FsetEnum) && (setenum!=SsetEnum))_error_("%s%s%s"," dof distribution for set of enum type ",EnumToString(setenum)," not supported yet!");
    7777
    7878        /*Go through objects, and distribute dofs locally, from 0 to numberofdofs: */

  • TabularUnified issm/trunk/src/c/EnumDefinitions/EnumToModelField.cpp

    r6099 r6412  
    2222                case VyEnum : return "vy";
    2323                case VyObsEnum : return "vy_obs";
    24                 default : ISSMERROR("No model field is associated to enum %s",EnumToString(en));
     24                default : _error_("No model field is associated to enum %s",EnumToString(en));
    2525        }
    2626}

  • TabularUnified issm/trunk/src/c/EnumDefinitions/StringToEnum.cpp

    r6374 r6412  
    344344        else if (strcmp(name,"Sset")==0) return SsetEnum;
    345345        else if (strcmp(name,"Yts")==0) return YtsEnum;
    346         else ISSMERROR("Enum %s not found",name);
     346        else _error_("Enum %s not found",name);
    347347
    348348}

  • TabularUnified issm/trunk/src/c/EnumDefinitions/Synchronize.sh

    r6311 r6412  
    202202#Add footer of of StringToEnum.cpp{{{1
    203203cat <<END >> StringToEnum.cpp
    204         else ISSMERROR("Enum %s not found",name);
     204        else _error_("Enum %s not found",name);
    205205
    206206}

  • TabularUnified issm/trunk/src/c/include/macros.h

    r6322 r6412  
    1818/* _printf_ {{{1*/
    1919/*Printing macro: only cpu number 0 */
    20 #define _printf_(...) PrintfFunction(__VA_ARGS__)
     20#define _printf_(flag,...) if(flag) PrintfFunction(__VA_ARGS__)
    2121/*}}}*/
    22 /* ISSMPRINTF {{{1*/
    23 /*Printing macro with flag*/
    24 #define ISSMPRINTF(flag,...) if(flag) PrintfFunction(__VA_ARGS__)
    25 /*}}}*/
    26 /* ISSMERROR {{{1*/
     22/* _error_ {{{1*/
    2723/*Error exception macro*/
    2824#ifdef _INTEL_WIN_
    29 #define ISSMERROR(...)\
     25#define _error_(...)\
    3026  throw ErrorException(exprintf(__VA_ARGS__))
    3127#else
    32 #define ISSMERROR(...)\
     28#define _error_(...)\
    3329  throw ErrorException(__FILE__,__func__,__LINE__,exprintf(__VA_ARGS__))
    3430#endif
    3531/*}}}*/
    36 /* ISSMASSERT {{{1*/
     32/* _assert_ {{{1*/
    3733/*Assertion macro: do nothing if macro _ISSM_DEBUG_ undefined*/
    3834#ifdef _ISSM_DEBUG_
    39 #define ISSMASSERT(statement)\
    40   if (!(statement)) ISSMERROR("Assertion \"%s\" failed, please report bug to an ISSM developer",#statement)
     35#define _assert_(statement)\
     36  if (!(statement)) _error_("Assertion \"%s\" failed, please report bug to an ISSM developer",#statement)
    4137#else
    42 #define ISSMASSERT(ignore)\
     38#define _assert_(ignore)\
    4339  ((void) 0)
    4440#endif
    … …  
    5955        }\
    6056        catch (exception& e) {\
    61                 _printf_("Standard exception: %s\n",e.what());\
     57                _printf_(true,"Standard exception: %s\n",e.what());\
    6258                mexErrMsgTxt(" ");\
    6359        }
    … …  
    7470        }\
    7571        catch (exception& e) {\
    76                 _printf_("Standard exception: %s\n",e.what());\
     72                _printf_(true,"Standard exception: %s\n",e.what());\
    7773                return 1;\
    7874        }

  • TabularUnified issm/trunk/src/c/io/FetchData.cpp

    r6347 r6412  
    4141                else{
    4242                        /*This is an error: we don't have the correct input!: */
    43                         ISSMERROR("  wrong input parameter!");
     43                        _error_("  wrong input parameter!");
    4444                }
    4545        }
    … …  
    7777        else{
    7878                /*This is an error: we don't have the correct input!: */
    79                 ISSMERROR("Input parameter of class %s not supported yet",mxGetClassName(dataref));
     79                _error_("Input parameter of class %s not supported yet",mxGetClassName(dataref));
    8080        }
    8181
    … …  
    113113        else{
    114114                /*This is an error: we don't have the correct input!: */
    115                 ISSMERROR("wrong input parameter");
     115                _error_("wrong input parameter");
    116116        }
    117117
    … …  
    139139        else{
    140140                /*This is an error: we don't have the correct input!: */
    141                 ISSMERROR("wrong input parameter");
     141                _error_("wrong input parameter");
    142142        }
    143143
    … …  
    171171        else{
    172172                /*This is an error: we don't have the correct input!: */
    173                 ISSMERROR("wrong input parameter");
     173                _error_("wrong input parameter");
    174174        }
    175175
    … …  
    203203        else{
    204204                /*This is an error: we don't have the correct input!: */
    205                 ISSMERROR("wrong input parameter");
     205                _error_("wrong input parameter");
    206206        }
    207207
    … …  
    228228        else{
    229229                /*This is an error: we don't have the correct input!: */
    230                 ISSMERROR("wrong input parameter");
     230                _error_("wrong input parameter");
    231231        }
    232232
    … …  
    243243        /*Ok, the string should be coming directly from the matlab workspace: */
    244244        if (!mxIsChar(dataref)){
    245                 ISSMERROR("input data_type is not a string!");
     245                _error_("input data_type is not a string!");
    246246        }
    247247        else{
    … …  
    264264
    265265        if (!mxIsDouble(dataref)){
    266                 ISSMERROR("input data_type is not a double!");
     266                _error_("input data_type is not a double!");
    267267        }
    268268        else{
    … …  
    281281
    282282        if (!mxIsDouble(dataref)){
    283                 ISSMERROR("input data_type is not a scalar!");
     283                _error_("input data_type is not a scalar!");
    284284        }
    285285        else{
    … …  
    298298
    299299        if (mxIsClass(dataref,"logical")){
    300                 if(mxGetM(dataref)!=1) ISSMERROR("input data is not of size 1x1");
    301                 if(mxGetN(dataref)!=1) ISSMERROR("input data is not of size 1x1");
     300                if(mxGetM(dataref)!=1) _error_("input data is not of size 1x1");
     301                if(mxGetN(dataref)!=1) _error_("input data is not of size 1x1");
    302302                mxbool_ptr=mxGetLogicals(dataref);
    303303        }
    304304        else{
    305                 ISSMERROR("input data_type is not a bool!");
     305                _error_("input data_type is not a bool!");
    306306        }
    307307
    … …  
    325325        /*numberofelements: */
    326326        if(my_rank==0){ 
    327                 if(fread(&M,sizeof(int),1,fid)!=1) ISSMERROR("could not read number of rows for matrix ");
     327                if(fread(&M,sizeof(int),1,fid)!=1) _error_("could not read number of rows for matrix ");
    328328        }
    329329
    … …  
    331331
    332332        if(my_rank==0){ 
    333                 if(fread(&N,sizeof(int),1,fid)!=1) ISSMERROR("could not read number of columns for matrix ");
     333                if(fread(&N,sizeof(int),1,fid)!=1) _error_("could not read number of columns for matrix ");
    334334        }
    335335        MPI_Bcast(&N,1,MPI_INT,0,MPI_COMM_WORLD);
    … …  
    341341                /*Read matrix on node 0, then broadcast: */
    342342                if(my_rank==0){ 
    343                         if(fread(matrix,M*N*sizeof(double),1,fid)!=1) ISSMERROR("could not read matrix ");
     343                        if(fread(matrix,M*N*sizeof(double),1,fid)!=1) _error_("could not read matrix ");
    344344                }
    345345               
    … …  
    367367        /*We have to read a string from disk. First read the dimensions of the string, then the string: */
    368368        if(my_rank==0){ 
    369                 if(fread(&string_size,sizeof(int),1,fid)!=1) ISSMERROR(" could not read length of string ");
     369                if(fread(&string_size,sizeof(int),1,fid)!=1) _error_(" could not read length of string ");
    370370        }
    371371
    … …  
    379379                /*Read string on node 0, then broadcast: */
    380380                if(my_rank==0){ 
    381                         if(fread(string,string_size*sizeof(char),1,fid)!=1)ISSMERROR("  could not read string ");
     381                        if(fread(string,string_size*sizeof(char),1,fid)!=1)_error_("  could not read string ");
    382382                }
    383383                MPI_Bcast(string,string_size,MPI_CHAR,0,MPI_COMM_WORLD);
    … …  
    404404        /*We have to read a scalar from disk. First read the dimensions of the scalar, then the scalar: */
    405405        if(my_rank==0){
    406                 if(fread(&scalar,sizeof(double),1,fid)!=1)ISSMERROR(" could not read scalar ");
     406                if(fread(&scalar,sizeof(double),1,fid)!=1)_error_(" could not read scalar ");
    407407        }
    408408        MPI_Bcast(&scalar,1,MPI_DOUBLE,0,MPI_COMM_WORLD);
    … …  
    424424        /*We have to read a integer from disk. First read the dimensions of the integer, then the integer: */
    425425        if(my_rank==0){ 
    426                 if(fread(&integer,sizeof(int),1,fid)!=1) ISSMERROR(" could not read integer ");
     426                if(fread(&integer,sizeof(int),1,fid)!=1) _error_(" could not read integer ");
    427427        }
    428428

  • TabularUnified issm/trunk/src/c/io/FetchParams.cpp

    r5103 r6412  
    5555                enum_type=StringToEnum(name);
    5656                pfield=mxGetFieldByNumber(dataref,0,count);
    57                 ISSMASSERT(pfield);
     57                _assert_(pfield);
    5858               
    5959                /*Check type of field: */
    … …  
    6565
    6666                        if (M==0 | N==0){
    67                                 ISSMERROR("%s%i (%s) %s%i%s%i%s","array in parameters structure field ",count,name," is of size (",M,",",N,")");
     67                                _error_("%s%i (%s) %s%i%s%i%s","array in parameters structure field ",count,name," is of size (",M,",",N,")");
    6868                        }
    6969                        if (M==1 && N==1){
    … …  
    175175                        }
    176176                }
    177                 else ISSMERROR("%s%i","unknow type in parameters structure field ",i);
     177                else _error_("%s%i","unknow type in parameters structure field ",i);
    178178        }
    179179

  • TabularUnified issm/trunk/src/c/io/IoModelFetchData.cpp

    r3961 r6412  
    135135        MPI_Bcast(&found,1,MPI_INT,0,MPI_COMM_WORLD);
    136136
    137         if(!found)ISSMERROR("%s %s ","could not find data with name",data_name);
     137        if(!found)_error_("%s %s ","could not find data with name",data_name);
    138138
    139139        return fid;

  • TabularUnified issm/trunk/src/c/io/WriteDataToDisk.cpp

    r3775 r6412  
    6565        }
    6666        else{
    67                 ISSMERROR("data type not supported yet!");
     67                _error_("data type not supported yet!");
    6868        }
    6969}

  • TabularUnified issm/trunk/src/c/io/pfclose.cpp

    r6389 r6412  
    1717        /*Close file handle: */
    1818        extern int my_rank;
    19         if(fclose(fid)!=0)ISSMERROR("%s%s","could not close file ",filename);
     19        if(fclose(fid)!=0)_error_("%s%s","could not close file ",filename);
    2020}

  • TabularUnified issm/trunk/src/c/io/pfopen.cpp

    r6389 r6412  
    2020        /*Open handle to data on disk: */
    2121        fid=fopen(filename,format);
    22         if(fid==NULL) ISSMERROR("%s%s%s","could not open file ",filename," for binary reading or writing");
     22        if(fid==NULL) _error_("%s%s%s","could not open file ",filename," for binary reading or writing");
    2323
    2424        return fid;

  • TabularUnified issm/trunk/src/c/modules/AverageOntoPartitionx/AverageOntoPartitionx.cpp

    r6231 r6412  
    3535
    3636        /*First, recover qmu partition of vertices: */
    37         if(!parameters->FindParam(&qmu_part,&dummy,QmuPartEnum))ISSMERROR(" could not find qmu partition vector");
     37        if(!parameters->FindParam(&qmu_part,&dummy,QmuPartEnum))_error_(" could not find qmu partition vector");
    3838
    3939        /*Some parameters: */

  • TabularUnified issm/trunk/src/c/modules/BuildNodeSetsx/PartitionSets.cpp

    r3913 r6412  
    7979                                ccount++;
    8080                        }
    81                         if (flags_b_local[i] && flags_c_local[i]) ISSMERROR("%s%i%s"," for dof ",i,": breach of exclusive partitioning between sets");
     81                        if (flags_b_local[i] && flags_c_local[i]) _error_("%s%i%s"," for dof ",i,": breach of exclusive partitioning between sets");
    8282                       
    8383                        acount++;

  • TabularUnified issm/trunk/src/c/modules/ComputeBasalStressx/ComputeBasalStressx.cpp

    r4573 r6412  
    2323        /*Recover numberofelements: */
    2424        found= parameters->FindParam(&numberofelements,NumberOfElementsEnum);
    25         if (!found) ISSMERROR("numberofelements not provided in parameters");
     25        if (!found) _error_("numberofelements not provided in parameters");
    2626
    2727        /*Allocate sigma on numberofelements: */

  • TabularUnified issm/trunk/src/c/modules/ConfigureObjectsx/ConfigureObjectsx.cpp

    r6323 r6412  
    2424        parameters->FindParam(&configuration_type,ConfigurationTypeEnum);
    2525       
    26         ISSMPRINTF(VerboseMProcessor(),"      Configuring elements...\n");
     26        _printf_(VerboseMProcessor(),"      Configuring elements...\n");
    2727        for (i=0;i<elements->Size();i++){
    2828                element=(Element*)elements->GetObjectByOffset(i);
    2929                element->Configure(elements,loads,nodes,materials,parameters);
    3030        }
    31         ISSMPRINTF(VerboseMProcessor(),"      Configuring loads...\n");
     31        _printf_(VerboseMProcessor(),"      Configuring loads...\n");
    3232        for (i=0;i<loads->Size();i++){
    3333                load=(Load*)loads->GetObjectByOffset(i);
    … …  
    3636                }
    3737        }
    38         ISSMPRINTF(VerboseMProcessor(),"      Configuring nodes...\n");
     38        _printf_(VerboseMProcessor(),"      Configuring nodes...\n");
    3939        for (i=0;i<nodes->Size();i++){
    4040                node=(Node*)nodes->GetObjectByOffset(i);
    … …  
    4444        }
    4545       
    46         ISSMPRINTF(VerboseMProcessor(),"      Configuring materials...\n");
     46        _printf_(VerboseMProcessor(),"      Configuring materials...\n");
    4747        for (i=0;i<materials->Size();i++){
    4848                material=(Material*)materials->GetObjectByOffset(i);

  • TabularUnified issm/trunk/src/c/modules/DakotaResponsesx/DakotaResponsesx.cpp

    r6231 r6412  
    8787                }
    8888                else if (flag==NodalEnum){
    89                         ISSMERROR(" nodal response functions not supported yet!");
     89                        _error_(" nodal response functions not supported yet!");
    9090
    9191                        /*increment response_pointer :*/
    … …  
    105105                        }
    106106                }
    107                 else ISSMERROR("%s%i%s"," flag type ",flag," not supported yet for response analysis");
     107                else _error_("%s%i%s"," flag type ",flag," not supported yet for response analysis");
    108108        }
    109109

  • TabularUnified issm/trunk/src/c/modules/GetSolutionFromInputsx/GetSolutionFromInputsx.cpp

    r5772 r6412  
    2626        /*Get size of vector: */
    2727        gsize=nodes->NumberOfDofs(configuration_type,GsetEnum);
    28         if (gsize==0) ISSMERROR("Allocating a Vec of size 0 as gsize=0 for configuration: %s",EnumToString(configuration_type));
     28        if (gsize==0) _error_("Allocating a Vec of size 0 as gsize=0 for configuration: %s",EnumToString(configuration_type));
    2929       
    3030        /*Initialize solution: */

  • TabularUnified issm/trunk/src/c/modules/GetVectorFromInputsx/GetVectorFromInputsx.cpp

    r5103 r6412  
    2323                }
    2424        }
    25         else ISSMERROR("%s%s%s"," vector type: ",EnumToString(TypeEnum)," not supported yet!");
     25        else _error_("%s%s%s"," vector type: ",EnumToString(TypeEnum)," not supported yet!");
    2626
    2727        VecAssemblyBegin(vector);

  • TabularUnified issm/trunk/src/c/modules/InputConvergencex/InputConvergencex.cpp

    r6323 r6412  
    3333        num_notconverged=total_notconverged;
    3434        #endif
    35         ISSMPRINTF(VerboseConvergence(),"      #elements above convergence criterion = %i\n",num_notconverged);
     35        _printf_(VerboseConvergence(),"      #elements above convergence criterion = %i\n",num_notconverged);
    3636
    3737        /*Free ressources:*/

  • TabularUnified issm/trunk/src/c/modules/InputUpdateFromDakotax/InputUpdateFromDakotax.cpp

    r6323 r6412  
    5151                        /*Now, pick up the parameter corresponding to root: */
    5252                        if(!parameters->FindParam(&parameter,NULL,StringToEnum(root))){
    53                                 ISSMERROR("%s%s"," could not find Qmu parameter: ",root);
     53                                _error_("%s%s"," could not find Qmu parameter: ",root);
    5454                        }
    5555
    … …  
    8282                }
    8383                else if (strncmp(descriptor,"indexed_",8)==0){
    84                         ISSMERROR(" indexed variables not supported yet!");
     84                        _error_(" indexed variables not supported yet!");
    8585                }
    8686                else if (strncmp(descriptor,"nodal_",8)==0){
    87                         ISSMERROR(" nodal variables not supported yet!");
     87                        _error_(" nodal variables not supported yet!");
    8888                }
    8989                else{

  • TabularUnified issm/trunk/src/c/modules/InterpFromGridToMeshx/InterpFromGridToMeshx.cpp

    r3913 r6412  
    3535        /*Some checks on arguments: */
    3636        if ((M<=2) || (N<=2) || (nods<=0)){
    37                 ISSMERROR("nothing to be done according to the dimensions of input matrices and vectors.");
     37                _error_("nothing to be done according to the dimensions of input matrices and vectors.");
    3838        }
    3939        if (x_in[1]-x_in[0]<0){
    40                 ISSMERROR("x coordinate vectore should be increasing.\n   use Matlab's command x=flipud(x), also flip the data matrix data=fliplr(data)");
     40                _error_("x coordinate vectore should be increasing.\n   use Matlab's command x=flipud(x), also flip the data matrix data=fliplr(data)");
    4141        }
    4242        if (y_in[1]-y_in[0]<0){
    43                 ISSMERROR("y coordinate vectore should be increasing.\n   use Matlab's command y=flipud(y), also flip the data matrix data=flipud(data)");
     43                _error_("y coordinate vectore should be increasing.\n   use Matlab's command y=flipud(y), also flip the data matrix data=flipud(data)");
    4444        }
    4545
    … …  
    6767        }
    6868        else{
    69                 ISSMERROR("x and y vectors length should be 1 or 0 more than data number of rows.");
     69                _error_("x and y vectors length should be 1 or 0 more than data number of rows.");
    7070        }
    7171

  • TabularUnified issm/trunk/src/c/modules/InterpFromMesh2dx/InterpFromMesh2dx.cpp

    r5032 r6412  
    3333        /*some checks*/
    3434        if (nels_data<1 || nods_data<3 || nods_prime==0){
    35                 ISSMERROR("nothing to be done according to the mesh given in input");
     35                _error_("nothing to be done according to the mesh given in input");
    3636        }
    3737
    … …  
    4747        }
    4848        else{
    49                 ISSMERROR("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
     49                _error_("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
    5050        }
    5151
    5252        if((numcontours) && (interpolation_type==2)){
    53                 ISSMERROR(" element interpolation_type with contours not supported yet!");
     53                _error_(" element interpolation_type with contours not supported yet!");
    5454        }
    5555

  • TabularUnified issm/trunk/src/c/modules/InterpFromMeshToGridx/InterpFromMeshToGridx.cpp

    r3913 r6412  
    3333        /*some checks*/
    3434        if (nels<1 || nods<3 || nlines<1 || ncols<1 || xposting==0 || yposting==0){
    35                 ISSMERROR("nothing to be done according to the mesh given in input");
     35                _error_("nothing to be done according to the mesh given in input");
    3636        }
    3737
    … …  
    4444        }
    4545        else{
    46                 ISSMERROR("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
     46                _error_("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
    4747        }
    4848

  • TabularUnified issm/trunk/src/c/modules/InterpFromMeshToMesh2dx/InterpFromMeshToMesh2dx.cpp

    r5607 r6412  
    3939        /*Checks*/
    4040        if (data_cols<=0){
    41                 ISSMERROR("data provided has a negative number of columns");
     41                _error_("data provided has a negative number of columns");
    4242        }
    4343        if (data_rows!=nods_data && data_rows!=nels_data){
    44                 ISSMERROR("data provided should have either %i or %i lines (not %i)",nods_data,nels_data,data_rows);
     44                _error_("data provided should have either %i or %i lines (not %i)",nods_data,nels_data,data_rows);
    4545        }
    4646        if((num_default_values) && (data_cols>1)){
    47                 ISSMERROR("data provided can only have 1 column if a default value is provided");
     47                _error_("data provided can only have 1 column if a default value is provided");
    4848        }
    4949       
    … …  
    126126                                for (j=0;j<data_cols;j++){
    127127                                        if (it<0 || it>=nels_data){
    128                                                 ISSMERROR("Triangle number %i not in [0 %i], because not correctly implemented yet... interpolate on grid first",it,nels_data);
     128                                                _error_("Triangle number %i not in [0 %i], because not correctly implemented yet... interpolate on grid first",it,nels_data);
    129129                                        }
    130130                                        data_interp[i*data_cols+j]=data[data_cols*it+j];

  • TabularUnified issm/trunk/src/c/modules/InterpFromMeshToMesh3dx/InterpFromMeshToMesh3dx.cpp

    r3913 r6412  
    2727        /*some checks*/
    2828        if (nels_data<1 || nods_data<6 || nods_prime==0){
    29                 ISSMERROR("nothing to be done according to the mesh given in input");
     29                _error_("nothing to be done according to the mesh given in input");
    3030        }
    3131
    … …  
    4141        }
    4242        else{
    43                 ISSMERROR("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
     43                _error_("length of vector data not supported yet. It should be of length (number of nodes) or (number of elements)!");
    4444        }
    4545

  • TabularUnified issm/trunk/src/c/modules/MassFluxx/MassFluxx.cpp

    r5475 r6412  
    3939
    4040        /*Retrieve index of segments being used for MassFlux computation: */
    41         if(!parameters->FindParam(&counter,IndexEnum))ISSMERROR(" could not find IndexEnum");
     41        if(!parameters->FindParam(&counter,IndexEnum))_error_(" could not find IndexEnum");
    4242
    4343        /*retrieve segments from array: */

  • TabularUnified issm/trunk/src/c/modules/Mergesolutionfromftogx/Mergesolutionfromftogx.cpp

    r6323 r6412  
    1313       
    1414        /*Display message*/
    15         ISSMPRINTF(VerboseModule(),"   Merging solution vector from fset to gset\n");
     15        _printf_(VerboseModule(),"   Merging solution vector from fset to gset\n");
    1616
    1717        /*Merge f set back into g set: */

  • TabularUnified issm/trunk/src/c/modules/MeshPartitionx/MeshPartitionx.cpp

    r4021 r6412  
    4949                        for (i=0;i<numberofgrids;i++)    npart[i]=0;
    5050                }
    51                 else ISSMERROR("At least one processor is required");
     51                else _error_("At least one processor is required");
    5252        }
    5353        else{
    … …  
    7474                        for (i=0;i<numberofgrids2d;i++)    npart2d[i]=0;
    7575                }
    76                 else ISSMERROR("At least one processor is required");
     76                else _error_("At least one processor is required");
    7777
    7878                /*Extrude epart2d to epart, using numlayers: */

  • TabularUnified issm/trunk/src/c/modules/MeshProfileIntersectionx/ElementSegment.cpp

    r4994 r6412  
    3838        if(    (edge1==IntersectEnum) && (edge2==IntersectEnum) && (edge3==IntersectEnum)   ){
    3939                /*This case is impossible: */
    40                 ISSMERROR(" error: a line cannot go through 3 different vertices!");
     40                _error_(" error: a line cannot go through 3 different vertices!");
    4141        }
    4242        else if(    ((edge1==IntersectEnum) && (edge2==IntersectEnum)) || ((edge2==IntersectEnum) && (edge3==IntersectEnum)) || ((edge3==IntersectEnum) && (edge1==IntersectEnum))   ){

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/Balancedthickness/CreateNodesBalancedthickness.cpp

    r5524 r6412  
    3636
    3737        /*Check in 3d*/
    38         if(iomodel->prognostic_DG && iomodel->dim==3) ISSMERROR("DG 3d not implemented yet");
     38        if(iomodel->prognostic_DG && iomodel->dim==3) _error_("DG 3d not implemented yet");
    3939
    4040        /*First fetch data: */
    … …  
    7070                                        vertex_id=(int)*(iomodel->elements+3*i+j); //(Matlab indexing)
    7171                                        io_index=vertex_id-1;                      //(C indexing)
    72                                         ISSMASSERT(vertex_id>0 && vertex_id<=iomodel->numberofvertices);
     72                                        _assert_(vertex_id>0 && vertex_id<=iomodel->numberofvertices);
    7373
    7474                                        //Compute Node id

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/Control/UpdateElementsAndMaterialsControl.cpp

    r6216 r6412  
    4949                                break;
    5050                        default:
    51                                 ISSMERROR("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i]));
     51                                _error_("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i]));
    5252                }
    5353        }

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/CreateDataSets.cpp

    r6213 r6412  
    101101                        break;
    102102                default:
    103                         ISSMERROR("%s%s%s"," analysis_type: ",EnumToString(analysis_type)," not supported yet!");
     103                        _error_("%s%s%s"," analysis_type: ",EnumToString(analysis_type)," not supported yet!");
    104104        }
    105105

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/CreateNumberNodeToElementConnectivity.cpp

    r3984 r6412  
    2525
    2626        /*Some checks if debugging*/
    27         ISSMASSERT(iomodel->numberofvertices);
    28         ISSMASSERT(iomodel->numberofelements);
    29         ISSMASSERT(iomodel->elements);
     27        _assert_(iomodel->numberofvertices);
     28        _assert_(iomodel->numberofelements);
     29        _assert_(iomodel->elements);
    3030
    3131        /*Allocate ouput*/
    … …  
    4444                for (j=0;j<elementswidth;j++){
    4545                        vertexid=(int)iomodel->elements[elementswidth*i+j];
    46                         ISSMASSERT(vertexid>0 && vertexid-1<iomodel->numberofvertices);
     46                        _assert_(vertexid>0 && vertexid-1<iomodel->numberofvertices);
    4747                        connectivity[vertexid-1]+=1;
    4848                }

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/CreateSingleNodeToElementConnectivity.cpp

    r3984 r6412  
    2525
    2626        /*Some checks if debugging*/
    27         ISSMASSERT(iomodel->numberofvertices);
    28         ISSMASSERT(iomodel->numberofelements);
    29         ISSMASSERT(iomodel->my_elements);
    30         ISSMASSERT(iomodel->elements);
     27        _assert_(iomodel->numberofvertices);
     28        _assert_(iomodel->numberofelements);
     29        _assert_(iomodel->my_elements);
     30        _assert_(iomodel->elements);
    3131
    3232        /*Allocate ouput*/
    … …  
    4747                        for (j=0;j<elementswidth;j++){
    4848                                vertexid=(int)iomodel->elements[elementswidth*i+j];
    49                                 ISSMASSERT(vertexid>0 && vertexid-1<iomodel->numberofvertices);
     49                                _assert_(vertexid>0 && vertexid-1<iomodel->numberofvertices);
    5050                                connectivity[vertexid-1]=i+1;
    5151                        }

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateConstraintsDiagnosticHoriz.cpp

    r6141 r6412  
    8181
    8282                                        }
    83                                         else ISSMERROR("if vertices_type is MacAyealPattyn, you shoud have gridonpattyn or gridonmacayeal");
     83                                        else _error_("if vertices_type is MacAyealPattyn, you shoud have gridonpattyn or gridonmacayeal");
    8484                        }
    8585                        /*Also add spcs of coupling: zero at the border pattyn/stokes for the appropriate dofs*/
    … …  
    121121                                                }
    122122                                        }
    123                                         else ISSMERROR("if vertices_type is PattynStokes, you shoud have gridonpattyn or gridonstokes");
     123                                        else _error_("if vertices_type is PattynStokes, you shoud have gridonpattyn or gridonstokes");
    124124                        }
    125125                        /*Also add spcs of coupling: zero at the border pattyn/stokes for the appropriate dofs*/
    … …  
    161161                                                }
    162162                                        }
    163                                         else ISSMERROR("if vertices_type is MacAyealStokes, you shoud have gridonpattyn or gridonstokes");
     163                                        else _error_("if vertices_type is MacAyealStokes, you shoud have gridonpattyn or gridonstokes");
    164164                        }
    165165                        /*Now add the regular spcs*/

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/DiagnosticHoriz/CreateLoadsDiagnosticHoriz.cpp

    r6149 r6412  
    139139
    140140                        /*In debugging mode, check that the second node is in the same cpu*/
    141                         ISSMASSERT(iomodel->my_vertices[(int)iomodel->penalties[2*i+1]-1]);
     141                        _assert_(iomodel->my_vertices[(int)iomodel->penalties[2*i+1]-1]);
    142142
    143143                        /*Get node ids*/

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/DistributeNumDofs.cpp

    r6141 r6412  
    6161                        doftype[5]=StokesApproximationEnum;
    6262                }
    63                 else ISSMERROR("Approximationtype %i (%s) not implemented yet for DiagnosticHoriz",(int)*vertices_type,EnumToString((int)*vertices_type));
     63                else _error_("Approximationtype %i (%s) not implemented yet for DiagnosticHoriz",(int)*vertices_type,EnumToString((int)*vertices_type));
    6464        }
    6565        else if (analysis_type==DiagnosticVertAnalysisEnum){
    … …  
    8787                numdofs=1;
    8888        }
    89         else ISSMERROR("analysis type: %i (%s) not implemented yet",analysis_type,EnumToString(analysis_type));
     89        else _error_("analysis type: %i (%s) not implemented yet",analysis_type,EnumToString(analysis_type));
    9090
    9191        /*Now initialize the index*/

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/Melting/CreateLoadsMelting.cpp

    r4236 r6412  
    2020
    2121        /*if 2d: Error*/
    22         if (iomodel->dim==2) ISSMERROR("2d meshes not supported yet");
     22        if (iomodel->dim==2) _error_("2d meshes not supported yet");
    2323
    2424        /*Recover pointer: */

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/ModelProcessorx.cpp

    r6323 r6412  
    4040                analysis_type=analysis_type_list[i];
    4141       
    42                 ISSMPRINTF(VerboseMProcessor(),"   create datasets for analysis %s\n",EnumToString(analysis_type));
     42                _printf_(VerboseMProcessor(),"   create datasets for analysis %s\n",EnumToString(analysis_type));
    4343                CreateDataSets(&elements,&nodes,&vertices,&materials,&constraints,&loads,&parameters,iomodel,IOMODEL,solution_type,analysis_type,nummodels,i);
    4444        }

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/NodesPartitioning.cpp

    r6235 r6412  
    8787        }
    8888        else{
    89                 ISSMERROR("not implemented yet");
     89                _error_("not implemented yet");
    9090        }
    9191
    … …  
    9595        IoModelFetchData(&iomodel->edges,&iomodel->numberofedges,&cols,iomodel_handle,"edges");
    9696        IoModelFetchData(&iomodel->elements,NULL,NULL,iomodel_handle,"elements");
    97         if (cols!=4) ISSMERROR("field edges should have 4 columns");
     97        if (cols!=4) _error_("field edges should have 4 columns");
    9898
    9999        /*!All elements have been partitioned above, only create elements for this CPU: */
    … …  
    136136                        }
    137137                        else{
    138                                 ISSMERROR("Problem in edges creation");
     138                                _error_("Problem in edges creation");
    139139                        }
    140140                }

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/Prognostic/CreateNodesPrognostic.cpp

    r5524 r6412  
    3636
    3737        /*Check in 3d*/
    38         if(iomodel->prognostic_DG && iomodel->dim==3) ISSMERROR("DG 3d not implemented yet");
     38        if(iomodel->prognostic_DG && iomodel->dim==3) _error_("DG 3d not implemented yet");
    3939
    4040        /*First fetch data: */
    … …  
    7070                                        vertex_id=(int)*(iomodel->elements+3*i+j); //(Matlab indexing)
    7171                                        io_index=vertex_id-1;                      //(C indexing)
    72                                         ISSMASSERT(vertex_id>0 && vertex_id<=iomodel->numberofvertices);
     72                                        _assert_(vertex_id>0 && vertex_id<=iomodel->numberofvertices);
    7373
    7474                                        //Compute Node id

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/Qmu/CreateParametersQmu.cpp

    r5529 r6412  
    180180                         *responses. Let's build a DoubleMatArrayParam object with the array of segments: */
    181181                       
    182                         if(iomodel->qmu_mass_flux_num_profiles==0)ISSMERROR(" qmu_mass_flux_num_profiles is 0, when MassFlux computations were requested!");
     182                        if(iomodel->qmu_mass_flux_num_profiles==0)_error_(" qmu_mass_flux_num_profiles is 0, when MassFlux computations were requested!");
    183183
    184184                        array=(double**)xmalloc(iomodel->qmu_mass_flux_num_profiles*sizeof(double*));

  • TabularUnified issm/trunk/src/c/modules/ModelProcessorx/Thermal/CreateLoadsThermal.cpp

    r4236 r6412  
    2727
    2828        /*return if 2d mesh*/
    29         if (iomodel->dim==2) ISSMERROR("2d meshes not supported yet");
     29        if (iomodel->dim==2) _error_("2d meshes not supported yet");
    3030
    3131        //create penalties for grids: no grid can have a temperature over the melting point

  • TabularUnified issm/trunk/src/c/modules/NodeConnectivityx/NodeConnectivityx.cpp

    r3913 r6412  
    7171         * warn the user to increase the connectivity width: */
    7272        for(i=0;i<nods;i++){
    73                 if (*(connectivity+width*i+maxels)>maxels)ISSMERROR("%s%g%s"," max connectivity width reached (",*(connectivity+width*i+maxels),")! increase width of connectivity table");
     73                if (*(connectivity+width*i+maxels)>maxels)_error_("%s%g%s"," max connectivity width reached (",*(connectivity+width*i+maxels),")! increase width of connectivity table");
    7474        }
    7575

  • TabularUnified issm/trunk/src/c/modules/PenaltyConstraintsx/PenaltyConstraintsx.cpp

    r6323 r6412  
    2424
    2525        /*Display message*/
    26         ISSMPRINTF(VerboseModule(),"   Constraining penalties\n");
     26        _printf_(VerboseModule(),"   Constraining penalties\n");
    2727
    2828        /*recover parameters: */

  • TabularUnified issm/trunk/src/c/modules/PenaltyConstraintsx/RiftConstraints.cpp

    r6323 r6412  
    5555        }
    5656        else if(num_unstable_constraints<=min_mechanical_constraints){
    57                 ISSMPRINTF(VerboseModule(),"   freezing constraints\n");
     57                _printf_(VerboseModule(),"   freezing constraints\n");
    5858                RiftFreezeConstraints(loads,configuration_type);
    5959        }

  • TabularUnified issm/trunk/src/c/modules/Qmux/SpawnCoreParallel.cpp

    r6323 r6412  
    5252        /*synchronize all cpus, as CPU 0 is probably late (it is starting the entire dakota strategy!) : */
    5353        MPI_Barrier(MPI_COMM_WORLD);
    54         ISSMPRINTF(VerboseQmu(),"qmu iteration: %i\n",counter);
     54        _printf_(VerboseQmu(),"qmu iteration: %i\n",counter);
    5555       
    5656        /*retrieve parameters: */
    … …  
    6666
    6767        /*Determine solution sequence: */
    68         ISSMPRINTF(VerboseQmu(),"%s%s%s\n","Starting ",EnumToString(solution_type)," core:");
     68        _printf_(VerboseQmu(),"%s%s%s\n","Starting ",EnumToString(solution_type)," core:");
    6969        SolutionConfiguration(NULL,NULL,&solutioncore,solution_type);
    7070        if(control_analysis)solutioncore=&control_core;
    … …  
    7474
    7575        /*compute responses: */
    76         ISSMPRINTF(VerboseQmu(),"compute dakota responses:\n");
     76        _printf_(VerboseQmu(),"compute dakota responses:\n");
    7777        DakotaResponsesx(d_responses,femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,responses_descriptors,numresponsedescriptors,d_numresponses);
    7878       

  • TabularUnified issm/trunk/src/c/modules/Reduceloadfromgtofx/Reduceloadfromgtofx.cpp

    r6323 r6412  
    2727
    2828        parameters->FindParam(&kffpartition,KffEnum);
    29         ISSMPRINTF(VerboseModule(),"   Reducing Load vector from gset to fset\n");
     29        _printf_(VerboseModule(),"   Reducing Load vector from gset to fset\n");
    3030
    3131        if(!pg){

  • TabularUnified issm/trunk/src/c/modules/Reduceloadx/Reduceloadx.cpp

    r6323 r6412  
    2121        int         verbose;
    2222
    23         ISSMPRINTF(VerboseModule(),"   Dirichlet lifting applied to load vector\n");
     23        _printf_(VerboseModule(),"   Dirichlet lifting applied to load vector\n");
    2424       
    2525        if(pf && Kfs){

  • TabularUnified issm/trunk/src/c/modules/Reducematrixfromgtofx/Reducematrixfromgtofx.cpp

    r6323 r6412  
    1111
    1212        /*Display message*/
    13         ISSMPRINTF(VerboseModule(),"   Reducing Stiffness Matrix from gset to fset\n");
     13        _printf_(VerboseModule(),"   Reducing Stiffness Matrix from gset to fset\n");
    1414
    1515        //Reduce matrix from g-size to f-size

  • TabularUnified issm/trunk/src/c/modules/Responsex/Responsex.cpp

    r5473 r6412  
    3838                case SurfaceAverageVelMisfitEnum: SurfaceAverageVelMisfitx( responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
    3939                case ThicknessAbsMisfitEnum: ThicknessAbsMisfitx( responses, elements,nodes, vertices, loads, materials, parameters,process_units); break;
    40                 default: ISSMERROR(" response descriptor \"%s\" not supported yet!",response_descriptor); break;
     40                default: _error_(" response descriptor \"%s\" not supported yet!",response_descriptor); break;
    4141        }
    4242

  • TabularUnified issm/trunk/src/c/modules/Solverx/Solverx.cpp

    r6323 r6412  
    3333
    3434        /*Display message*/
    35         ISSMPRINTF(VerboseModule(),"   Solving\n");
     35        _printf_(VerboseModule(),"   Solving\n");
    3636        if(VerboseSolver())PetscOptionsPrint(stdout);
    3737
    … …  
    114114        /*Check convergence*/
    115115        KSPGetIterationNumber(ksp,&iteration_number);
    116         if (iteration_number<0) ISSMERROR("%s%i"," Solver diverged at iteration number: ",-iteration_number);
     116        if (iteration_number<0) _error_("%s%i"," Solver diverged at iteration number: ",-iteration_number);
    117117
    118118        /*Free ressources:*/

  • TabularUnified issm/trunk/src/c/modules/SystemMatricesx/SystemMatricesx.cpp

    r6323 r6412  
    2929
    3030        /*Display message*/
    31         ISSMPRINTF(VerboseModule(),"   Generating matrices\n");
     31        _printf_(VerboseModule(),"   Generating matrices\n");
    3232
    3333        /*retrive parameters: */
    … …  
    4545
    4646        /*Checks in debugging mode {{{1*/
    47         if(penalty_kflag)ISSMASSERT(kflag);
    48         if(penalty_pflag)ISSMASSERT(pflag);
     47        if(penalty_kflag)_assert_(kflag);
     48        if(penalty_pflag)_assert_(pflag);
    4949        /*}}}*/
    5050

  • TabularUnified issm/trunk/src/c/objects/Bamg/BamgGeom.cpp

    r5187 r6412  
    7171        fnames[i++] = "CrackedEdges";
    7272        fnames[i++] = "SubDomains";
    73         ISSMASSERT(i==numfields);
     73        _assert_(i==numfields);
    7474
    7575        /*Initialize Matlab structure*/
    … …  
    8585        i++; SetMatlabStructureField(output,"CrackedEdges",    this->CrackedEdgesSize[0],    this->CrackedEdgesSize[1],    this->CrackedEdges);
    8686        i++; SetMatlabStructureField(output,"SubDomains",      this->SubDomainsSize[0],      this->SubDomainsSize[1],      this->SubDomains);
    87         ISSMASSERT(i==numfields);
     87        _assert_(i==numfields);
    8888
    8989        /*Assign output*/

  • TabularUnified issm/trunk/src/c/objects/Bamg/BamgMesh.cpp

    r5573 r6412  
    120120        fnames[i++] = "CrackedVertices";
    121121        fnames[i++] = "CrackedEdges";
    122         ISSMASSERT(i==numfields);
     122        _assert_(i==numfields);
    123123
    124124        /*Initialize Matlab structure*/
    … …  
    143143        i++; SetMatlabStructureField(output,"CrackedVertices",          this->CrackedVerticesSize[0],          this->CrackedVerticesSize[1],           this->CrackedVertices);
    144144        i++; SetMatlabStructureField(output,"CrackedEdges",             this->CrackedEdgesSize[0],             this->CrackedEdgesSize[1],              this->CrackedEdges);
    145         ISSMASSERT(i==numfields);
     145        _assert_(i==numfields);
    146146
    147147        /*Assign output*/

  • TabularUnified issm/trunk/src/c/objects/Bamg/BamgOpts.cpp

    r5187 r6412  
    100100        int i;
    101101
    102         if (this->anisomax<1) ISSMERROR("'anisomax' option should be >=1");
    103         if (this->coeff==0) ISSMERROR("'coeff' should be positive");
    104         if (this->errg<0) ISSMERROR("'errg' option should be >0");
    105         if (this->gradation<1) ISSMERROR("'gradation' option should be >=1");
    106         if (this->Hessiantype!=0  && this->Hessiantype!=1) ISSMERROR("'Hessiantype' supported options are 0 and 1");
    107         if (this->maxnbv<3) ISSMERROR("'maxnbv' option should be >3");
    108         if (this->maxsubdiv<=1) ISSMERROR("'maxsubdiv' should be >1");
    109         if (this->Metrictype!=0   && this->Metrictype!=1 && this->Metrictype!=2) ISSMERROR("'Metrictype' supported options are 0, 1 and 2");
    110         if (this->nbjacobi<=0) ISSMERROR("'nbjacobi' option should be >0");
    111         if (this->nbsmooth<=0) ISSMERROR("'nbsmooth' option should be >0");
     102        if (this->anisomax<1) _error_("'anisomax' option should be >=1");
     103        if (this->coeff==0) _error_("'coeff' should be positive");
     104        if (this->errg<0) _error_("'errg' option should be >0");
     105        if (this->gradation<1) _error_("'gradation' option should be >=1");
     106        if (this->Hessiantype!=0  && this->Hessiantype!=1) _error_("'Hessiantype' supported options are 0 and 1");
     107        if (this->maxnbv<3) _error_("'maxnbv' option should be >3");
     108        if (this->maxsubdiv<=1) _error_("'maxsubdiv' should be >1");
     109        if (this->Metrictype!=0   && this->Metrictype!=1 && this->Metrictype!=2) _error_("'Metrictype' supported options are 0, 1 and 2");
     110        if (this->nbjacobi<=0) _error_("'nbjacobi' option should be >0");
     111        if (this->nbsmooth<=0) _error_("'nbsmooth' option should be >0");
    112112
    113         if (this->Crack!=0  && this->Crack!=1) ISSMERROR("'Crack' supported options are 0 and 1");
    114         if (this->KeepVertices!=0 && this->KeepVertices!=1) ISSMERROR("'KeepVertices' supported options are 0 and 1");
    115         if (this->geometricalmetric!=0  && this->geometricalmetric!=1) ISSMERROR("'geometricalmetric' supported options are 0 and 1");
     113        if (this->Crack!=0  && this->Crack!=1) _error_("'Crack' supported options are 0 and 1");
     114        if (this->KeepVertices!=0 && this->KeepVertices!=1) _error_("'KeepVertices' supported options are 0 and 1");
     115        if (this->geometricalmetric!=0  && this->geometricalmetric!=1) _error_("'geometricalmetric' supported options are 0 and 1");
    116116
    117         if (this->hmin<=0) ISSMERROR("'hmin' option should be >0");
    118         if (this->hmax<=0 || this->hmax<this->hmin) ISSMERROR("'hmax' option should be between 0 and hmin=%g",this->hmin);
    119         if (this->hminVertices && this->hminVerticesSize[1]!=1) ISSMERROR("'hminVertices' should be a column");
    120         if (this->hmaxVertices && this->hmaxVerticesSize[1]!=1) ISSMERROR("'hmaxVertices' should be a column");
    121         if (this->hVertices && this->hVerticesSize[1]!=1) ISSMERROR("'hVertices' should be a column");
    122         if (this->metric && (this->metricSize[1]!=1 && this->metricSize[1]!=3)) ISSMERROR("'metric' should have either 1 (iso) or 3 (aniso) columns.");
     117        if (this->hmin<=0) _error_("'hmin' option should be >0");
     118        if (this->hmax<=0 || this->hmax<this->hmin) _error_("'hmax' option should be between 0 and hmin=%g",this->hmin);
     119        if (this->hminVertices && this->hminVerticesSize[1]!=1) _error_("'hminVertices' should be a column");
     120        if (this->hmaxVertices && this->hmaxVerticesSize[1]!=1) _error_("'hmaxVertices' should be a column");
     121        if (this->hVertices && this->hVerticesSize[1]!=1) _error_("'hVertices' should be a column");
     122        if (this->metric && (this->metricSize[1]!=1 && this->metricSize[1]!=3)) _error_("'metric' should have either 1 (iso) or 3 (aniso) columns.");
    123123        if (this->field){
    124                 if (this->errSize[0]!=1 || this->errSize[1]!=this->fieldSize[1]) ISSMERROR("'err' should be of size %i x %i",1,this->fieldSize[1]);
    125                 for (i=0;i<this->fieldSize[1];i++) {if (this->err[i]<=0) ISSMERROR("'err' option should be >0");};
     124                if (this->errSize[0]!=1 || this->errSize[1]!=this->fieldSize[1]) _error_("'err' should be of size %i x %i",1,this->fieldSize[1]);
     125                for (i=0;i<this->fieldSize[1];i++) {if (this->err[i]<=0) _error_("'err' option should be >0");};
    126126        }
    127127

  • TabularUnified issm/trunk/src/c/objects/Bamg/BamgVertex.cpp

    r5460 r6412  
    7676                }
    7777                else{
    78                         ISSMERROR("Metrictype %i not supported yet (use 0,1 or 2(default))",Metrictype);
     78                        _error_("Metrictype %i not supported yet (use 0,1 or 2(default))",Metrictype);
    7979                }
    8080
    … …  
    146146                        j = NextEdge[jc];
    147147                        if (k>=2000){
    148                                 ISSMERROR("k>=2000 (Maximum number of iterations reached)");
     148                                _error_("k>=2000 (Maximum number of iterations reached)");
    149149                        }
    150150                } while ( tbegin != tria);
    … …  
    213213                                j = NextEdge[jc];
    214214                                if (k>=2000){
    215                                         ISSMERROR("k>=2000");
     215                                        _error_("k>=2000");
    216216                                }
    217217                        }while ( tbegin != tria);

  • TabularUnified issm/trunk/src/c/objects/Bamg/Edge.cpp

    r5573 r6412  
    4545
    4646                /*some shecks*/
    47                 if (!(adj[0]==&e || adj[1]==&e)){ ISSMERROR("Intersection bug"); }
    48                 ISSMASSERT(adj[0]==&e || adj[1]==&e);
     47                if (!(adj[0]==&e || adj[1]==&e)){ _error_("Intersection bug"); }
     48                _assert_(adj[0]==&e || adj[1]==&e);
    4949
    5050                return adj[0]==&e?0:1;

  • TabularUnified issm/trunk/src/c/objects/Bamg/GeomEdge.cpp

    r5573 r6412  
    2929
    3030                //Check that theta is in [0 1]
    31                 ISSMASSERT(theta>-1e-12 && theta<1+1e-12);
     31                _assert_(theta>-1e-12 && theta<1+1e-12);
    3232
    3333                if (TgA()){
    … …  
    7878
    7979                //check theta
    80                 ISSMASSERT(theta>=0 && theta<=1);
     80                _assert_(theta>=0 && theta<=1);
    8181
    8282                if (TgA()){

  • TabularUnified issm/trunk/src/c/objects/Bamg/Geometry.cpp

    r5573 r6412  
    4848        Geometry::~Geometry() {
    4949                /*Original code from Frederic Hecht <hecht@ann.jussieu.fr> (BAMG v1.01, MeshGeom.cpp/~Geometry)*/
    50                 if(NbRef>0)    ISSMERROR("Trying to delete geometry and NbRef>0");
     50                if(NbRef>0)    _error_("Trying to delete geometry and NbRef>0");
    5151                if(vertices)   delete [] vertices;  vertices=0;
    5252                if(edges)      delete [] edges;     edges=0;
    … …  
    7676
    7777                //some checks
    78                 if (bamggeom->Vertices==NULL) ISSMERROR("the domain provided does not contain any vertex");
    79                 if (bamggeom->Edges==NULL) ISSMERROR("the domain provided does not contain any edge");
     78                if (bamggeom->Vertices==NULL) _error_("the domain provided does not contain any vertex");
     79                if (bamggeom->Edges==NULL) _error_("the domain provided does not contain any edge");
    8080
    8181                //Vertices
    8282                if (bamggeom->Vertices){
    8383                        if(verbose>5) printf("      processing Vertices\n");
    84                         if (bamggeom->VerticesSize[1]!=3) ISSMERROR("Vertices should have 3 columns");
     84                        if (bamggeom->VerticesSize[1]!=3) _error_("Vertices should have 3 columns");
    8585                        vertices = new GeomVertex[nbv];
    8686                        for (i=0;i<nbv;i++) {
    … …  
    115115                         */
    116116                        coefIcoor=(MaxICoor)/(Max(pmax.x-pmin.x,pmax.y-pmin.y));
    117                         if(coefIcoor<=0) ISSMERROR("coefIcoor should be positive");
     117                        if(coefIcoor<=0) _error_("coefIcoor should be positive");
    118118                }
    119119                else{
    120                         ISSMERROR("No BamgVertex provided");
     120                        _error_("No BamgVertex provided");
    121121                }
    122122
    … …  
    127127
    128128                        if(verbose>5) printf("      processing Edges\n");
    129                         if (bamggeom->EdgesSize[1]!=3) ISSMERROR("Edges should have 3 columns");
     129                        if (bamggeom->EdgesSize[1]!=3) _error_("Edges should have 3 columns");
    130130                        edges = new GeomEdge[nbe];
    131131
    … …  
    176176                }
    177177                else{
    178                         ISSMERROR("No edges provided");
     178                        _error_("No edges provided");
    179179                }
    180180
    … …  
    206206                if (bamggeom->TangentAtEdges){
    207207                        if(verbose>5) printf("      processing TangentAtEdges");
    208                         if (bamggeom->TangentAtEdgesSize[1]!=4) ISSMERROR("TangentAtEdges should have 4 columns");
     208                        if (bamggeom->TangentAtEdgesSize[1]!=4) _error_("TangentAtEdges should have 4 columns");
    209209                        int n,i,j,k;
    210210                        R2 tg;
    … …  
    216216                                tg.x=bamggeom->TangentAtEdges[k*4+2];
    217217                                tg.y=bamggeom->TangentAtEdges[k*4+3];
    218                                 if (i<0 || i>=nbe) ISSMERROR("TangentAtEdges first index exceeds matrix dimension");
    219                                 if (j!=0 && j!=1)  ISSMERROR("TangentAtEdges second index should be 1 or 2 only");
     218                                if (i<0 || i>=nbe) _error_("TangentAtEdges first index exceeds matrix dimension");
     219                                if (j!=0 && j!=1)  _error_("TangentAtEdges second index should be 1 or 2 only");
    220220                                edges[i].tg[j] = tg;
    221221                        }
    … …  
    225225                if(bamggeom->Corners){
    226226                        if(verbose>5) printf("      processing Corners");
    227                         if (bamggeom->CornersSize[1]!=1) ISSMERROR("Corners should have 1 column");
     227                        if (bamggeom->CornersSize[1]!=1) _error_("Corners should have 1 column");
    228228                        n=bamggeom->CornersSize[0];
    229229                        for (i=0;i<n;i++) {     
    230230                                j=(int)bamggeom->Corners[i]-1; //for C indexing
    231                                 if (j>nbv-1 || j<0) ISSMERROR("Bad corner definition: should in [0 %i]",nbv);
     231                                if (j>nbv-1 || j<0) _error_("Bad corner definition: should in [0 %i]",nbv);
    232232                                /*Required => at the same time SetRequired and SetCorner*/
    233233                                vertices[j].SetCorner();
    … …  
    239239                if(bamggeom->RequiredVertices){
    240240                        if(verbose>5) printf("      processing RequiredVertices\n");
    241                         if (bamggeom->RequiredVerticesSize[1]!=1) ISSMERROR("RequiredVertices should have 1 column");
     241                        if (bamggeom->RequiredVerticesSize[1]!=1) _error_("RequiredVertices should have 1 column");
    242242                        n=bamggeom->RequiredVerticesSize[0];
    243243                        for (i=0;i<n;i++) {     
    244244                                j=(int)bamggeom->RequiredVertices[i]-1; //for C indexing
    245                                 if (j>nbv-1 || j<0) ISSMERROR("Bad RequiredVerticess  definition: should in [0 %i]",nbv);
     245                                if (j>nbv-1 || j<0) _error_("Bad RequiredVerticess  definition: should in [0 %i]",nbv);
    246246                                vertices[j].SetRequired();
    247247                        }
    … …  
    251251                if(bamggeom->RequiredEdges){
    252252                        if(verbose>5) printf("      processing RequiredEdges\n");
    253                         if (bamggeom->RequiredEdgesSize[1]!=1) ISSMERROR("RequiredEdges should have 1 column");
     253                        if (bamggeom->RequiredEdgesSize[1]!=1) _error_("RequiredEdges should have 1 column");
    254254                        n=bamggeom->RequiredEdgesSize[0];
    255255                        for (i=0;i<n;i++) {     
    256256                                j=(int)bamggeom->RequiredEdges[i]-1; //for C indexing
    257                                 if (j>nbe-1 || j<0) ISSMERROR("Bad RequiredEdges definition: should in [0 %i]",nbe);
     257                                if (j>nbe-1 || j<0) _error_("Bad RequiredEdges definition: should in [0 %i]",nbe);
    258258                                edges[j].SetRequired(); 
    259259                        }
    … …  
    263263                if(bamggeom->SubDomains){
    264264                        if(verbose>5) printf("      processing SubDomains\n");
    265                         if (bamggeom->SubDomainsSize[1]!=4) ISSMERROR("SubDomains should have 4 columns");
     265                        if (bamggeom->SubDomainsSize[1]!=4) _error_("SubDomains should have 4 columns");
    266266                        nbsubdomains=bamggeom->SubDomainsSize[0];
    267267                        subdomains = new GeomSubDomain[nbsubdomains];
    … …  
    271271                                i2=(int)bamggeom->SubDomains[i*4+2];
    272272                                i3=(int)bamggeom->SubDomains[i*4+3];
    273                                 if (i0!=2) ISSMERROR("Bad Subdomain definition: first number should be 2 (for Edges)");
    274                                 if (i1>nbe || i1<=0) ISSMERROR("Bad Subdomain definition: second number should in [1 %i] (edge number)",nbe);
     273                                if (i0!=2) _error_("Bad Subdomain definition: first number should be 2 (for Edges)");
     274                                if (i1>nbe || i1<=0) _error_("Bad Subdomain definition: second number should in [1 %i] (edge number)",nbe);
    275275                                subdomains[i].edge=edges + (i1-1);
    276276                                subdomains[i].direction = (int) i2;
    … …  
    478478                while(pon != on){ 
    479479                        counter++;
    480                         ISSMASSERT(counter<100);
     480                        _assert_(counter<100);
    481481                        pon = on;
    482482                        R2 A= (*on)[0];
    … …  
    527527                        /*if there is a vertex found that is to close to vertices[i] -> error*/
    528528                        if( v && Norme1(v->r - vertices[i].r) < eps ){
    529                                 ISSMERROR("two points of the geometry are very closed to each other");
     529                                _error_("two points of the geometry are very closed to each other");
    530530                        }
    531531
    … …  
    601601                        double lv10=Norme2(v10);
    602602                        //check that its length is not 0
    603                         if(lv10==0)ISSMERROR("Length of edge %i is 0",i);
     603                        if(lv10==0)_error_("Length of edge %i is 0",i);
    604604                        //compute angle in [-Pi Pi]
    605605                        eangle[i] = atan2(v10.y,v10.x);
    … …  
    694694                                long i1 = n1/2 ,j1=n1%2;
    695695
    696                                 if( edges[i1].v[j1] != edges[i].v[j]) ISSMERROR("Problem while processing edges: check the edge list");
     696                                if( edges[i1].v[j1] != edges[i].v[j]) _error_("Problem while processing edges: check the edge list");
    697697
    698698                                edges[i1].Adj[j1] = edges + i;
    … …  
    796796                                }
    797797                        }
    798                         ISSMASSERT(nb_marked_edges && nbe);
     798                        _assert_(nb_marked_edges && nbe);
    799799                        //allocate if first step
    800800                        if(step==0) curves=new Curve[nbcurves];
    … …  
    821821                GeomEdge* on=e.GeomEdgeHook;
    822822                if (!on){
    823                         ISSMERROR("ProjectOnCurve error message: edge provided should be on geometry");
     823                        _error_("ProjectOnCurve error message: edge provided should be on geometry");
    824824                }
    825825                if (!e[0].GeomEdgeHook ||  !e[1].GeomEdgeHook){
    826                         ISSMERROR("ProjectOnCurve error message: at least one of the vertex of the edge provided is not on geometry");
     826                        _error_("ProjectOnCurve error message: at least one of the vertex of the edge provided is not on geometry");
    827827                }
    828828
    … …  
    865865                                        printf(" 2)  code bug : be sure that we call   Mesh::SetVertexFieldOn() before\n");
    866866                                        printf("To solve the problem do a coarsening of the geometrical mesh or change the constant value of mxe (dangerous)\n");
    867                                         ISSMERROR("see above");
     867                                        _error_("see above");
    868868                                }
    869869                                NbTry++;
    … …  
    872872                        GeomEdge* tmpge = eg0;
    873873                        ge[--bge] =eg0 = eg0->Adj[direction0];
    874                         ISSMASSERT(bge>=0 && bge<=mxe);
     874                        _assert_(bge>=0 && bge<=mxe);
    875875                        direction0 = 1-( directionge[bge] = tmpge->AdjVertexIndex[direction0]);
    876876                }
    … …  
    885885                                printf(" 2)  code bug : be sure that we call   Mesh::SetVertexFieldOn() before\n");
    886886                                printf("To solve the problem do a coarsening of the geometrical mesh or change the constant value of mxe (dangerous)\n");
    887                                 ISSMERROR("see above");
     887                                _error_("see above");
    888888                        }
    889889                        GeomEdge* tmpge = eg1;
    890890                        ge[++tge] =eg1 = eg1->Adj[direction1];
    891891                        directionge[tge]= direction1 = 1-tmpge->AdjVertexIndex[direction1];
    892                         ISSMASSERT(tge>=0 && tge<=mxe);
     892                        _assert_(tge>=0 && tge<=mxe);
    893893                }
    894894
    … …  
    912912                        double ll=0;
    913913                        for(i=bge;i<tge;i++){
    914                                 ISSMASSERT(i>=0 && i<=mxe);
     914                                _assert_(i>=0 && i<=mxe);
    915915                                BB =  (*ge[i])[directionge[i]];
    916916                                lge[i]=ll += Norme2(AA-BB);
    … …  
    918918                                lge[tge]=ll+=Norme2(AA-V1);
    919919                                // search the geometrical edge
    920                                 ISSMASSERT(s<=1.0);
     920                                _assert_(s<=1.0);
    921921                                double ls= s*ll;
    922922                                on =0;
    … …  
    926926                                i=bge;
    927927                                while (  (l1=lge[i]) < ls ) {
    928                                         ISSMASSERT(i>=0 && i<=mxe);
     928                                        _assert_(i>=0 && i<=mxe);
    929929                                        i++,s0=1-(s1=directionge[i]),l0=l1;
    930930                                }
    … …  
    936936                                sg =s0*(1.0-s)+s*s1;   
    937937                }
    938                 ISSMASSERT(on);
     938                _assert_(on);
    939939                V.r= on->F(sg);
    940940                GV=VertexOnGeom(V,*on,sg);

  • TabularUnified issm/trunk/src/c/objects/Bamg/ListofIntersectionTriangles.cpp

    r5573 r6412  
    3838                // check Size
    3939                if (Size<=0){
    40                         ISSMERROR("Size<=0");
     40                        _error_("Size<=0");
    4141                }
    4242
    … …  
    190190                        SegInterpolation * lEn =  new SegInterpolation[MaxNbSeg];
    191191                        if (!lSegsI || NbSeg>=MaxNbSeg){
    192                                 ISSMERROR("!lSegsI || NbSeg>=MaxNbSeg");
     192                                _error_("!lSegsI || NbSeg>=MaxNbSeg");
    193193                        }
    194194                        for (int i=0;i< NbSeg;i++)
    … …  
    209209                register int newsize = MaxSize*2;
    210210                IntersectionTriangles* nw = new IntersectionTriangles[newsize];
    211                 ISSMASSERT(nw);
     211                _assert_(nw);
    212212
    213213                // recopy
    … …  
    271271                                k=(*t)(0) ?  ((  (*t)(1) ? ( (*t)(2) ? -1 : 2) : 1  )) : 0;
    272272                                if (k<0){
    273                                         ISSMERROR("k<0");
     273                                        _error_("k<0");
    274274                                }
    275275                                ocut = OppositeEdge[k];
    … …  
    315315                                double dij = detj-deti;
    316316                                if (i+j+k != 0 + 1 +2){
    317                                         ISSMERROR("i+j+k != 0 + 1 +2");
     317                                        _error_("i+j+k != 0 + 1 +2");
    318318                                }
    319319                                ba[j] =  detj/dij;
    … …  
    387387                                        }
    388388                                        else {
    389                                                 ISSMERROR("Bug Split Edge");
     389                                                _error_("Bug Split Edge");
    390390                                        }
    391391                                }

  • TabularUnified issm/trunk/src/c/objects/Bamg/ListofIntersectionTriangles.h

    r5573 r6412  
    3434                                        double c01=lEnd-lBegin, c0=(lEnd-s)/c01, c1=(s-lBegin)/c01;
    3535                                        if (lBegin>s || s>lEnd){
    36                                                 ISSMERROR("lBegin>s || s>lEnd");
     36                                                _error_("lBegin>s || s>lEnd");
    3737                                        }
    3838                                        return e->F(sBegin*c0+sEnd*c1);

  • TabularUnified issm/trunk/src/c/objects/Bamg/Mesh.cpp

    r5623 r6412  
    110110                          }
    111111                  if (imaxnbv != nbv){
    112                           ISSMERROR("imaxnbv != nbv");
     112                          _error_("imaxnbv != nbv");
    113113                  }
    114114                  for (i=0;i<Tho.nbt;i++)
    … …  
    120120                                int i2 = Tho.GetId(t[2]);
    121121                                if (i0<0 || i1<0 || i2<0){
    122                                         ISSMERROR("i0<0 || i1<0 || i2< 0");
     122                                        _error_("i0<0 || i1<0 || i2< 0");
    123123                                }
    124124                                if (i0>=Tho.nbv || i1>=Tho.nbv || i2>=Tho.nbv){
    125                                         ISSMERROR("i0>=Tho.nbv || i1>=Tho.nbv || i2>=Tho.nbv");
     125                                        _error_("i0>=Tho.nbv || i1>=Tho.nbv || i2>=Tho.nbv");
    126126                                }
    127127                                triangles[nbt] = Triangle(this,kk[i0],kk[i1],kk[i2]);
    … …  
    130130                          }
    131131                  if (kt!=nbt){
    132                           ISSMERROR("kt!=nbt");
     132                          _error_("kt!=nbt");
    133133                  }
    134134                  if (nbt==0 && nbv==0) {
    135                           ISSMERROR("All triangles have been removed");
     135                          _error_("All triangles have been removed");
    136136                  }
    137137                  delete [] kk;
    … …  
    145145
    146146                  if (!nbsubdomains){
    147                           ISSMERROR("nbsubdomains==0");
     147                          _error_("nbsubdomains==0");
    148148                  }
    149149                  if (!subdomains[0].head || !subdomains[0].head->link){
    150                           ISSMERROR("!subdomains[0].head || !subdomains[0].head->link");
     150                          _error_("!subdomains[0].head || !subdomains[0].head->link");
    151151                  }
    152152
    … …  
    337337                }
    338338                else{
    339                         if(verbose>5) ISSMERROR("no Vertices found in the initial mesh");
     339                        if(verbose>5) _error_("no Vertices found in the initial mesh");
    340340                }
    341341
    … …  
    355355                }
    356356                else{
    357                         if(verbose>5) ISSMERROR("no Triangles found in the initial mesh");
     357                        if(verbose>5) _error_("no Triangles found in the initial mesh");
    358358                }
    359359
    … …  
    462462                                                j0 = i0%2;
    463463                                                i0 = i0/2;
    464                                                 ISSMASSERT(v==edges[i0 ].v[j0]);
     464                                                _assert_(v==edges[i0 ].v[j0]);
    465465                                                edges[i ].adj[j ] =edges +i0;
    466466                                                edges[i0].adj[j0] =edges +i ;
    … …  
    481481                                //Check value
    482482                                if(!(i>=0 && j>=0 && i<nbe && j<Gh.nbe)) {
    483                                         ISSMERROR("ReadMesh error: EdgesOnGeomEdge edge provided (line %i: [%i %i]) is incorrect (must be positive, [0<i<nbe=%i 0<j<Gh.nbe=%i]",i1+1,i+1,j+1,nbe,Gh.nbe);
     483                                        _error_("ReadMesh error: EdgesOnGeomEdge edge provided (line %i: [%i %i]) is incorrect (must be positive, [0<i<nbe=%i 0<j<Gh.nbe=%i]",i1+1,i+1,j+1,nbe,Gh.nbe);
    484484                                }
    485485                                edges[i].GeomEdgeHook=Gh.edges+j;
    … …  
    497497                                head=(int)bamgmesh->SubDomains[i*3+1]-1;//C indexing
    498498                                direction=(int)bamgmesh->SubDomains[i*3+2];
    499                                 if (i3!=23) ISSMERROR("Bad Subdomain definition: first number should be 3");
    500                                 if (head<0 || head>=nbt) ISSMERROR("Bad Subdomain definition: head should in [1 %i] (triangle number)",nbt);
     499                                if (i3!=23) _error_("Bad Subdomain definition: first number should be 3");
     500                                if (head<0 || head>=nbt) _error_("Bad Subdomain definition: head should in [1 %i] (triangle number)",nbt);
    501501                                subdomains[i].head = triangles+head;
    502502                        }
    … …  
    542542                                for (j=0;j<3;j++){
    543543                                        int v=GetId(triangles[i][j]); //jth vertex of the ith triangle
    544                                         if (k>3*nbt-1 || k<0) ISSMERROR("k = %i, nbt = %i",k,nbt);
     544                                        if (k>3*nbt-1 || k<0) _error_("k = %i, nbt = %i",k,nbt);
    545545                                        next_1[k]=head_1[v];
    546                                         if (v>nbv-1 || v<0)   ISSMERROR("v = %i, nbv = %i",v,nbv);
     546                                        if (v>nbv-1 || v<0)   _error_("v = %i, nbv = %i",v,nbv);
    547547                                        head_1[v]=k++;
    548548                                        connectivitysize_1[v]+=1;
    … …  
    636636                                }
    637637                        }
    638                         ISSMASSERT(found);
     638                        _assert_(found);
    639639                        bamgmesh->IssmEdges[i*4+2]=elemedge[2*i+0]+1; // back to M indexing
    640640                        bamgmesh->IssmEdges[i*4+3]=elemedge[2*i+1]+1; // back to M indexing
    … …  
    682682                                }
    683683                                if (!stop){
    684                                         ISSMERROR("Element holding segment [%i %i] not found...",i1+1,i2+1);
     684                                        _error_("Element holding segment [%i %i] not found...",i1+1,i2+1);
    685685                                }
    686686                        }
    … …  
    765765                        for (i=0;i<NbVerticesOnGeomVertex;i++){
    766766                                VertexOnGeom &v=VerticesOnGeomVertex[i];
    767                                 ISSMASSERT(v.OnGeomVertex());
     767                                _assert_(v.OnGeomVertex());
    768768                                bamgmesh->VerticesOnGeomVertex[i*2+0]=GetId((BamgVertex*)v)+1; //back to Matlab indexing
    769769                                bamgmesh->VerticesOnGeomVertex[i*2+1]=Gh.GetId((GeomVertex*)v)+1; //back to Matlab indexing
    … …  
    780780                                const VertexOnGeom &v=VerticesOnGeomEdge[i];
    781781                                if (!v.OnGeomEdge()){
    782                                         ISSMERROR("A vertices supposed to be OnGeomEdge is actually not");
     782                                        _error_("A vertices supposed to be OnGeomEdge is actually not");
    783783                                }
    784784                                bamgmesh->VerticesOnGeomEdge[i*3+0]=GetId((BamgVertex*)v)+1; //back to Matlab indexing
    … …  
    820820                                        k=GetId(triangles[i].TriangleAdj(j));
    821821                                        if (reft[k]>=0){
    822                                                 ISSMASSERT(3*num+j<3*(nbt-nbtout));
     822                                                _assert_(3*num+j<3*(nbt-nbtout));
    823823                                                bamgmesh->ElementConnectivity[3*num+j]=k+1; // back to Matlab indexing
    824824                                        }
    … …  
    837837                        k=0;
    838838                        for(j=head_1[i];j!=-1;j=next_1[j]){
    839                                 ISSMASSERT(connectivitymax_1*i+k < connectivitymax_1*nbv);
     839                                _assert_(connectivitymax_1*i+k < connectivitymax_1*nbv);
    840840                                bamgmesh->NodalElementConnectivity[connectivitymax_1*i+k]=floor(j/3)+1;
    841841                                k++;
    … …  
    863863                        for (j=0;j<2;j++){
    864864                                int v=(int)bamgmesh->IssmEdges[i*i2+j]-1; //back to C indexing
    865                                 if (k>2*i1-1 || k<0) ISSMERROR("Index exceed matrix dimensions (k=%i not in [0 %i]",k,2*i1-1);
     865                                if (k>2*i1-1 || k<0) _error_("Index exceed matrix dimensions (k=%i not in [0 %i]",k,2*i1-1);
    866866                                next_2[k]=head_2[v];
    867                                 if (v>nbv-1 || v<0)   ISSMERROR("Index exceed matrix dimensions (v=%i not in [0 %i])",v,nbv-1);
     867                                if (v>nbv-1 || v<0)   _error_("Index exceed matrix dimensions (v=%i not in [0 %i])",v,nbv-1);
    868868                                head_2[v]=k++;
    869869                                connectivitysize_2[v]+=1;
    … …  
    882882                        k=0;
    883883                        for(j=head_2[i];j!=-1;j=next_2[j]){
    884                                 ISSMASSERT(connectivitymax_2*i+k < connectivitymax_2*nbv);
     884                                _assert_(connectivitymax_2*i+k < connectivitymax_2*nbv);
    885885                                num=(int)bamgmesh->IssmEdges[int(j/2)*i2+0];
    886886                                if (i+1==num){ //carefull, ElementEdge is in M indexing
    … …  
    998998                //check that hmax is positive
    999999                if (hmax<=0){
    1000                         ISSMERROR("hmax<=0");
     1000                        _error_("hmax<=0");
    10011001                }
    10021002
    … …  
    10271027
    10281028                                if (ht<=0 || hn<=0){
    1029                                         ISSMERROR("ht<=0 || hn<=0");
     1029                                        _error_("ht<=0 || hn<=0");
    10301030                                }
    10311031                                EigenMetric Vp(1/(ht*ht),1/(hn*hn),tg);
    … …  
    10521052                }
    10531053                else{
    1054                         ISSMERROR("Hessiantype %i not supported yet (1->use Green formula, 0-> double P2 projection)",Hessiantype);
     1054                        _error_("Hessiantype %i not supported yet (1->use Green formula, 0-> double P2 projection)",Hessiantype);
    10551055                }
    10561056        }
    … …  
    10961096                //some checks
    10971097                if (( infvertexindex <0 ) && (detOld <0) ||  ( infvertexindex >=0  ) && (detOld >0) ){
    1098                         ISSMERROR("inconsistent configuration (Contact ISSM developers)");
     1098                        _error_("inconsistent configuration (Contact ISSM developers)");
    10991099                }
    11001100
    … …  
    11381138                        }
    11391139                        else{
    1140                                 ISSMERROR("Cannot add a vertex more than once. Check duplicates");
     1140                                _error_("Cannot add a vertex more than once. Check duplicates");
    11411141                        }
    11421142                }
    … …  
    11511151                tt[2]= &triangles[nbt++];
    11521152
    1153                 if (nbt>maxnbt) ISSMERROR("Not enough triangles");
     1153                if (nbt>maxnbt) _error_("Not enough triangles");
    11541154
    11551155                *tt[1]=*tt[2]=*t;
    … …  
    11881188
    11891189                        if (!rswap) {
    1190                                 ISSMERROR("swap the point s is on a edge");
     1190                                _error_("swap the point s is on a edge");
    11911191                        }
    11921192                }
    … …  
    12551255                //check that the mesh is not empty
    12561256                if (nbt<=0 || nbv <=0 ) {
    1257                         ISSMERROR("nbt or nbv is negative (Mesh empty?)");
     1257                        _error_("nbt or nbv is negative (Mesh empty?)");
    12581258                }
    12591259
    … …  
    12761276                //check that there is no double edge
    12771277                if (nbe !=  edge4->nb()){
    1278                         ISSMERROR("Some Double edge in the mesh, the number is %i, nbe4=%i",nbe,edge4->nb());
     1278                        _error_("Some Double edge in the mesh, the number is %i, nbe4=%i",nbe,edge4->nb());
    12791279                }
    12801280                //keep nbe in nbeold
    … …  
    12961296                                        //check that it is not an edge on boundary (should not already exist)
    12971297                                        if (triangles[i].TriangleAdj(j) || triangles[st[k]/3].TriangleAdj((int) (st[k]%3))){
    1298                                                 ISSMERROR("problem in Geometry reconstruction: an edge on boundary is duplicated (double element?)");
     1298                                                _error_("problem in Geometry reconstruction: an edge on boundary is duplicated (double element?)");
    12991299                                        }
    13001300                                        //OK, the element is not on boundary, is belongs to 2 triangles -> build Adjacent triangles list
    … …  
    13141314                                        printf("Edge %i of triangle %i\n",(-st[k]+2)%3,(-st[k]+2)/3);
    13151315                                        printf("Edge %i of triangle %i\n",triangles[(-st[k]+2)/3].NuEdgeTriangleAdj((int)((-st[k]+2)%3)),GetId(triangles[(-st[k]+2)/3].TriangleAdj((int)((-st[k]+2)%3))));
    1316                                         ISSMERROR("An edge belongs to more than 2 triangles");
     1316                                        _error_("An edge belongs to more than 2 triangles");
    13171317                                }       
    13181318                        }
    … …  
    13961396                        //check that we have been through all edges
    13971397                        if (k!=nbe){
    1398                                 ISSMERROR("problem in edge construction process: k!=nbe (should not happen)");
     1398                                _error_("problem in edge construction process: k!=nbe (should not happen)");
    13991399                        }
    14001400                        //delete edgessave
    … …  
    14411441                                        //check that we have the correct vertex
    14421442                                        if (v!=edges[i0 ].v[j0]){
    1443                                                 ISSMERROR("v!=edges[i0 ].v[j0]: this should not happen as the vertex belongs to this edge");
     1443                                                _error_("v!=edges[i0 ].v[j0]: this should not happen as the vertex belongs to this edge");
    14441444                                        }
    14451445
    … …  
    14581458                //check that nbsubdomains is empty
    14591459                if (nbsubdomains){
    1460                         ISSMERROR("nbsubdomains should be 0");
     1460                        _error_("nbsubdomains should be 0");
    14611461                }
    14621462                nbsubdomains=0;
    … …  
    15261526                //check that we have been through all subdomains
    15271527                if (k!= nbsubdomains){
    1528                         ISSMERROR("k!= nbsubdomains");
     1528                        _error_("k!= nbsubdomains");
    15291529                }
    15301530                //delete colorT and st
    … …  
    15861586                Gh.coefIcoor= (MaxICoor)/(Max(Gh.pmax.x-Gh.pmin.x,Gh.pmax.y-Gh.pmin.y));
    15871587                if (Gh.coefIcoor<=0){
    1588                         ISSMERROR("Gh.coefIcoor<=0 in infered Geometry (this should not happen)");
     1588                        _error_("Gh.coefIcoor<=0 in infered Geometry (this should not happen)");
    15891589                }
    15901590
    … …  
    16371637                        k = edge4->SortAndAdd(i0,i1);
    16381638                        if (k != i){
    1639                                 ISSMERROR("problem in Edge4 construction: k != i");
     1639                                _error_("problem in Edge4 construction: k != i");
    16401640                        }
    16411641                }
    … …  
    16661666                        }
    16671667                        else
    1668                          ISSMERROR("%i should be >=0");
     1668                         _error_("%i should be >=0");
    16691669                  }
    16701670
    … …  
    17001700
    17011701                /*Check size*/
    1702                 if (bamgopts->fieldSize[0] != nbv) ISSMERROR("'field' should have %i rows",nbv);
     1702                if (bamgopts->fieldSize[0] != nbv) _error_("'field' should have %i rows",nbv);
    17031703
    17041704                //initialization of some variables
    … …  
    19051905
    19061906                /*Check size*/
    1907                 if (bamgopts->fieldSize[0] != nbv) ISSMERROR("'field' should have %i rows",nbv);
     1907                if (bamgopts->fieldSize[0] != nbv) _error_("'field' should have %i rows",nbv);
    19081908
    19091909                //initialization of some variables
    … …  
    22192219                                i1=GetId(edges[i][0]);
    22202220                                i2=GetId(edges[i][1]);
    2221                                 ISSMASSERT(i1>=0 && i1<nbv && i2>=0 && i2<nbv);
     2221                                _assert_(i1>=0 && i1<nbv && i2>=0 && i2<nbv);
    22222222                                splitvertex[i1]++;
    22232223                                splitvertex[i2]++;
    … …  
    22292229                                //The vertex cannot be marked more than twice
    22302230                                if (splitvertex[i1]==3 || splitvertex[i2]==3){
    2231                                         ISSMERROR("Crossing rifts not supported yet");
    2232                                 }
    2233                         }
    2234                 }
    2235                 ISSMASSERT(k==NbCrackedEdges);
     2231                                        _error_("Crossing rifts not supported yet");
     2232                                }
     2233                        }
     2234                }
     2235                _assert_(k==NbCrackedEdges);
    22362236
    22372237                //Add new vertices
    … …  
    22472247                                }
    22482248                        }
    2249                         ISSMASSERT(num==NbCrackedVertices);
     2249                        _assert_(num==NbCrackedVertices);
    22502250                }
    22512251                delete [] splitvertex;
    … …  
    22652265                        Triangle* tbegin=vertices[i1].t;
    22662266                        k=vertices[i1].IndexInTriangle;//local number of i in triangle tbegin
    2267                         ISSMASSERT(GetId((*tbegin)[k])==GetId(vertices[i1]));
     2267                        _assert_(GetId((*tbegin)[k])==GetId(vertices[i1]));
    22682268
    22692269                        //Now, we are going to go through the adjacent triangle that hold i1 till
    … …  
    23072307                                //printf("%i -> %i %i %i, edge [%i->%i %i->%i]\n",element_renu[GetId(ta.t)],GetId((*ta.t)[0])+1,GetId((*ta.t)[1])+1,GetId((*ta.t)[2])+1,i1,j1,i2,j2);
    23082308                                ta = Next(ta).Adj();
    2309                                 if (count++>50) ISSMERROR("Maximum number of iteration exceeded");
     2309                                if (count++>50) _error_("Maximum number of iteration exceeded");
    23102310                        }while ((tbegin != ta));
    23112311                }
    … …  
    23142314                for(i=0;i<NbCrackedEdges;i++){
    23152315                        if (Edgeflags[i]!=2){
    2316                                 ISSMERROR("A problem occured: at least one crack edge (number %i) does not belong to 2 elements",i+1);
     2316                                _error_("A problem occured: at least one crack edge (number %i) does not belong to 2 elements",i+1);
    23172317                        }
    23182318                }
    … …  
    23642364                        }
    23652365                        if (k!=0) {
    2366                                 ISSMERROR("there is %i triangles of mes = 0",k);
     2366                                _error_("there is %i triangles of mes = 0",k);
    23672367                        }
    23682368
    … …  
    23782378                                if (nbswp) nbfe++;
    23792379                                if ( nbswp < 0 && k < 5){
    2380                                         ISSMERROR("Missing Edge %i, v0=%i,v1=%i",i,GetId(edges[i][0]),GetId(edges[i][1]));
     2380                                        _error_("Missing Edge %i, v0=%i,v1=%i",i,GetId(edges[i][0]),GetId(edges[i][1]));
    23812381                                }
    23822382                        }
    23832383
    23842384                        if (k!=0) {
    2385                                 ISSMERROR("There are %i lost edges, the boundary might be crossing",k);
     2385                                _error_("There are %i lost edges, the boundary might be crossing",k);
    23862386                        }
    23872387                        for (int j=0;j<nbv;j++){
    … …  
    24642464                        it++;} // end while (it<nbt)
    24652465                        if (nbt == nbtout ||  !NbSubDomTot) {
    2466                                 ISSMERROR("The boundary is not close: all triangles are outside");
     2466                                _error_("The boundary is not close: all triangles are outside");
    24672467                        }
    24682468
    … …  
    25012501                                                it++;} // end white (it<nbt)
    25022502                                                if (k!=nbsubdomains){
    2503                                                         ISSMERROR("k!=nbsubdomains");
     2503                                                        _error_("k!=nbsubdomains");
    25042504                                                }
    25052505                                                if(OutSide)
    … …  
    25712571                                        // see routine MakeGeomEdgeToEdge
    25722572                                        Edge &e = *GeomEdgetoEdge[Gh.GetId(eg)];
    2573                                         ISSMASSERT(&e);
     2573                                        _assert_(&e);
    25742574                                        BamgVertex * v0 =  e(0),*v1 = e(1);
    25752575                                        Triangle *t  = v0->t;
    … …  
    25792579                                        subdomains[i].direction = direction;
    25802580                                        subdomains[i].edge = &e;
    2581                                         ISSMASSERT(t && direction);
     2581                                        _assert_(t && direction);
    25822582
    25832583                                        AdjacentTriangle  ta(t,EdgesVertexTriangle[v0->IndexInTriangle][0]);// previous edges
    25842584
    25852585                                        while (1) {
    2586                                                 ISSMASSERT(v0==ta.EdgeVertex(1));
     2586                                                _assert_(v0==ta.EdgeVertex(1));
    25872587                                                if (ta.EdgeVertex(0) == v1) { // ok we find the edge
    25882588                                                        if (direction>0) 
    … …  
    25912591                                                         subdomains[i].head=t=ta;
    25922592                                                        if(t<triangles || t >= triangles+nbt || t->det < 0 || t->link == 0) {
    2593                                                                 ISSMERROR("bad definition of SubSomain %i",i);
     2593                                                                _error_("bad definition of SubSomain %i",i);
    25942594                                                        }
    25952595                                                        long it = GetId(t);
    … …  
    26062606                                                                kkk++;
    26072607                                                                if (mark[GetId(tt)]>=0){
    2608                                                                         ISSMERROR("mark[GetId(tt)]>=0");
     2608                                                                        _error_("mark[GetId(tt)]>=0");
    26092609                                                                }
    26102610                                                                mark[GetId(tt)]=i;
    … …  
    26152615                                                ta = Previous(Adj(ta));         
    26162616                                                if(t == (Triangle *) ta) {
    2617                                                         ISSMERROR("bad definition of SubSomain %i",i);
     2617                                                        _error_("bad definition of SubSomain %i",i);
    26182618                                                }
    26192619                                        }
    … …  
    27022702                if (maxnbv_in) {
    27032703                        vertices=new BamgVertex[maxnbv];
    2704                         ISSMASSERT(vertices);
     2704                        _assert_(vertices);
    27052705                        orderedvertices=new (BamgVertex* [maxnbv]);
    2706                         ISSMASSERT(orderedvertices);
     2706                        _assert_(orderedvertices);
    27072707                        triangles=new Triangle[maxnbt];
    2708                         ISSMASSERT(triangles);
     2708                        _assert_(triangles);
    27092709                }
    27102710                else {
    … …  
    27772777                        //if i is higher than nbv, it means that all the determinants are 0,
    27782778                        //all vertices are aligned!
    2779                         if  (++i>=nbv) ISSMERROR("all the vertices are aligned");
     2779                        if  (++i>=nbv) _error_("all the vertices are aligned");
    27802780                }
    27812781                // exchange i et 2 in "orderedvertices" so that
    … …  
    29132913                                long  j=vj.ReferenceNumber;
    29142914                                if (&vj!=orderedvertices[j]){
    2915                                         ISSMERROR("&vj!= orderedvertices[j]");
     2915                                        _error_("&vj!= orderedvertices[j]");
    29162916                                }
    29172917                                if(i!=j){
    … …  
    29232923                                if (tcvj && !tcvj->link){
    29242924                                        tcvj->Echo();
    2925                                         ISSMERROR("problem inserting point in InsertNewPoints (tcvj=%p and tcvj->link=%i)",tcvj,tcvj->link);
     2925                                        _error_("problem inserting point in InsertNewPoints (tcvj=%p and tcvj->link=%i)",tcvj,tcvj->link);
    29262926                                }
    29272927                                quadtree->Add(vj);
    … …  
    29552955
    29562956                if (!Gh.nbe){
    2957                         ISSMERROR("!Gh.nbe");
     2957                        _error_("!Gh.nbe");
    29582958                }
    29592959                Edge **e= new (Edge* [Gh.nbe]);
    … …  
    29882988                        }
    29892989                }
    2990                 if(kk) ISSMERROR("See above");
     2990                if(kk) _error_("See above");
    29912991
    29922992                return e;
    … …  
    31873187                                //check i
    31883188                                if (i<0 || i>=nbt ){
    3189                                         ISSMERROR("Index problem in NewPoints (i=%i not in [0 %i])",i,nbt-1);
     3189                                        _error_("Index problem in NewPoints (i=%i not in [0 %i])",i,nbt-1);
    31903190                                }
    31913191                                //change first_np_or_next_t[i]
    … …  
    32383238                                        }
    32393239                                        if (ta.EdgeVertex(0)!=s){
    3240                                                 ISSMERROR("ta.EdgeVertex(0)!=s");
     3240                                                _error_("ta.EdgeVertex(0)!=s");
    32413241                                        }
    32423242                                        ta = Next(Adj(ta));
    … …  
    32783278                }
    32793279                else {
    3280                         ISSMERROR("ProjectOnCurve On BamgVertex %i forget call to SetVertexFieldOnBTh",BTh.GetId(vA));
     3280                        _error_("ProjectOnCurve On BamgVertex %i forget call to SetVertexFieldOnBTh",BTh.GetId(vA));
    32813281                }
    32823282
    … …  
    32893289                }
    32903290                else {
    3291                         ISSMERROR("ProjectOnCurve On BamgVertex %i forget call to SetVertexFieldOnBTh",BTh.GetId(vB));
     3291                        _error_("ProjectOnCurve On BamgVertex %i forget call to SetVertexFieldOnBTh",BTh.GetId(vB));
    32923292                }
    32933293                Edge * e = &BhAB;
    32943294                if (!pA || !pB || !e){
    3295                         ISSMERROR("!pA || !pB || !e");
     3295                        _error_("!pA || !pB || !e");
    32963296                }
    32973297                // be carefull the back ground edge e is on same geom edge
    … …  
    32993299                //check Is a background Mesh;   
    33003300                if (e<BTh.edges || e>=BTh.edges+BTh.nbe){
    3301                         ISSMERROR("e<BTh.edges || e>=BTh.edges+BTh.nbe");
     3301                        _error_("e<BTh.edges || e>=BTh.edges+BTh.nbe");
    33023302                }
    33033303                // walk on BTh edge
    … …  
    33223322                  }
    33233323                else{ // do the search by walking
    3324                         ISSMERROR("case not supported yet");
     3324                        _error_("case not supported yet");
    33253325                  }
    33263326
    … …  
    33503350
    33513351                                kkk=kkk+1;
    3352                                 ISSMASSERT(kkk<100);
    3353                                 ISSMASSERT(eee);
     3352                                _assert_(kkk<100);
     3353                                _assert_(eee);
    33543354                                double lg0 = lg;
    33553355                                double dp = LengthInterpole(v0->m,v1->m,(R2) *v1 - (R2) *v0);
    … …  
    33583358                                        double sss  =   (abscisse-lg0)/dp;
    33593359                                        double thetab = te0*(1-sss)+ sss*iii;
    3360                                         ISSMASSERT(thetab>=0 && thetab<=1);
     3360                                        _assert_(thetab>=0 && thetab<=1);
    33613361                                        BR = VertexOnEdge(&R,eee,thetab);
    33623362                                        return  Gh.ProjectOnCurve(*eee,thetab,R,GR);
    … …  
    33693369
    33703370                                double lg0 = lg;
    3371                                 ISSMASSERT(eee);
     3371                                _assert_(eee);
    33723372                                v1 = pvB;
    33733373                                double dp = LengthInterpole(v0->m,v1->m,(R2) *v1 - (R2) *v0);
    … …  
    33783378                                        double sss  =   (abscisse-lg0)/dp;
    33793379                                        double thetab = te0*(1-sss)+ sss*tB;
    3380                                         ISSMASSERT(thetab>=0 && thetab<=1);
     3380                                        _assert_(thetab>=0 && thetab<=1);
    33813381                                        BR = VertexOnEdge(&R,eee,thetab);
    33823382                                        return  Gh.ProjectOnCurve(*eee,thetab,R,GR);
    … …  
    33863386
    33873387                  }
    3388                 ISSMERROR("Big bug...");
     3388                _error_("Big bug...");
    33893389                return 0; // just for the compiler
    33903390        }                 
    … …  
    34123412
    34133413        //initialize orderedvertices
    3414         ISSMASSERT(orderedvertices);
     3414        _assert_(orderedvertices);
    34153415        for (i=0;i<nbv;i++) orderedvertices[i]=0;
    34163416
    … …  
    34273427        }
    34283428        if (kk != nbe){
    3429                 ISSMERROR("There are %i double edges in the mesh",kk-nbe);
     3429                _error_("There are %i double edges in the mesh",kk-nbe);
    34303430        }
    34313431
    … …  
    34463446                        //If the edge already exists, add adjacency
    34473447                        else if(st[k]>=0) {
    3448                                 ISSMASSERT(!triangles[i].TriangleAdj(j));
    3449                                 ISSMASSERT(!triangles[st[k]/3].TriangleAdj((int) (st[k]%3)));
     3448                                _assert_(!triangles[i].TriangleAdj(j));
     3449                                _assert_(!triangles[st[k]/3].TriangleAdj((int) (st[k]%3)));
    34503450
    34513451                                triangles[i].SetAdj2(j,triangles+st[k]/3,(int)(st[k]%3));
    … …  
    34593459                        //An edge belongs to 2 triangles
    34603460                        else {
    3461                                 ISSMERROR("The edge (%i , %i) belongs to more than 2 triangles",GetId(triangles[i][VerticesOfTriangularEdge[j][0]]),GetId(triangles[i][VerticesOfTriangularEdge[j][1]]));
     3461                                _error_("The edge (%i , %i) belongs to more than 2 triangles",GetId(triangles[i][VerticesOfTriangularEdge[j][0]]),GetId(triangles[i][VerticesOfTriangularEdge[j][1]]));
    34623462                        }
    34633463                }
    … …  
    34973497        }
    34983498        if(k) {
    3499                 ISSMERROR("%i boundary edges (from the geometry) are not defined as mesh edges",k);
     3499                _error_("%i boundary edges (from the geometry) are not defined as mesh edges",k);
    35003500        }
    35013501
    … …  
    35243524        for (i=2;det(orderedvertices[0]->i,orderedvertices[1]->i,orderedvertices[i]->i)==0;)
    35253525         if  (++i>=nbvb) {
    3526                  ISSMERROR("ReconstructExistingMesh: All the vertices are aligned");
     3526                 _error_("ReconstructExistingMesh: All the vertices are aligned");
    35273527         }
    35283528        //Move this vertex (i) to the 2d position in orderedvertices
    … …  
    35843584        }
    35853585        if(nbloss) {
    3586                 ISSMERROR("we lost %i existing edges other %i",nbloss,knbe);
     3586                _error_("we lost %i existing edges other %i",nbloss,knbe);
    35873587        }
    35883588
    … …  
    36053605                                        long k =edge4->SortAndAdd(v0?GetId(v0):nbv,v1? GetId(v1):nbv);
    36063606
    3607                                         ISSMASSERT(st[k]>=0);
     3607                                        _assert_(st[k]>=0);
    36083608                                        tta.SetAdj2(ja,savetriangles + st[k] / 3,(int) (st[k]%3));
    36093609                                        ta.SetLock();
    … …  
    36233623                }
    36243624        }
    3625         ISSMASSERT(savenbt+NbTfillHoll<=savemaxnbt);
     3625        _assert_(savenbt+NbTfillHoll<=savemaxnbt);
    36263626
    36273627        // copy of the outside triangles in saveMesh
    … …  
    36593659        subdomains = savesubdomains;
    36603660        if (k) {
    3661                 ISSMERROR("number of triangles edges alone = %i",k);
     3661                _error_("number of triangles edges alone = %i",k);
    36623662        }
    36633663        FindSubDomain();
    … …  
    36893689
    36903690                                                printf("This edge is on geometry and has no adjacent edge (open curve) and one of the tip is not required\n");
    3691                                                 ISSMERROR("See above (might be cryptic...)");
     3691                                                _error_("See above (might be cryptic...)");
    36923692                                        }
    36933693                                }
    … …  
    37123712                        t=t0=subdomains[i].head;
    37133713                        if (!t0){ // not empty sub domain
    3714                                 ISSMERROR("!t0");
     3714                                _error_("!t0");
    37153715                        }
    37163716                        do {
    37173717                                long kt = GetId(t);
    37183718                                if (kt<0 || kt >= nbt ){
    3719                                         ISSMERROR("kt<0 || kt >= nbt");
     3719                                        _error_("kt<0 || kt >= nbt");
    37203720                                }
    37213721                                if (renu[kt]!=-1){
    3722                                         ISSMERROR("renu[kt]!=-1");
     3722                                        _error_("renu[kt]!=-1");
    37233723                                }
    37243724                                renu[kt]=k++;
    … …  
    37373737                }
    37383738                if (k != nbt){
    3739                         ISSMERROR("k != nbt");
     3739                        _error_("k != nbt");
    37403740                }
    37413741                // do the change on all the pointeur
    … …  
    38633863        coefIcoor= (MaxICoor)/(Max(pmax.x-pmin.x,pmax.y-pmin.y));
    38643864        if (coefIcoor<=0){
    3865                 ISSMERROR("coefIcoor should be positive, a problem in the geometry is likely");
     3865                _error_("coefIcoor should be positive, a problem in the geometry is likely");
    38663866        }
    38673867
    … …  
    38993899        }
    39003900
    3901         if (number_of_errors) ISSMERROR("Fatal error: some triangles have negative areas, see above");
     3901        if (number_of_errors) _error_("Fatal error: some triangles have negative areas, see above");
    39023902}
    39033903/*}}}1*/
    … …  
    40804080                        register Triangle* t= vertices[i].t;
    40814081                        if (!t){
    4082                                 ISSMERROR("!t");
     4082                                _error_("!t");
    40834083                        }
    40844084                        BamgVertex & vi = vertices[i];
    … …  
    40884088                                ta=Previous(Adj(ta));
    40894089                                if (vertices+i != ta.EdgeVertex(1)){
    4090                                         ISSMERROR("vertices+i != ta.EdgeVertex(1)");
     4090                                        _error_("vertices+i != ta.EdgeVertex(1)");
    40914091                                }
    40924092                                BamgVertex & vj = *(ta.EdgeVertex(0));
    … …  
    40944094                                        j= &vj-vertices;
    40954095                                        if (j<0 || j >= nbv){
    4096                                                 ISSMERROR("j<0 || j >= nbv");
     4096                                                _error_("j<0 || j >= nbv");
    40974097                                        }
    40984098                                        R2 Aij = (R2) vj - (R2) vi;
    … …  
    42184218                                        // the first PB is to now a background edge between the 2 vertices
    42194219                                        if (!edgesGtoB){
    4220                                                 ISSMERROR("!edgesGtoB");
     4220                                                _error_("!edgesGtoB");
    42214221                                        }
    42224222                                        ong= ProjectOnCurve(*edgesGtoB[Gh.GetId(edges[i].GeomEdgeHook)],
    … …  
    42904290                        Triangle & t = triangles[i];
    42914291                        if (!t.link){
    4292                                 ISSMERROR("!t.link");
     4292                                _error_("!t.link");
    42934293                        }
    42944294                        for(int j=0;j<3;j++)
    … …  
    43174317                                                                                ||   (cc=Area2( t[0].r , t[1].r , A.r    )) < 0.0)){
    43184318                                                        printf("%i not in triangle %i In= %i %g %g %g %g\n",ke + nbvold,i,!!t.link,aa,bb,cc,dd);
    4319                                                         ISSMERROR("Number of triangles with P2 interpolation Problem");
     4319                                                        _error_("Number of triangles with P2 interpolation Problem");
    43204320                                                }
    43214321                                        }
    … …  
    43254325                                                                                ||   (cc=Area2( tt[0].r , tt[1].r , A.r     )) < 0)){
    43264326                                                        printf("%i not in triangle %i In= %i %g %g %g %g\n",ke + nbvold,ii,!!tt.link,aa,bb,cc,dd);
    4327                                                         ISSMERROR("Number of triangles with P2 interpolation Problem");
     4327                                                        _error_("Number of triangles with P2 interpolation Problem");
    43284328                                                }
    43294329                                        }
    … …  
    43734373                                                  } // tt
    43744374                                                else
    4375                                                  ISSMERROR("Bug...");
     4375                                                 _error_("Bug...");
    43764376                                          } // ke<0           
    43774377                                        else
    … …  
    43864386                          }
    43874387                        if (nbinvisible>=2){
    4388                                 ISSMERROR("nbinvisible>=2");
     4388                                _error_("nbinvisible>=2");
    43894389                        }
    43904390                        switch (nbsplitedge) {
    … …  
    43984398                        }
    43994399                        if (ksplit[i]<40){
    4400                                 ISSMERROR("ksplit[i]<40");
     4400                                _error_("ksplit[i]<40");
    44014401                        }
    44024402                  }
    … …  
    44154415                        int  ke=(int) (ksplit[i]%10);
    44164416                        if (kk>=7 || kk<=0){
    4417                                 ISSMERROR("kk>=7 || kk<=0");
     4417                                _error_("kk>=7 || kk<=0");
    44184418                        }
    44194419
    … …  
    44324432
    44334433                        if (nbmkadj>=10){
    4434                                 ISSMERROR("nbmkadj>=10");
     4434                                _error_("nbmkadj>=10");
    44354435                        }
    44364436                        // --------------------------
    … …  
    44504450                                                        t1=t0;
    44514451                                                        if (kedge[3*i+i0]<0){
    4452                                                                 ISSMERROR("kedge[3*i+i0]<0");
     4452                                                                _error_("kedge[3*i+i0]<0");
    44534453                                                        }
    44544454                                                        BamgVertex * v3 = vertices + kedge[3*i+k0];
    … …  
    44664466                                                        t2=t1=t0;
    44674467                                                        if (kedge[3*i+k1]<0){
    4468                                                                 ISSMERROR("kedge[3*i+k1]<0");
     4468                                                                _error_("kedge[3*i+k1]<0");
    44694469                                                        }
    44704470                                                        if (kedge[3*i+k2]<0){
    4471                                                                 ISSMERROR("kedge[3*i+k2]<0");
     4471                                                                _error_("kedge[3*i+k2]<0");
    44724472                                                        }
    44734473
    … …  
    44934493                                                        t3=t2=t1=t0;
    44944494                                                        if (kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0){
    4495                                                                 ISSMERROR("kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0");
     4495                                                                _error_("kedge[3*i+k0] <0 || kedge[3*i+k1]<0 || kedge[3*i+k2]<0");
    44964496                                                        }
    44974497                                                        BamgVertex * v12 = vertices + kedge[3*i+k0];
    … …  
    45674567                                }
    45684568                        if (nbmkadj>13){// 13 = 6 + 4 +
    4569                                 ISSMERROR("nbmkadj>13");
     4569                                _error_("nbmkadj>13");
    45704570                        }
    45714571
    … …  
    46934693                        quadtree->Add(vi);
    46944694                        if (!tcvi || tcvi->det<0){// internal
    4695                                 ISSMERROR("!tcvi || tcvi->det < 0");
     4695                                _error_("!tcvi || tcvi->det < 0");
    46964696                        }
    46974697                        AddVertex(vi,tcvi,det3);
    … …  
    47374737
    47384738                /*Check that the quadtree does exist*/
    4739                 if (!quadtree) ISSMERROR("no starting triangle provided and no quadtree available");
     4739                if (!quadtree) _error_("no starting triangle provided and no quadtree available");
    47404740
    47414741                /*Call NearestVertex*/
    … …  
    47434743
    47444744                /*Check output (Vertex a)*/
    4745                 if (!a)    ISSMERROR("problem while trying to find nearest vertex from a given point. No output found");
    4746                 if (!a->t) ISSMERROR("no triangle is associated to vertex number %i (orphan?)",GetId(a)+1);
    4747                 ISSMASSERT(a>=vertices && a<vertices+nbv);
     4745                if (!a)    _error_("problem while trying to find nearest vertex from a given point. No output found");
     4746                if (!a->t) _error_("no triangle is associated to vertex number %i (orphan?)",GetId(a)+1);
     4747                _assert_(a>=vertices && a<vertices+nbv);
    47484748
    47494749                /*Get starting triangle*/
    47504750                t = a->t;
    4751                 ISSMASSERT(t>=triangles && t<triangles+nbt);
     4751                _assert_(t>=triangles && t<triangles+nbt);
    47524752        }
    47534753
    … …  
    47624762                /*Get a real vertex from this triangle (k0)*/
    47634763                int k0=(*t)(0)?(((*t)(1)?((*t)(2)?-1:2):1)):0;
    4764                 ISSMASSERT(k0>=0);// k0 the NULL vertex
     4764                _assert_(k0>=0);// k0 the NULL vertex
    47654765                int k1=NextVertex[k0],k2=PreviousVertex[k0];
    47664766                det3[k0]=det(B,(*t)[k1],(*t)[k2]);
    … …  
    47704770                t = t->TriangleAdj(OppositeEdge[k0]);
    47714771                counter++;
    4772                 ISSMASSERT(counter<2);
     4772                _assert_(counter<2);
    47734773        }
    47744774
    … …  
    47794779
    47804780                /*Increase counter*/
    4781                 if (++counter>=10000) ISSMERROR("Maximum number of iteration reached (threshold = %i).",counter);
     4781                if (++counter>=10000) _error_("Maximum number of iteration reached (threshold = %i).",counter);
    47824782
    47834783                j= OppositeVertex[jj];
    … …  
    47994799                if (k==0) break;
    48004800                if (k==2 && BinaryRand()) Exchange(ii[0],ii[1]);
    4801                 ISSMASSERT(k<3);
     4801                _assert_(k<3);
    48024802                AdjacentTriangle t1 = t->Adj(jj=ii[0]);
    48034803                if ((t1.det() < 0 ) && (k == 2))
    … …  
    48434843
    48444844                //check that the subdomain is not empty
    4845                 if (!t0){ ISSMERROR("At least one subdomain is empty");}
     4845                if (!t0){ _error_("At least one subdomain is empty");}
    48464846
    48474847                //loop
    … …  
    48534853
    48544854                        //check that num is in [0 nbt[
    4855                         ISSMASSERT(num>=0 && num<nbt);
     4855                        _assert_(num>=0 && num<nbt);
    48564856
    48574857                        //reft of this triangle is the subdomain number
    … …  
    48994899                //allocate
    49004900                VerticesOnGeomVertex = new VertexOnGeom[NbVerticesOnGeomVertex]; 
    4901                 if(NbVerticesOnGeomVertex >= maxnbv) ISSMERROR("too many vertices on geometry: %i >= %i",NbVerticesOnGeomVertex,maxnbv);
    4902                 ISSMASSERT(nbv==0);
     4901                if(NbVerticesOnGeomVertex >= maxnbv) _error_("too many vertices on geometry: %i >= %i",NbVerticesOnGeomVertex,maxnbv);
     4902                _assert_(nbv==0);
    49034903                //Build VerticesOnGeomVertex
    49044904                for (i=0;i<Gh.nbv;i++){
    … …  
    49074907
    49084908                                //Add the vertex
    4909                                 ISSMASSERT(nbv<maxnbv);
     4909                                _assert_(nbv<maxnbv);
    49104910                                vertices[nbv]=Gh[i];
    49114911                               
    … …  
    49244924
    49254925                //check that edges is still empty (Init)
    4926                 ISSMASSERT(!edges);
     4926                _assert_(!edges);
    49274927
    49284928                /* Now we are going to create the first edges corresponding
    … …  
    49684968
    49694969                                                                        //check that edges has been allocated
    4970                                                                         ISSMASSERT(edges);
     4970                                                                        _assert_(edges);
    49714971                                                                        edges[nbe].v[0]=a->MeshVertexHook;
    49724972                                                                        edges[nbe].v[1]=b->MeshVertexHook;;
    … …  
    49884988                                                                NbNewPoints=0;
    49894989                                                                NbEdgeCurve=0;
    4990                                                                 if (nbvend>=maxnbv) ISSMERROR("maximum number of vertices too low! Check the domain outline or increase maxnbv");
     4990                                                                if (nbvend>=maxnbv) _error_("maximum number of vertices too low! Check the domain outline or increase maxnbv");
    49914991                                                                lcurve =0;
    49924992                                                                s = lstep; //-1 initially, then length of each sub edge
    … …  
    50715071                                                                                         kk0=kkk,ll0=llk;
    50725072                                                                                }
    5073                                                                                 ISSMASSERT(kk1!=kk0);
     5073                                                                                _assert_(kk1!=kk0);
    50745074
    50755075                                                                                /*Curvilinear coordinate in [0 1] of ss in current edge*/
    … …  
    51155115                                                                        k = e->AdjVertexIndex[kprev];// next vertices
    51165116                                                                        e = e->Adj[kprev];
    5117                                                                         ISSMASSERT(e);
     5117                                                                        _assert_(e);
    51185118                                                                }// for(;;)
    51195119                                                                vb = b->MeshVertexHook;
    … …  
    51465146                        } // for (i=0;i<nbe;i++)
    51475147                        if(!step) {
    5148                                 ISSMASSERT(!edges);
    5149                                 ISSMASSERT(!VerticesOnGeomEdge);
     5148                                _assert_(!edges);
     5149                                _assert_(!VerticesOnGeomEdge);
    51505150
    51515151                                edges = new Edge[nbex=nbe];
    … …  
    51535153
    51545154                                // do the vertex on a geometrical vertex
    5155                                 ISSMASSERT(VerticesOnGeomEdge || NbVerticesOnGeomEdge0==0);
     5155                                _assert_(VerticesOnGeomEdge || NbVerticesOnGeomEdge0==0);
    51565156                                NbVerticesOnGeomEdge0 = NbVerticesOnGeomEdge;       
    51575157                        }
    51585158                        else{
    5159                                 ISSMASSERT(NbVerticesOnGeomEdge==NbVerticesOnGeomEdge0);
     5159                                _assert_(NbVerticesOnGeomEdge==NbVerticesOnGeomEdge0);
    51605160                        }
    51615161                }
    … …  
    52075207
    52085208                //Check that background mesh and current mesh do have the same geometry
    5209                 ISSMASSERT(&BTh.Gh==&Gh);
     5209                _assert_(&BTh.Gh==&Gh);
    52105210                BTh.NbRef++; // add a ref to BackGround Mesh
    52115211
    … …  
    52285228                int i;
    52295229                for (i=0;i<Gh.nbv;i++) if (Gh[i].Required()) NbVerticesOnGeomVertex++;
    5230                 if(NbVerticesOnGeomVertex >= maxnbv) { ISSMERROR("too many vertices on geometry: %i >= %i",NbVerticesOnGeomVertex,maxnbv);}
     5230                if(NbVerticesOnGeomVertex >= maxnbv) { _error_("too many vertices on geometry: %i >= %i",NbVerticesOnGeomVertex,maxnbv);}
    52315231
    52325232                VerticesOnGeomVertex = new VertexOnGeom[  NbVerticesOnGeomVertex];
    … …  
    52345234
    52355235                //At this point there is NO vertex but vertices should have been allocated by Init
    5236                 ISSMASSERT(vertices);
     5236                _assert_(vertices);
    52375237                for (i=0;i<Gh.nbv;i++){
    52385238                        if (Gh[i].Required()) {//Gh vertices Required
    … …  
    52505250                                GeomVertex* gv=vog;
    52515251                                BamgVertex *bv = vog;
    5252                                 ISSMASSERT(gv->MeshVertexHook); // use of Geom -> Th
     5252                                _assert_(gv->MeshVertexHook); // use of Geom -> Th
    52535253                                VertexOnBThVertex[NbVertexOnBThVertex++]=VertexOnVertex(gv->MeshVertexHook,bv);
    52545254                                gv->MeshVertexHook->m = bv->m; // for taking the metrix of the background mesh
    52555255                        }
    52565256                }
    5257                 ISSMASSERT(NbVertexOnBThVertex==NbVerticesOnGeomVertex);
     5257                _assert_(NbVertexOnBThVertex==NbVerticesOnGeomVertex);
    52585258
    52595259                /*STEP 2: reseed boundary edges*/
    … …  
    52965296                        }
    52975297                }
    5298                 if (bfind!=Gh.nbcurves) ISSMERROR("problem generating number of curves (%i found in the geometry but %i curve found in the mesh)",Gh.nbcurves,bfind);
     5298                if (bfind!=Gh.nbcurves) _error_("problem generating number of curves (%i found in the geometry but %i curve found in the mesh)",Gh.nbcurves,bfind);
    52995299
    53005300                // method in 2 + 1 step
    … …  
    53585358
    53595359                                        // New Curve phase
    5360                                         ISSMASSERT(A0-vertices>=0 && A0-vertices<nbv);
     5360                                        _assert_(A0-vertices>=0 && A0-vertices<nbv);
    53615361                                        if(ongequi->Required()){
    53625362                                                GeomVertex *GA1 = *(*peequi)[1-k0equi].GeomEdgeHook;
    … …  
    53695369                                                        k1 = 1-k0; // next vertex of the edge
    53705370                                                        k1equi= 1 - k0equi;
    5371                                                         ISSMASSERT(pe && ee.GeomEdgeHook);
     5371                                                        _assert_(pe && ee.GeomEdgeHook);
    53725372                                                        ee.GeomEdgeHook->SetMark();
    53735373                                                        BamgVertex & v0=ee[0], & v1=ee[1];
    … …  
    53825382
    53835383                                                                        //some checks
    5384                                                                         ISSMASSERT(sNew>=L0);
    5385                                                                         ISSMASSERT(LAB);
    5386                                                                         ISSMASSERT(vertices && nbv<maxnbv);
    5387                                                                         ISSMASSERT(edges && nbe<nbex);
    5388                                                                         ISSMASSERT(VerticesOnGeomEdge && NbVerticesOnGeomEdge<NbVerticesOnGeomEdgex);
     5384                                                                        _assert_(sNew>=L0);
     5385                                                                        _assert_(LAB);
     5386                                                                        _assert_(vertices && nbv<maxnbv);
     5387                                                                        _assert_(edges && nbe<nbex);
     5388                                                                        _assert_(VerticesOnGeomEdge && NbVerticesOnGeomEdge<NbVerticesOnGeomEdgex);
    53895389
    53905390                                                                        // new vertex on edge
    … …  
    53945394                                                                        double se= (sNew-L0)/LAB;
    53955395                                                                        if (se<0 || se>=1.000000001){
    5396                                                                                 ISSMERROR("Problem creating point on a boundary: se=%g should be in [0 1]",se);
     5396                                                                                _error_("Problem creating point on a boundary: se=%g should be in [0 1]",se);
    53975397                                                                        }
    53985398                                                                        se = abscisseInterpole(v0.m,v1.m,AB,se,1);
    53995399                                                                        if (se<0 || se>1){
    5400                                                                                 ISSMERROR("Problem creating point on a boundary: se=%g should be in [0 1]",se);
     5400                                                                                _error_("Problem creating point on a boundary: se=%g should be in [0 1]",se);
    54015401                                                                        }
    54025402                                                                        se = k1         ? se : 1. - se;
    … …  
    54215421
    54225422                                                        //some checks
    5423                                                         ISSMASSERT(ee.GeomEdgeHook->CurveNumber==ei.GeomEdgeHook->CurveNumber);
     5423                                                        _assert_(ee.GeomEdgeHook->CurveNumber==ei.GeomEdgeHook->CurveNumber);
    54245424                                                        if (ee[k1].GeomEdgeHook->IsRequiredVertex()) {
    5425                                                                 ISSMASSERT(eeequi[k1equi].GeomEdgeHook->IsRequiredVertex());
     5425                                                                _assert_(eeequi[k1equi].GeomEdgeHook->IsRequiredVertex());
    54265426                                                                register GeomVertex * GA1 = *eeequi[k1equi].GeomEdgeHook;
    54275427                                                                A1=GA1->MeshVertexHook;// the vertex in new mesh
    5428                                                                 ISSMASSERT(A1-vertices>=0 && A1-vertices<nbv);
     5428                                                                _assert_(A1-vertices>=0 && A1-vertices<nbv);
    54295429                                                                break;
    54305430                                                        }
    54315431                                                        if (!ee.adj[k1]) {
    5432                                                                 ISSMERROR(" adj edge %i, nbe=%i, Gh.vertices=%i",BTh.GetId(ee),nbe,Gh.vertices);
     5432                                                                _error_(" adj edge %i, nbe=%i, Gh.vertices=%i",BTh.GetId(ee),nbe,Gh.vertices);
    54335433                                                        }
    54345434                                                        pe = ee.adj[k1]; // next edge
    … …  
    54515451                                                PreviousNewEdge = e;
    54525452
    5453                                                 ISSMASSERT(i==NbCreatePointOnCurve);
     5453                                                _assert_(i==NbCreatePointOnCurve);
    54545454                                        }
    54555455
    … …  
    54685468                        if(step==0){
    54695469                                if(nbv+NbOfNewPoints > maxnbv) {
    5470                                         ISSMERROR("too many vertices on geometry: %i >= %i",nbv+NbOfNewPoints,maxnbv);
     5470                                        _error_("too many vertices on geometry: %i >= %i",nbv+NbOfNewPoints,maxnbv);
    54715471                                }
    54725472                                edges = new Edge[NbOfNewEdge];
    … …  
    54825482                        }
    54835483                }
    5484                 ISSMASSERT(nbe!=0);
     5484                _assert_(nbe!=0);
    54855485                delete [] bcurve;
    54865486
    … …  
    55135513                int dir=0;
    55145514                if (k<0){
    5515                         ISSMERROR("k<0");
     5515                        _error_("k<0");
    55165516                }
    55175517                int kkk=0; 
    … …  
    55215521                        kkk++;
    55225522                        if (kkk>=1000){
    5523                                 ISSMERROR("kkk>=1000");
     5523                                _error_("kkk>=1000");
    55245524                        }
    55255525                        BamgVertex  &vI =  *edge.EdgeVertex(0);
    … …  
    55385538                                                        double IJ2 = IJ_IA + IJ_AJ;
    55395539                                                        if (IJ2==0){
    5540                                                                 ISSMERROR("IJ2==0");
     5540                                                                _error_("IJ2==0");
    55415541                                                        }
    55425542                                                        a= IJ_AJ/IJ2;
    … …  
    55565556                //   int dir=0;
    55575557                if (t->link != 0){
    5558                         ISSMERROR("t->link != 0");
     5558                        _error_("t->link != 0");
    55595559                }
    55605560                // to have a starting edges
    … …  
    56285628                  }
    56295629                if (cas ==-2){
    5630                         ISSMERROR("cas==-2");
     5630                        _error_("cas==-2");
    56315631                }
    56325632                // l1 = ||C s1||  , l0 = ||C s0||
    … …  
    56455645                                kkk++;
    56465646                                if (edge.EdgeVertex(0)!=s && kkk>=10000){
    5647                                         ISSMERROR("edge.EdgeVertex(0)!=s && kkk>=10000");
     5647                                        _error_("edge.EdgeVertex(0)!=s && kkk>=10000");
    56485648                                }
    56495649
    … …  
    56775677
    56785678                        if (!(Triangle *) er){
    5679                                 ISSMERROR("!(Triangle *) er");
     5679                                _error_("!(Triangle *) er");
    56805680                        }
    56815681                        I2 A((I2)*er.EdgeVertex(0));
    … …  
    57015701        int NbSwap =0;
    57025702        if (!a.t || !b.t){ // the 2 vertex is in a mesh
    5703                 ISSMERROR("!a.t || !b.t");
     5703                _error_("!a.t || !b.t");
    57045704        }
    57055705        int k=0;
    … …  
    57185718                vbegin =v2;
    57195719                if (!v2){
    5720                         ISSMERROR("!v2");
     5720                        _error_("!v2");
    57215721                }
    57225722                det2 = det(*v2,a,b);
    … …  
    57355735                        tc = Previous(tc);
    57365736                        if (!v1 || !v2){
    5737                                 ISSMERROR("!v1 || !v2");
     5737                                _error_("!v1 || !v2");
    57385738                        }
    57395739                        Icoor2 detss = 0,l=0,ks;
    57405740                        while ((ks=SwapForForcingEdge(  va,  vb, tc, detss, det1,det2,NbSwap)))
    57415741                         if(l++ > 10000000) {
    5742                                  ISSMERROR("Loop in forcing Egde, nb de swap=%i, nb of try swap (%i) too big",NbSwap,l);
     5742                                 _error_("Loop in forcing Egde, nb de swap=%i, nb of try swap (%i) too big",NbSwap,l);
    57435743                         }
    57445744                        BamgVertex *aa = tc.EdgeVertex(0), *bb = tc.EdgeVertex(1);
    … …  
    57595759                k++;
    57605760                if (k>=2000){
    5761                         ISSMERROR("k>=2000");
     5761                        _error_("k>=2000");
    57625762                }
    57635763                if ( vbegin == v2 ) return -1;// error
    … …  
    58315831                short a1=tt1,a2=tt2;// les 2 numero de l arete dans les 2 triangles
    58325832                if ( a1<0 || a1>=3 ){
    5833                         ISSMERROR("a1<0 || a1>=3");
     5833                        _error_("a1<0 || a1>=3");
    58345834                }
    58355835
    … …  
    58435843                Icoor2 detT = det1+det2;
    58445844                if ((det1<=0 ) || (det2<=0)){
    5845                         ISSMERROR("(det1<=0 ) || (det2<=0)");
     5845                        _error_("(det1<=0 ) || (det2<=0)");
    58465846                }
    58475847                if ( (detsa>=0) || (detsb<=0) ){ // [a,b] cut infinite line va,bb
    5848                         ISSMERROR("(detsa>=0) || (detsb<=0)");
     5848                        _error_("(detsa>=0) || (detsb<=0)");
    58495849                }
    58505850                Icoor2 ndet1 = bamg::det(s1,sa,s2);

  • TabularUnified issm/trunk/src/c/objects/Bamg/Metric.cpp

    r5489 r6412  
    201201                // warning for optimisation S is in [0:0.5] not in [0:1]
    202202                if (i>=512){
    203                         ISSMERROR("i>=512");
     203                        _error_("i>=512");
    204204                }
    205205                LastMetricInterpole.lab=l;
    … …  
    345345                  }
    346346                if (r>1 || r<0){
    347                         ISSMERROR("r>1 || r<0");
     347                        _error_("r>1 || r<0");
    348348                }
    349349                return r ;

  • TabularUnified issm/trunk/src/c/objects/Bamg/QuadTree.cpp

    r5300 r6412  
    126126
    127127                /*Check Sizes*/
    128                 ISSMASSERT(MaxISize>MaxICoor);
     128                _assert_(MaxISize>MaxICoor);
    129129
    130130                /*Add all vertices of the mesh*/
    … …  
    180180
    181181                /*check that l is not 0 (this should not happen as MaxDeep = 30)*/
    182                 ISSMASSERT(level>0);
     182                _assert_(level>0);
    183183
    184184                /*Now, try to add the vertex, if the subbox is full (nbitems=4), we have to divide it

  • TabularUnified issm/trunk/src/c/objects/Bamg/QuadTree.h

    r5269 r6412  
    2929                                        };
    3030                                        /*Object functions*/
    31                                         void  Echo(){ISSMERROR("not implemented yet");};
    32                                         void  DeepEcho(){ISSMERROR("not implemented yet");};
    33                                         int   Id(){ISSMERROR("not implemented yet");};
    34                                         int   MyRank(){ISSMERROR("not implemented yet");};
    35                                         void  Marshall(char** pmarshalled_dataset){ISSMERROR("not implemented yet");};
    36                                         int   MarshallSize(){ISSMERROR("not implemented yet");};
    37                                         void  Demarshall(char** pmarshalled_dataset){ISSMERROR("not implemented yet");};
    38                                         int   Enum(){ISSMERROR("not implemented yet");};
    39                                         Object* copy(){ISSMERROR("not implemented yet");};
     31                                        void  Echo(){_error_("not implemented yet");};
     32                                        void  DeepEcho(){_error_("not implemented yet");};
     33                                        int   Id(){_error_("not implemented yet");};
     34                                        int   MyRank(){_error_("not implemented yet");};
     35                                        void  Marshall(char** pmarshalled_dataset){_error_("not implemented yet");};
     36                                        int   MarshallSize(){_error_("not implemented yet");};
     37                                        void  Demarshall(char** pmarshalled_dataset){_error_("not implemented yet");};
     38                                        int   Enum(){_error_("not implemented yet");};
     39                                        Object* copy(){_error_("not implemented yet");};
    4040                        };
    4141

  • TabularUnified issm/trunk/src/c/objects/Bamg/SetOfE4.cpp

    r5150 r6412  
    3434
    3535                //get n from h (usually h=ii)
    36                 ISSMASSERT(head);
     36                _assert_(head);
    3737                n=head[h=Abs(ii)%nx];
    3838
    … …  
    5050                //check that nbax <=NbOfEdges
    5151                if (nbax <=NbOfEdges ) {
    52                         ISSMERROR("SetOfEdges4::add overflow: NbOfEdges=%i > nbax=%i",NbOfEdges,nbax);
     52                        _error_("SetOfEdges4::add overflow: NbOfEdges=%i > nbax=%i",NbOfEdges,nbax);
    5353                }
    5454
    … …  
    6969
    7070                //check that head is not empty
    71                 ISSMASSERT(head);
     71                _assert_(head);
    7272
    7373                //get n from h (usually h=ii)

  • TabularUnified issm/trunk/src/c/objects/Bamg/SubDomain.cpp

    r5149 r6412  
    1616                *this = Th.subdomains[i];
    1717                if ( head-Th.triangles<0 || head-Th.triangles>=Th.nbt){
    18                         ISSMERROR("head-Th.triangles<0 || head-Th.triangles>=Th.nbt");
     18                        _error_("head-Th.triangles<0 || head-Th.triangles>=Th.nbt");
    1919                }
    2020                head = ThNew.triangles + Th.GetId(head) ;
    2121                if (edge-Th.edges<0 || edge-Th.edges>=Th.nbe);{
    22                         ISSMERROR("edge-Th.edges<0 || edge-Th.edges>=Th.nbe");
     22                        _error_("edge-Th.edges<0 || edge-Th.edges>=Th.nbe");
    2323                }
    2424                edge = ThNew.edges+ Th.GetId(edge);

  • TabularUnified issm/trunk/src/c/objects/Bamg/Triangle.cpp

    r5605 r6412  
    1414                long nbv = Th->nbv;
    1515                if (i<0 || j<0 || k<0){
    16                         ISSMERROR("i<0 || j<0 || k<0");
     16                        _error_("i<0 || j<0 || k<0");
    1717                }
    1818                if (i>=nbv || j>=nbv || k>=nbv){
    19                         ISSMERROR("i>=nbv || j>=nbv || k>=nbv");
     19                        _error_("i>=nbv || j>=nbv || k>=nbv");
    2020                }
    2121                vertices[0]=v+i;
    … …  
    117117                        //check number of iterations
    118118                        if (k>=2000){
    119                                 ISSMERROR("too many iteration in Triangle::FindBoundaryEdge (k>=2000)");
     119                                _error_("too many iteration in Triangle::FindBoundaryEdge (k>=2000)");
    120120                        }
    121121                } while (this!= t);
    … …  
    157157                do {
    158158                        while (t->swap(j,koption)){
    159                                 if (k>=20000) ISSMERROR("k>=20000");
     159                                if (k>=20000) _error_("k>=20000");
    160160                                NbSwap++;
    161161                                k++;

  • TabularUnified issm/trunk/src/c/objects/Contour.cpp

    r3775 r6412  
    1717        int i;
    1818
    19         _printf_("Number of grids in contour: %i\n",contour->nods);
    20         _printf_("Grid coordinates: \n");
     19        _printf_(true,"Number of grids in contour: %i\n",contour->nods);
     20        _printf_(true,"Grid coordinates: \n");
    2121        for (i=0;i<contour->nods;i++){
    22                 _printf_("%lf %lf\n",*(contour->x+i),*(contour->y+i));
     22                _printf_(true,"%lf %lf\n",*(contour->x+i),*(contour->y+i));
    2323        }
    2424}

  • TabularUnified issm/trunk/src/c/objects/DofIndexing.cpp

    r5792 r6412  
    141141                else this->sdoflist=NULL;
    142142        }
    143         else ISSMERROR("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     143        else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
    144144
    145145

  • TabularUnified issm/trunk/src/c/objects/ElementResults/PentaVertexElementResult.cpp

    r5529 r6412  
    156156
    157157                /*Check index value*/
    158                 ISSMASSERT(indices[i]>=0 && indices[i]<6);
     158                _assert_(indices[i]>=0 && indices[i]<6);
    159159
    160160                /*Assign value to new result*/

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

    r6410 r6412  
    5757        /*Checks in debugging mode*/
    5858        /*{{{2*/
    59         ISSMASSERT(iomodel->upperelements);
    60         ISSMASSERT(iomodel->lowerelements);
     59        _assert_(iomodel->upperelements);
     60        _assert_(iomodel->lowerelements);
    6161        /*}}}*/
    6262
    … …  
    282282/*FUNCTION Penta::AverageOntoPartition {{{1*/
    283283void  Penta::AverageOntoPartition(Vec partition_contributions,Vec partition_areas,double* vertex_response,double* qmu_part){
    284         ISSMERROR("Not supported yet!");
     284        _error_("Not supported yet!");
    285285}
    286286/*}}}*/
    … …  
    336336
    337337        /*Check analysis_types*/
    338         if (analysis_type!=DiagnosticHorizAnalysisEnum) ISSMERROR("Not supported yet!");
    339         if (approximation!=StokesApproximationEnum) ISSMERROR("Not supported yet!");
     338        if (analysis_type!=DiagnosticHorizAnalysisEnum) _error_("Not supported yet!");
     339        if (approximation!=StokesApproximationEnum) _error_("Not supported yet!");
    340340
    341341        /*retrieve some parameters: */
    … …  
    357357
    358358        /*Retrieve all inputs we will be needing: */
    359         Input* pressure_input=inputs->GetInput(PressureEnum); ISSMASSERT(pressure_input);
    360         Input* vx_input=inputs->GetInput(VxEnum);             ISSMASSERT(vx_input);
    361         Input* vy_input=inputs->GetInput(VyEnum);             ISSMASSERT(vy_input);
    362         Input* vz_input=inputs->GetInput(VzEnum);             ISSMASSERT(vz_input);
     359        Input* pressure_input=inputs->GetInput(PressureEnum); _assert_(pressure_input);
     360        Input* vx_input=inputs->GetInput(VxEnum);             _assert_(vx_input);
     361        Input* vy_input=inputs->GetInput(VyEnum);             _assert_(vy_input);
     362        Input* vz_input=inputs->GetInput(VzEnum);             _assert_(vz_input);
    363363
    364364        /* Start  looping on the number of gaussian points: */
    … …  
    402402void  Penta::ComputeStrainRate(Vec eps){
    403403
    404         ISSMERROR("Not implemented yet");
     404        _error_("Not implemented yet");
    405405
    406406}
    … …  
    448448                input=inputs->GetInput(enum_type);
    449449        }
    450         if (!input) ISSMERROR("Input %s not found",EnumToString(enum_type));
    451         if (input->Enum()!=ControlInputEnum) ISSMERROR("Input %s is not a ControlInput",EnumToString(enum_type));
     450        if (!input) _error_("Input %s not found",EnumToString(enum_type));
     451        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
    452452
    453453        this->GetDofList1(&doflist1[0]);
    … …  
    466466                input=inputs->GetInput(enum_type);
    467467        }
    468         if (!input) ISSMERROR("Input %s not found",EnumToString(enum_type));
    469         if (input->Enum()!=ControlInputEnum) ISSMERROR("Input %s is not a ControlInput",EnumToString(enum_type));
     468        if (!input) _error_("Input %s not found",EnumToString(enum_type));
     469        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
    470470
    471471        ((ControlInput*)input)->ScaleGradient(scale);
    … …  
    485485                input=inputs->GetInput(enum_type);
    486486        }
    487         if (!input) ISSMERROR("Input %s not found",EnumToString(enum_type));
    488         if (input->Enum()!=ControlInputEnum) ISSMERROR("Input %s is not a ControlInput",EnumToString(enum_type));
     487        if (!input) _error_("Input %s not found",EnumToString(enum_type));
     488        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
    489489
    490490        this->GetDofList1(&doflist1[0]);
    … …  
    503503
    504504        /*Checks in debugging {{{2*/
    505         ISSMASSERT(this->nodes && this->matice && this->matpar && this->neighbors && this->parameters && this->inputs);
     505        _assert_(this->nodes && this->matice && this->matpar && this->neighbors && this->parameters && this->inputs);
    506506        /*}}}*/
    507507
    … …  
    536536                        break;
    537537                default:
    538                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     538                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    539539        }
    540540
    … …  
    647647        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    648648        this->parameters->FindParam(&viscosity_overshoot,ViscosityOvershootEnum);
    649         Input* vx_input=inputs->GetInput(VxEnum);       ISSMASSERT(vx_input);
    650         Input* vy_input=inputs->GetInput(VyEnum);       ISSMASSERT(vy_input);
    651         Input* vxold_input=inputs->GetInput(VxOldEnum); ISSMASSERT(vxold_input);
    652         Input* vyold_input=inputs->GetInput(VyOldEnum); ISSMASSERT(vyold_input);
     649        Input* vx_input=inputs->GetInput(VxEnum);       _assert_(vx_input);
     650        Input* vy_input=inputs->GetInput(VyEnum);       _assert_(vy_input);
     651        Input* vxold_input=inputs->GetInput(VxOldEnum); _assert_(vxold_input);
     652        Input* vyold_input=inputs->GetInput(VyOldEnum); _assert_(vyold_input);
    653653
    654654        /* Start  looping on the number of gaussian points: */
    … …  
    758758                        return CreateKMatrixDiagnosticPattynStokes();
    759759                default:
    760                         ISSMERROR("Approximation %s not supported yet",EnumToString(approximation));
     760                        _error_("Approximation %s not supported yet",EnumToString(approximation));
    761761        }
    762762}
    … …  
    896896        GetVerticesCoordinates(&xyz_list[0][0], nodes,NUMVERTICES);
    897897        this->parameters->FindParam(&viscosity_overshoot,ViscosityOvershootEnum);
    898         Input* vx_input=inputs->GetInput(VxEnum);       ISSMASSERT(vx_input);
    899         Input* vy_input=inputs->GetInput(VyEnum);       ISSMASSERT(vy_input);
    900         Input* vxold_input=inputs->GetInput(VxOldEnum); ISSMASSERT(vxold_input);
    901         Input* vyold_input=inputs->GetInput(VyOldEnum); ISSMASSERT(vyold_input);
     898        Input* vx_input=inputs->GetInput(VxEnum);       _assert_(vx_input);
     899        Input* vy_input=inputs->GetInput(VyEnum);       _assert_(vy_input);
     900        Input* vxold_input=inputs->GetInput(VxOldEnum); _assert_(vxold_input);
     901        Input* vyold_input=inputs->GetInput(VyOldEnum); _assert_(vyold_input);
    902902
    903903        /* Start  looping on the number of gaussian points: */
    … …  
    10141014        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    10151015        this->parameters->FindParam(&viscosity_overshoot,ViscosityOvershootEnum);
    1016         Input* vx_input=inputs->GetInput(VxEnum);       ISSMASSERT(vx_input);
    1017         Input* vy_input=inputs->GetInput(VyEnum);       ISSMASSERT(vy_input);
    1018         Input* vxold_input=inputs->GetInput(VxOldEnum); ISSMASSERT(vxold_input);
    1019         Input* vyold_input=inputs->GetInput(VyOldEnum); ISSMASSERT(vyold_input);
     1016        Input* vx_input=inputs->GetInput(VxEnum);       _assert_(vx_input);
     1017        Input* vy_input=inputs->GetInput(VyEnum);       _assert_(vy_input);
     1018        Input* vxold_input=inputs->GetInput(VxOldEnum); _assert_(vxold_input);
     1019        Input* vyold_input=inputs->GetInput(VyOldEnum); _assert_(vyold_input);
    10201020
    10211021        /* Start  looping on the number of gaussian points: */
    … …  
    11221122        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    11231123        parameters->FindParam(&stokesreconditioning,StokesReconditioningEnum);
    1124         Input* vx_input=inputs->GetInput(VxEnum); ISSMASSERT(vx_input);
    1125         Input* vy_input=inputs->GetInput(VyEnum); ISSMASSERT(vy_input);
    1126         Input* vz_input=inputs->GetInput(VzEnum); ISSMASSERT(vz_input);
     1124        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
     1125        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
     1126        Input* vz_input=inputs->GetInput(VzEnum); _assert_(vz_input);
    11271127
    11281128        /* Start  looping on the number of gaussian points: */
    … …  
    11911191        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    11921192        parameters->FindParam(&stokesreconditioning,StokesReconditioningEnum);
    1193         Input* vx_input=inputs->GetInput(VxEnum); ISSMASSERT(vx_input);
    1194         Input* vy_input=inputs->GetInput(VyEnum); ISSMASSERT(vy_input);
    1195         Input* vz_input=inputs->GetInput(VzEnum); ISSMASSERT(vz_input);
     1193        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
     1194        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
     1195        Input* vz_input=inputs->GetInput(VzEnum); _assert_(vz_input);
    11961196        for(i=0;i<NUMVERTICES2D;i++) for(j=0;j<3;j++) xyz_list_tria[i][j]=xyz_list[i][j];
    11971197
    … …  
    14271427        this->parameters->FindParam(&artdiff,ArtDiffEnum);
    14281428        this->parameters->FindParam(&epsvel,EpsVelEnum);
    1429         Input* vx_input=inputs->GetInput(VxEnum); ISSMASSERT(vx_input);
    1430         Input* vy_input=inputs->GetInput(VyEnum); ISSMASSERT(vy_input);
    1431         Input* vz_input=inputs->GetInput(VzEnum); ISSMASSERT(vz_input);
     1429        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
     1430        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
     1431        Input* vz_input=inputs->GetInput(VzEnum); _assert_(vz_input);
    14321432        if (artdiff==2) diameter=MinEdgeLength(xyz_list);
    14331433
    … …  
    15621562
    15631563        /*if debugging mode, check that all pointers exist {{{2*/
    1564         ISSMASSERT(this->nodes && this->matice && this->matpar && this->neighbors && this->parameters && this->inputs);
     1564        _assert_(this->nodes && this->matice && this->matpar && this->neighbors && this->parameters && this->inputs);
    15651565        /*}}}*/
    15661566
    … …  
    15981598                        break;
    15991599                default:
    1600                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     1600                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    16011601        }
    16021602
    … …  
    16241624                        return CreatePVectorAdjointStokes();
    16251625                default:
    1626                         ISSMERROR("Approximation %s not supported yet",EnumToString(approximation));
     1626                        _error_("Approximation %s not supported yet",EnumToString(approximation));
    16271627        }
    16281628}
    … …  
    17411741        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    17421742        this->parameters->FindParam(&stokesreconditioning,StokesReconditioningEnum);
    1743         Input* vx_input=inputs->GetInput(VxEnum);               ISSMASSERT(vx_input);
    1744         Input* vy_input=inputs->GetInput(VyEnum);               ISSMASSERT(vy_input);
    1745         Input* vz_input=inputs->GetInput(VzEnum);               ISSMASSERT(vz_input);
    1746         Input* vzpattyn_input=inputs->GetInput(VzPattynEnum);   ISSMASSERT(vzpattyn_input);
     1743        Input* vx_input=inputs->GetInput(VxEnum);               _assert_(vx_input);
     1744        Input* vy_input=inputs->GetInput(VyEnum);               _assert_(vy_input);
     1745        Input* vz_input=inputs->GetInput(VzEnum);               _assert_(vz_input);
     1746        Input* vzpattyn_input=inputs->GetInput(VzPattynEnum);   _assert_(vzpattyn_input);
    17471747
    17481748        /* Start  looping on the number of gaussian points: */
    … …  
    18061806        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    18071807        this->parameters->FindParam(&stokesreconditioning,StokesReconditioningEnum);
    1808         Input* vx_input=inputs->GetInput(VxEnum);               ISSMASSERT(vx_input);
    1809         Input* vy_input=inputs->GetInput(VyEnum);               ISSMASSERT(vy_input);
    1810         Input* vz_input=inputs->GetInput(VzEnum);               ISSMASSERT(vz_input);
    1811         Input* vzpattyn_input=inputs->GetInput(VzPattynEnum);   ISSMASSERT(vzpattyn_input);
     1808        Input* vx_input=inputs->GetInput(VxEnum);               _assert_(vx_input);
     1809        Input* vy_input=inputs->GetInput(VyEnum);               _assert_(vy_input);
     1810        Input* vz_input=inputs->GetInput(VzEnum);               _assert_(vz_input);
     1811        Input* vzpattyn_input=inputs->GetInput(VzPattynEnum);   _assert_(vzpattyn_input);
    18121812
    18131813        for(i=0;i<NUMVERTICES2D;i++) for(j=0;j<3;j++) xyz_list_tria[i][j]=xyz_list[i][j];
    … …  
    18671867                        return CreatePVectorDiagnosticPattynStokes();
    18681868                default:
    1869                         ISSMERROR("Approximation %s not supported yet",EnumToString(approximation));
     1869                        _error_("Approximation %s not supported yet",EnumToString(approximation));
    18701870        }
    18711871}
    … …  
    19311931        n=matice->GetN();
    19321932        B=matice->GetB();
    1933         Input* thickness_input=inputs->GetInput(ThicknessEnum);  ISSMASSERT(thickness_input);
    1934         Input* surface_input=inputs->GetInput(SurfaceEnum);      ISSMASSERT(surface_input);
    1935         Input* slopex_input=inputs->GetInput(SurfaceSlopeXEnum); ISSMASSERT(slopex_input);
    1936         Input* slopey_input=inputs->GetInput(SurfaceSlopeYEnum); ISSMASSERT(slopey_input);
     1933        Input* thickness_input=inputs->GetInput(ThicknessEnum);  _assert_(thickness_input);
     1934        Input* surface_input=inputs->GetInput(SurfaceEnum);      _assert_(surface_input);
     1935        Input* slopex_input=inputs->GetInput(SurfaceSlopeXEnum); _assert_(slopex_input);
     1936        Input* slopey_input=inputs->GetInput(SurfaceSlopeYEnum); _assert_(slopey_input);
    19371937        for(i=0;i<NUMVERTICES;i++)z_list[i]=xyz_list[i][2];
    19381938
    … …  
    20252025        /*Retrieve all inputs and parameters*/
    20262026        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    2027         Input* thickness_input=inputs->GetInput(ThicknessEnum); ISSMASSERT(thickness_input);
    2028         Input* surface_input=inputs->GetInput(SurfaceEnum);     ISSMASSERT(surface_input);
     2027        Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
     2028        Input* surface_input=inputs->GetInput(SurfaceEnum);     _assert_(surface_input);
    20292029
    20302030        /* Start  looping on the number of gaussian points: */
    … …  
    20992099        gravity=matpar->GetG();
    21002100        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    2101         Input* vx_input=inputs->GetInput(VxEnum);   ISSMASSERT(vx_input);
    2102         Input* vy_input=inputs->GetInput(VyEnum);   ISSMASSERT(vy_input);
    2103         Input* vz_input=inputs->GetInput(VzEnum);   ISSMASSERT(vz_input);
     2101        Input* vx_input=inputs->GetInput(VxEnum);   _assert_(vx_input);
     2102        Input* vy_input=inputs->GetInput(VyEnum);   _assert_(vy_input);
     2103        Input* vz_input=inputs->GetInput(VzEnum);   _assert_(vz_input);
    21042104
    21052105        /* Start  looping on the number of gaussian points: */
    … …  
    21682168        gravity=matpar->GetG();
    21692169        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    2170         Input* bed_input=inputs->GetInput(BedEnum); ISSMASSERT(bed_input);
     2170        Input* bed_input=inputs->GetInput(BedEnum); _assert_(bed_input);
    21712171
    21722172        for(i=0;i<NUMVERTICES2D;i++) for(j=0;j<3;j++) xyz_list_tria[i][j]=xyz_list[i][j];
    … …  
    22442244        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    22452245        inputs->GetParameterValue(&approximation,ApproximationEnum);
    2246         Input* vx_input=inputs->GetInput(VxEnum); ISSMASSERT(vx_input);
    2247         Input* vy_input=inputs->GetInput(VyEnum); ISSMASSERT(vy_input);
     2246        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
     2247        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    22482248        Input* vzstokes_input=NULL;
    22492249        if(approximation==PattynStokesApproximationEnum){
    2250                 vzstokes_input=inputs->GetInput(VzStokesEnum); ISSMASSERT(vzstokes_input);
     2250                vzstokes_input=inputs->GetInput(VzStokesEnum); _assert_(vzstokes_input);
    22512251        }
    22522252
    … …  
    23832383        this->inputs->GetParameterValue(&dt,DtEnum);
    23842384        this->parameters->FindParam(&artdiff,ArtDiffEnum);
    2385         Input* vx_input=inputs->GetInput(VxEnum); ISSMASSERT(vx_input);
    2386         Input* vy_input=inputs->GetInput(VyEnum); ISSMASSERT(vy_input);
    2387         Input* vz_input=inputs->GetInput(VzEnum); ISSMASSERT(vz_input);
     2385        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
     2386        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
     2387        Input* vz_input=inputs->GetInput(VzEnum); _assert_(vz_input);
    23882388        Input* temperature_input=NULL;
    2389         if (dt) temperature_input=inputs->GetInput(TemperatureEnum); ISSMASSERT(inputs);
     2389        if (dt) temperature_input=inputs->GetInput(TemperatureEnum); _assert_(inputs);
    23902390        if (artdiff==2) diameter=MinEdgeLength(xyz_list);
    23912391
    … …  
    25252525                GradjB(gradient);
    25262526        }
    2527         else ISSMERROR("control type %s not supported yet: ",EnumToString(control_type));
     2527        else _error_("control type %s not supported yet: ",EnumToString(control_type));
    25282528}
    25292529/*}}}*/
    … …  
    26032603                return;
    26042604        }
    2605         else ISSMERROR("approximation %s not supported yet",EnumToString(approximation));
     2605        else _error_("approximation %s not supported yet",EnumToString(approximation));
    26062606}
    26072607/*}}}*/
    … …  
    26202620                /* get lower Penta*/
    26212621                penta=penta->GetLowerElement();
    2622                 ISSMASSERT(penta->Id()!=this->id);
     2622                _assert_(penta->Id()!=this->id);
    26232623        }
    26242624
    … …  
    26792679int Penta::GetNodeIndex(Node* node){
    26802680
    2681         ISSMASSERT(nodes);
     2681        _assert_(nodes);
    26822682        for(int i=0;i<NUMVERTICES;i++){
    26832683                if(node==nodes[i])
    26842684                 return i;
    26852685        }
    2686         ISSMERROR("Node provided not found among element nodes");
     2686        _error_("Node provided not found among element nodes");
    26872687
    26882688}
    … …  
    26972697        /*Recover input*/
    26982698        Input* input=inputs->GetInput(enumtype);
    2699         if (!input) ISSMERROR("Input %s not found in element",EnumToString(enumtype));
     2699        if (!input) _error_("Input %s not found in element",EnumToString(enumtype));
    27002700
    27012701        /*Checks in debugging mode*/
    2702         ISSMASSERT(pvalue);
     2702        _assert_(pvalue);
    27032703
    27042704        /* Start looping on the number of vertices: */
    … …  
    27242724
    27252725        /*Checks in debugging mode*/
    2726         ISSMASSERT(pvalue);
     2726        _assert_(pvalue);
    27272727
    27282728        /* Start looping on the number of vertices: */
    … …  
    27462746
    27472747        Input* input=inputs->GetInput(enumtype);
    2748         if(!input) ISSMERROR("No input of type %s found in tria",EnumToString(enumtype));
     2748        if(!input) _error_("No input of type %s found in tria",EnumToString(enumtype));
    27492749
    27502750        GaussPenta* gauss=new GaussPenta();
    … …  
    28332833        }
    28342834        else{
    2835                 ISSMERROR("analysis: %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     2835                _error_("analysis: %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    28362836        }
    28372837}
    … …  
    28512851        /*Get approximation enum and dof list: */
    28522852        inputs->GetParameterValue(&approximation,ApproximationEnum);
    2853         Input* vx_input=inputs->GetInput(VxEnum); ISSMASSERT(vx_input);
    2854         Input* vy_input=inputs->GetInput(VyEnum); ISSMASSERT(vy_input);
     2853        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
     2854        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    28552855
    28562856        /*If the element is a coupling, do nothing: every grid is also on an other elements
    … …  
    28922892        /*Get dof list: */
    28932893        GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
    2894         Input* vx_input=inputs->GetInput(VxEnum); ISSMASSERT(vx_input);
    2895         Input* vy_input=inputs->GetInput(VyEnum); ISSMASSERT(vy_input);
     2894        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
     2895        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    28962896
    28972897        /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
    … …  
    29282928        /*Get dof list: */
    29292929        GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
    2930         Input* vz_input=inputs->GetInput(VzEnum); ISSMASSERT(vz_input);
     2930        Input* vz_input=inputs->GetInput(VzEnum); _assert_(vz_input);
    29312931
    29322932        /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
    … …  
    29622962        /*Get dof list: */
    29632963        GetDofList(&doflist,StokesApproximationEnum,GsetEnum);
    2964         Input* vx_input=inputs->GetInput(VxEnum);       ISSMASSERT(vx_input);
    2965         Input* vy_input=inputs->GetInput(VyEnum);       ISSMASSERT(vy_input);
    2966         Input* vz_input=inputs->GetInput(VzEnum);       ISSMASSERT(vz_input);
    2967         Input* p_input =inputs->GetInput(PressureEnum); ISSMASSERT(p_input);
     2964        Input* vx_input=inputs->GetInput(VxEnum);       _assert_(vx_input);
     2965        Input* vy_input=inputs->GetInput(VyEnum);       _assert_(vy_input);
     2966        Input* vz_input=inputs->GetInput(VzEnum);       _assert_(vz_input);
     2967        Input* p_input =inputs->GetInput(PressureEnum); _assert_(p_input);
    29682968
    29692969        /*Recondition pressure: */
    … …  
    30063006        /*Get dof list: */
    30073007        GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
    3008         Input* t_input=inputs->GetInput(TemperatureEnum); ISSMASSERT(t_input);
     3008        Input* t_input=inputs->GetInput(TemperatureEnum); _assert_(t_input);
    30093009
    30103010        gauss=new GaussPenta();
    … …  
    30583058        /*Check that both inputs have been found*/
    30593059        if (!vx_input || !vy_input){
    3060                 ISSMERROR("Input missing. Here are the input pointers we have for vx: %p, vy: %p\n",vx_input,vy_input);
     3060                _error_("Input missing. Here are the input pointers we have for vx: %p, vy: %p\n",vx_input,vy_input);
    30613061        }
    30623062
    … …  
    30833083        /*Check that both inputs have been found*/
    30843084        if (!vx_input || !vy_input || !vz_input){
    3085                 ISSMERROR("Input missing. Here are the input pointers we have for vx: %p, vy: %p, vz: %p\n",vx_input,vy_input,vz_input);
     3085                _error_("Input missing. Here are the input pointers we have for vx: %p, vy: %p, vz: %p\n",vx_input,vy_input,vz_input);
    30863086        }
    30873087
    … …  
    31503150        /*Make a copy of the original input: */
    31513151        input=(Input*)this->inputs->GetInput(enum_type);
    3152         if(!input)ISSMERROR(" could not find old input with enum: %s",EnumToString(enum_type));
     3152        if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type));
    31533153
    31543154        /*ArtificialNoise: */
    … …  
    31703170                new_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+0]);
    31713171                old_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+1]);
    3172                 if(!new_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
    3173                 if(!old_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
     3172                if(!new_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
     3173                if(!old_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
    31743174        }
    31753175
    … …  
    32083208                if(control_type[i]==RheologyBbarEnum){
    32093209                        if (!IsOnBed()) return;
    3210                         input=(Input*)matice->inputs->GetInput(RheologyBEnum); ISSMASSERT(input);
     3210                        input=(Input*)matice->inputs->GetInput(RheologyBEnum); _assert_(input);
    32113211                }
    32123212                else{
    3213                         input=(Input*)this->inputs->GetInput(control_type[i]); ISSMASSERT(input);
    3214                 }
    3215 
    3216                 if (input->Enum()!=ControlInputEnum) ISSMERROR("input %s is not a ControlInput",EnumToString(control_type[i]));
     3213                        input=(Input*)this->inputs->GetInput(control_type[i]); _assert_(input);
     3214                }
     3215
     3216                if (input->Enum()!=ControlInputEnum) _error_("input %s is not a ControlInput",EnumToString(control_type[i]));
    32173217
    32183218                ((ControlInput*)input)->UpdateValue(scalar);
    … …  
    32653265                 original_input=(Input*)penta->matice->inputs->GetInput(enum_type);
    32663266                else
    3267                  ISSMERROR("object %s not supported yet",EnumToString(object_enum));
    3268                 if(!original_input) ISSMERROR("could not find input with enum %s",EnumToString(enum_type));
     3267                 _error_("object %s not supported yet",EnumToString(object_enum));
     3268                if(!original_input) _error_("could not find input with enum %s",EnumToString(enum_type));
    32693269
    32703270                /*If first time, initialize total_integrated_input*/
    … …  
    32773277                         total_integrated_input=new DoubleInput(average_enum_type,0.0);
    32783278                        else
    3279                          ISSMERROR("object %s not supported yet",EnumToString(original_input->Enum()));
     3279                         _error_("object %s not supported yet",EnumToString(original_input->Enum()));
    32803280                }
    32813281
    … …  
    33053305                /* get upper Penta*/
    33063306                penta=penta->GetUpperElement();
    3307                 ISSMASSERT(penta->Id()!=this->id);
     3307                _assert_(penta->Id()!=this->id);
    33083308
    33093309                /*increase couter*/
    … …  
    33253325         this->matice->inputs->AddInput((Input*)depth_averaged_input);
    33263326        else
    3327          ISSMERROR("object %s not supported yet",EnumToString(object_enum));
     3327         _error_("object %s not supported yet",EnumToString(object_enum));
    33283328}
    33293329/*}}}*/
    … …  
    33553355                 original_input=(Input*)matice->inputs->GetInput(enum_type);
    33563356                else
    3357                  ISSMERROR("object of type %s not supported yet",EnumToString(object_type));
    3358                 if(!original_input) ISSMERROR("%s%s"," could not find input with enum:",EnumToString(enum_type));
     3357                 _error_("object of type %s not supported yet",EnumToString(object_type));
     3358                if(!original_input) _error_("%s%s"," could not find input with enum:",EnumToString(enum_type));
    33593359                original_input->Extrude();
    33603360
    … …  
    33683368                        /* get upper Penta*/
    33693369                        penta=penta->GetUpperElement();
    3370                         ISSMASSERT(penta->Id()!=this->id);
     3370                        _assert_(penta->Id()!=this->id);
    33713371
    33723372                        /*Add input of the basal element to penta->inputs*/
    … …  
    33783378                         penta->matice->inputs->AddInput((Input*)copy);
    33793379                        else
    3380                          ISSMERROR("object of type %s not supported yet",EnumToString(object_type));
     3380                         _error_("object of type %s not supported yet",EnumToString(object_type));
    33813381
    33823382                        /*Stop if we have reached the surface*/
    … …  
    33953395        /*Make a copy of the original input: */
    33963396        input=(Input*)this->inputs->GetInput(enum_type);
    3397         if(!input)ISSMERROR(" could not find old input with enum: %s",EnumToString(enum_type));
     3397        if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type));
    33983398
    33993399        /*Scale: */
    … …  
    34113411        if (enum_type==RheologyBbarEnum) input=this->matice->inputs->GetInput(RheologyBEnum);
    34123412        else input=this->inputs->GetInput(enum_type);
    3413         if (!input) ISSMERROR("Input %s not found in penta->inputs",EnumToString(enum_type));
     3413        if (!input) _error_("Input %s not found in penta->inputs",EnumToString(enum_type));
    34143414
    34153415        /*If we don't find it, no big deal, just don't do the transfer. Otherwise, build a new Result
    … …  
    34583458        /*Checks if debuging*/
    34593459        /*{{{2*/
    3460         ISSMASSERT(iomodel->elements);
     3460        _assert_(iomodel->elements);
    34613461        /*}}}*/
    34623462
    … …  
    35863586                                        /*Matice will take care of it*/ break;
    35873587                                default:
    3588                                         ISSMERROR("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i]));
     3588                                        _error_("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i]));
    35893589                        }
    35903590                }
    … …  
    36153615                }
    36163616                else{
    3617                         ISSMERROR("Approximation type %s not supported yet",EnumToString((int)*(iomodel->elements_type+index)));
     3617                        _error_("Approximation type %s not supported yet",EnumToString((int)*(iomodel->elements_type+index)));
    36183618                }
    36193619        }
    … …  
    36773677        }
    36783678        else{
    3679                 ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     3679                _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    36803680        }
    36813681}
    … …  
    37643764                Input* vz_input=inputs->GetInput(VzEnum);
    37653765                if (vz_input){
    3766                         if (vz_input->Enum()!=PentaVertexInputEnum) ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
     3766                        if (vz_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
    37673767                        vz_input->GetValuesPtr(&vz_ptr,&dummy);
    37683768                        for(i=0;i<NUMVERTICES;i++) vz[i]=vz_ptr[i];
    … …  
    37913791
    37923792                /* get upper Penta*/
    3793                 penta=penta->GetUpperElement(); ISSMASSERT(penta->Id()!=this->id);
     3793                penta=penta->GetUpperElement(); _assert_(penta->Id()!=this->id);
    37943794        }
    37953795       
    … …  
    38513851        if (vz_input){
    38523852                if (vz_input->Enum()!=PentaVertexInputEnum){
    3853                         ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
     3853                        _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
    38543854                }
    38553855                vz_input->GetValuesPtr(&vz_ptr,&dummy);
    … …  
    39443944        if (vzmacayeal_input){
    39453945                if (vzmacayeal_input->Enum()!=PentaVertexInputEnum){
    3946                         ISSMERROR("Cannot compute Vel as VzMacAyeal is of type %s",EnumToString(vzmacayeal_input->Enum()));
     3946                        _error_("Cannot compute Vel as VzMacAyeal is of type %s",EnumToString(vzmacayeal_input->Enum()));
    39473947                }
    39483948                vzmacayeal_input->GetValuesPtr(&vzmacayeal_ptr,&dummy);
    … …  
    39503950        }
    39513951        else{
    3952                 ISSMERROR("Cannot update solution as VzMacAyeal is not present");
     3952                _error_("Cannot update solution as VzMacAyeal is not present");
    39533953        }
    39543954
    … …  
    40164016        if (vz_input){
    40174017                if (vz_input->Enum()!=PentaVertexInputEnum){
    4018                         ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
     4018                        _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
    40194019                }
    40204020                vz_input->GetValuesPtr(&vz_ptr,&dummy);
    … …  
    41024102        if (vzpattyn_input){
    41034103                if (vzpattyn_input->Enum()!=PentaVertexInputEnum){
    4104                         ISSMERROR("Cannot compute Vel as VzPattyn is of type %s",EnumToString(vzpattyn_input->Enum()));
     4104                        _error_("Cannot compute Vel as VzPattyn is of type %s",EnumToString(vzpattyn_input->Enum()));
    41054105                }
    41064106                vzpattyn_input->GetValuesPtr(&vzpattyn_ptr,&dummy);
    … …  
    41084108        }
    41094109        else{
    4110                 ISSMERROR("Cannot update solution as VzPattyn is not present");
     4110                _error_("Cannot update solution as VzPattyn is not present");
    41114111        }
    41124112
    … …  
    41744174        if (vz_input){
    41754175                if (vz_input->Enum()!=PentaVertexInputEnum){
    4176                         ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
     4176                        _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
    41774177                }
    41784178                vz_input->GetValuesPtr(&vz_ptr,&dummy);
    … …  
    42514251        Input* vx_input=inputs->GetInput(VxEnum);
    42524252        if (vx_input){
    4253                 if (vx_input->Enum()!=PentaVertexInputEnum) ISSMERROR("Cannot compute Vel as Vx is of type %s",EnumToString(vx_input->Enum()));
     4253                if (vx_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vx is of type %s",EnumToString(vx_input->Enum()));
    42544254                vx_input->GetValuesPtr(&vx_ptr,&dummy);
    42554255                for(i=0;i<NUMVERTICES;i++) vx[i]=vx_ptr[i];
    … …  
    42594259        Input* vy_input=inputs->GetInput(VyEnum);
    42604260        if (vy_input){
    4261                 if (vy_input->Enum()!=PentaVertexInputEnum) ISSMERROR("Cannot compute Vel as Vy is of type %s",EnumToString(vy_input->Enum()));
     4261                if (vy_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as Vy is of type %s",EnumToString(vy_input->Enum()));
    42624262                vy_input->GetValuesPtr(&vy_ptr,&dummy);
    42634263                for(i=0;i<NUMVERTICES;i++) vy[i]=vy_ptr[i];
    … …  
    42694269                Input* vzstokes_input=inputs->GetInput(VzStokesEnum);
    42704270                if (vzstokes_input){
    4271                         if (vzstokes_input->Enum()!=PentaVertexInputEnum) ISSMERROR("Cannot compute Vel as VzStokes is of type %s",EnumToString(vy_input->Enum()));
     4271                        if (vzstokes_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToString(vy_input->Enum()));
    42724272                        vzstokes_input->GetValuesPtr(&vzstokes_ptr,&dummy);
    42734273                        for(i=0;i<NUMVERTICES;i++) vzstokes[i]=vzstokes_ptr[i];
    42744274                }
    4275                 else ISSMERROR("Cannot compute Vz as VzStokes in not present in PattynStokes element");
     4275                else _error_("Cannot compute Vz as VzStokes in not present in PattynStokes element");
    42764276                for(i=0;i<NUMVERTICES;i++){
    42774277                        vzpattyn[i]=vz[i];
    … …  
    42824282                Input* vzstokes_input=inputs->GetInput(VzStokesEnum);
    42834283                if (vzstokes_input){
    4284                         if (vzstokes_input->Enum()!=PentaVertexInputEnum) ISSMERROR("Cannot compute Vel as VzStokes is of type %s",EnumToString(vy_input->Enum()));
     4284                        if (vzstokes_input->Enum()!=PentaVertexInputEnum) _error_("Cannot compute Vel as VzStokes is of type %s",EnumToString(vy_input->Enum()));
    42854285                        vzstokes_input->GetValuesPtr(&vzstokes_ptr,&dummy);
    42864286                        for(i=0;i<NUMVERTICES;i++) vzstokes[i]=vzstokes_ptr[i];
    42874287                }
    4288                 else ISSMERROR("Cannot compute Vz as VzStokes in not present in MacAyealStokes element");
     4288                else _error_("Cannot compute Vz as VzStokes in not present in MacAyealStokes element");
    42894289                for(i=0;i<NUMVERTICES;i++){
    42904290                        vzmacayeal[i]=vz[i];
    … …  
    45364536
    45374537                /* get upper Penta*/
    4538                 penta=penta->GetUpperElement(); ISSMASSERT(penta->Id()!=this->id);
     4538                penta=penta->GetUpperElement(); _assert_(penta->Id()!=this->id);
    45394539        }
    45404540       
    … …  
    45694569                default:
    45704570
    4571                         ISSMERROR("type %i (%s) not implemented yet",type,EnumToString(type));
     4571                        _error_("type %i (%s) not implemented yet",type,EnumToString(type));
    45724572        }
    45734573}
    … …  
    45754575/*FUNCTION Penta::InputUpdateFromVector(int* vector, int name, int type);{{{1*/
    45764576void  Penta::InputUpdateFromVector(int* vector, int name, int type){
    4577         ISSMERROR(" not supported yet!");
     4577        _error_(" not supported yet!");
    45784578}
    45794579/*}}}*/
    45804580/*FUNCTION Penta::InputUpdateFromVector(bool* vector, int name, int type);{{{1*/
    45814581void  Penta::InputUpdateFromVector(bool* vector, int name, int type){
    4582         ISSMERROR(" not supported yet!");
     4582        _error_(" not supported yet!");
    45834583}
    45844584/*}}}*/
    45854585/*FUNCTION Penta::InputUpdateFromVectorDakota(double* vector, int name, int type);{{{1*/
    45864586void  Penta::InputUpdateFromVectorDakota(double* vector, int name, int type){
    4587         ISSMERROR(" not supported yet!");
     4587        _error_(" not supported yet!");
    45884588}
    45894589/*}}}*/
    45904590/*FUNCTION Penta::InputUpdateFromVectorDakota(int* vector, int name, int type);{{{1*/
    45914591void  Penta::InputUpdateFromVectorDakota(int* vector, int name, int type){
    4592         ISSMERROR(" not supported yet!");
     4592        _error_(" not supported yet!");
    45934593}
    45944594/*}}}*/
    45954595/*FUNCTION Penta::InputUpdateFromVectorDakota(bool* vector, int name, int type);{{{1*/
    45964596void  Penta::InputUpdateFromVectorDakota(bool* vector, int name, int type){
    4597         ISSMERROR(" not supported yet!");
     4597        _error_(" not supported yet!");
    45984598}
    45994599/*}}}*/
    … …  
    46644664/*FUNCTION Penta::MassFlux {{{1*/
    46654665double Penta::MassFlux( double* segment,bool process_units){
    4666         ISSMERROR(" not supported yet!");
     4666        _error_(" not supported yet!");
    46674667}
    46684668/*}}}*/
    … …  
    50365036void  Penta::SetClone(int* minranks){
    50375037
    5038         ISSMERROR("not implemented yet");
     5038        _error_("not implemented yet");
    50395039}
    50405040/*}}}1*/
    … …  
    54025402        /*If on water, return 0: */
    54035403        if(IsOnWater())return 0;
    5404         ISSMERROR("Not implemented yet");
     5404        _error_("Not implemented yet");
    54055405
    54065406        tria=(Tria*)SpawnTria(3,4,5); //grids 3, 4 and 5 make the new tria (upper face).
    … …  
    54225422        /*Checks if debuging*/
    54235423        /*{{{2*/
    5424         ISSMASSERT(iomodel->elements);
     5424        _assert_(iomodel->elements);
    54255425        /*}}}*/
    54265426

  • TabularUnified issm/trunk/src/c/objects/Elements/PentaRef.cpp

    r5808 r6412  
    5353void PentaRef::SetElementType(int type,int type_counter){
    5454
    55         ISSMASSERT(type==P1Enum || type==P1DGEnum);
     55        _assert_(type==P1Enum || type==P1DGEnum);
    5656
    5757        /*initialize element type*/
    … …  
    702702        /*Get Determinant*/
    703703        Matrix3x3Determinant(Jdet,&J[0][0]);
    704         if(*Jdet<0) ISSMERROR("negative jacobian determinant!");
     704        if(*Jdet<0) _error_("negative jacobian determinant!");
    705705
    706706}
    … …  
    725725        /*Jdet = norm( AB ^ AC ) / (2 * area of the reference triangle), with areaRef=sqrt(3) */
    726726        *Jdet=SQRT3/6.0*pow(pow(((y2-y1)*(z3-z1)-(z2-z1)*(y3-y1)),2.0)+pow(((z2-z1)*(x3-x1)-(x2-x1)*(z3-z1)),2.0)+pow(((x2-x1)*(y3-y1)-(y2-y1)*(x3-x1)),2.0),0.5);
    727         if(*Jdet<0) ISSMERROR("negative jacobian determinant!");
     727        if(*Jdet<0) _error_("negative jacobian determinant!");
    728728
    729729}
    … …  
    744744
    745745        *Jdet=1.0/2.0*sqrt(pow(x2-x1,2.) + pow(y2-y1,2.) + pow(z2-z1,2.));
    746         if(*Jdet<0) ISSMERROR("negative jacobian determinant!");
     746        if(*Jdet<0) _error_("negative jacobian determinant!");
    747747
    748748}
    … …  
    902902        double A1,A2,A3,z;
    903903
    904         A1=gauss->coord1; ISSMASSERT(A1>=0 && A1<=1);//first area coordinate value. In term of xi and eta: A1=(1-xi)/2-eta/(2*SQRT3);
    905         A2=gauss->coord2; ISSMASSERT(A2>=0 && A2<=1);//second area coordinate value In term of xi and eta: A2=(1+xi)/2-eta/(2*SQRT3);
    906         A3=gauss->coord3; ISSMASSERT(A3>=0 && A3<=1);//third area coordinate value  In term of xi and eta: A3=y/SQRT3;
    907         z =gauss->coord4; ISSMASSERT(z>=-1 &&  z<=1);//fourth vertical coordinate value. Corresponding nodal function: (1-z)/2 and (1+z)/2
     904        A1=gauss->coord1; _assert_(A1>=0 && A1<=1);//first area coordinate value. In term of xi and eta: A1=(1-xi)/2-eta/(2*SQRT3);
     905        A2=gauss->coord2; _assert_(A2>=0 && A2<=1);//second area coordinate value In term of xi and eta: A2=(1+xi)/2-eta/(2*SQRT3);
     906        A3=gauss->coord3; _assert_(A3>=0 && A3<=1);//third area coordinate value  In term of xi and eta: A3=y/SQRT3;
     907        z =gauss->coord4; _assert_(z>=-1 &&  z<=1);//fourth vertical coordinate value. Corresponding nodal function: (1-z)/2 and (1+z)/2
    908908
    909909        /*First nodal function derivatives. The corresponding nodal function is N=A1*(1-z)/2. Its derivatives follow*/
    … …  
    946946        GetNodalFunctionsP1(&BasisFunctions[0],gauss);
    947947
    948         ISSMASSERT(index1>=0 && index1<6);
    949         ISSMASSERT(index2>=0 && index2<6);
    950         ISSMASSERT(index3>=0 && index3<6);
    951         ISSMASSERT(index4>=0 && index4<6);
     948        _assert_(index1>=0 && index1<6);
     949        _assert_(index2>=0 && index2<6);
     950        _assert_(index3>=0 && index3<6);
     951        _assert_(index4>=0 && index4<6);
    952952
    953953        l1l4[0]=BasisFunctions[index1];
    … …  
    980980        /*Area of a trabezoid = altitude * (base1 + base2)/2 */
    981981        *Jdet= pow(pow(x2-x1,2.) + pow(y2-y1,2.),0.5) * (z4-z1 + z3-z2)/8;
    982         if(*Jdet<0) ISSMERROR("negative jacobian determinant!");
     982        if(*Jdet<0) _error_("negative jacobian determinant!");
    983983
    984984}

  • TabularUnified issm/trunk/src/c/objects/Elements/PentaRef.h

    r5808 r6412  
    5050                void GetLprimeStokes(double* LprimeStokes, double* xyz_list, GaussPenta* gauss);
    5151                void GetParameterValue(double* pvalue,double* plist, GaussPenta* gauss);
    52                 void GetParameterValue(double* pvalue,double* plist,GaussTria* gauss){ISSMERROR("only PentaGauss are supported");};
     52                void GetParameterValue(double* pvalue,double* plist,GaussTria* gauss){_error_("only PentaGauss are supported");};
    5353                void GetParameterDerivativeValue(double* pvalues, double* plist,double* xyz_list, GaussPenta* gauss);
    54                 void GetParameterDerivativeValue(double* pvalues, double* plist,double* xyz_list, GaussTria* gauss){ISSMERROR("only PentaGauss are supported");};
     54                void GetParameterDerivativeValue(double* pvalues, double* plist,double* xyz_list, GaussTria* gauss){_error_("only PentaGauss are supported");};
    5555
    5656};

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

    r6410 r6412  
    305305
    306306        /*Checks in debugging mode{{{2*/
    307         ISSMASSERT(this->nodes && this->matice && this->matpar && this->parameters && this->inputs);
     307        _assert_(this->nodes && this->matice && this->matpar && this->parameters && this->inputs);
    308308        /*}}}*/
    309309
    … …  
    332332                        break;
    333333                default:
    334                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     334                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    335335        }
    336336
    … …  
    356356                        break;
    357357                default:
    358                         ISSMERROR("Element type %s not supported yet",EnumToString(GetElementType()));
     358                        _error_("Element type %s not supported yet",EnumToString(GetElementType()));
    359359        }
    360360
    … …  
    373373                        return CreateKMatrixBalancedthickness_DG();
    374374                default:
    375                         ISSMERROR("Element type %s not supported yet",EnumToString(GetElementType()));
     375                        _error_("Element type %s not supported yet",EnumToString(GetElementType()));
    376376        }
    377377
    … …  
    414414        Input* vyaverage_input=NULL;
    415415        if(dim==2){
    416                 vxaverage_input=inputs->GetInput(VxEnum); ISSMASSERT(vxaverage_input);
    417                 vyaverage_input=inputs->GetInput(VyEnum); ISSMASSERT(vyaverage_input);
     416                vxaverage_input=inputs->GetInput(VxEnum); _assert_(vxaverage_input);
     417                vyaverage_input=inputs->GetInput(VyEnum); _assert_(vyaverage_input);
    418418        }
    419419        else{
    420                 vxaverage_input=inputs->GetInput(VxAverageEnum); ISSMASSERT(vxaverage_input);
    421                 vyaverage_input=inputs->GetInput(VyAverageEnum); ISSMASSERT(vyaverage_input);
     420                vxaverage_input=inputs->GetInput(VxAverageEnum); _assert_(vxaverage_input);
     421                vyaverage_input=inputs->GetInput(VyAverageEnum); _assert_(vyaverage_input);
    422422        }
    423423
    … …  
    515515        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    516516        this->parameters->FindParam(&dim,DimEnum);
    517         Input* vx_input=inputs->GetInput(VxEnum); ISSMASSERT(vx_input);
    518         Input* vy_input=inputs->GetInput(VyEnum); ISSMASSERT(vy_input);
     517        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
     518        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    519519
    520520        /*Start looping on the number of gaussian points:*/
    … …  
    583583        this->parameters->FindParam(&artdiff,ArtDiffEnum);
    584584        this->parameters->FindParam(&dim,DimEnum);
    585         Input* surface_input=inputs->GetInput(SurfaceEnum); ISSMASSERT(surface_input);
     585        Input* surface_input=inputs->GetInput(SurfaceEnum); _assert_(surface_input);
    586586        Input* vxaverage_input=NULL;
    587587        Input* vyaverage_input=NULL;
    588588        if(dim==2){
    589                 vxaverage_input=inputs->GetInput(VxEnum); ISSMASSERT(vxaverage_input);
    590                 vyaverage_input=inputs->GetInput(VyEnum); ISSMASSERT(vyaverage_input);
     589                vxaverage_input=inputs->GetInput(VxEnum); _assert_(vxaverage_input);
     590                vyaverage_input=inputs->GetInput(VyEnum); _assert_(vyaverage_input);
    591591        }
    592592        else{
    593                 vxaverage_input=inputs->GetInput(VxAverageEnum); ISSMASSERT(vxaverage_input);
    594                 vyaverage_input=inputs->GetInput(VyAverageEnum); ISSMASSERT(vyaverage_input);
     593                vxaverage_input=inputs->GetInput(VxAverageEnum); _assert_(vxaverage_input);
     594                vyaverage_input=inputs->GetInput(VyAverageEnum); _assert_(vyaverage_input);
    595595        }
    596596
    … …  
    713713        /*Retrieve all inputs and parameters*/
    714714        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    715         Input* thickness_input=inputs->GetInput(ThicknessEnum); ISSMASSERT(thickness_input);
    716         Input* vx_input=inputs->GetInput(VxEnum);               ISSMASSERT(vx_input);
    717         Input* vy_input=inputs->GetInput(VyEnum);               ISSMASSERT(vy_input);
    718         Input* vxold_input=inputs->GetInput(VxOldEnum);         ISSMASSERT(vxold_input);
    719         Input* vyold_input=inputs->GetInput(VyOldEnum);         ISSMASSERT(vyold_input);
     715        Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
     716        Input* vx_input=inputs->GetInput(VxEnum);               _assert_(vx_input);
     717        Input* vy_input=inputs->GetInput(VyEnum);               _assert_(vy_input);
     718        Input* vxold_input=inputs->GetInput(VxOldEnum);         _assert_(vxold_input);
     719        Input* vyold_input=inputs->GetInput(VyOldEnum);         _assert_(vyold_input);
    720720        this->parameters->FindParam(&viscosity_overshoot,ViscosityOvershootEnum);
    721721
    … …  
    781781        /*Retrieve all inputs and parameters*/
    782782        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    783         Input* surface_input=inputs->GetInput(SurfaceEnum); ISSMASSERT(surface_input);
    784         Input* vx_input=inputs->GetInput(VxEnum);           ISSMASSERT(vx_input);
    785         Input* vy_input=inputs->GetInput(VyEnum);           ISSMASSERT(vy_input);
    786         Input* vz_input=inputs->GetInput(VzEnum);           ISSMASSERT(vz_input);
     783        Input* surface_input=inputs->GetInput(SurfaceEnum); _assert_(surface_input);
     784        Input* vx_input=inputs->GetInput(VxEnum);           _assert_(vx_input);
     785        Input* vy_input=inputs->GetInput(VyEnum);           _assert_(vy_input);
     786        Input* vz_input=inputs->GetInput(VzEnum);           _assert_(vz_input);
    787787        inputs->GetParameterValue(&drag_type,DragTypeEnum);
    788788        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    789789
    790790        /*build friction object, used later on: */
    791         if (drag_type!=2) ISSMERROR(" non-viscous friction not supported yet!");
     791        if (drag_type!=2) _error_(" non-viscous friction not supported yet!");
    792792        friction=new Friction("2d",inputs,matpar,analysis_type);
    793793
    … …  
    857857        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    858858        inputs->GetParameterValue(&drag_type,DragTypeEnum);
    859         Input* surface_input=inputs->GetInput(SurfaceEnum); ISSMASSERT(surface_input);
    860         Input* vx_input=inputs->GetInput(VxEnum);           ISSMASSERT(vx_input);
    861         Input* vy_input=inputs->GetInput(VyEnum);           ISSMASSERT(vy_input);
    862         Input* vz_input=inputs->GetInput(VzEnum);           ISSMASSERT(vz_input);
     859        Input* surface_input=inputs->GetInput(SurfaceEnum); _assert_(surface_input);
     860        Input* vx_input=inputs->GetInput(VxEnum);           _assert_(vx_input);
     861        Input* vy_input=inputs->GetInput(VyEnum);           _assert_(vy_input);
     862        Input* vz_input=inputs->GetInput(VzEnum);           _assert_(vz_input);
    863863
    864864        /*build friction object, used later on: */
    865         if (drag_type!=2)ISSMERROR(" non-viscous friction not supported yet!");
     865        if (drag_type!=2)_error_(" non-viscous friction not supported yet!");
    866866        friction=new Friction("2d",inputs,matpar,analysis_type);
    867867
    … …  
    943943        parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    944944        inputs->GetParameterValue(&drag_type,DragTypeEnum);
    945         Input* surface_input=inputs->GetInput(SurfaceEnum); ISSMASSERT(surface_input);
    946         Input* vx_input=inputs->GetInput(VxEnum);           ISSMASSERT(vx_input);
    947         Input* vy_input=inputs->GetInput(VyEnum);           ISSMASSERT(vy_input);
    948         Input* vz_input=inputs->GetInput(VzEnum);           ISSMASSERT(vz_input);
     945        Input* surface_input=inputs->GetInput(SurfaceEnum); _assert_(surface_input);
     946        Input* vx_input=inputs->GetInput(VxEnum);           _assert_(vx_input);
     947        Input* vy_input=inputs->GetInput(VyEnum);           _assert_(vy_input);
     948        Input* vz_input=inputs->GetInput(VzEnum);           _assert_(vz_input);
    949949
    950950        /*build friction object, used later on: */
    951         if (drag_type!=2)ISSMERROR(" non-viscous friction not supported yet!");
     951        if (drag_type!=2)_error_(" non-viscous friction not supported yet!");
    952952        friction=new Friction("2d",inputs,matpar,analysis_type);
    953953
    … …  
    11161116                        return CreateKMatrixPrognostic_DG();
    11171117                default:
    1118                         ISSMERROR("Element type %s not supported yet",EnumToString(GetElementType()));
     1118                        _error_("Element type %s not supported yet",EnumToString(GetElementType()));
    11191119        }
    11201120
    … …  
    11591159        Input* vyaverage_input=NULL;
    11601160        if(dim==2){
    1161                 vxaverage_input=inputs->GetInput(VxEnum); ISSMASSERT(vxaverage_input);
    1162                 vyaverage_input=inputs->GetInput(VyEnum); ISSMASSERT(vyaverage_input);
     1161                vxaverage_input=inputs->GetInput(VxEnum); _assert_(vxaverage_input);
     1162                vyaverage_input=inputs->GetInput(VyEnum); _assert_(vyaverage_input);
    11631163        }
    11641164        else{
    1165                 vxaverage_input=inputs->GetInput(VxAverageEnum); ISSMASSERT(vxaverage_input);
    1166                 vyaverage_input=inputs->GetInput(VyAverageEnum); ISSMASSERT(vyaverage_input);
     1165                vxaverage_input=inputs->GetInput(VxAverageEnum); _assert_(vxaverage_input);
     1166                vyaverage_input=inputs->GetInput(VyAverageEnum); _assert_(vyaverage_input);
    11671167        }
    11681168
    … …  
    12771277        Input* vyaverage_input=NULL;
    12781278        if(dim==2){
    1279                 vxaverage_input=inputs->GetInput(VxEnum); ISSMASSERT(vxaverage_input);
    1280                 vyaverage_input=inputs->GetInput(VyEnum); ISSMASSERT(vyaverage_input);
     1279                vxaverage_input=inputs->GetInput(VxEnum); _assert_(vxaverage_input);
     1280                vyaverage_input=inputs->GetInput(VyEnum); _assert_(vyaverage_input);
    12811281        }
    12821282        else{
    1283                 vxaverage_input=inputs->GetInput(VxAverageEnum); ISSMASSERT(vxaverage_input);
    1284                 vyaverage_input=inputs->GetInput(VyAverageEnum); ISSMASSERT(vyaverage_input);
     1283                vxaverage_input=inputs->GetInput(VxAverageEnum); _assert_(vxaverage_input);
     1284                vyaverage_input=inputs->GetInput(VyAverageEnum); _assert_(vyaverage_input);
    12851285        }
    12861286
    … …  
    14361436        /*asserts: {{{*/
    14371437        /*if debugging mode, check that all pointers exist*/
    1438         ISSMASSERT(this->nodes && this->matice && this->matpar && this->parameters && this->inputs);
     1438        _assert_(this->nodes && this->matice && this->matpar && this->parameters && this->inputs);
    14391439        /*}}}*/
    14401440
    … …  
    14661466                        break;
    14671467                default:
    1468                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     1468                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    14691469        }
    14701470
    … …  
    14861486                        return CreatePVectorBalancedthickness_DG();
    14871487                default:
    1488                         ISSMERROR("Element type %s not supported yet",EnumToString(GetElementType()));
     1488                        _error_("Element type %s not supported yet",EnumToString(GetElementType()));
    14891489        }
    14901490}
    … …  
    15091509        /*Retrieve all inputs and parameters*/
    15101510        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    1511         Input* accumulation_input=inputs->GetInput(AccumulationRateEnum); ISSMASSERT(accumulation_input);
    1512         Input* melting_input=inputs->GetInput(MeltingRateEnum);           ISSMASSERT(melting_input);
    1513         Input* dhdt_input=inputs->GetInput(DhDtEnum);                     ISSMASSERT(dhdt_input);
     1511        Input* accumulation_input=inputs->GetInput(AccumulationRateEnum); _assert_(accumulation_input);
     1512        Input* melting_input=inputs->GetInput(MeltingRateEnum);           _assert_(melting_input);
     1513        Input* dhdt_input=inputs->GetInput(DhDtEnum);                     _assert_(dhdt_input);
    15141514       
    15151515        /* Start  looping on the number of gaussian points: */
    … …  
    15531553        /*Retrieve all inputs and parameters*/
    15541554        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    1555         Input* accumulation_input=inputs->GetInput(AccumulationRateEnum); ISSMASSERT(accumulation_input);
    1556         Input* melting_input=inputs->GetInput(MeltingRateEnum);           ISSMASSERT(melting_input);
    1557         Input* dhdt_input=inputs->GetInput(DhDtEnum);                     ISSMASSERT(dhdt_input);
     1555        Input* accumulation_input=inputs->GetInput(AccumulationRateEnum); _assert_(accumulation_input);
     1556        Input* melting_input=inputs->GetInput(MeltingRateEnum);           _assert_(melting_input);
     1557        Input* dhdt_input=inputs->GetInput(DhDtEnum);                     _assert_(dhdt_input);
    15581558
    15591559        /* Start  looping on the number of gaussian points: */
    … …  
    15971597        /*Retrieve all inputs and parameters*/
    15981598        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    1599         Input* accumulation_input=inputs->GetInput(AccumulationRateEnum); ISSMASSERT(accumulation_input);
    1600         Input* melting_input=inputs->GetInput(MeltingRateEnum);           ISSMASSERT(melting_input);
     1599        Input* accumulation_input=inputs->GetInput(AccumulationRateEnum); _assert_(accumulation_input);
     1600        Input* melting_input=inputs->GetInput(MeltingRateEnum);           _assert_(melting_input);
    16011601
    16021602        /* Start  looping on the number of gaussian points: */
    … …  
    16431643        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    16441644        inputs->GetParameterValue(&approximation,ApproximationEnum);
    1645         Input* bed_input=inputs->GetInput(BedEnum);             ISSMASSERT(bed_input);
    1646         Input* melting_input=inputs->GetInput(MeltingRateEnum); ISSMASSERT(melting_input);
    1647         Input* vx_input=inputs->GetInput(VxEnum);               ISSMASSERT(vx_input);
    1648         Input* vy_input=inputs->GetInput(VyEnum);               ISSMASSERT(vy_input);
     1645        Input* bed_input=inputs->GetInput(BedEnum);             _assert_(bed_input);
     1646        Input* melting_input=inputs->GetInput(MeltingRateEnum); _assert_(melting_input);
     1647        Input* vx_input=inputs->GetInput(VxEnum);               _assert_(vx_input);
     1648        Input* vy_input=inputs->GetInput(VyEnum);               _assert_(vy_input);
    16491649        Input* vzstokes_input=NULL;
    16501650        if(approximation==PattynStokesApproximationEnum){
    1651                 vzstokes_input=inputs->GetInput(VzStokesEnum);       ISSMASSERT(vzstokes_input);
     1651                vzstokes_input=inputs->GetInput(VzStokesEnum);       _assert_(vzstokes_input);
    16521652        }
    16531653
    … …  
    17041704        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    17051705        inputs->GetParameterValue(&drag_type,DragTypeEnum);
    1706         Input* thickness_input=inputs->GetInput(ThicknessEnum); ISSMASSERT(thickness_input);
    1707         Input* surface_input=inputs->GetInput(SurfaceEnum);     ISSMASSERT(surface_input);
    1708         Input* drag_input=inputs->GetInput(DragCoefficientEnum);ISSMASSERT(drag_input);
     1706        Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
     1707        Input* surface_input=inputs->GetInput(SurfaceEnum);     _assert_(surface_input);
     1708        Input* drag_input=inputs->GetInput(DragCoefficientEnum);_assert_(drag_input);
    17091709
    17101710        /* Start  looping on the number of gaussian points: */
    … …  
    17681768        /*Retrieve all inputs and parameters*/
    17691769        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    1770         Input* thickness_input   =inputs->GetInput(ThicknessEnum);   ISSMASSERT(thickness_input);
    1771         Input* thicknessobs_input=inputs->GetInput(ThicknessObsEnum);ISSMASSERT(thicknessobs_input);
    1772         Input* weights_input     =inputs->GetInput(WeightsEnum);     ISSMASSERT(weights_input);
     1770        Input* thickness_input   =inputs->GetInput(ThicknessEnum);   _assert_(thickness_input);
     1771        Input* thicknessobs_input=inputs->GetInput(ThicknessObsEnum);_assert_(thicknessobs_input);
     1772        Input* weights_input     =inputs->GetInput(WeightsEnum);     _assert_(weights_input);
    17731773
    17741774        /* Start  looping on the number of gaussian points: */
    … …  
    19431943        else{
    19441944                /*Not supported yet! : */
    1945                 ISSMERROR("response %s not supported yet",EnumToString(response));
     1945                _error_("response %s not supported yet",EnumToString(response));
    19461946        }
    19471947
    … …  
    21242124        else{
    21252125                /*Not supported yet! : */
    2126                 ISSMERROR("response %s not supported yet",EnumToString(response));
     2126                _error_("response %s not supported yet",EnumToString(response));
    21272127        }
    21282128
    … …  
    21762176        n=matice->GetN();
    21772177        B=matice->GetBbar();
    2178         Input* slopex_input=inputs->GetInput(SurfaceSlopeXEnum); ISSMASSERT(slopex_input);
    2179         Input* slopey_input=inputs->GetInput(SurfaceSlopeYEnum); ISSMASSERT(slopey_input);
    2180         Input* thickness_input=inputs->GetInput(ThicknessEnum);  ISSMASSERT(thickness_input);
     2178        Input* slopex_input=inputs->GetInput(SurfaceSlopeXEnum); _assert_(slopex_input);
     2179        Input* slopey_input=inputs->GetInput(SurfaceSlopeYEnum); _assert_(slopey_input);
     2180        Input* thickness_input=inputs->GetInput(ThicknessEnum);  _assert_(thickness_input);
    21812181
    21822182        /*Spawn 3 sing elements: */
    … …  
    22162216                        return CreatePVectorPrognostic_DG();
    22172217                default:
    2218                         ISSMERROR("Element type %s not supported yet",EnumToString(GetElementType()));
     2218                        _error_("Element type %s not supported yet",EnumToString(GetElementType()));
    22192219        }
    22202220}
    … …  
    22412241        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    22422242        this->parameters->FindParam(&dt,DtEnum);
    2243         Input* accumulation_input=inputs->GetInput(AccumulationRateEnum); ISSMASSERT(accumulation_input);
    2244         Input* melting_input=inputs->GetInput(MeltingRateEnum);           ISSMASSERT(melting_input);
    2245         Input* thickness_input=inputs->GetInput(ThicknessEnum);           ISSMASSERT(thickness_input);
     2243        Input* accumulation_input=inputs->GetInput(AccumulationRateEnum); _assert_(accumulation_input);
     2244        Input* melting_input=inputs->GetInput(MeltingRateEnum);           _assert_(melting_input);
     2245        Input* thickness_input=inputs->GetInput(ThicknessEnum);           _assert_(thickness_input);
    22462246
    22472247        /* Start  looping on the number of gaussian points: */
    … …  
    22872287        this->parameters->FindParam(&dt,DtEnum);
    22882288        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICES);
    2289         Input* accumulation_input=inputs->GetInput(AccumulationRateEnum); ISSMASSERT(accumulation_input);
    2290         Input* melting_input=inputs->GetInput(MeltingRateEnum);           ISSMASSERT(melting_input);
    2291         Input* thickness_input=inputs->GetInput(ThicknessEnum);           ISSMASSERT(thickness_input);
     2289        Input* accumulation_input=inputs->GetInput(AccumulationRateEnum); _assert_(accumulation_input);
     2290        Input* melting_input=inputs->GetInput(MeltingRateEnum);           _assert_(melting_input);
     2291        Input* thickness_input=inputs->GetInput(ThicknessEnum);           _assert_(thickness_input);
    22922292
    22932293        /* Start  looping on the number of gaussian points: */
    … …  
    23362336        Input* slope_input=NULL;
    23372337        if ( (analysis_type==SurfaceSlopeXAnalysisEnum) || (analysis_type==SurfaceSlopeYAnalysisEnum)){
    2338                 slope_input=inputs->GetInput(SurfaceEnum); ISSMASSERT(slope_input);
     2338                slope_input=inputs->GetInput(SurfaceEnum); _assert_(slope_input);
    23392339        }
    23402340        if ( (analysis_type==BedSlopeXAnalysisEnum) || (analysis_type==BedSlopeYAnalysisEnum)){
    2341                 slope_input=inputs->GetInput(BedEnum);     ISSMASSERT(slope_input);
     2341                slope_input=inputs->GetInput(BedEnum);     _assert_(slope_input);
    23422342        }
    23432343               
    … …  
    23962396        meltingpoint=matpar->GetMeltingPoint();
    23972397        this->parameters->FindParam(&dt,DtEnum);
    2398         Input* pressure_input=inputs->GetInput(PressureEnum); ISSMASSERT(pressure_input);
     2398        Input* pressure_input=inputs->GetInput(PressureEnum); _assert_(pressure_input);
    23992399
    24002400        /* Start looping on the number of gauss 2d (nodes on the bedrock) */
    … …  
    24502450        heatcapacity=matpar->GetHeatCapacity();
    24512451        this->inputs->GetParameterValue(&dt,DtEnum);
    2452         Input* vx_input=inputs->GetInput(VxEnum);                         ISSMASSERT(vx_input);
    2453         Input* vy_input=inputs->GetInput(VyEnum);                         ISSMASSERT(vy_input);
    2454         Input* vz_input=inputs->GetInput(VzEnum);                         ISSMASSERT(vz_input);
    2455         Input* geothermalflux_input=inputs->GetInput(GeothermalFluxEnum); ISSMASSERT(geothermalflux_input);
     2452        Input* vx_input=inputs->GetInput(VxEnum);                         _assert_(vx_input);
     2453        Input* vy_input=inputs->GetInput(VyEnum);                         _assert_(vy_input);
     2454        Input* vz_input=inputs->GetInput(VzEnum);                         _assert_(vz_input);
     2455        Input* geothermalflux_input=inputs->GetInput(GeothermalFluxEnum); _assert_(geothermalflux_input);
    24562456
    24572457        /*Build frictoin element, needed later: */
    24582458        inputs->GetParameterValue(&drag_type,DragTypeEnum);
    2459         if (drag_type!=2)ISSMERROR(" non-viscous friction not supported yet!");
     2459        if (drag_type!=2)_error_(" non-viscous friction not supported yet!");
    24602460        friction=new Friction("3d",inputs,matpar,analysis_type);
    24612461
    … …  
    24892489/*FUNCTION Tria::ComputeBasalStress {{{1*/
    24902490void  Tria::ComputeBasalStress(Vec eps){
    2491         ISSMERROR("Not Implemented yet");
     2491        _error_("Not Implemented yet");
    24922492}
    24932493/*}}}*/
    24942494/*FUNCTION Tria::ComputeStrainRate {{{1*/
    24952495void  Tria::ComputeStrainRate(Vec eps){
    2496         ISSMERROR("Not Implemented yet");
     2496        _error_("Not Implemented yet");
    24972497}
    24982498/*}}}*/
    … …  
    25362536                input=inputs->GetInput(enum_type);
    25372537        }
    2538         if (!input) ISSMERROR("Input %s not found",EnumToString(enum_type));
    2539         if (input->Enum()!=ControlInputEnum) ISSMERROR("Input %s is not a ControlInput",EnumToString(enum_type));
     2538        if (!input) _error_("Input %s not found",EnumToString(enum_type));
     2539        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
    25402540
    25412541        this->GetDofList1(&doflist1[0]);
    … …  
    25542554                input=inputs->GetInput(enum_type);
    25552555        }
    2556         if (!input) ISSMERROR("Input %s not found",EnumToString(enum_type));
    2557         if (input->Enum()!=ControlInputEnum) ISSMERROR("Input %s is not a ControlInput",EnumToString(enum_type));
     2556        if (!input) _error_("Input %s not found",EnumToString(enum_type));
     2557        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
    25582558
    25592559        ((ControlInput*)input)->ScaleGradient(scale);
    … …  
    25732573                input=inputs->GetInput(enum_type);
    25742574        }
    2575         if (!input) ISSMERROR("Input %s not found",EnumToString(enum_type));
    2576         if (input->Enum()!=ControlInputEnum) ISSMERROR("Input %s is not a ControlInput",EnumToString(enum_type));
     2575        if (!input) _error_("Input %s not found",EnumToString(enum_type));
     2576        if (input->Enum()!=ControlInputEnum) _error_("Input %s is not a ControlInput",EnumToString(enum_type));
    25772577
    25782578        this->GetDofList1(&doflist1[0]);
    … …  
    27182718int Tria::GetNodeIndex(Node* node){
    27192719
    2720         ISSMASSERT(nodes);
     2720        _assert_(nodes);
    27212721        for(int i=0;i<NUMVERTICES;i++){
    27222722                if(node==nodes[i])
    27232723                 return i;
    27242724        }
    2725         ISSMERROR("Node provided not found among element nodes");
     2725        _error_("Node provided not found among element nodes");
    27262726}
    27272727/*}}}*/
    … …  
    27352735        /*Recover input*/
    27362736        Input* input=inputs->GetInput(enumtype);
    2737         if (!input) ISSMERROR("Input %s not found in element",EnumToString(enumtype));
     2737        if (!input) _error_("Input %s not found in element",EnumToString(enumtype));
    27382738
    27392739        /*Checks in debugging mode*/
    2740         ISSMASSERT(pvalue);
     2740        _assert_(pvalue);
    27412741
    27422742        /* Start looping on the number of vertices: */
    … …  
    27592759
    27602760        /*Checks in debugging mode*/
    2761         ISSMASSERT(pvalue);
     2761        _assert_(pvalue);
    27622762
    27632763        /* Start looping on the number of vertices: */
    … …  
    27812781
    27822782        Input* input=inputs->GetInput(enumtype);
    2783         if(!input) ISSMERROR("No input of type %s found in tria",EnumToString(enumtype));
     2783        if(!input) _error_("No input of type %s found in tria",EnumToString(enumtype));
    27842784
    27852785        GaussTria* gauss=new GaussTria();
    … …  
    28112811         GetSolutionFromInputsDiagnosticHutter(solution);
    28122812        else
    2813          ISSMERROR("analysis: %s not supported yet",EnumToString(analysis_type));
     2813         _error_("analysis: %s not supported yet",EnumToString(analysis_type));
    28142814
    28152815}
    … …  
    28302830
    28312831        /*Get inputs*/
    2832         Input* vx_input=inputs->GetInput(VxEnum); ISSMASSERT(vx_input);
    2833         Input* vy_input=inputs->GetInput(VyEnum); ISSMASSERT(vy_input);
     2832        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
     2833        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    28342834
    28352835        /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
    … …  
    28692869
    28702870        /*Get inputs*/
    2871         Input* vx_input=inputs->GetInput(VxEnum); ISSMASSERT(vx_input);
    2872         Input* vy_input=inputs->GetInput(VyEnum); ISSMASSERT(vy_input);
     2871        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
     2872        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    28732873
    28742874        /*Ok, we have vx and vy in values, fill in vx and vy arrays: */
    … …  
    29042904        /*Check that both inputs have been found*/
    29052905        if (!vx_input || !vy_input){
    2906                 ISSMERROR("Input missing. Here are the input pointers we have for vx: %p, vy: %p\n",vx_input,vy_input);
     2906                _error_("Input missing. Here are the input pointers we have for vx: %p, vy: %p\n",vx_input,vy_input);
    29072907        }
    29082908
    … …  
    29552955                        break;
    29562956                default:
    2957                         ISSMERROR("%s%i","control type not supported yet: ",control_type);
     2957                        _error_("%s%i","control type not supported yet: ",control_type);
    29582958        }
    29592959}
    … …  
    29832983
    29842984        /*Retrieve all inputs*/
    2985         Input* thickness_input=inputs->GetInput(ThicknessEnum);            ISSMASSERT(thickness_input);
    2986         Input* vx_input=inputs->GetInput(VxEnum);                          ISSMASSERT(vx_input);
    2987         Input* vy_input=inputs->GetInput(VyEnum);                          ISSMASSERT(vy_input);
    2988         Input* adjointx_input=inputs->GetInput(AdjointxEnum);              ISSMASSERT(adjointx_input);
    2989         Input* adjointy_input=inputs->GetInput(AdjointyEnum);              ISSMASSERT(adjointy_input);
    2990         Input* rheologyb_input=matice->inputs->GetInput(RheologyBbarEnum); ISSMASSERT(rheologyb_input);
     2985        Input* thickness_input=inputs->GetInput(ThicknessEnum);            _assert_(thickness_input);
     2986        Input* vx_input=inputs->GetInput(VxEnum);                          _assert_(vx_input);
     2987        Input* vy_input=inputs->GetInput(VyEnum);                          _assert_(vy_input);
     2988        Input* adjointx_input=inputs->GetInput(AdjointxEnum);              _assert_(adjointx_input);
     2989        Input* adjointy_input=inputs->GetInput(AdjointyEnum);              _assert_(adjointy_input);
     2990        Input* rheologyb_input=matice->inputs->GetInput(RheologyBbarEnum); _assert_(rheologyb_input);
    29912991
    29922992        /* Start  looping on the number of gaussian points: */
    … …  
    30573057
    30583058        /*Retrieve all inputs we will be needing: */
    3059         Input* adjointx_input=inputs->GetInput(AdjointxEnum);               ISSMASSERT(adjointx_input);
    3060         Input* adjointy_input=inputs->GetInput(AdjointyEnum);               ISSMASSERT(adjointy_input);
    3061         Input* vx_input=inputs->GetInput(VxEnum);                           ISSMASSERT(vx_input);
    3062         Input* vy_input=inputs->GetInput(VyEnum);                           ISSMASSERT(vy_input);
    3063         Input* dragcoefficient_input=inputs->GetInput(DragCoefficientEnum); ISSMASSERT(dragcoefficient_input);
     3059        Input* adjointx_input=inputs->GetInput(AdjointxEnum);               _assert_(adjointx_input);
     3060        Input* adjointy_input=inputs->GetInput(AdjointyEnum);               _assert_(adjointy_input);
     3061        Input* vx_input=inputs->GetInput(VxEnum);                           _assert_(vx_input);
     3062        Input* vy_input=inputs->GetInput(VyEnum);                           _assert_(vy_input);
     3063        Input* dragcoefficient_input=inputs->GetInput(DragCoefficientEnum); _assert_(dragcoefficient_input);
    30643064
    30653065        /* Start  looping on the number of gaussian points: */
    … …  
    31303130        /*retrieve inputs :*/
    31313131        inputs->GetParameterValue(&drag_type,DragTypeEnum);
    3132         Input* drag_input    =inputs->GetInput(DragCoefficientEnum); ISSMASSERT(drag_input);
    3133         Input* vx_input      =inputs->GetInput(VxEnum);              ISSMASSERT(vx_input);
    3134         Input* vy_input      =inputs->GetInput(VyEnum);              ISSMASSERT(vy_input);
    3135         Input* vz_input      =inputs->GetInput(VzEnum);              ISSMASSERT(vz_input);
    3136         Input* adjointx_input=inputs->GetInput(AdjointxEnum);        ISSMASSERT(adjointx_input);
    3137         Input* adjointy_input=inputs->GetInput(AdjointyEnum);        ISSMASSERT(adjointy_input);
    3138         Input* adjointz_input=inputs->GetInput(AdjointzEnum);        ISSMASSERT(adjointz_input);
     3132        Input* drag_input    =inputs->GetInput(DragCoefficientEnum); _assert_(drag_input);
     3133        Input* vx_input      =inputs->GetInput(VxEnum);              _assert_(vx_input);
     3134        Input* vy_input      =inputs->GetInput(VyEnum);              _assert_(vy_input);
     3135        Input* vz_input      =inputs->GetInput(VzEnum);              _assert_(vz_input);
     3136        Input* adjointx_input=inputs->GetInput(AdjointxEnum);        _assert_(adjointx_input);
     3137        Input* adjointy_input=inputs->GetInput(AdjointyEnum);        _assert_(adjointy_input);
     3138        Input* adjointz_input=inputs->GetInput(AdjointzEnum);        _assert_(adjointz_input);
    31393139
    31403140        /*retrieve some parameters: */
    … …  
    32523252        /*Retrieve all inputs we will be needing: */
    32533253        this->parameters->FindParam(&cm_noisedmp,CmNoiseDmpEnum);
    3254         Input* adjoint_input=inputs->GetInput(AdjointEnum);     ISSMASSERT(adjoint_input);
    3255         Input* thickness_input=inputs->GetInput(ThicknessEnum); ISSMASSERT(thickness_input);
     3254        Input* adjoint_input=inputs->GetInput(AdjointEnum);     _assert_(adjoint_input);
     3255        Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    32563256
    32573257        /* Start  looping on the number of gaussian points: */
    … …  
    33013301
    33023302        /*Retrieve all inputs we will be needing: */
    3303         Input* adjoint_input=inputs->GetInput(AdjointEnum);     ISSMASSERT(adjoint_input);
    3304         Input* thickness_input=inputs->GetInput(ThicknessEnum); ISSMASSERT(thickness_input);
     3303        Input* adjoint_input=inputs->GetInput(AdjointEnum);     _assert_(adjoint_input);
     3304        Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    33053305
    33063306        /* Start  looping on the number of gaussian points: */
    … …  
    33443344        /*Make a copy of the original input: */
    33453345        input=(Input*)this->inputs->GetInput(enum_type);
    3346         if(!input)ISSMERROR(" could not find old input with enum: %s",EnumToString(enum_type));
     3346        if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type));
    33473347
    33483348        /*ArtificialNoise: */
    … …  
    33693369
    33703370                if(control_type[i]==RheologyBbarEnum){
    3371                         input=(Input*)matice->inputs->GetInput(control_type[i]); ISSMASSERT(input);
     3371                        input=(Input*)matice->inputs->GetInput(control_type[i]); _assert_(input);
    33723372                }
    33733373                else{
    3374                         input=(Input*)this->inputs->GetInput(control_type[i]);   ISSMASSERT(input);
     3374                        input=(Input*)this->inputs->GetInput(control_type[i]);   _assert_(input);
    33753375                }
    33763376
    33773377                if (input->Enum()!=ControlInputEnum){
    3378                         ISSMERROR("input %s is not a ControlInput",EnumToString(control_type[i]));
     3378                        _error_("input %s is not a ControlInput",EnumToString(control_type[i]));
    33793379                }
    33803380
    … …  
    34053405                new_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+0]);
    34063406                old_inputs[i]=(Input*)this->inputs->GetInput(enums[2*i+1]);
    3407                 if(!new_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
    3408                 if(!old_inputs[i])ISSMERROR("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
     3407                if(!new_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
     3408                if(!old_inputs[i])_error_("%s%s"," could not find input with enum ",EnumToString(enums[2*i+0]));
    34093409        }
    34103410
    … …  
    34343434         oldinput=(Input*)this->matice->inputs->GetInput(enum_type);
    34353435        else
    3436          ISSMERROR("object %s not supported yet",EnumToString(object_enum));
    3437         if(!oldinput)ISSMERROR("%s%s"," could not find old input with enum: ",EnumToString(enum_type));
     3436         _error_("object %s not supported yet",EnumToString(object_enum));
     3437        if(!oldinput)_error_("%s%s"," could not find old input with enum: ",EnumToString(enum_type));
    34383438        newinput=(Input*)oldinput->copy();
    34393439
    … …  
    34473447         this->matice->inputs->AddInput((Input*)newinput);
    34483448        else
    3449          ISSMERROR("object %s not supported yet",EnumToString(object_enum));
     3449         _error_("object %s not supported yet",EnumToString(object_enum));
    34503450}
    34513451/*}}}*/
    … …  
    34653465        /*Make a copy of the original input: */
    34663466        input=(Input*)this->inputs->GetInput(enum_type);
    3467         if(!input)ISSMERROR(" could not find old input with enum: %s",EnumToString(enum_type));
     3467        if(!input)_error_(" could not find old input with enum: %s",EnumToString(enum_type));
    34683468
    34693469        /*Scale: */
    … …  
    34803480        if (enum_type==RheologyBbarEnum) input=this->matice->inputs->GetInput(enum_type);
    34813481        else input=this->inputs->GetInput(enum_type);
    3482         if (!input) ISSMERROR("Input %s not found in tria->inputs",EnumToString(enum_type));
     3482        if (!input) _error_("Input %s not found in tria->inputs",EnumToString(enum_type));
    34833483
    34843484        /*If we don't find it, no big deal, just don't do the transfer. Otherwise, build a new Result
    … …  
    35253525        /*Checks if debuging*/
    35263526        /*{{{2*/
    3527         ISSMASSERT(iomodel->elements);
     3527        _assert_(iomodel->elements);
    35283528        /*}}}*/
    35293529
    … …  
    36563656                                        /*Matice will take care of it*/ break;
    36573657                                default:
    3658                                         ISSMERROR("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i]));
     3658                                        _error_("Control %s not implemented yet",EnumToString((int)iomodel->control_type[i]));
    36593659                        }
    36603660                }
    … …  
    37053705                        break;
    37063706                default:
    3707                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     3707                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    37083708        }
    37093709}
    … …  
    38583858        if (vz_input){
    38593859                if (vz_input->Enum()!=TriaVertexInputEnum){
    3860                         ISSMERROR("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
     3860                        _error_("Cannot compute Vel as Vz is of type %s",EnumToString(vz_input->Enum()));
    38613861                }
    38623862                vz_input->GetValuesPtr(&vz_ptr,&dummy);
    … …  
    39423942
    39433943                default:
    3944                         ISSMERROR("type %i (%s) not implemented yet",type,EnumToString(type));
     3944                        _error_("type %i (%s) not implemented yet",type,EnumToString(type));
    39453945        }
    39463946}
    … …  
    39483948/*FUNCTION Tria::InputUpdateFromVector(int* vector, int name, int type);{{{1*/
    39493949void  Tria::InputUpdateFromVector(int* vector, int name, int type){
    3950         ISSMERROR(" not supported yet!");
     3950        _error_(" not supported yet!");
    39513951}
    39523952/*}}}*/
    39533953/*FUNCTION Tria::InputUpdateFromVector(bool* vector, int name, int type);{{{1*/
    39543954void  Tria::InputUpdateFromVector(bool* vector, int name, int type){
    3955         ISSMERROR(" not supported yet!");
     3955        _error_(" not supported yet!");
    39563956}
    39573957/*}}}*/
    … …  
    40234023
    40244024                default:
    4025                         ISSMERROR("type %i (%s) not implemented yet",type,EnumToString(type));
     4025                        _error_("type %i (%s) not implemented yet",type,EnumToString(type));
    40264026        }
    40274027
    … …  
    40304030/*FUNCTION Tria::InputUpdateFromVectorDakota(int* vector, int name, int type);{{{1*/
    40314031void  Tria::InputUpdateFromVectorDakota(int* vector, int name, int type){
    4032         ISSMERROR(" not supported yet!");
     4032        _error_(" not supported yet!");
    40334033}
    40344034/*}}}*/
    40354035/*FUNCTION Tria::InputUpdateFromVectorDakota(bool* vector, int name, int type);{{{1*/
    40364036void  Tria::InputUpdateFromVectorDakota(bool* vector, int name, int type){
    4037         ISSMERROR(" not supported yet!");
     4037        _error_(" not supported yet!");
    40384038}
    40394039/*}}}*/
    … …  
    41074107
    41084108        /*First off, check that this segment belongs to this element: */
    4109         if ((int)*(segment+4)!=this->id)ISSMERROR("%s%i%s%i","error message: segment with id ",(int)*(segment+4)," does not belong to element with id:",this->id);
     4109        if ((int)*(segment+4)!=this->id)_error_("%s%i%s%i","error message: segment with id ",(int)*(segment+4)," does not belong to element with id:",this->id);
    41104110
    41114111        /*Recover segment node locations: */
    … …  
    41264126        length=sqrt(pow(x2-x1,2.0)+pow(y2-y1,2));
    41274127
    4128         Input* thickness_input=inputs->GetInput(ThicknessEnum); ISSMASSERT(thickness_input);
    4129         Input* vx_input=inputs->GetInput(VxEnum); ISSMASSERT(vx_input);
    4130         Input* vy_input=inputs->GetInput(VyEnum); ISSMASSERT(vy_input);
     4128        Input* thickness_input=inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
     4129        Input* vx_input=inputs->GetInput(VxEnum); _assert_(vx_input);
     4130        Input* vy_input=inputs->GetInput(VyEnum); _assert_(vy_input);
    41314131
    41324132        thickness_input->GetParameterValue(&h1, gauss_1);
    … …  
    44044404                         * */
    44054405                        if (control_type[i]==DragCoefficientEnum){
    4406                                 Input* drag_input=inputs->GetInput(DragCoefficientEnum);      ISSMASSERT(drag_input);
     4406                                Input* drag_input=inputs->GetInput(DragCoefficientEnum);      _assert_(drag_input);
    44074407                                drag_input->GetParameterDerivativeValue(&dk[0],&xyz_list[0][0],gauss);
    44084408                                //Jelem+=cm_noisedmp*1/2*(pow(dk[0],2)+pow(dk[1],2))*Jdet*gauss->weight;
    … …  
    44214421                        }
    44224422                        else{
    4423                                 ISSMERROR("unsupported control type: %s",EnumToString(control_type[i]));
     4423                                _error_("unsupported control type: %s",EnumToString(control_type[i]));
    44244424                        }
    44254425                }
    … …  
    44364436void  Tria::SetClone(int* minranks){
    44374437
    4438         ISSMERROR("not implemented yet");
     4438        _error_("not implemented yet");
    44394439}
    44404440/*}}}1*/
    … …  
    49384938
    49394939        /*Retrieve all inputs we will be needing: */
    4940         Input* thickness_input   =inputs->GetInput(ThicknessEnum);   ISSMASSERT(thickness_input);
    4941         Input* thicknessobs_input=inputs->GetInput(ThicknessObsEnum);ISSMASSERT(thicknessobs_input);
    4942         Input* weights_input     =inputs->GetInput(WeightsEnum);     ISSMASSERT(weights_input);
     4940        Input* thickness_input   =inputs->GetInput(ThicknessEnum);   _assert_(thickness_input);
     4941        Input* thicknessobs_input=inputs->GetInput(ThicknessObsEnum);_assert_(thicknessobs_input);
     4942        Input* weights_input     =inputs->GetInput(WeightsEnum);     _assert_(weights_input);
    49434943
    49444944        /* Start  looping on the number of gaussian points: */
    … …  
    50195019        /*Checks if debuging*/
    50205020        /*{{{2*/
    5021         ISSMASSERT(iomodel->elements);
     5021        _assert_(iomodel->elements);
    50225022        /*}}}*/
    50235023

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

    r6410 r6412  
    100100                void   InputToResult(int enum_type,int step,double time);
    101101                void   DeleteResults(void);
    102                 void   MaterialUpdateFromTemperature(void){ISSMERROR("not implemented yet");};
     102                void   MaterialUpdateFromTemperature(void){_error_("not implemented yet");};
    103103                double MassFlux(double* segment,bool process_units);
    104104                void   MaxAbsVx(double* pmaxabsvx, bool process_units);

  • TabularUnified issm/trunk/src/c/objects/Elements/TriaRef.cpp

    r5808 r6412  
    5252void TriaRef::SetElementType(int type,int type_counter){
    5353
    54         ISSMASSERT(type==P1Enum || type==P1DGEnum);
     54        _assert_(type==P1Enum || type==P1DGEnum);
    5555
    5656        /*initialize element type*/
    … …  
    277277
    278278        *Jdet=1.0/2.0*sqrt(pow(x2-x1,2.) + pow(y2-y1,2.));
    279         if(*Jdet<0) ISSMERROR("negative jacobian determinant!");
     279        if(*Jdet<0) _error_("negative jacobian determinant!");
    280280
    281281}
    … …  
    292292        /*Get Determinant*/
    293293        Matrix2x2Determinant(Jdet,&J[0][0]);
    294         if(*Jdet<0) ISSMERROR("negative jacobian determinant!");
     294        if(*Jdet<0) _error_("negative jacobian determinant!");
    295295
    296296}
    … …  
    314314
    315315        *Jdet=SQRT3/6.0*pow(pow(((y2-y1)*(z3-z1)-(z2-z1)*(y3-y1)),2.0)+pow(((z2-z1)*(x3-x1)-(x2-x1)*(z3-z1)),2.0)+pow(((x2-x1)*(y3-y1)-(y2-y1)*(x3-x1)),2.0),0.5);
    316         if(*Jdet<0) ISSMERROR("negative jacobian determinant!");
     316        if(*Jdet<0) _error_("negative jacobian determinant!");
    317317
    318318}
    … …  
    350350        GetNodalFunctions(&BasisFunctions[0],gauss);
    351351
    352         ISSMASSERT(index1>=0 && index1<3);
    353         ISSMASSERT(index2>=0 && index2<3);
     352        _assert_(index1>=0 && index1<3);
     353        _assert_(index2>=0 && index2<3);
    354354        l1l2[0]=BasisFunctions[index1];
    355355        l1l2[1]=BasisFunctions[index2];

  • TabularUnified issm/trunk/src/c/objects/FemModel.cpp

    r6372 r6412  
    5353        for(i=0;i<nummodels;i++){
    5454
    55                 ISSMPRINTF(VerboseMProcessor(),"   Processing finite element model of analysis %s:\n",EnumToString(analysis_type_list[i]));
     55                _printf_(VerboseMProcessor(),"   Processing finite element model of analysis %s:\n",EnumToString(analysis_type_list[i]));
    5656                analysis_type=analysis_type_list[i];
    5757                this->SetCurrentConfiguration(analysis_type);
    5858       
    5959                if(i==0){
    60                         ISSMPRINTF(VerboseMProcessor(),"      create vertex degrees of freedom\n");
     60                        _printf_(VerboseMProcessor(),"      create vertex degrees of freedom\n");
    6161                        VerticesDofx(vertices,parameters); //only call once, we only have one set of vertices
    6262                }
    6363
    64                 ISSMPRINTF(VerboseMProcessor(),"      resolve node constraints\n");
     64                _printf_(VerboseMProcessor(),"      resolve node constraints\n");
    6565                SpcNodesx(nodes,constraints,analysis_type);
    6666       
    67                 ISSMPRINTF(VerboseMProcessor(),"      create nodal degrees of freedom\n");
     67                _printf_(VerboseMProcessor(),"      create nodal degrees of freedom\n");
    6868                NodesDofx(nodes,parameters,analysis_type);
    6969       
    70                 ISSMPRINTF(VerboseMProcessor(),"      create nodal constraints vector\n");
     70                _printf_(VerboseMProcessor(),"      create nodal constraints vector\n");
    7171                CreateNodalConstraintsx(&m_ys[i],nodes,analysis_type);
    7272
    73                 ISSMPRINTF(VerboseMProcessor(),"      create node sets\n");
     73                _printf_(VerboseMProcessor(),"      create node sets\n");
    7474                BuildNodeSetsx(&m_nodesets[i], nodes,analysis_type);
    7575
    76                 ISSMPRINTF(VerboseMProcessor(),"      configuring element and loads\n");
     76                _printf_(VerboseMProcessor(),"      configuring element and loads\n");
    7777                ConfigureObjectsx(elements, loads, nodes, vertices, materials,parameters);
    7878        }
    … …  
    152152        }
    153153        if(found!=-1) analysis_counter=found;
    154         else ISSMERROR("Could not find alias for analysis_type %s in list of FemModel analyses",EnumToString(configuration_type));
     154        else _error_("Could not find alias for analysis_type %s in list of FemModel analyses",EnumToString(configuration_type));
    155155
    156156        /*activate matrices/vectors: */
    … …  
    170170        /*take care of petsc options, that depend on this analysis type: */
    171171        PetscOptionsFromAnalysis(this->parameters,analysis_type);
    172         ISSMPRINTF(VerboseSolver(),"      petsc Options set for analysis type: %s\n",EnumToString(analysis_type));
     172        _printf_(VerboseSolver(),"      petsc Options set for analysis type: %s\n",EnumToString(analysis_type));
    173173
    174174}

  • TabularUnified issm/trunk/src/c/objects/Gauss/GaussPenta.cpp

    r5808 r6412  
    121121        }
    122122        else{
    123                 ISSMERROR("Penta not supported yet");
     123                _error_("Penta not supported yet");
    124124        }
    125125
    … …  
    151151        }
    152152        else{
    153                 ISSMERROR("Tria not supported yet");
     153                _error_("Tria not supported yet");
    154154        }
    155155
    … …  
    213213        }
    214214        else{
    215                 ISSMERROR("Tria not supported yet (user provided indices %i %i %i %i)",index1,index2,index3,index4);
     215                _error_("Tria not supported yet (user provided indices %i %i %i %i)",index1,index2,index3,index4);
    216216        }
    217217
    … …  
    294294
    295295        /*Check input in debugging mode*/
    296          ISSMASSERT(ig>=0 && ig< numgauss);
     296         _assert_(ig>=0 && ig< numgauss);
    297297
    298298         /*update static arrays*/
    … …  
    309309
    310310        /*in debugging mode: check that the default constructor has been called*/
    311         ISSMASSERT(numgauss==-1);
     311        _assert_(numgauss==-1);
    312312
    313313        /*update static arrays*/
    … …  
    332332                        break;
    333333                default:
    334                         ISSMERROR("vertex index should be in [0 5]");
     334                        _error_("vertex index should be in [0 5]");
    335335
    336336        }
    … …  
    342342
    343343        /*in debugging mode: check that the default constructor has been called*/
    344         ISSMASSERT(numgauss==-1);
     344        _assert_(numgauss==-1);
    345345
    346346        /*Basal Tria*/
    … …  
    351351        }
    352352        else{
    353                 ISSMERROR("Tria not supported yet");
     353                _error_("Tria not supported yet");
    354354        }
    355355
    … …  
    360360
    361361        /*Check that this has been initialized*/
    362         ISSMASSERT(numgauss>0);
    363         ISSMASSERT(weights);
    364         ISSMASSERT(coords1);
    365         ISSMASSERT(coords2);
    366         ISSMASSERT(coords3);
    367         ISSMASSERT(coords4);
     362        _assert_(numgauss>0);
     363        _assert_(weights);
     364        _assert_(coords1);
     365        _assert_(coords2);
     366        _assert_(coords3);
     367        _assert_(coords4);
    368368
    369369        /*return first gauss index*/
    … …  
    375375
    376376        /*Check that this has been initialized*/
    377         ISSMASSERT(numgauss>0);
    378         ISSMASSERT(weights);
    379         ISSMASSERT(coords1);
    380         ISSMASSERT(coords2);
    381         ISSMASSERT(coords3);
    382         ISSMASSERT(coords4);
     377        _assert_(numgauss>0);
     378        _assert_(weights);
     379        _assert_(coords1);
     380        _assert_(coords2);
     381        _assert_(coords3);
     382        _assert_(coords4);
    383383
    384384        /*return last gauss index +1*/

  • TabularUnified issm/trunk/src/c/objects/Gauss/GaussTria.cpp

    r5739 r6412  
    8282        }
    8383        else
    84          ISSMERROR("The 2 indices provided are not supported yet (user provided %i and %i)",index1,index2);
     84         _error_("The 2 indices provided are not supported yet (user provided %i and %i)",index1,index2);
    8585
    8686        /*Initialize static fields as undefined*/
    … …  
    180180        }
    181181        else
    182          ISSMERROR("The 2 indices provided are not supported yet (user provided %i and %i)",index1,index2);
     182         _error_("The 2 indices provided are not supported yet (user provided %i and %i)",index1,index2);
    183183
    184184}
    … …  
    188188
    189189        /*Check input in debugging mode*/
    190          ISSMASSERT(ig>=0 && ig< numgauss);
     190         _assert_(ig>=0 && ig< numgauss);
    191191
    192192         /*update static arrays*/
    … …  
    206206
    207207        /*in debugging mode: check that the default constructor has been called*/
    208         ISSMASSERT(numgauss==-1);
     208        _assert_(numgauss==-1);
    209209
    210210        x1=*(xyz_list+3*0+0); y1=*(xyz_list+3*0+1);
    … …  
    229229
    230230        /*in debugging mode: check that the default constructor has been called*/
    231         ISSMASSERT(numgauss==-1);
     231        _assert_(numgauss==-1);
    232232
    233233        /*update static arrays*/
    … …  
    243243                        break;
    244244                default:
    245                         ISSMERROR("vertex index should be in [0 2]");
     245                        _error_("vertex index should be in [0 2]");
    246246
    247247        }
    … …  
    253253
    254254        /*Check that this has been initialized*/
    255         ISSMASSERT(numgauss>0);
    256         ISSMASSERT(weights);
    257         ISSMASSERT(coords1);
    258         ISSMASSERT(coords2);
    259         ISSMASSERT(coords3);
     255        _assert_(numgauss>0);
     256        _assert_(weights);
     257        _assert_(coords1);
     258        _assert_(coords2);
     259        _assert_(coords3);
    260260
    261261        /*return first gauss index*/
    … …  
    267267
    268268        /*Check that this has been initialized*/
    269         ISSMASSERT(numgauss>0);
    270         ISSMASSERT(weights);
    271         ISSMASSERT(coords1);
    272         ISSMASSERT(coords2);
    273         ISSMASSERT(coords3);
     269        _assert_(numgauss>0);
     270        _assert_(weights);
     271        _assert_(coords1);
     272        _assert_(coords2);
     273        _assert_(coords3);
    274274
    275275        /*return last gauss index +1*/

  • TabularUnified issm/trunk/src/c/objects/Hook.cpp

    r5607 r6412  
    172172        /*allocate: */
    173173        if (num<0){
    174                 ISSMERROR("cannot demarshall Hook as num<=0");
     174                _error_("cannot demarshall Hook as num<=0");
    175175        }
    176176        else if (num==0){
    … …  
    185185
    186186                /*demarshall allocated ids and offsets: */
    187                 ISSMASSERT(num<1000);
     187                _assert_(num<1000);
    188188                for (i=0;i<num;i++){
    189189                        memcpy(&this->ids[i],marshalled_dataset,sizeof(int));marshalled_dataset+=sizeof(int);
    … …  
    241241
    242242        /*Checks if debugging mode*/
    243         ISSMASSERT(this->num==0 || this->ids!=NULL);
     243        _assert_(this->num==0 || this->ids!=NULL);
    244244
    245245        for(i=0;i<this->num;i++){
    … …  
    270270                        this->objects[i]=(Object*)dataset->GetObjectById(this->offsets+i,this->ids[i]); //remember the offset for later on.
    271271                        /*check the id is correct!: */
    272                         if (this->objects[i]->Id()!=this->ids[i]) ISSMERROR("%s%i%s%i%s"," wrong id: ",this->objects[i]->Id()," vs ",this->ids[i],"  in resolved pointer!");
     272                        if (this->objects[i]->Id()!=this->ids[i]) _error_("%s%i%s%i%s"," wrong id: ",this->objects[i]->Id()," vs ",this->ids[i],"  in resolved pointer!");
    273273                }
    274274        }
    … …  
    279279       
    280280        /*first, check that we only have one T object in our object list: */
    281         if (this->num!=1) ISSMERROR("%s%i%s\n"," trying to delivery a single hook object when hook holds ",this->num," objects");
     281        if (this->num!=1) _error_("%s%i%s\n"," trying to delivery a single hook object when hook holds ",this->num," objects");
    282282
    283283        /*check NULL: */
    284         if (this->objects==NULL) ISSMERROR("hook is not pointing to any object, objects pointer is NULL");
     284        if (this->objects==NULL) _error_("hook is not pointing to any object, objects pointer is NULL");
    285285
    286286        return *objects;
    … …  
    331331
    332332        /*Else, check that we are requesting a half of num*/
    333         if (numindices>this->num) ISSMERROR("Cannot spawn hook with %i objects from a Hook of %i objects",numindices,this->num);
     333        if (numindices>this->num) _error_("Cannot spawn hook with %i objects from a Hook of %i objects",numindices,this->num);
    334334
    335335        /*go pickup the correct objects, ids and offsets :*/
    336336        output->num=numindices;
    337         if(output->num<1) ISSMERROR("Trying to spawn an empty ElementProperties!");
     337        if(output->num<1) _error_("Trying to spawn an empty ElementProperties!");
    338338
    339339        output->objects=(Object**)xmalloc(output->num*sizeof(Object*));

  • TabularUnified issm/trunk/src/c/objects/Inputs/BoolInput.cpp

    r5743 r6412  
    149149ElementResult* BoolInput::SpawnResult(int step, double time){
    150150
    151         ISSMERROR(" not supported yet!");
     151        _error_(" not supported yet!");
    152152
    153153}
    … …  
    161161/*}}}*/
    162162/*FUNCTION BoolInput::GetParameterValue(int* pvalue){{{1*/
    163 void BoolInput::GetParameterValue(int* pvalue){ISSMERROR(" not supported yet!");}
     163void BoolInput::GetParameterValue(int* pvalue){_error_(" not supported yet!");}
    164164/*}}}*/
    165165/*FUNCTION BoolInput::GetParameterValue(double* pvalue){{{1*/
    166 void BoolInput::GetParameterValue(double* pvalue){ISSMERROR(" not supported yet!");}
     166void BoolInput::GetParameterValue(double* pvalue){_error_(" not supported yet!");}
    167167/*}}}*/
    168168/*FUNCTION BoolInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/
    169 void BoolInput::GetParameterValue(double* pvalue,GaussTria* gauss){ISSMERROR(" not supported yet!");}
     169void BoolInput::GetParameterValue(double* pvalue,GaussTria* gauss){_error_(" not supported yet!");}
    170170/*}}}*/
    171171/*FUNCTION BoolInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/
    172 void BoolInput::GetParameterValue(double* pvalue,GaussPenta* gauss){ISSMERROR(" not supported yet!");}
     172void BoolInput::GetParameterValue(double* pvalue,GaussPenta* gauss){_error_(" not supported yet!");}
    173173/*}}}*/
    174174/*FUNCTION BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
    175 void BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){ISSMERROR(" not supported yet!");}
     175void BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");}
    176176/*}}}*/
    177177/*FUNCTION BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
    178 void BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){ISSMERROR(" not supported yet!");}
     178void BoolInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");}
    179179/*}}}*/
    180180/*FUNCTION BoolInput::ChangeEnum{{{1*/
    … …  
    210210
    211211                default:
    212                         ISSMERROR("not implemented yet");
     212                        _error_("not implemented yet");
    213213        }
    214214
    … …  
    226226void BoolInput::GetVectorFromInputs(Vec vector,int* doflist){
    227227
    228         ISSMERROR(" not supporte yet!");
     228        _error_(" not supporte yet!");
    229229
    230230}
    … …  
    233233void BoolInput::GetValuesPtr(double** pvalues,int* pnum_values){
    234234
    235         ISSMERROR(" not supported yet!");
    236 
    237 }
    238 /*}}}*/
     235        _error_(" not supported yet!");
     236
     237}
     238/*}}}*/

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

    r5743 r6412  
    4040                int   EnumType();
    4141                Input* SpawnTriaInput(int* indices);
    42                 Input* PointwiseDivide(Input* inputB){ISSMERROR("not implemented yet");};
     42                Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};
    4343                ElementResult* SpawnResult(int step, double time);
    4444                /*}}}*/
    … …  
    5151                void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
    5252                void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
    53                 void GetParameterAverage(double* pvalue){ISSMERROR("not implemented yet");};
    54                 void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){ISSMERROR("not implemented yet");};
    55                 void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){ISSMERROR("not implemented yet");};
    56                 void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    57                 void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    58                 void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    59                 void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    60                 void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
     53                void GetParameterAverage(double* pvalue){_error_("not implemented yet");};
     54                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
     55                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
     56                void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     57                void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     58                void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     59                void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     60                void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    6161                void ChangeEnum(int newenumtype);
    6262                void SquareMin(double* psquaremin, bool process_units,Parameters* parameters);
    63                 void ConstrainMin(double minimum){ISSMERROR("not implemented yet");};
    64                 double InfinityNorm(void){ISSMERROR("InfinityNorm not implemented for booleans");};
    65                 double Max(void){ISSMERROR("Max not implemented for booleans");};
    66                 double MaxAbs(void){ISSMERROR("Max not implemented for booleans");};
    67                 double Min(void){ISSMERROR("Min not implemented for booleans");};
    68                 double MinAbs(void){ISSMERROR("Min not implemented for booleans");};
     63                void ConstrainMin(double minimum){_error_("not implemented yet");};
     64                double InfinityNorm(void){_error_("InfinityNorm not implemented for booleans");};
     65                double Max(void){_error_("Max not implemented for booleans");};
     66                double MaxAbs(void){_error_("Max not implemented for booleans");};
     67                double Min(void){_error_("Min not implemented for booleans");};
     68                double MinAbs(void){_error_("Min not implemented for booleans");};
    6969                void Scale(double scale_factor);
    70                 void ArtificialNoise(double min,double max){ISSMERROR("not implemented yet");};
     70                void ArtificialNoise(double min,double max){_error_("not implemented yet");};
    7171                void AXPY(Input* xinput,double scalar);
    7272                void Constrain(double cm_min, double cm_max);
    73                 void Extrude(void){ISSMERROR("not supported yet");};
    74                 void VerticallyIntegrate(Input* thickness_input){ISSMERROR("not supported yet");};
     73                void Extrude(void){_error_("not supported yet");};
     74                void VerticallyIntegrate(Input* thickness_input){_error_("not supported yet");};
    7575                void GetVectorFromInputs(Vec vector,int* doflist);
    7676                void GetValuesPtr(double** pvalues,int* pnum_values);

  • TabularUnified issm/trunk/src/c/objects/Inputs/ControlInput.cpp

    r6260 r6412  
    4242                        break;
    4343                default:
    44                         ISSMERROR("Input of Enum %s not supported yet by ControlInput",EnumToString(enum_input));
     44                        _error_("Input of Enum %s not supported yet by ControlInput",EnumToString(enum_input));
    4545        }
    4646        gradient   =NULL;
    … …  
    179179                        values->Demarshall(&marshalled_dataset);
    180180                }
    181                 else ISSMERROR("Not supported yet");
     181                else _error_("Not supported yet");
    182182        }
    183183        else{
    … …  
    197197                        savedvalues->Demarshall(&marshalled_dataset);
    198198                }
    199                 else ISSMERROR("Not supported yet");
     199                else _error_("Not supported yet");
    200200        }
    201201        else{
    … …  
    215215                        gradient->Demarshall(&marshalled_dataset);
    216216                }
    217                 else ISSMERROR("Not supported yet");
     217                else _error_("Not supported yet");
    218218        }
    219219        else{
    … …  
    276276/*FUNCTION ControlInput::ScaleGradient{{{1*/
    277277void ControlInput::ScaleGradient(double scaling_factor){
    278         if(!gradient) ISSMERROR("Gradient of ControlInput %s not found",EnumToString(enum_type));
     278        if(!gradient) _error_("Gradient of ControlInput %s not found",EnumToString(enum_type));
    279279        gradient->Scale(scaling_factor);
    280280}/*}}}*/
    … …  
    294294                        break;
    295295                default:
    296                         ISSMERROR("more than 3 controls not implemented yet (Gradient %i was requested). EnumDefinitions.h needs to be updated.",this->control_id);
     296                        _error_("more than 3 controls not implemented yet (Gradient %i was requested). EnumDefinitions.h needs to be updated.",this->control_id);
    297297        }
    298298
    … …  
    348348/*FUNCTION ControlInput::SaveValue{{{1*/
    349349void ControlInput::SaveValue(void){
    350         if(!values) ISSMERROR("Values of %s not found",EnumToString(this->enum_type));
     350        if(!values) _error_("Values of %s not found",EnumToString(this->enum_type));
    351351
    352352        if(savedvalues) delete this->savedvalues;
    … …  
    355355/*FUNCTION ControlInput::UpdateValue{{{1*/
    356356void ControlInput::UpdateValue(double scalar){
    357         if(!gradient)    ISSMERROR("Gradient of %s not found",EnumToString(this->enum_type));
    358         if(!savedvalues) ISSMERROR("Values of %s not found",EnumToString(this->enum_type));
     357        if(!gradient)    _error_("Gradient of %s not found",EnumToString(this->enum_type));
     358        if(!savedvalues) _error_("Values of %s not found",EnumToString(this->enum_type));
    359359
    360360        if(values) delete this->values;

  • TabularUnified issm/trunk/src/c/objects/Inputs/ControlInput.h

    r6260 r6412  
    4242                int    EnumType();
    4343                Input* SpawnTriaInput(int* indices);
    44                 Input* PointwiseDivide(Input* inputB){ISSMERROR("not implemented yet");};
     44                Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};
    4545                ElementResult* SpawnResult(int step, double time);
    4646                /*}}}*/
    … …  
    5454                void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
    5555                void GetParameterAverage(double* pvalue);
    56                 void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){ISSMERROR("not implemented yet");};
    57                 void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){ISSMERROR("not implemented yet");};
    58                 void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    59                 void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    60                 void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    61                 void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    62                 void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    63                 void ChangeEnum(int newenumtype){ISSMERROR("not implemented yet");};
    64                 void SquareMin(double* psquaremin, bool process_units,Parameters* parameters){ISSMERROR("not implemented yet");};
    65                 void ConstrainMin(double minimum){ISSMERROR("not implemented yet");};
    66                 void Scale(double scale_factor){ISSMERROR("not implemented yet");};
    67                 void ArtificialNoise(double min,double max){ISSMERROR("not implemented yet");};
    68                 void AXPY(Input* xinput,double scalar){ISSMERROR("not implemented yet");};
     56                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
     57                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
     58                void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     59                void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     60                void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     61                void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     62                void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     63                void ChangeEnum(int newenumtype){_error_("not implemented yet");};
     64                void SquareMin(double* psquaremin, bool process_units,Parameters* parameters){_error_("not implemented yet");};
     65                void ConstrainMin(double minimum){_error_("not implemented yet");};
     66                void Scale(double scale_factor){_error_("not implemented yet");};
     67                void ArtificialNoise(double min,double max){_error_("not implemented yet");};
     68                void AXPY(Input* xinput,double scalar){_error_("not implemented yet");};
    6969                void Constrain(double cm_min, double cm_max);
    70                 double InfinityNorm(void){ISSMERROR("not implemented yet");};
    71                 double Max(void){ISSMERROR("not implemented yet");};
    72                 double MaxAbs(void){ISSMERROR("not implemented yet");};
    73                 double Min(void){ISSMERROR("not implemented yet");};
    74                 double MinAbs(void){ISSMERROR("not implemented yet");};
     70                double InfinityNorm(void){_error_("not implemented yet");};
     71                double Max(void){_error_("not implemented yet");};
     72                double MaxAbs(void){_error_("not implemented yet");};
     73                double Min(void){_error_("not implemented yet");};
     74                double MinAbs(void){_error_("not implemented yet");};
    7575                void Extrude(void);
    7676                void VerticallyIntegrate(Input* thickness_input);
    77                 void GetVectorFromInputs(Vec vector,int* doflist){ISSMERROR("not implemented yet");};
    78                 void GetValuesPtr(double** pvalues,int* pnum_values){ISSMERROR("not implemented yet");};
     77                void GetVectorFromInputs(Vec vector,int* doflist){_error_("not implemented yet");};
     78                void GetValuesPtr(double** pvalues,int* pnum_values){_error_("not implemented yet");};
    7979                ElementResult* SpawnGradient(int step, double time);
    8080                void GetGradient(Vec gradient_vec,int* doflist);

  • TabularUnified issm/trunk/src/c/objects/Inputs/DoubleInput.cpp

    r5743 r6412  
    160160        *pvalue=(bool)value;
    161161#else
    162         ISSMERROR("Double input of enum %s cannot return a boolean",EnumToString(enum_type));
     162        _error_("Double input of enum %s cannot return a boolean",EnumToString(enum_type));
    163163#endif
    164164
    … …  
    170170        *pvalue=(int)value;
    171171#else
    172         ISSMERROR("Double input of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));
     172        _error_("Double input of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));
    173173#endif
    174174
    … …  
    183183/*}}}*/
    184184/*FUNCTION DoubleInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/
    185 void DoubleInput::GetParameterValue(double* pvalue,GaussTria* gauss){ISSMERROR(" not supported yet!");}
     185void DoubleInput::GetParameterValue(double* pvalue,GaussTria* gauss){_error_(" not supported yet!");}
    186186/*}}}*/
    187187/*FUNCTION DoubleInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/
    188 void DoubleInput::GetParameterValue(double* pvalue,GaussPenta* gauss){ISSMERROR(" not supported yet!");}
     188void DoubleInput::GetParameterValue(double* pvalue,GaussPenta* gauss){_error_(" not supported yet!");}
    189189/*}}}*/
    190190/*FUNCTION DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
    191 void DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){ISSMERROR(" not supported yet!");}
     191void DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");}
    192192/*}}}*/
    193193/*FUNCTION DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
    194 void DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){ISSMERROR(" not supported yet!");}
     194void DoubleInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");}
    195195/*}}}*/
    196196/*FUNCTION DoubleInput::ChangeEnum{{{1*/
    … …  
    232232
    233233                default:
    234                         ISSMERROR("not implemented yet");
     234                        _error_("not implemented yet");
    235235        }
    236236
    … …  
    268268void DoubleInput::GetVectorFromInputs(Vec vector,int* doflist){
    269269
    270         ISSMERROR(" not supporte yet!");
     270        _error_(" not supporte yet!");
    271271
    272272}
    … …  
    275275void DoubleInput::GetValuesPtr(double** pvalues,int* pnum_values){
    276276
    277         ISSMERROR(" not supported yet!");
     277        _error_(" not supported yet!");
    278278
    279279}
    … …  
    291291
    292292        /*Check that input provided is a thickness*/
    293         if (thickness_input->EnumType()!=ThicknessEnum) ISSMERROR("Input provided is not a Thickness (enum_type is %s)",EnumToString(thickness_input->EnumType()));
     293        if (thickness_input->EnumType()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToString(thickness_input->EnumType()));
    294294
    295295        /*vertically integrate depending on type:*/
    … …  
    302302
    303303                default:
    304                         ISSMERROR("not implemented yet");
     304                        _error_("not implemented yet");
    305305        }
    306306}

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

    r5743 r6412  
    5151                void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
    5252                void GetParameterAverage(double* pvalue);
    53                 void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){ISSMERROR("not implemented yet");};
    54                 void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){ISSMERROR("not implemented yet");};
    55                 void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    56                 void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    57                 void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    58                 void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    59                 void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
     53                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
     54                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
     55                void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     56                void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     57                void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     58                void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     59                void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    6060                void ChangeEnum(int newenumtype);
    6161                void SquareMin(double* psquaremin, bool process_units,Parameters* parameters);
    6262                void ConstrainMin(double minimum);
    6363                void Scale(double scale_factor);
    64                 void ArtificialNoise(double min,double max){ISSMERROR("not implemented yet");};
     64                void ArtificialNoise(double min,double max){_error_("not implemented yet");};
    6565                void AXPY(Input* xinput,double scalar);
    6666                void Constrain(double cm_min, double cm_max);
    67                 double InfinityNorm(void){ISSMERROR("not implemented yet");};
     67                double InfinityNorm(void){_error_("not implemented yet");};
    6868                double Max(void);
    6969                double MaxAbs(void);
    7070                double Min(void);
    7171                double MinAbs(void);
    72                 void Extrude(void){ISSMERROR("not supported yet");};
     72                void Extrude(void){_error_("not supported yet");};
    7373                void VerticallyIntegrate(Input* thickness_input);
    7474                void GetVectorFromInputs(Vec vector,int* doflist);

  • TabularUnified issm/trunk/src/c/objects/Inputs/IntInput.cpp

    r5743 r6412  
    148148ElementResult* IntInput::SpawnResult(int step, double time){
    149149       
    150         ISSMERROR(" not supported yet!");
     150        _error_(" not supported yet!");
    151151
    152152}
    … …  
    155155/*Object functions*/
    156156/*FUNCTION IntInput::GetParameterValue(bool* pvalue) {{{1*/
    157 void IntInput::GetParameterValue(bool* pvalue){ISSMERROR(" not supported yet!");}
     157void IntInput::GetParameterValue(bool* pvalue){_error_(" not supported yet!");}
    158158/*}}}*/
    159159/*FUNCTION IntInput::GetParameterValue(int* pvalue){{{1*/
    … …  
    164164/*FUNCTION IntInput::GetParameterValue(double* pvalue){{{1*/
    165165void IntInput::GetParameterValue(double* pvalue){
    166         ISSMERROR("IntInput cannot return a double in parallel");
     166        _error_("IntInput cannot return a double in parallel");
    167167}
    168168/*}}}*/
    169169/*FUNCTION IntInput::GetParameterValue(double* pvalue,GaussTria* gauss){{{1*/
    170 void IntInput::GetParameterValue(double* pvalue,GaussTria* gauss){ISSMERROR(" not supported yet!");}
     170void IntInput::GetParameterValue(double* pvalue,GaussTria* gauss){_error_(" not supported yet!");}
    171171/*}}}*/
    172172/*FUNCTION IntInput::GetParameterValue(double* pvalue,GaussPenta* gauss){{{1*/
    173 void IntInput::GetParameterValue(double* pvalue,GaussPenta* gauss){ISSMERROR(" not supported yet!");}
     173void IntInput::GetParameterValue(double* pvalue,GaussPenta* gauss){_error_(" not supported yet!");}
    174174/*}}}*/
    175175/*FUNCTION IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){{{1*/
    176 void IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){ISSMERROR(" not supported yet!");}
     176void IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_(" not supported yet!");}
    177177/*}}}*/
    178178/*FUNCTION IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){{{1*/
    179 void IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){ISSMERROR(" not supported yet!");}
     179void IntInput::GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_(" not supported yet!");}
    180180/*}}}*/
    181181/*FUNCTION IntInput::ChangeEnum{{{1*/
    … …  
    215215
    216216                default:
    217                         ISSMERROR("not implemented yet");
     217                        _error_("not implemented yet");
    218218        }
    219219
    … …  
    231231void IntInput::GetVectorFromInputs(Vec vector,int* doflist){
    232232
    233         ISSMERROR(" not supporte yet!");
     233        _error_(" not supporte yet!");
    234234
    235235}
    … …  
    238238void IntInput::GetValuesPtr(double** pvalues,int* pnum_values){
    239239
    240         ISSMERROR(" not supported yet!");
    241 
    242 }
    243 /*}}}*/
     240        _error_(" not supported yet!");
     241
     242}
     243/*}}}*/

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

    r5743 r6412  
    4040                int   EnumType();
    4141                Input* SpawnTriaInput(int* indices);
    42                 Input* PointwiseDivide(Input* inputB){ISSMERROR("not implemented yet");};
     42                Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};
    4343                ElementResult* SpawnResult(int step, double time);
    4444                /*}}}*/
    … …  
    5151                void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
    5252                void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
    53                 void GetParameterAverage(double* pvalue){ISSMERROR("not implemented yet");};
    54                 void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){ISSMERROR("not implemented yet");};
    55                 void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){ISSMERROR("not implemented yet");};
    56                 void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    57                 void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    58                 void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    59                 void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    60                 void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
     53                void GetParameterAverage(double* pvalue){_error_("not implemented yet");};
     54                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
     55                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
     56                void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     57                void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     58                void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     59                void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     60                void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    6161                void ChangeEnum(int newenumtype);
    6262                void SquareMin(double* psquaremin, bool process_units,Parameters* parameters);
    63                 void ConstrainMin(double minimum){ISSMERROR("not implemented yet");};
     63                void ConstrainMin(double minimum){_error_("not implemented yet");};
    6464                void Scale(double scale_factor);
    65                 void ArtificialNoise(double min,double max){ISSMERROR("not implemented yet");};
     65                void ArtificialNoise(double min,double max){_error_("not implemented yet");};
    6666                void AXPY(Input* xinput,double scalar);
    6767                void Constrain(double cm_min, double cm_max);
    68                 double InfinityNorm(void){ISSMERROR("InfinityNorm not implemented for integers");};
    69                 double Max(void){ISSMERROR("Max not implemented for integers");};
    70                 double MaxAbs(void){ISSMERROR("Max not implemented for integers");};
    71                 double Min(void){ISSMERROR("Min not implemented for integers");};
    72                 double MinAbs(void){ISSMERROR("Min not implemented for integers");};
    73                 void Extrude(void){ISSMERROR("not supported yet");};
    74                 void VerticallyIntegrate(Input* thickness_input){ISSMERROR("not supported yet");};
     68                double InfinityNorm(void){_error_("InfinityNorm not implemented for integers");};
     69                double Max(void){_error_("Max not implemented for integers");};
     70                double MaxAbs(void){_error_("Max not implemented for integers");};
     71                double Min(void){_error_("Min not implemented for integers");};
     72                double MinAbs(void){_error_("Min not implemented for integers");};
     73                void Extrude(void){_error_("not supported yet");};
     74                void VerticallyIntegrate(Input* thickness_input){_error_("not supported yet");};
    7575                void GetVectorFromInputs(Vec vector,int* doflist);
    7676                void GetValuesPtr(double** pvalues,int* pnum_values);

  • TabularUnified issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp

    r6200 r6412  
    153153
    154154                /*Check index value*/
    155                 ISSMASSERT(indices[i]>=0 && indices[i]<6);
     155                _assert_(indices[i]>=0 && indices[i]<6);
    156156
    157157                /*Assign value to new input*/
    … …  
    506506                case ControlInputEnum:{
    507507                        ControlInput* cont_input=(ControlInput*)xinput;
    508                         if(cont_input->values->Enum()!=PentaVertexInputEnum) ISSMERROR("not supported yet");
     508                        if(cont_input->values->Enum()!=PentaVertexInputEnum) _error_("not supported yet");
    509509                        PentaVertexInput* cast_input=(PentaVertexInput*)cont_input->values;
    510510                        for(i=0;i<numgrids;i++)this->values[i]=this->values[i]+scalar*(cast_input->values[i]);}
    511511                        return;
    512512                default:
    513                         ISSMERROR("not implemented yet");
     513                        _error_("not implemented yet");
    514514        }
    515515
    … …  
    547547
    548548        /*Check that input provided is a thickness*/
    549         if (thickness_input->EnumType()!=ThicknessEnum) ISSMERROR("Input provided is not a Thickness (enum_type is %s)",EnumToString(thickness_input->EnumType()));
     549        if (thickness_input->EnumType()!=ThicknessEnum) _error_("Input provided is not a Thickness (enum_type is %s)",EnumToString(thickness_input->EnumType()));
    550550
    551551        /*Get Thickness value pointer*/
    … …  
    563563
    564564                default:
    565                         ISSMERROR("not implemented yet");
     565                        _error_("not implemented yet");
    566566        }
    567567}
    … …  
    582582
    583583        /*Check that inputB is of the same type*/
    584         if (inputB->Enum()!=PentaVertexInputEnum) ISSMERROR("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum()));
     584        if (inputB->Enum()!=PentaVertexInputEnum) _error_("Operation not permitted because inputB is of type %s",EnumToString(inputB->Enum()));
    585585        xinputB=(PentaVertexInput*)inputB;
    586586
    587587        /*Create point wise sum*/
    588588        for(i=0;i<numgrids;i++){
    589                 ISSMASSERT(xinputB->values[i]!=0);
     589                _assert_(xinputB->values[i]!=0);
    590590                AdotBvalues[i]=this->values[i]/xinputB->values[i];
    591591        }

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

    r5743 r6412  
    4444                /*}}}*/
    4545                /*numerics: {{{1*/
    46                 void GetParameterValue(bool* pvalue){ISSMERROR("not implemented yet");};
    47                 void GetParameterValue(int* pvalue){ISSMERROR("not implemented yet");};
    48                 void GetParameterValue(double* pvalue){ISSMERROR("not implemented yet");};
    49                 void GetParameterValue(double* pvalue,GaussTria* gauss){ISSMERROR("not implemented yet");};
     46                void GetParameterValue(bool* pvalue){_error_("not implemented yet");};
     47                void GetParameterValue(int* pvalue){_error_("not implemented yet");};
     48                void GetParameterValue(double* pvalue){_error_("not implemented yet");};
     49                void GetParameterValue(double* pvalue,GaussTria* gauss){_error_("not implemented yet");};
    5050                void GetParameterValue(double* pvalue,GaussPenta* gauss);
    51                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){ISSMERROR("not implemented yet");};
     51                void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    5252                void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss);
    5353                void GetParameterAverage(double* pvalue);
    54                 void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){ISSMERROR("not implemented yet");};
    55                 void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){ISSMERROR("not implemented yet");};
     54                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
     55                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    5656                void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss);
    5757                void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss);
    … …  
    6464                void ConstrainMin(double minimum);
    6565                void Scale(double scale_factor);
    66                 void ArtificialNoise(double min,double max){ISSMERROR("not implemented yet");};
     66                void ArtificialNoise(double min,double max){_error_("not implemented yet");};
    6767                void AXPY(Input* xinput,double scalar);
    6868                void Constrain(double cm_min, double cm_max);

  • TabularUnified issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp

    r5743 r6412  
    374374
    375375                default :
    376                         ISSMERROR("not implemented yet");
     376                        _error_("not implemented yet");
    377377        }
    378378

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

    r5743 r6412  
    4040                int   EnumType();
    4141                Input* SpawnTriaInput(int* indices);
    42                 Input* PointwiseDivide(Input* inputB){ISSMERROR("not implemented yet");};
     42                Input* PointwiseDivide(Input* inputB){_error_("not implemented yet");};
    4343                ElementResult* SpawnResult(int step, double time);
    4444                /*}}}*/
    4545                /*numerics: {{{1*/
    46                 void GetParameterValue(bool* pvalue){ISSMERROR("not implemented yet");}
    47                 void GetParameterValue(int* pvalue){ISSMERROR("not implemented yet");}
    48                 void GetParameterValue(double* pvalue){ISSMERROR("not implemented yet");}
     46                void GetParameterValue(bool* pvalue){_error_("not implemented yet");}
     47                void GetParameterValue(int* pvalue){_error_("not implemented yet");}
     48                void GetParameterValue(double* pvalue){_error_("not implemented yet");}
    4949                void GetParameterValue(double* pvalue,GaussTria* gauss);
    50                 void GetParameterValue(double* pvalue,GaussPenta* gauss){ISSMERROR("not implemented yet");};
     50                void GetParameterValue(double* pvalue,GaussPenta* gauss){_error_("not implemented yet");};
    5151                void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussTria* gauss);
    52                 void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
     52                void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    5353                void GetParameterAverage(double* pvalue);
    5454                void GetVxStrainRate2d(double* epsilonvx,double* xyz_list, GaussTria* gauss);
    5555                void GetVyStrainRate2d(double* epsilonvy,double* xyz_list, GaussTria* gauss);
    56                 void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    57                 void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    58                 void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    59                 void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
    60                 void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){ISSMERROR("not implemented yet");};
     56                void GetVxStrainRate3d(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     57                void GetVyStrainRate3d(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     58                void GetVzStrainRate3d(double* epsilonvz,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     59                void GetVxStrainRate3dPattyn(double* epsilonvx,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     60                void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
    6161                void ChangeEnum(int newenumtype);
    6262
    … …  
    7272                double Min(void);
    7373                double MinAbs(void);
    74                 void Extrude(void){ISSMERROR("not supported yet");};
    75                 void VerticallyIntegrate(Input* thickness_input){ISSMERROR("not supported yet");};
     74                void Extrude(void){_error_("not supported yet");};
     75                void VerticallyIntegrate(Input* thickness_input){_error_("not supported yet");};
    7676                void GetVectorFromInputs(Vec vector,int* doflist);
    7777                void GetValuesPtr(double** pvalues,int* pnum_values);

  • TabularUnified issm/trunk/src/c/objects/Loads/Friction.cpp

    r5749 r6412  
    108108                vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2));
    109109        }
    110         else ISSMERROR("element_type %s not supported yet",element_type);
     110        else _error_("element_type %s not supported yet",element_type);
    111111
    112112        alpha2=pow(drag_coefficient,2)*pow(Neff,r)*pow(vmag,(s-1));
    … …  
    169169                vmag=sqrt(pow(vx,2)+pow(vy,2)+pow(vz,2));
    170170        }
    171         else ISSMERROR("element_type %s not supported yet",element_type);
     171        else _error_("element_type %s not supported yet",element_type);
    172172
    173173        alpha2=pow(drag_coefficient,2)*pow(Neff,r)*pow(vmag,(s-1));
    … …  
    239239
    240240        Input* input=inputs->GetInput(enum_type);
    241         if(!input) ISSMERROR("input %s not found",EnumToString(enum_type));
     241        if(!input) _error_("input %s not found",EnumToString(enum_type));
    242242        input->GetParameterValue(pvalue,gauss);
    243243
    … …  
    248248
    249249        Input* input=inputs->GetInput(enum_type);
    250         if(!input) ISSMERROR("input %s not found",EnumToString(enum_type));
     250        if(!input) _error_("input %s not found",EnumToString(enum_type));
    251251        input->GetParameterValue(pvalue,gauss);
    252252

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

    r5986 r6412  
    7878                icefront_node_ids[3]=iomodel->nodecounter+(int)*(iomodel->pressureload+segment_width*i+3);
    7979        }
    80         else ISSMERROR("in_icefront_type %s not supported yet!",EnumToString(in_icefront_type));
     80        else _error_("in_icefront_type %s not supported yet!",EnumToString(in_icefront_type));
    8181
    8282        if (in_icefront_type==PattynIceFrontEnum || in_icefront_type==StokesIceFrontEnum) num_nodes=4;
    … …  
    319319        /*Checks in debugging mode*/
    320320        /*{{{2*/
    321         ISSMASSERT(nodes);
    322         ISSMASSERT(element);
    323         ISSMASSERT(matpar);
     321        _assert_(nodes);
     322        _assert_(element);
     323        _assert_(matpar);
    324324        /*}}}*/
    325325
    … …  
    338338                        break;
    339339                default:
    340                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     340                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    341341        }
    342342
    … …  
    436436                        return CreatePVectorDiagnosticStokes();
    437437                default:
    438                         ISSMERROR("Icefront type %s not supported yet",EnumToString(type));
     438                        _error_("Icefront type %s not supported yet",EnumToString(type));
    439439        }
    440440}
    … …  
    472472        /*Retrieve all inputs and parameters*/
    473473        GetVerticesCoordinates(&xyz_list[0][0],nodes,numnodes);
    474         Input* thickness_input=tria->inputs->GetInput(ThicknessEnum); ISSMASSERT(thickness_input);
    475         Input* bed_input      =tria->inputs->GetInput(BedEnum);       ISSMASSERT(bed_input);
     474        Input* thickness_input=tria->inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
     475        Input* bed_input      =tria->inputs->GetInput(BedEnum);       _assert_(bed_input);
    476476        inputs->GetParameterValue(&fill,FillEnum);
    477477        rho_water=matpar->GetRhoWater();
    … …  
    502502                                break;
    503503                        default:
    504                                 ISSMERROR("fill type %s not supported yet",EnumToString(fill));
     504                                _error_("fill type %s not supported yet",EnumToString(fill));
    505505                }
    506506                ice_pressure=1.0/2.0*gravity*rho_ice*pow(thickness,2);
    … …  
    575575        /*Retrieve all inputs and parameters*/
    576576        GetVerticesCoordinates(&xyz_list[0][0], nodes, NUMVERTICESQUA);
    577         Input* surface_input  =penta->inputs->GetInput(SurfaceEnum);   ISSMASSERT(surface_input);
     577        Input* surface_input  =penta->inputs->GetInput(SurfaceEnum);   _assert_(surface_input);
    578578        inputs->GetParameterValue(&fill,FillEnum);
    579579        rho_water=matpar->GetRhoWater();
    … …  
    610610                                break;
    611611                        default:
    612                                 ISSMERROR("fill type %s not supported yet",EnumToString(fill));
     612                                _error_("fill type %s not supported yet",EnumToString(fill));
    613613                }
    614614                ice_pressure=rho_ice*gravity*(surface-z_g);
    … …  
    681681                                break;
    682682                        default:
    683                                 ISSMERROR("fill type %s not supported yet",EnumToString(fill));
     683                                _error_("fill type %s not supported yet",EnumToString(fill));
    684684                }
    685685                air_pressure=0;
    … …  
    716716
    717717        /*Some checks for debugging*/
    718         ISSMASSERT(nodes);
     718        _assert_(nodes);
    719719               
    720720        /*How many nodes? :*/

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

    r6216 r6412  
    6666                void  InputUpdateFromConstant(bool constant, int name);
    6767                void  InputUpdateFromSolution(double* solution);
    68                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){ISSMERROR("not implemented yet");};
     68                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
    6969                /*}}}*/
    7070                /*Load virtual functions definitions: {{{1*/

  • TabularUnified issm/trunk/src/c/objects/Loads/Numericalflux.cpp

    r6033 r6412  
    9292                        if (iomodel->elements[3*(e2-1)+j]==i2) pos4=j+1;
    9393                }
    94                 ISSMASSERT(pos1!=UNDEF && pos2!=UNDEF && pos3!=UNDEF && pos4!=UNDEF);
     94                _assert_(pos1!=UNDEF && pos2!=UNDEF && pos3!=UNDEF && pos4!=UNDEF);
    9595
    9696                /*3: We have the id of the elements and the position of the vertices in the index
    … …  
    109109                        if (iomodel->elements[3*(e1-1)+j]==i2) pos2=j+1;
    110110                }
    111                 ISSMASSERT(pos1!=UNDEF && pos2!=UNDEF);
     111                _assert_(pos1!=UNDEF && pos2!=UNDEF);
    112112
    113113                /*3: We have the id of the elements and the position of the vertices in the index
    … …  
    347347                        break;
    348348                default:
    349                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     349                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    350350        }
    351351
    … …  
    377377                        break;
    378378                default:
    379                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     379                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    380380        }
    381381
    … …  
    424424                        return CreateKMatrixPrognosticBoundary();
    425425                default:
    426                         ISSMERROR("type not supported yet");
     426                        _error_("type not supported yet");
    427427        }
    428428}
    … …  
    577577                        return CreateKMatrixBalancedthicknessBoundary();
    578578                default:
    579                         ISSMERROR("type not supported yet");
     579                        _error_("type not supported yet");
    580580        }
    581581}
    … …  
    728728                        return CreateKMatrixAdjointBalancedthicknessBoundary();
    729729                default:
    730                         ISSMERROR("type not supported yet");
     730                        _error_("type not supported yet");
    731731        }
    732732}
    … …  
    760760                        return CreatePVectorPrognosticBoundary();
    761761                default:
    762                         ISSMERROR("type not supported yet");
     762                        _error_("type not supported yet");
    763763        }
    764764}
    … …  
    794794        GetVerticesCoordinates(&xyz_list[0][0],nodes,NUMVERTICES_BOUNDARY);
    795795        parameters->FindParam(&dt,DtEnum);
    796         Input* vxaverage_input=tria->inputs->GetInput(VxEnum); ISSMASSERT(vxaverage_input);
    797         Input* vyaverage_input=tria->inputs->GetInput(VyEnum); ISSMASSERT(vyaverage_input);
    798         Input* thickness_input=tria->inputs->GetInput(ThicknessEnum); ISSMASSERT(thickness_input);
     796        Input* vxaverage_input=tria->inputs->GetInput(VxEnum); _assert_(vxaverage_input);
     797        Input* vyaverage_input=tria->inputs->GetInput(VyEnum); _assert_(vyaverage_input);
     798        Input* thickness_input=tria->inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    799799        GetNormal(&normal[0],xyz_list);
    800800
    … …  
    852852                        return CreatePVectorBalancedthicknessBoundary();
    853853                default:
    854                         ISSMERROR("type not supported yet");
     854                        _error_("type not supported yet");
    855855        }
    856856}
    … …  
    885885        /*Retrieve all inputs and parameters*/
    886886        GetVerticesCoordinates(&xyz_list[0][0],nodes,NUMVERTICES_BOUNDARY);
    887         Input* vxaverage_input=tria->inputs->GetInput(VxEnum); ISSMASSERT(vxaverage_input);
    888         Input* vyaverage_input=tria->inputs->GetInput(VyEnum); ISSMASSERT(vyaverage_input);
    889         Input* thickness_input=tria->inputs->GetInput(ThicknessEnum); ISSMASSERT(thickness_input);
     887        Input* vxaverage_input=tria->inputs->GetInput(VxEnum); _assert_(vxaverage_input);
     888        Input* vyaverage_input=tria->inputs->GetInput(VyEnum); _assert_(vyaverage_input);
     889        Input* thickness_input=tria->inputs->GetInput(ThicknessEnum); _assert_(thickness_input);
    890890        GetNormal(&normal[0],xyz_list);
    891891

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

    r6216 r6412  
    5353                /*Update virtual functions resolution: {{{1*/
    5454                void    InputUpdateFromVector(double* vector, int name, int type){/*Do nothing*/}
    55                 void    InputUpdateFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    56                 void    InputUpdateFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     55                void    InputUpdateFromVector(int* vector, int name, int type){_error_("Not implemented yet!");}
     56                void    InputUpdateFromVector(bool* vector, int name, int type){_error_("Not implemented yet!");}
    5757                void    InputUpdateFromVectorDakota(double* vector, int name, int type){/*Do nothing*/}
    58                 void    InputUpdateFromVectorDakota(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    59                 void    InputUpdateFromVectorDakota(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     58                void    InputUpdateFromVectorDakota(int* vector, int name, int type){_error_("Not implemented yet!");}
     59                void    InputUpdateFromVectorDakota(bool* vector, int name, int type){_error_("Not implemented yet!");}
    6060                void    InputUpdateFromConstant(double constant, int name){/*Do nothing*/};
    6161                void    InputUpdateFromConstant(int constant, int name){/*Do nothing*/};
    62                 void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    63                 void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    64                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){ISSMERROR("not implemented yet");};
     62                void    InputUpdateFromConstant(bool constant, int name){_error_("Not implemented yet!");}
     63                void    InputUpdateFromSolution(double* solution){_error_("Not implemented yet!");}
     64                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
    6565                /*}}}*/
    6666                /*Load virtual functions definitions: {{{1*/

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

    r6052 r6412  
    5454
    5555        /*Some checks if debugging activated*/
    56         ISSMASSERT(iomodel->singlenodetoelementconnectivity);
    57         ISSMASSERT(index>=0 && index<iomodel->numberofvertices);
    58         ISSMASSERT(id);
     56        _assert_(iomodel->singlenodetoelementconnectivity);
     57        _assert_(index>=0 && index<iomodel->numberofvertices);
     58        _assert_(id);
    5959
    6060        /*id: */
    … …  
    6565        pengrid_node_id=iomodel->nodecounter+index+1;
    6666        pengrid_element_id=iomodel->singlenodetoelementconnectivity[index];
    67         ISSMASSERT(pengrid_element_id);
     67        _assert_(pengrid_element_id);
    6868        pengrid_matpar_id=iomodel->numberofelements+1; //refers to the constant material parameters object
    6969
    … …  
    324324                        break;
    325325                default:
    326                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     326                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    327327        }
    328328
    … …  
    352352                        break;
    353353                default:
    354                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     354                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    355355        }
    356356
    … …  
    455455        }
    456456        else{
    457                 ISSMERROR("analysis: %s not supported yet",EnumToString(analysis_type));
     457                _error_("analysis: %s not supported yet",EnumToString(analysis_type));
    458458        }
    459459
    … …  
    682682/*FUNCTION Pengrid::UpdateInputs {{{1*/
    683683void  Pengrid::UpdateInputs(double* solution){
    684         ISSMERROR("not supported yet!");
    685 }
    686 /*}}}1*/
     684        _error_("not supported yet!");
     685}
     686/*}}}1*/

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

    r6216 r6412  
    6767                void  InputUpdateFromConstant(bool constant, int name);
    6868                void  InputUpdateFromSolution(double* solution);
    69                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){ISSMERROR("not implemented yet");};
     69                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
    7070                /*}}}*/
    7171                /*Load virtual functions definitions: {{{1*/

  • TabularUnified issm/trunk/src/c/objects/Loads/Penpair.cpp

    r5989 r6412  
    229229                        break;
    230230                default:
    231                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     231                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    232232        }
    233233
    … …  
    281281                                case MacAyealApproximationEnum: return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
    282282                                case PattynApproximationEnum:   return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
    283                                 default: ISSMERROR("not supported yet");
     283                                default: _error_("not supported yet");
    284284                        }
    285285                case PattynApproximationEnum:
    … …  
    287287                                case MacAyealApproximationEnum: return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
    288288                                case PattynApproximationEnum:   return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
    289                                 default: ISSMERROR("not supported yet");
     289                                default: _error_("not supported yet");
    290290                        }
    291291                case StokesApproximationEnum:
    … …  
    293293                                case StokesApproximationEnum: return PenaltyCreateKMatrixDiagnosticStokes(kmax);
    294294                                case NoneApproximationEnum: return   PenaltyCreateKMatrixDiagnosticStokes(kmax);
    295                                 default: ISSMERROR("not supported yet");
     295                                default: _error_("not supported yet");
    296296                        }
    297297                case NoneApproximationEnum:
    … …  
    299299                                case StokesApproximationEnum: return PenaltyCreateKMatrixDiagnosticStokes(kmax);
    300300                                case NoneApproximationEnum: return   PenaltyCreateKMatrixDiagnosticStokes(kmax);
    301                                 default: ISSMERROR("not supported yet");
     301                                default: _error_("not supported yet");
    302302                        }
    303                 default: ISSMERROR("not supported yet");
     303                default: _error_("not supported yet");
    304304        }
    305305}

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

    r6216 r6412  
    4444                /*}}}*/
    4545                /*Update virtual functions resolution: {{{1*/
    46                 void  InputUpdateFromVector(double* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    47                 void  InputUpdateFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    48                 void  InputUpdateFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    49                 void  InputUpdateFromVectorDakota(double* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    50                 void  InputUpdateFromVectorDakota(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    51                 void  InputUpdateFromVectorDakota(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     46                void  InputUpdateFromVector(double* vector, int name, int type){_error_("Not implemented yet!");}
     47                void  InputUpdateFromVector(int* vector, int name, int type){_error_("Not implemented yet!");}
     48                void  InputUpdateFromVector(bool* vector, int name, int type){_error_("Not implemented yet!");}
     49                void  InputUpdateFromVectorDakota(double* vector, int name, int type){_error_("Not implemented yet!");}
     50                void  InputUpdateFromVectorDakota(int* vector, int name, int type){_error_("Not implemented yet!");}
     51                void  InputUpdateFromVectorDakota(bool* vector, int name, int type){_error_("Not implemented yet!");}
    5252                void  InputUpdateFromConstant(double constant, int name);
    5353                void  InputUpdateFromConstant(int constant, int name);
    5454                void  InputUpdateFromConstant(bool constant, int name);
    55                 void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    56                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){ISSMERROR("not implemented yet");};
     55                void  InputUpdateFromSolution(double* solution){_error_("Not implemented yet!");}
     56                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
    5757                /*}}}*/
    5858                        /*Load virtual functions definitions: {{{1*/

  • TabularUnified issm/trunk/src/c/objects/Loads/Riftfront.cpp

    r6207 r6412  
    385385
    386386        /*update input*/
    387         ISSMERROR("not implemented yet");
     387        _error_("not implemented yet");
    388388        //this->inputs->AddInput(new DoubleInput(name,constant));
    389389
    … …  
    433433                        break;
    434434                default:
    435                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     435                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    436436        }
    437437
    … …  
    459459                        break;
    460460                default:
    461                         ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     461                        _error_("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    462462        }
    463463
    … …  
    506506
    507507        /*enum of element? */
    508         if(elements[0]->Enum()!=TriaEnum)ISSMERROR(" only Tria element allowed for Riftfront load!");
     508        if(elements[0]->Enum()!=TriaEnum)_error_(" only Tria element allowed for Riftfront load!");
    509509        tria1=(Tria*)elements[0];
    510510        tria2=(Tria*)elements[1];
    … …  
    519519        tria1->GetParameterValue(&h[0],nodes[0],ThicknessEnum);
    520520        tria2->GetParameterValue(&h[1],nodes[1],ThicknessEnum);
    521         if (h[0]!=h[1])ISSMERROR(" different thicknesses not supported for rift fronts");
     521        if (h[0]!=h[1])_error_(" different thicknesses not supported for rift fronts");
    522522        thickness=h[0];
    523523
    … …  
    597597
    598598        /*enum of element? */
    599         if(elements[0]->Enum()!=TriaEnum)ISSMERROR(" only Tria element allowed for Riftfront load!");
     599        if(elements[0]->Enum()!=TriaEnum)_error_(" only Tria element allowed for Riftfront load!");
    600600        tria1=(Tria*)elements[0];
    601601        tria2=(Tria*)elements[1];
    … …  
    613613        tria1->GetParameterValue(&h[0],nodes[0],ThicknessEnum);
    614614        tria2->GetParameterValue(&h[1],nodes[1],ThicknessEnum);
    615         if (h[0]!=h[1])ISSMERROR(" different thicknesses not supported for rift fronts");
     615        if (h[0]!=h[1])_error_(" different thicknesses not supported for rift fronts");
    616616        thickness=h[0];
    617617        tria1->GetParameterValue(&b[0],nodes[0],BedEnum);
    618618        tria2->GetParameterValue(&b[1],nodes[1],BedEnum);
    619         if (b[0]!=b[1])ISSMERROR(" different beds not supported for rift fronts");
     619        if (b[0]!=b[1])_error_(" different beds not supported for rift fronts");
    620620        bed=b[0];
    621621
    … …  
    645645        else if(fill==MelangeEnum){ //icefront finding itself against another icefront (pressure imbalance is fully compensated, ice vs ice)
    646646
    647                 if(!shelf) ISSMERROR("%s%i%s","fill type ",fill," not supported on ice sheets yet.");
     647                if(!shelf) _error_("%s%i%s","fill type ",fill," not supported on ice sheets yet.");
    648648
    649649                pressure_litho=rho_ice*gravity*pow(thickness,(double)2)/(double)2;
    … …  
    655655        }
    656656        else{
    657                 ISSMERROR("%s%i%s","fill type ",fill," not supported yet.");
     657                _error_("%s%i%s","fill type ",fill," not supported yet.");
    658658        }
    659659
    … …  
    694694
    695695        /*enum of element? */
    696         if(elements[0]->Enum()!=TriaEnum)ISSMERROR(" only Tria element allowed for Riftfront load!");
     696        if(elements[0]->Enum()!=TriaEnum)_error_(" only Tria element allowed for Riftfront load!");
    697697
    698698        /*recover elements on both side of rift: */
    … …  
    802802
    803803        /*enum of element? */
    804         if(elements[0]->Enum()!=TriaEnum)ISSMERROR(" only Tria element allowed for Riftfront load!");
     804        if(elements[0]->Enum()!=TriaEnum)_error_(" only Tria element allowed for Riftfront load!");
    805805
    806806        /*recover elements on both side of rift: */
    … …  
    861861
    862862        /*enum of element? */
    863         if(elements[0]->Enum()!=TriaEnum)ISSMERROR(" only Tria element allowed for Riftfront load!");
     863        if(elements[0]->Enum()!=TriaEnum)_error_(" only Tria element allowed for Riftfront load!");
    864864
    865865        /*recover elements on both side of rift: */
    … …  
    904904
    905905        /*enum of element? */
    906         if(elements[0]->Enum()!=TriaEnum)ISSMERROR(" only Tria element allowed for Riftfront load!");
     906        if(elements[0]->Enum()!=TriaEnum)_error_(" only Tria element allowed for Riftfront load!");
    907907
    908908        /*recover elements on both side of rift: */
    … …  
    953953
    954954        /*enum of element? */
    955         if(elements[0]->Enum()!=TriaEnum)ISSMERROR(" only Tria element allowed for Riftfront load!");
     955        if(elements[0]->Enum()!=TriaEnum)_error_(" only Tria element allowed for Riftfront load!");
    956956
    957957        /*recover elements on both side of rift: */

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

    r6216 r6412  
    6464                /*Update virtual functions resolution: {{{1*/
    6565                void    InputUpdateFromVector(double* vector, int name, int type);
    66                 void    InputUpdateFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    67                 void    InputUpdateFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    68                 void    InputUpdateFromVectorDakota(double* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    69                 void    InputUpdateFromVectorDakota(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    70                 void    InputUpdateFromVectorDakota(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     66                void    InputUpdateFromVector(int* vector, int name, int type){_error_("Not implemented yet!");}
     67                void    InputUpdateFromVector(bool* vector, int name, int type){_error_("Not implemented yet!");}
     68                void    InputUpdateFromVectorDakota(double* vector, int name, int type){_error_("Not implemented yet!");}
     69                void    InputUpdateFromVectorDakota(int* vector, int name, int type){_error_("Not implemented yet!");}
     70                void    InputUpdateFromVectorDakota(bool* vector, int name, int type){_error_("Not implemented yet!");}
    7171                void    InputUpdateFromConstant(double constant, int name);
    7272                void    InputUpdateFromConstant(int constant, int name);
    73                 void    InputUpdateFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    74                 void    InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    75                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){ISSMERROR("not implemented yet");};
     73                void    InputUpdateFromConstant(bool constant, int name){_error_("Not implemented yet!");}
     74                void    InputUpdateFromSolution(double* solution){_error_("Not implemented yet!");}
     75                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
    7676                /*}}}*/
    7777                /*Load virtual functions definitions: {{{1*/

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

    r6260 r6412  
    282282
    283283        /*Checks in debugging mode*/
    284         if(viscosity<=0) ISSMERROR("Negative viscosity");
    285         ISSMASSERT(B>0);
    286         ISSMASSERT(n>0);
     284        if(viscosity<=0) _error_("Negative viscosity");
     285        _assert_(B>0);
     286        _assert_(n>0);
    287287
    288288        /*Return: */
    … …  
    353353
    354354        /*Checks in debugging mode*/
    355         if(viscosity3d<=0) ISSMERROR("Negative viscosity");
    356         ISSMASSERT(B>0);
    357         ISSMASSERT(n>0);
     355        if(viscosity3d<=0) _error_("Negative viscosity");
     356        _assert_(B>0);
     357        _assert_(n>0);
    358358
    359359        /*Assign output pointers:*/
    … …  
    425425
    426426        /*Checks in debugging mode*/
    427         if(viscosity3d<=0) ISSMERROR("Negative viscosity");
    428         ISSMASSERT(B>0);
    429         ISSMASSERT(n>0);
     427        if(viscosity3d<=0) _error_("Negative viscosity");
     428        _assert_(B>0);
     429        _assert_(n>0);
    430430
    431431        /*Assign output pointers:*/
    … …  
    481481
    482482        /*Checks in debugging mode*/
    483         ISSMASSERT(B>0);
    484         ISSMASSERT(n>0);
    485         ISSMASSERT(viscosity_complement>0);
     483        _assert_(B>0);
     484        _assert_(n>0);
     485        _assert_(viscosity_complement>0);
    486486               
    487487        /*Return: */
    … …  
    521521                                        return;
    522522
    523                                 default: ISSMERROR("element %s not implemented yet",EnumToString(element->Enum()));
    524                         }
    525                 default: ISSMERROR("type %i (%s) not implemented yet",type,EnumToString(type));
     523                                default: _error_("element %s not implemented yet",EnumToString(element->Enum()));
     524                        }
     525                default: _error_("type %i (%s) not implemented yet",type,EnumToString(type));
    526526        }
    527527}
    … …  
    561561                                        return;
    562562
    563                                 default: ISSMERROR("element %s not implemented yet",EnumToString(element->Enum()));
    564                         }
    565                 default: ISSMERROR("type %i (%s) not implemented yet",type,EnumToString(type));
     563                                default: _error_("element %s not implemented yet",EnumToString(element->Enum()));
     564                        }
     565                default: _error_("type %i (%s) not implemented yet",type,EnumToString(type));
    566566        }
    567567}
    … …  
    670670        }
    671671        else{
    672                 ISSMERROR(" Mesh type not supported yet!");
     672                _error_(" Mesh type not supported yet!");
    673673        }
    674674

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

    r6216 r6412  
    5656                void   InputUpdateFromConstant(bool constant, int name);
    5757                void   InputUpdateFromSolution(double* solution);
    58                 void   InputUpdateFromIoModel(int index, IoModel* iomodel){ISSMERROR("not implemented yet");};
     58                void   InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("not implemented yet");};
    5959                /*}}}*/
    6060                /*Material virtual functions resolution: {{{1*/
    61                 void   InputDuplicate(int original_enum,int new_enum){ISSMERROR("not implemented yet");};
     61                void   InputDuplicate(int original_enum,int new_enum){_error_("not implemented yet");};
    6262                void   Configure(Elements* elements);
    6363                /*}}}*/

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

    r6231 r6412  
    9292                if (iomodel->dim==3){
    9393                        /*We have a  3d mesh, we may have collapsed elements, hence dead grids. Freeze them out: */
    94                         if (!iomodel->gridonbed) ISSMERROR("iomodel->gridonbed is NULL");
    95                         if (!iomodel->vertices_type) ISSMERROR("iomodel->vertices_type is NULL");
     94                        if (!iomodel->gridonbed) _error_("iomodel->gridonbed is NULL");
     95                        if (!iomodel->vertices_type) _error_("iomodel->vertices_type is NULL");
    9696                        if (iomodel->vertices_type[io_index]==MacAyealApproximationEnum && !iomodel->gridonbed[io_index]){
    9797                                for(k=1;k<=gsize;k++) this->FreezeDof(k);
    … …  
    109109                }
    110110                /*spc all nodes on hutter*/
    111                 if (!iomodel->gridonhutter) ISSMERROR("iomodel->gridonhutter is NULL");
     111                if (!iomodel->gridonhutter) _error_("iomodel->gridonhutter is NULL");
    112112                if (iomodel->gridonhutter[io_index]){
    113113                        for(k=1;k<=gsize;k++){
    … …  
    120120        if (analysis_type==DiagnosticHutterAnalysisEnum){
    121121                /*Spc all nodes that are not Hutter*/
    122                 if (!iomodel->gridonhutter) ISSMERROR("iomodel->gridonhutter is NULL");
     122                if (!iomodel->gridonhutter) _error_("iomodel->gridonhutter is NULL");
    123123                if (!iomodel->gridonhutter[io_index]){
    124124                        for(k=1;k<=gsize;k++){
    … …  
    139139                if (iomodel->dim==3){
    140140                        /*On a 3d mesh, we may have collapsed elements, hence dead grids. Freeze them out: */
    141                         if (!iomodel->gridonbed) ISSMERROR("iomodel->gridonbed is NULL");
     141                        if (!iomodel->gridonbed) _error_("iomodel->gridonbed is NULL");
    142142                        if (!iomodel->gridonbed[io_index]){
    143143                                for(k=1;k<=gsize;k++){
    … …  
    319319                return indexing.sdoflist[dofindex];
    320320        }
    321         else ISSMERROR("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     321        else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
    322322
    323323}
    … …  
    355355                                        }
    356356                                }
    357                                 ISSMASSERT(count); //at least one dof should be the approximation requested
     357                                _assert_(count); //at least one dof should be the approximation requested
    358358                        }
    359359                        else for(i=0;i<this->indexing.gsize;i++) outdoflist[i]=indexing.gdoflist[i];
    … …  
    391391                        else for(i=0;i<this->indexing.ssize;i++) outdoflist[i]=indexing.sdoflist[i];
    392392                }
    393                 else ISSMERROR("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     393                else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
    394394        }
    395395}
    … …  
    431431                        }
    432432                }
    433                 else ISSMERROR("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     433                else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
    434434        }
    435435        else{
    … …  
    444444                                        }
    445445                                }
    446                                 ISSMASSERT(count);
     446                                _assert_(count);
    447447                        }
    448448                        else for(i=0;i<this->indexing.gsize;i++) outdoflist[i]=i;
    … …  
    462462                                        }
    463463                                }
    464                                 ISSMASSERT(count2);
     464                                _assert_(count2);
    465465                        }
    466466                        else{
    … …  
    488488                                        }
    489489                                }
    490                                 ISSMASSERT(count2);
     490                                _assert_(count2);
    491491                        }
    492492                        else{
    … …  
    500500                        }
    501501                }
    502                 else ISSMERROR("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     502                else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
    503503        }
    504504}
    … …  
    659659                else if (setenum==FsetEnum) numdofs=this->indexing.fsize;
    660660                else if (setenum==SsetEnum) numdofs=this->indexing.ssize;
    661                 else ISSMERROR("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     661                else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
    662662        }
    663663        else{
    … …  
    689689                        else numdofs=this->indexing.ssize;
    690690                }
    691                 else ISSMERROR("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     691                else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
    692692        }
    693693        return numdofs;
    … …  
    872872                dofcount+=this->indexing.ssize;
    873873        }
    874         else ISSMERROR("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     874        else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
    875875
    876876
    … …  
    901901                for(i=0;i<this->indexing.ssize;i++) indexing.sdoflist[i]+=dofcount;
    902902        }
    903         else ISSMERROR("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     903        else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
    904904}
    905905/*}}}*/
    … …  
    917917        else if(setenum==FsetEnum)for(j=0;j<this->indexing.fsize;j++)  *(truedofs+ncols*sid+j)=indexing.fdoflist[j];
    918918        else if(setenum==SsetEnum)for(j=0;j<this->indexing.ssize;j++)  *(truedofs+ncols*sid+j)=indexing.sdoflist[j];
    919         else ISSMERROR("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     919        else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
    920920
    921921}
    … …  
    936936        else if(setenum==FsetEnum)for(j=0;j<this->indexing.fsize;j++) indexing.fdoflist[j]=*(alltruedofs+ncols*sid+j);
    937937        else if(setenum==SsetEnum)for(j=0;j<this->indexing.ssize;j++) indexing.sdoflist[j]=*(alltruedofs+ncols*sid+j);
    938         else ISSMERROR("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
     938        else _error_("%s%s%s"," set of enum type ",EnumToString(setenum)," not supported yet!");
    939939
    940940}

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

    r6231 r6412  
    6161                void  InputUpdateFromConstant(int constant, int name);
    6262                void  InputUpdateFromConstant(bool constant, int name);
    63                 void  InputUpdateFromSolution(double* solution){ISSMERROR("Not implemented yet!");}
    64                 void  InputUpdateFromIoModel(int index, IoModel* iomodel){ISSMERROR("Not implemented yet!");}
     63                void  InputUpdateFromSolution(double* solution){_error_("Not implemented yet!");}
     64                void  InputUpdateFromIoModel(int index, IoModel* iomodel){_error_("Not implemented yet!");}
    6565                /*}}}*/
    6666                /*Node numerical routines {{{1*/

  • TabularUnified issm/trunk/src/c/objects/Numerics/ElementMatrix.cpp

    r6031 r6412  
    4848ElementMatrix::ElementMatrix(ElementMatrix* Ke){
    4949
    50         if(!Ke) ISSMERROR("Input Element Matrix is a NULL pointer");
     50        if(!Ke) _error_("Input Element Matrix is a NULL pointer");
    5151        this->Init(Ke);
    5252        return;
    … …  
    6464        /*If one of the two matrix is NULL, we copy the other one*/
    6565        if(!Ke1 && !Ke2){
    66                 ISSMERROR("Two input element matrices are NULL");
     66                _error_("Two input element matrices are NULL");
    6767        }
    6868        else if(!Ke1){
    … …  
    7676
    7777        /*General Case: Ke1 and Ke2 are not empty*/
    78         if(!Ke1->dofsymmetrical || !Ke2->dofsymmetrical) ISSMERROR("merging 2 non dofsymmetrical matrices not implemented yet");
     78        if(!Ke1->dofsymmetrical || !Ke2->dofsymmetrical) _error_("merging 2 non dofsymmetrical matrices not implemented yet");
    7979
    8080        /*Initialize itransformation matrix Ke[P[i]] = Ke2[i]*/
    … …  
    307307        }
    308308        else{
    309                 ISSMERROR(" non dofsymmetrical matrix AddToGlobal routine not support yet!");
     309                _error_(" non dofsymmetrical matrix AddToGlobal routine not support yet!");
    310310        }
    311311
    … …  
    318318        for (int i=0;i<this->nrows;i++){
    319319                for(int j=0;j<this->ncols;j++){
    320                         if (isnan(this->values[i*this->ncols+j])) ISSMERROR("NaN found in Element Matrix");
    321                         if (fabs(this->values[i*this->ncols+j])>1.e+50) ISSMERROR("Element Matrix values exceeds 1.e+50");
     320                        if (isnan(this->values[i*this->ncols+j])) _error_("NaN found in Element Matrix");
     321                        if (fabs(this->values[i*this->ncols+j])>1.e+50) _error_("Element Matrix values exceeds 1.e+50");
    322322                }
    323323        }
    … …  
    340340        /*Transpose indices*/
    341341        if(!dofsymmetrical){
    342                 ISSMERROR("not supported yet");
     342                _error_("not supported yet");
    343343        }
    344344
    … …  
    398398void ElementMatrix::Init(ElementMatrix* Ke){
    399399
    400         ISSMASSERT(Ke);
     400        _assert_(Ke);
    401401
    402402        this->nrows =Ke->nrows;

  • TabularUnified issm/trunk/src/c/objects/Numerics/ElementVector.cpp

    r6034 r6412  
    4242        /*If one of the two matrix is NULL, we copy the other one*/
    4343        if(!pe1 && !pe2){
    44                 ISSMERROR("Two input element matrices are NULL");
     44                _error_("Two input element matrices are NULL");
    4545        }
    4646        else if(!pe1){
    … …  
    223223void ElementVector::Init(ElementVector* pe){
    224224
    225         ISSMASSERT(pe);
     225        _assert_(pe);
    226226
    227227        this->nrows =pe->nrows;

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

    r6165 r6412  
    5050                int   EnumType(){return enum_type;}
    5151                void  GetParameterValue(bool* pbool){*pbool=value;}
    52                 void  GetParameterValue(int* pinteger){ISSMERROR("Bool param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int** pintarray,int* pM){ISSMERROR("Bool param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(double* pdouble){ISSMERROR("Bool param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(char** pstring){ISSMERROR("Bool param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("Bool param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    59                 void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Bool param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
    60                 void  GetParameterValue(Vec* pvec){ISSMERROR("Bool param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(Mat* pmat){ISSMERROR("Bool param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(FILE** pfid){ISSMERROR("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(int* pinteger){_error_("Bool param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
     53                void  GetParameterValue(int** pintarray,int* pM){_error_("Bool param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(double* pdouble){_error_("Bool param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     55                void  GetParameterValue(char** pstring){_error_("Bool param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Bool param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(double** pdoublearray,int* pM){_error_("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     58                void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("Bool param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     59                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("Bool param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(Vec* pvec){_error_("Bool param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(Mat* pmat){_error_("Bool param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     62                void  GetParameterValue(FILE** pfid){_error_("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
    6363
    6464                void  SetValue(bool boolean){this->value=boolean;}
    6565                void  SetValue(int integer){this->value=(bool)integer;}
    66                 void  SetValue(int* intarray,int M){ISSMERROR("Bool param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     66                void  SetValue(int* intarray,int M){_error_("Bool param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    6767                void  SetValue(double scalar){this->value=(bool)scalar;}
    68                 void  SetValue(char* string){ISSMERROR("Bool param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(char** stringarray,int M){ISSMERROR("Bool param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(double* doublearray,int M){ISSMERROR("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* pdoublearray,int M,int N){ISSMERROR("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(Vec vec){ISSMERROR("Bool param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(Mat mat){ISSMERROR("Bool param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(FILE* fid){ISSMERROR("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("Bool param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
     68                void  SetValue(char* string){_error_("Bool param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     69                void  SetValue(char** stringarray,int M){_error_("Bool param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     70                void  SetValue(double* doublearray,int M){_error_("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     71                void  SetValue(double* pdoublearray,int M,int N){_error_("Bool param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     72                void  SetValue(Vec vec){_error_("Bool param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     73                void  SetValue(Mat mat){_error_("Bool param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
     74                void  SetValue(FILE* fid){_error_("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     75                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("Bool param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
    7676               
    7777                char* GetParameterName(void);

  • TabularUnified issm/trunk/src/c/objects/Params/DoubleMatArrayParam.h

    r6165 r6412  
    5252                /*Param vritual function definitions: {{{1*/
    5353                int   EnumType(){return enum_type;}
    54                 void  GetParameterValue(bool* pbool){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(int* pinteger){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(int** pintarray,int* pM){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(double* pdouble){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(char** pstring){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    59                 void  GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    60                 void  GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(bool* pbool){_error_("DoubleMatArray param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
     55                void  GetParameterValue(int* pinteger){_error_("DoubleMatArray param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(int** pintarray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(double* pdouble){_error_("DoubleMatArray param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     58                void  GetParameterValue(char** pstring){_error_("DoubleMatArray param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     59                void  GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(double** pdoublearray,int* pM){_error_("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("DoubleMatArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    6262                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims);
    63                 void  GetParameterValue(Vec* pvec){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    64                 void  GetParameterValue(Mat* pmat){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    65                 void  GetParameterValue(FILE** pfid){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(Vec* pvec){_error_("DoubleMatArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
     64                void  GetParameterValue(Mat* pmat){_error_("DoubleMatArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     65                void  GetParameterValue(FILE** pfid){_error_("DoubleMatArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
    6666
    67                 void  SetValue(bool boolean){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(int integer){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(int* intarray,int M){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(double scalar){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(char* string){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(char** stringarray,int M){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(double* doublearray,int M){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(double* doublearray,int M,int N){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(Vec vec){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(Mat mat){ISSMERROR("DoubleMatArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    77                 void  SetValue(FILE* fid){ISSMERROR("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     67                void  SetValue(bool boolean){_error_("DoubleMatArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
     68                void  SetValue(int integer){_error_("DoubleMatArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
     69                void  SetValue(int* intarray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     70                void  SetValue(double scalar){_error_("DoubleMatArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
     71                void  SetValue(char* string){_error_("DoubleMatArray param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     72                void  SetValue(char** stringarray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     73                void  SetValue(double* doublearray,int M){_error_("DoubleMatArray param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToString(enum_type));}
     74                void  SetValue(double* doublearray,int M,int N){_error_("DoubleMatArray param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));}
     75                void  SetValue(Vec vec){_error_("DoubleMatArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     76                void  SetValue(Mat mat){_error_("DoubleMatArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
     77                void  SetValue(FILE* fid){_error_("Bool param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    7878                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array);
    7979

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

    r6165 r6412  
    5151                /*Param vritual function definitions: {{{1*/
    5252                int   EnumType(){return enum_type;}
    53                 void  GetParameterValue(bool* pbool){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(int* pinteger){ISSMERROR("DoubleMat param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(int** pintarray,int* pM){ISSMERROR("DoubleMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(double* pdouble){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char** pstring){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    59                 void  GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     53                void  GetParameterValue(bool* pbool){_error_("DoubleMat param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(int* pinteger){_error_("DoubleMat param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
     55                void  GetParameterValue(int** pintarray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(double* pdouble){_error_("DoubleMat param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(char** pstring){_error_("DoubleMat param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     58                void  GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     59                void  GetParameterValue(double** pdoublearray,int* pM){_error_("DoubleMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    6060                void  GetParameterValue(double** pdoublearray,int* pM,int* pN);
    61                 void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(Vec* pvec){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(Mat* pmat){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    64                 void  GetParameterValue(FILE** pfid){ISSMERROR("DoubleMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("DoubleMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
     62                void  GetParameterValue(Vec* pvec){_error_("DoubleMat param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(Mat* pmat){_error_("DoubleMat param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     64                void  GetParameterValue(FILE** pfid){_error_("DoubleMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
    6565
    66                 void  SetValue(bool boolean){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int integer){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(int* intarray,int M){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(double scalar){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char* string){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(char** stringarray,int M){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(double* doublearray,int M){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToString(enum_type));}
     66                void  SetValue(bool boolean){_error_("DoubleMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
     67                void  SetValue(int integer){_error_("DoubleMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
     68                void  SetValue(int* intarray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     69                void  SetValue(double scalar){_error_("DoubleMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
     70                void  SetValue(char* string){_error_("DoubleMat param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     71                void  SetValue(char** stringarray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     72                void  SetValue(double* doublearray,int M){_error_("DoubleMat param of enum %i (%s) cannot hold a double vec array",enum_type,EnumToString(enum_type));}
    7373                void  SetValue(double* doublearray,int M,int N);
    74                 void  SetValue(Vec vec){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(Mat mat){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(FILE* fid){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    77                 void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("DoubleMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
     74                void  SetValue(Vec vec){_error_("DoubleMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     75                void  SetValue(Mat mat){_error_("DoubleMat param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
     76                void  SetValue(FILE* fid){_error_("DoubleMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     77                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("DoubleMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
    7878
    7979                char* GetParameterName(void);

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

    r6226 r6412  
    134134        *pinteger=(int)value;
    135135#else
    136         ISSMERROR("Double param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));
     136        _error_("Double param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));
    137137#endif
    138138}
    … …  
    143143
    144144        /*If debugging mode, cheeck that the double is 0 or 1*/
    145         ISSMASSERT(value==0 || value==1);
     145        _assert_(value==0 || value==1);
    146146        *pbool=(bool)value;
    147147
    148148#else
    149         ISSMERROR("Double param of enum %i (%s) cannot return an bool",enum_type,EnumToString(enum_type));
     149        _error_("Double param of enum %i (%s) cannot return an bool",enum_type,EnumToString(enum_type));
    150150#endif
    151151}
    … …  
    163163        *pintarray=output;
    164164#else
    165         ISSMERROR("Double param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));
     165        _error_("Double param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));
    166166#endif
    167167}
    … …  
    179179        *pdoublearray=output;
    180180#else
    181         ISSMERROR("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type));
     181        _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type));
    182182#endif
    183183}
    … …  
    196196        *pdoublearray=output;
    197197#else
    198         ISSMERROR("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type));
     198        _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type));
    199199#endif
    200200}

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

    r6226 r6412  
    5454                void  GetParameterValue(int** pintarray,int* pM);
    5555                void  GetParameterValue(double* pdouble){*pdouble=value;}
    56                 void  GetParameterValue(char** pstring){ISSMERROR("Double param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("Double param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(char** pstring){_error_("Double param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Double param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    5858                void  GetParameterValue(double** pdoublearray,int* pM);
    5959                void  GetParameterValue(double** pdoublearray,int* pM, int* pN);
    60                 void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Double param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(Vec* pvec){ISSMERROR("Double param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(Mat* pmat){ISSMERROR("Double param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(FILE** pfid){ISSMERROR("Double param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("Double param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(Vec* pvec){_error_("Double param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
     62                void  GetParameterValue(Mat* pmat){_error_("Double param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("Double param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
    6464
    6565                void  SetValue(bool boolean){this->value=(double)boolean;}
    6666                void  SetValue(int integer){this->value=(double)integer;}
    67                 void  SetValue(int* intarray,int M){ISSMERROR("Double param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("Double param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    6868                void  SetValue(double scalar){this->value=(double)scalar;}
    69                 void  SetValue(char* string){ISSMERROR("Double param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char** stringarray,int M){ISSMERROR("Double param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* doublearray,int M){ISSMERROR("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(double* pdoublearray,int M,int N){ISSMERROR("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(Vec vec){ISSMERROR("Double param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(Mat mat){ISSMERROR("Double param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(FILE* fid){ISSMERROR("Double param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("Double param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
     69                void  SetValue(char* string){_error_("Double param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     70                void  SetValue(char** stringarray,int M){_error_("Double param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     71                void  SetValue(double* doublearray,int M){_error_("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     72                void  SetValue(double* pdoublearray,int M,int N){_error_("Double param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     73                void  SetValue(Vec vec){_error_("Double param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     74                void  SetValue(Mat mat){_error_("Double param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
     75                void  SetValue(FILE* fid){_error_("Double param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     76                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("Double param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
    7777
    7878                char* GetParameterName(void);

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

    r6260 r6412  
    174174        *pintarray=output;
    175175#else
    176         ISSMERROR("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type));
     176        _error_("Double param of enum %i (%s) cannot return an array of double",enum_type,EnumToString(enum_type));
    177177#endif
    178178}

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

    r6260 r6412  
    5050                /*Param virtual functions definitions: {{{1*/
    5151                int   EnumType(){return enum_type;}
    52                 void  GetParameterValue(bool* pbool){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int* pinteger){ISSMERROR("DoubleVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(bool* pbool){_error_("DoubleVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
     53                void  GetParameterValue(int* pinteger){_error_("DoubleVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    5454                void  GetParameterValue(int** pintarray,int* pM);
    55                 void  GetParameterValue(double* pdouble){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char** pstring){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     55                void  GetParameterValue(double* pdouble){_error_("DoubleVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(char** pstring){_error_("DoubleVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("DoubleVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    5858                void  GetParameterValue(double** pdoublearray,int* pM);
    59                 void  GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    60                 void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(Vec* pvec){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(Mat* pmat){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(FILE** pfid){ISSMERROR("DoubleVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     59                void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("DoubleVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("DoubleVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(Vec* pvec){_error_("DoubleVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
     62                void  GetParameterValue(Mat* pmat){_error_("DoubleVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("DoubleVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
    6464
    65                 void  SetValue(bool boolean){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    66                 void  SetValue(int integer){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int* intarray,int M){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(double scalar){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(char* string){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char** stringarray,int M){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     65                void  SetValue(bool boolean){_error_("DoubleVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
     66                void  SetValue(int integer){_error_("DoubleVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("DoubleVec param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     68                void  SetValue(double scalar){_error_("DoubleVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
     69                void  SetValue(char* string){_error_("DoubleVec param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     70                void  SetValue(char** stringarray,int M){_error_("DoubleVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    7171                void  SetValue(double* doublearray,int M);
    72                 void  SetValue(double* pdoublearray,int M,int N){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(Vec vec){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(Mat mat){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(FILE* fid){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("DoubleVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
     72                void  SetValue(double* pdoublearray,int M,int N){_error_("DoubleVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));}
     73                void  SetValue(Vec vec){_error_("DoubleVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     74                void  SetValue(Mat mat){_error_("DoubleVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
     75                void  SetValue(FILE* fid){_error_("DoubleVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     76                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("DoubleVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
    7777               
    7878                char* GetParameterName(void);

  • TabularUnified issm/trunk/src/c/objects/Params/FileParam.cpp

    r5103 r6412  
    6565void  FileParam::Marshall(char** pmarshalled_dataset){
    6666
    67         ISSMERROR("FileParam is a pointer and cannot be marshalled");
     67        _error_("FileParam is a pointer and cannot be marshalled");
    6868}
    6969/*}}}*/
    7070/*FUNCTION FileParam::MarshallSize{{{1*/
    7171int   FileParam::MarshallSize(){
    72         ISSMERROR("FileParam is a pointer and cannot be marshalled");
     72        _error_("FileParam is a pointer and cannot be marshalled");
    7373}
    7474/*}}}*/
    7575/*FUNCTION FileParam::Demarshall{{{1*/
    7676void  FileParam::Demarshall(char** pmarshalled_dataset){
    77         ISSMERROR("FileParam is a pointer and cannot be marshalled");
     77        _error_("FileParam is a pointer and cannot be marshalled");
    7878}
    7979/*}}}*/
    … …  
    103103void  FileParam::SetMatlabField(mxArray* dataref){
    104104       
    105         ISSMERROR("FileParam is a pointer and cannot be converted into a matlab object");
     105        _error_("FileParam is a pointer and cannot be converted into a matlab object");
    106106}
    107107#endif

  • TabularUnified issm/trunk/src/c/objects/Params/FileParam.h

    r6165 r6412  
    4949                /*Param vritual function definitions: {{{1*/
    5050                int   EnumType(){return enum_type;}
    51                 void  GetParameterValue(bool* pbool){  ISSMERROR("FileParam of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    52                 void  GetParameterValue(int* pinteger){ISSMERROR("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int** pintarray,int* pM){ISSMERROR("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(double* pdouble){ISSMERROR("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(char** pstring){ISSMERROR("FileParam of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("FileParam of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    59                 void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("File param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
    60                 void  GetParameterValue(Vec* pvec){ISSMERROR("FileParam of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(Mat* pmat){ISSMERROR("FileParam of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     51                void  GetParameterValue(bool* pbool){  _error_("FileParam of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(int* pinteger){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     53                void  GetParameterValue(int** pintarray,int* pM){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(double* pdouble){_error_("FileParam of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     55                void  GetParameterValue(char** pstring){_error_("FileParam of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(char*** pstringarray,int* pM){_error_("FileParam of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(double** pdoublearray,int* pM){_error_("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     58                void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("FileParam of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     59                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("File param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(Vec* pvec){_error_("FileParam of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(Mat* pmat){_error_("FileParam of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    6262                void  GetParameterValue(FILE** pfid){*pfid=value;};
    6363
    64                 void  SetValue(bool boolean){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    65                 void  SetValue(int integer){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    66                 void  SetValue(int* intarray,int M){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(double scalar){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(char* string){ISSMERROR("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(char** stringarray,int M){ISSMERROR("FileParam of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(double* doublearray,int M){ISSMERROR("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* pdoublearray,int M,int N){ISSMERROR("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(Vec vec){ISSMERROR("FileParam of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(Mat mat){ISSMERROR("FileParam of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(FILE* fid){ISSMERROR("File param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("File param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
     64                void  SetValue(bool boolean){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     65                void  SetValue(int integer){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     66                void  SetValue(int* intarray,int M){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     67                void  SetValue(double scalar){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     68                void  SetValue(char* string){_error_("FileParam of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     69                void  SetValue(char** stringarray,int M){_error_("FileParam of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     70                void  SetValue(double* doublearray,int M){_error_("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     71                void  SetValue(double* pdoublearray,int M,int N){_error_("FileParam of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     72                void  SetValue(Vec vec){_error_("FileParam of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     73                void  SetValue(Mat mat){_error_("FileParam of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
     74                void  SetValue(FILE* fid){_error_("File param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     75                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("File param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
    7676
    7777                char* GetParameterName(void);

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

    r6165 r6412  
    5050                /*Param vritual function definitions: {{{1*/
    5151                int   EnumType(){return enum_type;}
    52                 void  GetParameterValue(bool* pbool){ISSMERROR("Int param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(bool* pbool){_error_("Int param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    5353                void  GetParameterValue(int* pinteger){*pinteger=value;}
    54                 void  GetParameterValue(int** pintarray,int* pM){ISSMERROR("Int param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(double* pdouble){ISSMERROR("Int param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char** pstring){ISSMERROR("Int param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("Int param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("Int param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    59                 void  GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("Int param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    60                 void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Int param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(Vec* pvec){ISSMERROR("Int param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(Mat* pmat){ISSMERROR("Int param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(FILE** pfid){ISSMERROR("Int param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(int** pintarray,int* pM){_error_("Int param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
     55                void  GetParameterValue(double* pdouble){_error_("Int param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(char** pstring){_error_("Int param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("Int param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     58                void  GetParameterValue(double** pdoublearray,int* pM){_error_("Int param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     59                void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("Int param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("Int param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(Vec* pvec){_error_("Int param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
     62                void  GetParameterValue(Mat* pmat){_error_("Int param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("Int param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
    6464
    6565                void  SetValue(bool boolean){this->value=(int)boolean;}
    6666                void  SetValue(int integer){this->value=integer;}
    67                 void  SetValue(int* intarray,int M){ISSMERROR("Int param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("Int param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    6868                void  SetValue(double scalar){this->value=(int)scalar;}
    69                 void  SetValue(char* string){ISSMERROR("Int param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char** stringarray,int M){ISSMERROR("Int param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* doublearray,int M){ISSMERROR("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(double* pdoublearray,int M,int N){ISSMERROR("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(Vec vec){ISSMERROR("Int param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(Mat mat){ISSMERROR("Int param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(FILE* fid){ISSMERROR("Int param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("Int param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
     69                void  SetValue(char* string){_error_("Int param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     70                void  SetValue(char** stringarray,int M){_error_("Int param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     71                void  SetValue(double* doublearray,int M){_error_("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     72                void  SetValue(double* pdoublearray,int M,int N){_error_("Int param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     73                void  SetValue(Vec vec){_error_("Int param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     74                void  SetValue(Mat mat){_error_("Int param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
     75                void  SetValue(FILE* fid){_error_("Int param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     76                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("Int param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
    7777
    7878                char* GetParameterName(void);

  • TabularUnified issm/trunk/src/c/objects/Params/IntVecParam.h

    r6213 r6412  
    5151                /*Param virtual functions definitions: {{{1*/
    5252                int   EnumType(){return enum_type;}
    53                 void  GetParameterValue(bool* pbool){ISSMERROR("IntVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(int* pinteger){ISSMERROR("IntVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
     53                void  GetParameterValue(bool* pbool){_error_("IntVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(int* pinteger){_error_("IntVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    5555                void  GetParameterValue(int** pintarray,int* pM);
    56                 void  GetParameterValue(double* pdouble){ISSMERROR("IntVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char** pstring){ISSMERROR("IntVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("IntVec param of enum %i (%s) cannot return a string array",enum_type,EnumToString(enum_type));}
    59                 void  GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("IntVec param of enum %i (%s) cannot return a double array (maybe in serial?)",enum_type,EnumToString(enum_type));}
    60                 void  GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("IntVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("IntVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(Vec* pvec){ISSMERROR("IntVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(Mat* pmat){ISSMERROR("IntVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    64                 void  GetParameterValue(FILE** pfid){ISSMERROR("IntVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(double* pdouble){_error_("IntVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(char** pstring){_error_("IntVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     58                void  GetParameterValue(char*** pstringarray,int* pM){_error_("IntVec param of enum %i (%s) cannot return a string array",enum_type,EnumToString(enum_type));}
     59                void  GetParameterValue(double** pdoublearray,int* pM){_error_("IntVec param of enum %i (%s) cannot return a double array (maybe in serial?)",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("IntVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("IntVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
     62                void  GetParameterValue(Vec* pvec){_error_("IntVec param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(Mat* pmat){_error_("IntVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     64                void  GetParameterValue(FILE** pfid){_error_("IntVec param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
    6565
    66                 void  SetValue(bool boolean){ISSMERROR("IntVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int integer){ISSMERROR("IntVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
     66                void  SetValue(bool boolean){_error_("IntVec param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
     67                void  SetValue(int integer){_error_("IntVec param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    6868                void  SetValue(int* intarray,int M);
    69                 void  SetValue(double scalar){ISSMERROR("IntVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char* string){ISSMERROR("IntVec param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(char** stringarray,int M){ISSMERROR("IntVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(double* doublearray,int M){ISSMERROR("IntVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(double* pdoublearray,int M,int N){ISSMERROR("IntVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(Vec vec){ISSMERROR("IntVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(Mat mat){ISSMERROR("IntVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(FILE* fid){ISSMERROR("IntVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    77                 void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("IntVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
     69                void  SetValue(double scalar){_error_("IntVec param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
     70                void  SetValue(char* string){_error_("IntVec param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     71                void  SetValue(char** stringarray,int M){_error_("IntVec param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     72                void  SetValue(double* doublearray,int M){_error_("IntVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));}
     73                void  SetValue(double* pdoublearray,int M,int N){_error_("IntVec param of enum %i (%s) cannot hold a double mat array",enum_type,EnumToString(enum_type));}
     74                void  SetValue(Vec vec){_error_("IntVec param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     75                void  SetValue(Mat mat){_error_("IntVec param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
     76                void  SetValue(FILE* fid){_error_("IntVec param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     77                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("IntVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
    7878               
    7979                char* GetParameterName(void);

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

    r6165 r6412  
    5050                /*Param vritual function definitions: {{{1*/
    5151                int   EnumType(){return enum_type;}
    52                 void  GetParameterValue(bool* pbool){ISSMERROR("PetscMat param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int* pinteger){ISSMERROR("PetscMat param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(int** pintarray,int* pM){ISSMERROR("PetscMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(double* pdouble){ISSMERROR("PetscMat param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char** pstring){ISSMERROR("PetscMat param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("PetscMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    59                 void  GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    60                 void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("PetscMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(Vec* pvec){ISSMERROR("PetscMat param of enum %i (%s) cannot return a vec",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(bool* pbool){_error_("PetscMat param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
     53                void  GetParameterValue(int* pinteger){_error_("PetscMat param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(int** pintarray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
     55                void  GetParameterValue(double* pdouble){_error_("PetscMat param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(char** pstring){_error_("PetscMat param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     58                void  GetParameterValue(double** pdoublearray,int* pM){_error_("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     59                void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("PetscMat param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("PetscMat param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(Vec* pvec){_error_("PetscMat param of enum %i (%s) cannot return a vec",enum_type,EnumToString(enum_type));}
    6262                void  GetParameterValue(Mat* poutput);
    63                 void  GetParameterValue(FILE** pfid){ISSMERROR("PetscMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("PetscMat param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
    6464
    65                 void  SetValue(bool boolean){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    66                 void  SetValue(int integer){ISSMERROR("PetscMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int* intarray,int M){ISSMERROR("PetscMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(double scalar){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(char* string){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char** stringarray,int M){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* doublearray,int M){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(double* pdoublearray,int M,int N){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(Vec vec){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     65                void  SetValue(bool boolean){_error_("PetscMat param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
     66                void  SetValue(int integer){_error_("PetscMat param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("PetscMat param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     68                void  SetValue(double scalar){_error_("PetscMat param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
     69                void  SetValue(char* string){_error_("PetscMat param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     70                void  SetValue(char** stringarray,int M){_error_("PetscMat param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     71                void  SetValue(double* doublearray,int M){_error_("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     72                void  SetValue(double* pdoublearray,int M,int N){_error_("PetscMat param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     73                void  SetValue(Vec vec){_error_("PetscMat param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    7474                void  SetValue(Mat mat);
    75                 void  SetValue(FILE* fid){ISSMERROR("PetscMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("PetscMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
     75                void  SetValue(FILE* fid){_error_("PetscMat param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     76                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("PetscMat param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
    7777
    7878                char* GetParameterName(void);

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

    r6165 r6412  
    5050                /*Param vritual function definitions: {{{1*/
    5151                int   EnumType(){return enum_type;}
    52                 void  GetParameterValue(bool* pbool){ISSMERROR("PetscVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int* pinteger){ISSMERROR("PetscVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(int** pintarray,int* pM){ISSMERROR("PetscVec param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(double* pdouble){ISSMERROR("PetscVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(char** pstring){ISSMERROR("PetscVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("PetscVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    59                 void  GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    60                 void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("PetscVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(Mat* pmat){ISSMERROR("PetscVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(bool* pbool){_error_("PetscVec param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
     53                void  GetParameterValue(int* pinteger){_error_("PetscVec param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(int** pintarray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
     55                void  GetParameterValue(double* pdouble){_error_("PetscVec param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(char** pstring){_error_("PetscVec param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     58                void  GetParameterValue(double** pdoublearray,int* pM){_error_("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     59                void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("PetscVec param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("PetscVec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(Mat* pmat){_error_("PetscVec param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    6262                void  GetParameterValue(Vec* poutput);
    63                 void  GetParameterValue(FILE** pfid){ISSMERROR("PetscVec of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("PetscVec of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
    6464
    65                 void  SetValue(bool boolean){ISSMERROR("PetscVec of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    66                 void  SetValue(int integer){ISSMERROR("PetscVec of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int* intarray,int M){ISSMERROR("PetscVec of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(double scalar){ISSMERROR("PetscVec of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(char* string){ISSMERROR("PetscVec of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(char** stringarray,int M){ISSMERROR("PetscVec of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* doublearray,int M){ISSMERROR("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(double* pdoublearray,int M,int N){ISSMERROR("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     65                void  SetValue(bool boolean){_error_("PetscVec of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
     66                void  SetValue(int integer){_error_("PetscVec of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("PetscVec of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     68                void  SetValue(double scalar){_error_("PetscVec of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
     69                void  SetValue(char* string){_error_("PetscVec of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     70                void  SetValue(char** stringarray,int M){_error_("PetscVec of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     71                void  SetValue(double* doublearray,int M){_error_("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     72                void  SetValue(double* pdoublearray,int M,int N){_error_("PetscVec of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    7373                void  SetValue(Vec vec);
    74                 void  SetValue(Mat mat){ISSMERROR("PetscVec of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(FILE* fid){ISSMERROR("PetscVec of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("PetscVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
     74                void  SetValue(Mat mat){_error_("PetscVec of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
     75                void  SetValue(FILE* fid){_error_("PetscVec of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     76                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("PetscVec param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
    7777
    7878                char* GetParameterName(void);

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

    r6165 r6412  
    5252                /*Param vritual function definitions: {{{1*/
    5353                int   EnumType(){return enum_type;}
    54                 void  GetParameterValue(bool* pbool){ISSMERROR("StringArray param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(int* pinteger){ISSMERROR("StringArray param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    56                 void  GetParameterValue(int** pintarray,int* pM){ISSMERROR("StringArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    57                 void  GetParameterValue(double* pdouble){ISSMERROR("StringArray param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(char** pstring){ISSMERROR("StringArray param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(bool* pbool){_error_("StringArray param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
     55                void  GetParameterValue(int* pinteger){_error_("StringArray param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
     56                void  GetParameterValue(int** pintarray,int* pM){_error_("StringArray param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(double* pdouble){_error_("StringArray param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     58                void  GetParameterValue(char** pstring){_error_("StringArray param of enum %i (%s) cannot return a string",enum_type,EnumToString(enum_type));}
    5959                void  GetParameterValue(char*** pstringarray,int* pM);
    60                 void  GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("Vec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(Vec* pvec){ISSMERROR("StringArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    64                 void  GetParameterValue(Mat* pmat){ISSMERROR("StringArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    65                 void  GetParameterValue(FILE** pfid){ISSMERROR("StringArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(double** pdoublearray,int* pM){_error_("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("StringArray param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     62                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("Vec param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(Vec* pvec){_error_("StringArray param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
     64                void  GetParameterValue(Mat* pmat){_error_("StringArray param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     65                void  GetParameterValue(FILE** pfid){_error_("StringArray param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
    6666
    67                 void  SetValue(bool boolean){ISSMERROR("StringArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(int integer){ISSMERROR("StringArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    69                 void  SetValue(int* intarray,int M){ISSMERROR("StringArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    70                 void  SetValue(double scalar){ISSMERROR("StringArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(char* string){ISSMERROR("StringArray param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
     67                void  SetValue(bool boolean){_error_("StringArray param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
     68                void  SetValue(int integer){_error_("StringArray param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
     69                void  SetValue(int* intarray,int M){_error_("StringArray param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     70                void  SetValue(double scalar){_error_("StringArray param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
     71                void  SetValue(char* string){_error_("StringArray param of enum %i (%s) cannot hold a string",enum_type,EnumToString(enum_type));}
    7272                void  SetValue(char** stringarray,int M);
    73                 void  SetValue(double* doublearray,int M){ISSMERROR("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(double* pdoublearray,int M,int N){ISSMERROR("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(Vec vec){ISSMERROR("StringArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(Mat mat){ISSMERROR("StringArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    77                 void  SetValue(FILE* fid){ISSMERROR("StringArray param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    78                 void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("StringArray param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
     73                void  SetValue(double* doublearray,int M){_error_("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     74                void  SetValue(double* pdoublearray,int M,int N){_error_("StringArray param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     75                void  SetValue(Vec vec){_error_("StringArray param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     76                void  SetValue(Mat mat){_error_("StringArray param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
     77                void  SetValue(FILE* fid){_error_("StringArray param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     78                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("StringArray param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
    7979
    8080                char* GetParameterName(void);

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

    r6165 r6412  
    5050                /*Param vritual function definitions: {{{1*/
    5151                int   EnumType(){return enum_type;}
    52                 void  GetParameterValue(bool* pbool){ISSMERROR("String param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
    53                 void  GetParameterValue(int* pinteger){ISSMERROR("String param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
    54                 void  GetParameterValue(int** pintarray,int* pM){ISSMERROR("String param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
    55                 void  GetParameterValue(double* pdouble){ISSMERROR("String param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
     52                void  GetParameterValue(bool* pbool){_error_("String param of enum %i (%s) cannot return a bool",enum_type,EnumToString(enum_type));}
     53                void  GetParameterValue(int* pinteger){_error_("String param of enum %i (%s) cannot return an integer",enum_type,EnumToString(enum_type));}
     54                void  GetParameterValue(int** pintarray,int* pM){_error_("String param of enum %i (%s) cannot return an array of integers",enum_type,EnumToString(enum_type));}
     55                void  GetParameterValue(double* pdouble){_error_("String param of enum %i (%s) cannot return a double",enum_type,EnumToString(enum_type));}
    5656                void  GetParameterValue(char** pstring);
    57                 void  GetParameterValue(char*** pstringarray,int* pM){ISSMERROR("String param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
    58                 void  GetParameterValue(double** pdoublearray,int* pM){ISSMERROR("String param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    59                 void  GetParameterValue(double** pdoublearray,int* pM, int* pN){ISSMERROR("String param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
    60                 void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){ISSMERROR("String param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
    61                 void  GetParameterValue(Vec* pvec){ISSMERROR("String param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
    62                 void  GetParameterValue(Mat* pmat){ISSMERROR("String param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
    63                 void  GetParameterValue(FILE** pfid){ISSMERROR("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
     57                void  GetParameterValue(char*** pstringarray,int* pM){_error_("String param of enum %i (%s) cannot return a string arrayl",enum_type,EnumToString(enum_type));}
     58                void  GetParameterValue(double** pdoublearray,int* pM){_error_("String param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     59                void  GetParameterValue(double** pdoublearray,int* pM, int* pN){_error_("String param of enum %i (%s) cannot return a double array",enum_type,EnumToString(enum_type));}
     60                void  GetParameterValue(double*** parray, int* pM,int** pmdims, int** pndims){_error_("String param of enum %i (%s) cannot return a matrix array",enum_type,EnumToString(enum_type));}
     61                void  GetParameterValue(Vec* pvec){_error_("String param of enum %i (%s) cannot return a Vec",enum_type,EnumToString(enum_type));}
     62                void  GetParameterValue(Mat* pmat){_error_("String param of enum %i (%s) cannot return a Mat",enum_type,EnumToString(enum_type));}
     63                void  GetParameterValue(FILE** pfid){_error_("Bool param of enum %i (%s) cannot return a FILE",enum_type,EnumToString(enum_type));}
    6464
    65                 void  SetValue(bool boolean){ISSMERROR("String param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
    66                 void  SetValue(int integer){ISSMERROR("String param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
    67                 void  SetValue(int* intarray,int M){ISSMERROR("String param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
    68                 void  SetValue(double scalar){ISSMERROR("String param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
     65                void  SetValue(bool boolean){_error_("String param of enum %i (%s) cannot hold a boolean",enum_type,EnumToString(enum_type));}
     66                void  SetValue(int integer){_error_("String param of enum %i (%s) cannot hold an integer",enum_type,EnumToString(enum_type));}
     67                void  SetValue(int* intarray,int M){_error_("String param of enum %i (%s) cannot hold an int array",enum_type,EnumToString(enum_type));}
     68                void  SetValue(double scalar){_error_("String param of enum %i (%s) cannot hold a scalar",enum_type,EnumToString(enum_type));}
    6969                void  SetValue(char* string);
    70                 void  SetValue(char** stringarray,int M){ISSMERROR("String param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
    71                 void  SetValue(double* doublearray,int M){ISSMERROR("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    72                 void  SetValue(double* pdoublearray,int M,int N){ISSMERROR("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
    73                 void  SetValue(Vec vec){ISSMERROR("String param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
    74                 void  SetValue(Mat mat){ISSMERROR("String param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
    75                 void  SetValue(FILE* fid){ISSMERROR("String param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
    76                 void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){ISSMERROR("String param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
     70                void  SetValue(char** stringarray,int M){_error_("String param of enum %i (%s) cannot hold a string array",enum_type,EnumToString(enum_type));}
     71                void  SetValue(double* doublearray,int M){_error_("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     72                void  SetValue(double* pdoublearray,int M,int N){_error_("String param of enum %i (%s) cannot hold a double array",enum_type,EnumToString(enum_type));}
     73                void  SetValue(Vec vec){_error_("String param of enum %i (%s) cannot hold a Vec",enum_type,EnumToString(enum_type));}
     74                void  SetValue(Mat mat){_error_("String param of enum %i (%s) cannot hold a Mat",enum_type,EnumToString(enum_type));}
     75                void  SetValue(FILE* fid){_error_("String param of enum %i (%s) cannot hold a FILE",enum_type,EnumToString(enum_type));}
     76                void  SetValue(double** array, int M, int* mdim_array, int* ndim_array){_error_("String param of enum %i (%s) cannot hold an array of matrices",enum_type,EnumToString(enum_type));}
    7777
    7878                char* GetParameterName(void);

  • TabularUnified issm/trunk/src/c/objects/Segment.cpp

    r4773 r6412  
    7474void  Segment::Marshall(char** pmarshalled_dataset){
    7575
    76         ISSMERROR(" not supported yet!");
     76        _error_(" not supported yet!");
    7777}
    7878/*}}}*/
    7979/*FUNCTION Segment::MarshallSize{{{1*/
    8080int   Segment::MarshallSize(){
    81         ISSMERROR(" not supported yet!");
     81        _error_(" not supported yet!");
    8282}
    8383/*}}}*/
    8484/*FUNCTION Segment::Demarshall{{{1*/
    8585void  Segment::Demarshall(char** pmarshalled_dataset){
    86         ISSMERROR(" not supported yet!");
     86        _error_(" not supported yet!");
    8787}
    8888/*}}}*/

  • TabularUnified issm/trunk/src/c/shared/Alloc/alloc.cpp

    r5768 r6412  
    3333        void* memptr=NULL;
    3434
    35         if(!size)ISSMERROR(" attempting to 0 size allocation!");
     35        if(!size)_error_(" attempting to 0 size allocation!");
    3636
    3737        #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    … …  
    4242        memptr=malloc(size);
    4343        #endif
    44         if(!memptr) ISSMERROR("memory allocation failed!");
     44        if(!memptr) _error_("memory allocation failed!");
    4545
    4646        return memptr;
    … …  
    5151        void* memptr=NULL;
    5252       
    53         if(!size)ISSMERROR("attempting to 0 size allocation!");
     53        if(!size)_error_("attempting to 0 size allocation!");
    5454
    5555        #if defined(_HAVE_MATLAB_) && defined(_SERIAL_)
    … …  
    6060        memptr=calloc(n,size);
    6161        #endif
    62         if(!memptr) ISSMERROR("memory allocation failed!");
     62        if(!memptr) _error_("memory allocation failed!");
    6363
    6464        return memptr;
    … …  
    8383        register void* value=NULL;
    8484       
    85         if(!size)ISSMERROR("attempting to realloc to zero");
     85        if(!size)_error_("attempting to realloc to zero");
    8686
    8787        #ifndef MATLAB
    … …  
    9292
    9393        if (value == NULL) {
    94                 ISSMERROR("virtual memory exhausted");
     94                _error_("virtual memory exhausted");
    9595        }
    9696        return value;

  • TabularUnified issm/trunk/src/c/shared/Elements/GetVerticesCoordinates.cpp

    r5908 r6412  
    88
    99        /*In debugging mode, check that nodes is not a NULL pointer*/
    10         ISSMASSERT(nodes);
     10        _assert_(nodes);
    1111
    1212        for(int i=0;i<numvertices;i++) {

  • TabularUnified issm/trunk/src/c/shared/Exp/DomainOutlineRead.cpp

    r3775 r6412  
    3737        /*open domain outline file for reading: */
    3838        if ((fid=fopen(domainname,"r"))==NULL){
    39                 ISSMERROR("%s%s","could not find domain file ",domainname);
     39                _error_("%s%s","could not find domain file ",domainname);
    4040                noerr=0; goto cleanupandreturn;
    4141        }

  • TabularUnified issm/trunk/src/c/shared/Matlab/CheckNumMatlabArguments.cpp

    r3775 r6412  
    1717                /* special case: */
    1818                function();
    19                 ISSMERROR("usage: see above");
     19                _error_("usage: see above");
    2020        }
    2121        else if (nlhs!=NLHS || nrhs!=NRHS ) {
    2222                function();
    23                 ISSMERROR("usage error.");
     23                _error_("usage error.");
    2424        }
    2525        return 1;

  • TabularUnified issm/trunk/src/c/shared/Matrix/MatrixUtils.cpp

    r5371 r6412  
    3636        if (!itrnb) {
    3737                if (nrowb != idimb) {
    38                         ISSMERROR("Matrix A and B inner vectors not equal size.");
     38                        _error_("Matrix A and B inner vectors not equal size.");
    3939                }
    4040                idimc=ncolb;
    … …  
    4242        else {
    4343                if (ncolb != idimb) {
    44                         ISSMERROR("Matrix A and B inner vectors not equal size.");
     44                        _error_("Matrix A and B inner vectors not equal size.");
    4545                }
    4646                idimc=nrowb;
    … …  
    4949        if (!itrnc) {
    5050                if (nrowc != idimc) {
    51                         ISSMERROR("Matrix B and C inner vectors not equal size.");
     51                        _error_("Matrix B and C inner vectors not equal size.");
    5252                }
    5353                idimd=ncolc;
    … …  
    5555        else {
    5656                if (ncolc != idimc) {
    57                         ISSMERROR("Matrix B and C inner vectors not equal size.");
     57                        _error_("Matrix B and C inner vectors not equal size.");
    5858                }
    5959                idimd=nrowc;
    … …  
    134134
    135135        if (ntrma != ntrmb) {
    136                 ISSMERROR("Matrix A and B inner vectors not equal size");
     136                _error_("Matrix A and B inner vectors not equal size");
    137137            noerr=0;   
    138138                return noerr;
    … …  
    185185
    186186        if (!b && nvec) {
    187                 ISSMERROR("No right-hand side for nvec=%d.",nvec);
     187                _error_("No right-hand side for nvec=%d.",nvec);
    188188                noerr=0;
    189189                return noerr;
    … …  
    191191
    192192        /*In debugging mode, check that we are not dealing with simple matrices*/
    193         ISSMASSERT(!(ndim==2 && nrow==2));
    194         ISSMASSERT(!(ndim==3 && nrow==3));
     193        _assert_(!(ndim==2 && nrow==2));
     194        _assert_(!(ndim==3 && nrow==3));
    195195
    196196/*  initialize local variables and arrays  */
    … …  
    223223                        xfree((void **)&pivrc);
    224224                        xfree((void **)&pindx);
    225                         ISSMERROR("Pivot %f less than machine epsilon",pivot);
     225                        _error_("Pivot %f less than machine epsilon",pivot);
    226226                        noerr=0;
    227227                        return noerr;
    … …  
    234234                pindx[ipiv]++;
    235235
    236 //              _printf_("pivot for i=%d: irow=%d, icol=%d, pindx[%d]=%d\n",
     236//              _printf_(true,"pivot for i=%d: irow=%d, icol=%d, pindx[%d]=%d\n",
    237237//                               i,irow,icol,ipiv,pindx[ipiv]);
    238238
    … …  
    241241
    242242                if (irow != icol) {
    243 //                      _printf_("row switch for i=%d: irow=%d, icol=%d\n",
     243//                      _printf_(true,"row switch for i=%d: irow=%d, icol=%d\n",
    244244//                                       i,irow,icol);
    245245
    … …  
    323323                        icol=pivrc[j][1];
    324324
    325 //                      _printf_("column switch back for j=%d: irow=%d, icol=%d\n",
     325//                      _printf_(true,"column switch back for j=%d: irow=%d, icol=%d\n",
    326326//                                       j,irow,icol);
    327327
    … …  
    360360        /*Compute determinant*/
    361361        Matrix2x2Determinant(&det,A);
    362         if (fabs(det) < DBL_EPSILON) ISSMERROR("Determinant smaller that machine epsilon");
     362        if (fabs(det) < DBL_EPSILON) _error_("Determinant smaller that machine epsilon");
    363363
    364364        /*Compute invert*/
    … …  
    385385        /*Compute determinant*/
    386386        Matrix3x3Determinant(&det,A);
    387         if (fabs(det) < DBL_EPSILON) ISSMERROR("Determinant smaller that machine epsilon");
     387        if (fabs(det) < DBL_EPSILON) _error_("Determinant smaller that machine epsilon");
    388388
    389389        /*Compute invert*/
    … …  
    406406
    407407        /*Check the the matrix has been allocated*/
    408         ISSMASSERT(tA);
     408        _assert_(tA);
    409409
    410410        /*Transpose*/

  • TabularUnified issm/trunk/src/c/shared/Numerics/BrentSearch.cpp

    r6323 r6412  
    5656        //get the value of the function at the first boundary
    5757        fxmin = (*f)(xmin,optargs);
    58         if isnan(fxmin) ISSMERROR("Function evaluation returned NaN");
     58        if isnan(fxmin) _error_("Function evaluation returned NaN");
    5959
    6060        //display result
    61         ISSMPRINTF(VerboseControl(),"\n        Iteration         x           f(x)       Tolerance         Procedure\n\n");
    62         ISSMPRINTF(VerboseControl(),"        %s    %12.6g  %12.6g  %s","   N/A",xmin,fxmin,"         N/A         boundary\n");
     61        _printf_(VerboseControl(),"\n        Iteration         x           f(x)       Tolerance         Procedure\n\n");
     62        _printf_(VerboseControl(),"        %s    %12.6g  %12.6g  %s","   N/A",xmin,fxmin,"         N/A         boundary\n");
    6363
    6464        //get the value of the function at the first boundary xmax and display result
    6565        fxmax = (*f)(xmax,optargs);
    66         if isnan(fxmax) ISSMERROR("Function evaluation returned NaN");
    67         ISSMPRINTF(VerboseControl(),"        %s    %12.6g  %12.6g  %s","   N/A",xmax,fxmax,"         N/A         boundary\n");
     66        if isnan(fxmax) _error_("Function evaluation returned NaN");
     67        _printf_(VerboseControl(),"        %s    %12.6g  %12.6g  %s","   N/A",xmax,fxmax,"         N/A         boundary\n");
    6868
    6969        //test if jump option activated and xmin==0
    … …  
    9696        //2: call the function to be evaluated
    9797        fxbest = (*f)(x,optargs);
    98         if isnan(fxbest) ISSMERROR("Function evaluation returned NaN");
     98        if isnan(fxbest) _error_("Function evaluation returned NaN");
    9999        iter=iter+1;
    100100
    … …  
    109109
    110110        //4: print result
    111         ISSMPRINTF(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,xbest,fxbest,pow(pow(xbest-xm,2),0.5),"       initial");
     111        _printf_(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,xbest,fxbest,pow(pow(xbest-xm,2),0.5),"       initial");
    112112
    113113        //Main Loop
    … …  
    193193                //evaluate function on x
    194194                fx = (*f)(x,optargs);
    195                 if isnan(fx) ISSMERROR("Function evaluation returned NaN");
     195                if isnan(fx) _error_("Function evaluation returned NaN");
    196196                iter=iter+1;
    197197
    … …  
    230230                //print result
    231231                if (goldenflag){
    232                         ISSMPRINTF(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,x,fx,pow(pow(xbest-xm,2),0.5),"       golden");
    233                 }
    234                 else{
    235                         ISSMPRINTF(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,x,fx,pow(pow(xbest-xm,2),0.5),"       parabolic");
     232                        _printf_(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,x,fx,pow(pow(xbest-xm,2),0.5),"       golden");
     233                }
     234                else{
     235                        _printf_(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g  %s\n",iter,x,fx,pow(pow(xbest-xm,2),0.5),"       parabolic");
    236236                }
    237237
    238238                //Stop the optimization?
    239239                if (sqrt(pow(xbest-xm,2)) < (tol2-0.5*(xmax-xmin))){
    240                         ISSMPRINTF(VerboseControl(),"      %s%g\n","optimization terminated: the current x satisfies the termination criteria using 'tolx' of" ,tolerance);
     240                        _printf_(VerboseControl(),"      %s%g\n","optimization terminated: the current x satisfies the termination criteria using 'tolx' of" ,tolerance);
    241241                        loop=0;
    242242                }
    243243                else if (iter>=maxiter){
    244                         ISSMPRINTF(VerboseControl(),"      %s\n","exiting: Maximum number of iterations has been exceeded  - increase 'maxiter'\n");
     244                        _printf_(VerboseControl(),"      %s\n","exiting: Maximum number of iterations has been exceeded  - increase 'maxiter'\n");
    245245                        loop=0;
    246246                }

  • TabularUnified issm/trunk/src/c/shared/Numerics/GaussPoints.cpp

    r5808 r6412  
    5151                sizeof(wgt4 )/sizeof(double)};
    5252
    53         //      _printf_("Gauss-Legendre recurrence coefficients ngaus=%d\n",ngaus);
     53        //      _printf_(true,"Gauss-Legendre recurrence coefficients ngaus=%d\n",ngaus);
    5454        *pxgaus = (double *) xmalloc(ngaus*sizeof(double));
    5555        *pxwgt  = (double *) xmalloc(ngaus*sizeof(double));
    … …  
    11391139                sizeof(wgt20)/sizeof(double)};
    11401140
    1141         //      _printf_("GaussLegendreTria: iord=%d\n",iord);
     1141        //      _printf_(true,"GaussLegendreTria: iord=%d\n",iord);
    11421142
    11431143        /*  check to see if Gauss points need to be calculated  */
    … …  
    11991199        }
    12001200
    1201         //      _printf_("GaussLegendreTria - ngaus=%d\n",*pngaus);
     1201        //      _printf_(true,"GaussLegendreTria - ngaus=%d\n",*pngaus);
    12021202        //      for (i=0; i<*pngaus; i++)
    1203         //              _printf_("i=%d: l1gaus=%f,l2gaus=%f,l3gaus=%f,wgt=%f\n",
     1203        //              _printf_(true,"i=%d: l1gaus=%f,l2gaus=%f,l3gaus=%f,wgt=%f\n",
    12041204        //                               i,(*pl1 )[i],(*pl2 )[i],(*pl3 )[i],(*pwgt)[i]);
    12051205
    … …  
    13981398                sizeof(wgt6 )/sizeof(double)};
    13991399
    1400         //      _printf_("GaussLegendreTetra: iord=%d\n",iord);
     1400        //      _printf_(true,"GaussLegendreTetra: iord=%d\n",iord);
    14011401
    14021402        /*  check to see if Gauss points need to be calculated  */
    … …  
    15211521                sizeof(wgt5 )/sizeof(double)};
    15221522
    1523         //      _printf_("Gauss-Lobatto recurrence coefficients ngaus=%d\n",ngaus);
     1523        //      _printf_(true,"Gauss-Lobatto recurrence coefficients ngaus=%d\n",ngaus);
    15241524        *pxgaus = (double *) xmalloc(ngaus*sizeof(double));
    15251525        *pxwgt  = (double *) xmalloc(ngaus*sizeof(double));
    … …  
    16701670                if (iter >= MAX_GAUS_ITER) {
    16711671                        xfree((void **)&work);
    1672                         ISSMERROR("%s%i"," Max iterations exceeded for l=",MAX_GAUS_ITER);
     1672                        _error_("%s%i"," Max iterations exceeded for l=",MAX_GAUS_ITER);
    16731673                }
    16741674        }

  • TabularUnified issm/trunk/src/c/shared/Numerics/IsInputConverged.cpp

    r5103 r6412  
    3434
    3535                        /*in debugging mode, check that the inputs are of the same type*/
    36                         ISSMASSERT(new_inputs[i]->Enum()==old_inputs[i]->Enum());
     36                        _assert_(new_inputs[i]->Enum()==old_inputs[i]->Enum());
    3737
    3838                        /*Get pointers*/
    … …  
    5353                else eps=0;
    5454        }
    55         else ISSMERROR("%s%s%s"," convergence criterion ",EnumToString(criterion_enum)," not supported yet!");
     55        else _error_("%s%s%s"," convergence criterion ",EnumToString(criterion_enum)," not supported yet!");
    5656
    5757        /*Assign output pointers:*/

  • TabularUnified issm/trunk/src/c/shared/Numerics/OptFunc.cpp

    r4540 r6412  
    3838#else
    3939double OptFunc(double scalar, OptArgs* optargs){
    40         ISSMERROR(" not implemented yet");
     40        _error_(" not implemented yet");
    4141}
    4242#endif

  • TabularUnified issm/trunk/src/c/shared/Numerics/OptimalSearch.cpp

    r6323 r6412  
    4040        //get the value of the function at the first boundary
    4141        fx1= (*f)(x1,optargs);
    42         if isnan(fx1) ISSMERROR("Function evaluation returned NaN");
    43         ISSMPRINTF(VerboseControl(),"\n        Iteration         x           f(x)       Tolerance\n\n");
    44         ISSMPRINTF(VerboseControl(),"        %s    %12.6g  %12.6g  %s","   N/A",x1,fx1,"         N/A\n");
     42        if isnan(fx1) _error_("Function evaluation returned NaN");
     43        _printf_(VerboseControl(),"\n        Iteration         x           f(x)       Tolerance\n\n");
     44        _printf_(VerboseControl(),"        %s    %12.6g  %12.6g  %s","   N/A",x1,fx1,"         N/A\n");
    4545
    4646        //update tolerances
    … …  
    5353                iter++;
    5454                fx2 = (*f)(x2,optargs);
    55                 if isnan(fx2) ISSMERROR("Function evaluation returned NaN");
    56                 ISSMPRINTF(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g\n",iter,x2,fx2,fabs(x2-x1)>fabs(fx2-fx1)?fabs(fx2-fx1):fabs(x2-x1));
     55                if isnan(fx2) _error_("Function evaluation returned NaN");
     56                _printf_(VerboseControl(),"         %5i    %12.6g  %12.6g  %12.6g\n",iter,x2,fx2,fabs(x2-x1)>fabs(fx2-fx1)?fabs(fx2-fx1):fabs(x2-x1));
    5757
    5858                //Stop the optimization?
    5959                if ((fabs(x2-x1)+seps)<tolerance || (fabs(fx2-fx1)+seps)<tolerance){
    60                         ISSMPRINTF(VerboseControl(),"      %s%g\n","optimization terminated: the current x satisfies the termination criteria using 'tolx' of " ,tolerance);
     60                        _printf_(VerboseControl(),"      %s%g\n","optimization terminated: the current x satisfies the termination criteria using 'tolx' of " ,tolerance);
    6161                        loop=false;
    6262                }
    6363                else if (iter>=maxiter){
    64                         ISSMPRINTF(VerboseControl(),"      %s\n","exiting: Maximum number of iterations has been exceeded  - increase 'maxiter'\n");
     64                        _printf_(VerboseControl(),"      %s\n","exiting: Maximum number of iterations has been exceeded  - increase 'maxiter'\n");
    6565                        loop=false;
    6666                }

  • TabularUnified issm/trunk/src/c/shared/Numerics/PetscOptionsFromAnalysis.cpp

    r6020 r6412  
    5757        if (found==-1){
    5858                /*ok, we did not find anything, this is not good! error out: */
    59                 ISSMERROR("%s%s","could find neither a default analysis  nor analysis ",EnumToString(analysis_type));
     59                _error_("%s%s","could find neither a default analysis  nor analysis ",EnumToString(analysis_type));
    6060        }
    6161

  • TabularUnified issm/trunk/src/c/shared/Numerics/Synchronize.sh

    r6324 r6412  
    138138void SetVerbosityLevel(int level){
    139139
    140         if(level<0) ISSMERROR("vebosity level should be a positive integer (user provided %i)",level);
     140        if(level<0) _error_("vebosity level should be a positive integer (user provided %i)",level);
    141141
    142142#ifdef _SERIAL_
    … …  
    168168#else
    169169
    170         ISSMASSERT(verbositylevel>=0);
     170        _assert_(verbositylevel>=0);
    171171        return verbositylevel;
    172172

  • TabularUnified issm/trunk/src/c/shared/Numerics/UnitConversion.cpp

    r5659 r6412  
    2929        if(direction_enum==IuToExtEnum) for(i=0;i<numvalues;i++)values[i]=values[i]*scale;
    3030        else if(direction_enum==ExtToIuEnum) for(i=0;i<numvalues;i++)values[i]=values[i]/scale;
    31         else ISSMERROR(" wrong direction for unit conversion, either IuToExtEnum or ExtToIuEnum. ");
     31        else _error_(" wrong direction for unit conversion, either IuToExtEnum or ExtToIuEnum. ");
    3232
    3333}
    … …  
    4343        if(direction_enum==IuToExtEnum)value=value*scale;
    4444        else if(direction_enum==ExtToIuEnum)value=value/scale;
    45         else ISSMERROR(" wrong direction for unit conversion, either IuToExtEnum or ExtToIuEnum. ");
     45        else _error_(" wrong direction for unit conversion, either IuToExtEnum or ExtToIuEnum. ");
    4646
    4747        return value;

  • TabularUnified issm/trunk/src/c/shared/Numerics/Verbosity.cpp

    r6323 r6412  
    3737void SetVerbosityLevel(int level){
    3838
    39         if(level<0) ISSMERROR("vebosity level should be a positive integer (user provided %i)",level);
     39        if(level<0) _error_("vebosity level should be a positive integer (user provided %i)",level);
    4040
    4141#ifdef _SERIAL_
    … …  
    6767#else
    6868
    69         ISSMASSERT(verbositylevel>=0);
     69        _assert_(verbositylevel>=0);
    7070        return verbositylevel;
    7171

  • TabularUnified issm/trunk/src/c/shared/String/DescriptorIndex.cpp

    r5470 r6412  
    2323        /*retrieve first token, separated by underscore: */
    2424        pch = strtok (descriptor,"_");
    25         if(!pch)ISSMERROR("%s%s%s"," descriptor ",descriptor," is not correctly formatted!");
     25        if(!pch)_error_("%s%s%s"," descriptor ",descriptor," is not correctly formatted!");
    2626
    2727        if (strncmp(pch,"scaled",6)==0){
    2828                /*we have a scaled variable. recover the root: */
    2929                pch = strtok (NULL, "_");
    30                 if(!pch)ISSMERROR("%s%s%s"," scaled descriptor ",descriptor," is not correctly formatted!");
     30                if(!pch)_error_("%s%s%s"," scaled descriptor ",descriptor," is not correctly formatted!");
    3131                strcpy(root,pch);
    3232                /*now recover  the index if it exists: */
    … …  
    4343                /*we have an indexed variable. recover the root: */
    4444                pch = strtok (NULL, "_");
    45                 if(!pch)ISSMERROR("%s%s%s"," indexed descriptor ",descriptor," is not correctly formatted!");
     45                if(!pch)_error_("%s%s%s"," indexed descriptor ",descriptor," is not correctly formatted!");
    4646                strcpy(root,pch);
    4747                /*now recover  the index: */
    4848                pch = strtok (NULL, "_");
    49                 if(!pch)ISSMERROR("%s%s%s"," indexed descriptor ",descriptor," is not correctly formatted!");
     49                if(!pch)_error_("%s%s%s"," indexed descriptor ",descriptor," is not correctly formatted!");
    5050                sscanf(pch,"%i",pindex);
    5151                return IndexedEnum;
    … …  
    5454                /*we have an indexed variable. recover the root: */
    5555                pch = strtok (NULL, "_");
    56                 if(!pch)ISSMERROR("%s%s%s"," nodal descriptor ",descriptor," is not correctly formatted!");
     56                if(!pch)_error_("%s%s%s"," nodal descriptor ",descriptor," is not correctly formatted!");
    5757                strcpy(root,pch);
    5858                /*now recover  the index: */
    5959                pch = strtok (NULL, "_");
    60                 if(!pch)ISSMERROR("%s%s%s"," nodal descriptor ",descriptor," is not correctly formatted!");
     60                if(!pch)_error_("%s%s%s"," nodal descriptor ",descriptor," is not correctly formatted!");
    6161                sscanf(pch,"%i",pindex);
    6262                return NodalEnum;

  • TabularUnified issm/trunk/src/c/shared/Threads/LaunchThread.cpp

    r3775 r6412  
    4646
    4747                if(pthread_create(threads+i,NULL,function,(void*)(handles+i))){
    48                         ISSMERROR(" pthread_create error");
     48                        _error_(" pthread_create error");
    4949                }
    5050        }
    5151        for(i=0;i<num_threads;i++){
    5252                if(pthread_join(threads[i],(void**)&status)){
    53                         ISSMERROR(" pthread_join error");
     53                        _error_(" pthread_join error");
    5454                }
    5555        }

  • TabularUnified issm/trunk/src/c/shared/TriMesh/TriMeshUtils.cpp

    r5238 r6412  
    919919                /*Using the order vector, and the riftsegments_copy and riftspairs_copy, reorder the segments and the pairs: */
    920920                for (j=0;j<numsegs;j++){
    921                         ISSMASSERT(order[j]<numsegs);
     921                        _assert_(order[j]<numsegs);
    922922                        *(riftsegments_copy+3*j+0)=*(riftsegments+3*order[j]+0);
    923923                        *(riftsegments_copy+3*j+1)=*(riftsegments+3*order[j]+1);

  • TabularUnified issm/trunk/src/c/solutions/AdjointCorePointerFromSolutionEnum.cpp

    r5378 r6412  
    3535                        break;
    3636                default:
    37                         ISSMERROR("No adjoint has been implemented for solution %s yet",EnumToString(solutiontype));
     37                        _error_("No adjoint has been implemented for solution %s yet",EnumToString(solutiontype));
    3838                        break;
    3939        }
    4040       
    4141        /*Assign output pointer:*/
    42         ISSMASSERT(padjointcore);
     42        _assert_(padjointcore);
    4343        *padjointcore=adjointcore;
    4444

  • TabularUnified issm/trunk/src/c/solutions/CorePointerFromSolutionEnum.cpp

    r5247 r6412  
    5656                        break;
    5757                default:
    58                         ISSMERROR("%s%s%s"," solution type: ",EnumToString(solutiontype)," not supported yet!");
     58                        _error_("%s%s%s"," solution type: ",EnumToString(solutiontype)," not supported yet!");
    5959                        break;
    6060        }
    6161       
    6262        /*Assign output pointer:*/
    63         ISSMASSERT(psolutioncore);
     63        _assert_(psolutioncore);
    6464        *psolutioncore=solutioncore;
    6565

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

    r6323 r6412  
    1313        int analysis_counter;
    1414                       
    15         ISSMPRINTF(VerboseSolution(),"%s\n","   updating boundary conditions...");
     15        _printf_(VerboseSolution(),"%s\n","   updating boundary conditions...");
    1616                       
    1717        /*set current analysis: */

  • TabularUnified issm/trunk/src/c/solutions/SolutionConfiguration.cpp

    r5579 r6412  
    116116
    117117                default:
    118                         ISSMERROR("%s%s%s"," solution type: ",EnumToString(solutiontype)," not supported yet!");
     118                        _error_("%s%s%s"," solution type: ",EnumToString(solutiontype)," not supported yet!");
    119119                        break;
    120120        }

  • TabularUnified issm/trunk/src/c/solutions/WriteLockFile.cpp

    r3775 r6412  
    1717        if(my_rank==0){
    1818                fid=fopen(filename,"w");
    19                 if(fid==NULL) ISSMERROR("%s%s","error message: could not open lock file ",filename);
     19                if(fid==NULL) _error_("%s%s","error message: could not open lock file ",filename);
    2020
    2121                /*Close file: */
    22                 if(fclose(fid)!=0) ISSMERROR("%s%s","could not close lock file ",filename);
     22                if(fclose(fid)!=0) _error_("%s%s","could not close lock file ",filename);
    2323        }
    2424

  • TabularUnified issm/trunk/src/c/solutions/adjointbalancedthickness_core.cpp

    r6323 r6412  
    2323
    2424        /*compute thickness */
    25         ISSMPRINTF(VerboseSolution(),"%s\n","   computing thickness");
     25        _printf_(VerboseSolution(),"%s\n","   computing thickness");
    2626        femmodel->SetCurrentConfiguration(BalancedthicknessAnalysisEnum);
    2727        solver_linear(femmodel);
    … …  
    3131
    3232        /*compute adjoint*/
    33         ISSMPRINTF(VerboseSolution(),"%s\n","   computing adjoint");
     33        _printf_(VerboseSolution(),"%s\n","   computing adjoint");
    3434        femmodel->SetCurrentConfiguration(BalancedthicknessAnalysisEnum,AdjointBalancedthicknessAnalysisEnum);
    3535        solver_adjoint_linear(femmodel);
    … …  
    3737        /*Save results*/
    3838        if(solution_type==AdjointSolutionEnum && !control_analysis){
    39                 ISSMPRINTF(VerboseSolution(),"   saving results\n");
     39                _printf_(VerboseSolution(),"   saving results\n");
    4040                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointEnum);
    4141        }

  • TabularUnified issm/trunk/src/c/solutions/adjointdiagnostic_core.cpp

    r6323 r6412  
    2626
    2727        /*Compute velocities*/
    28         ISSMPRINTF(VerboseSolution(),"%s\n","   computing velocities");
     28        _printf_(VerboseSolution(),"%s\n","   computing velocities");
    2929        femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
    3030        solver_diagnostic_nonlinear(femmodel,conserve_loads);
    … …  
    3434
    3535        /*Compute adjoint*/
    36         ISSMPRINTF(VerboseSolution(),"%s\n","   computing adjoint");
     36        _printf_(VerboseSolution(),"%s\n","   computing adjoint");
    3737        femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum,AdjointHorizAnalysisEnum);
    3838        solver_adjoint_linear(femmodel);
    … …  
    4040        /*Save results*/
    4141        if(solution_type==AdjointSolutionEnum && !control_analysis){
    42                 ISSMPRINTF(VerboseSolution(),"   saving results\n");
     42                _printf_(VerboseSolution(),"   saving results\n");
    4343                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointxEnum);
    4444                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,AdjointyEnum);

  • TabularUnified issm/trunk/src/c/solutions/balancedthickness_core.cpp

    r6323 r6412  
    2727        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2828
    29         ISSMPRINTF(VerboseSolution(),"call computational core:\n");
     29        _printf_(VerboseSolution(),"call computational core:\n");
    3030        solver_linear(femmodel);
    3131
    3232        if(solution_type==BalancedthicknessSolutionEnum && !control_analysis){
    33                 ISSMPRINTF(VerboseSolution(),"   saving results\n");
     33                _printf_(VerboseSolution(),"   saving results\n");
    3434                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ThicknessEnum);
    3535        }

  • TabularUnified issm/trunk/src/c/solutions/balancedvelocities_core.cpp

    r6323 r6412  
    2626        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2727
    28         ISSMPRINTF(VerboseSolution(),"   call computational core\n");
     28        _printf_(VerboseSolution(),"   call computational core\n");
    2929        solver_linear(femmodel);
    3030
    3131        if(solution_type==BalancedvelocitiesSolutionEnum && !control_analysis){
    32                 ISSMPRINTF(VerboseSolution(),"   saving results\n");
     32                _printf_(VerboseSolution(),"   saving results\n");
    3333                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VelEnum);
    3434        }

  • TabularUnified issm/trunk/src/c/solutions/bedslope_core.cpp

    r6323 r6412  
    2424        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2525
    26         ISSMPRINTF(VerboseSolution(),"%s\n","   computing slope");
     26        _printf_(VerboseSolution(),"%s\n","   computing slope");
    2727
    2828        /*Call on core computations: */
    … …  
    3333       
    3434        if(solution_type==BedSlopeSolutionEnum && !control_analysis){
    35                 ISSMPRINTF(VerboseSolution(),"   saving results\n");
     35                _printf_(VerboseSolution(),"   saving results\n");
    3636                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BedSlopeXEnum);
    3737                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,BedSlopeYEnum);

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

    r6323 r6412  
    6666
    6767        /*Launch once a complete solution to set up all inputs*/
    68         ISSMPRINTF(VerboseControl(),"%s\n","   preparing initial solution");
     68        _printf_(VerboseControl(),"%s\n","   preparing initial solution");
    6969        if (isstokes) solutioncore(femmodel);
    7070
    … …  
    8080
    8181                /*Display info*/
    82                 ISSMPRINTF(VerboseControl(),"\n%s%i%s%i\n","   control method step ",n+1,"/",nsteps);
     82                _printf_(VerboseControl(),"\n%s%i%s%i\n","   control method step ",n+1,"/",nsteps);
    8383                InputUpdateFromConstantx(femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,(int)responses[n],CmResponseEnum);
    8484               
    … …  
    8686                if (solution_type==SteadystateSolutionEnum) solutioncore(femmodel);
    8787
    88                 ISSMPRINTF(VerboseControl(),"%s\n","   compute adjoint state:");
     88                _printf_(VerboseControl(),"%s\n","   compute adjoint state:");
    8989                adjointcore(femmodel);
    9090       
    … …  
    9797                }
    9898
    99                 ISSMPRINTF(VerboseControl(),"%s\n","   optimizing along gradient direction");
     99                _printf_(VerboseControl(),"%s\n","   optimizing along gradient direction");
    100100                optargs.n=n; optpars.maxiter=(int)maxiter[n]; optpars.cm_jump=cm_jump[n];
    101101                BrentSearch(&search_scalar,J+n,&optpars,&objectivefunctionC,&optargs);
    102102                //OptimalSearch(&search_scalar,J+n,&optpars,&objectivefunctionC,&optargs);
    103103
    104                 ISSMPRINTF(VerboseControl(),"%s\n","   updating parameter using optimized search scalar"); //true means update save controls
     104                _printf_(VerboseControl(),"%s\n","   updating parameter using optimized search scalar"); //true means update save controls
    105105                InputControlUpdatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,search_scalar,true);
    106106               
    … …  
    109109                /*Temporary saving every 5 control steps: */
    110110                if (((n+1)%5)==0){
    111                         ISSMPRINTF(VerboseControl(),"%s\n","   saving temporary results");
     111                        _printf_(VerboseControl(),"%s\n","   saving temporary results");
    112112                        controlrestart(femmodel,J);
    113113                }
    114114        }
    115115
    116         ISSMPRINTF(VerboseControl(),"%s\n","   preparing final solution");
     116        _printf_(VerboseControl(),"%s\n","   preparing final solution");
    117117        femmodel->parameters->SetParam(false,ControlAnalysisEnum); //needed to turn control result output in solutioncore
    118118        solutioncore(femmodel);

  • TabularUnified issm/trunk/src/c/solutions/controlconvergence.cpp

    r6323 r6412  
    3232                                        //convergence if convergence criteria fullfilled
    3333                                        converged=true;
    34                                         ISSMPRINTF(VerboseConvergence(),"%s%g%s%g\n","      Convergence criterion: dJ/J = ",(J[i]-J[n])/J[n],"<",eps_cm);
     34                                        _printf_(VerboseConvergence(),"%s%g%s%g\n","      Convergence criterion: dJ/J = ",(J[i]-J[n])/J[n],"<",eps_cm);
    3535                                }
    3636                                else{
    37                                         ISSMPRINTF(VerboseConvergence(),"%s%g%s%g\n","      Convergence criterion: dJ/J = ",(J[i]-J[n])/J[n],">",eps_cm);
     37                                        _printf_(VerboseConvergence(),"%s%g%s%g\n","      Convergence criterion: dJ/J = ",(J[i]-J[n])/J[n],">",eps_cm);
    3838                                }
    3939                                break;

  • TabularUnified issm/trunk/src/c/solutions/convergence.cpp

    r6322 r6412  
    5454                VecNorm(pf,NORM_2,&nF);
    5555                solver_residue=nKUF/nF;
    56                 _printf_("\n%s%g\n","   solver residue: norm(KU-F)/norm(F)=",solver_residue);
     56                _printf_(true,"\n%s%g\n","   solver residue: norm(KU-F)/norm(F)=",solver_residue);
    5757
    5858                //clean up
    … …  
    7070        res=nKUoldF/nF;
    7171        if (isnan(res)){
    72                 _printf_("norm nf = %lf and norm kuold = %lf\n",nF,nKUoldF);
    73                 ISSMERROR("mechanical equilibrium convergence criterion is NaN!");
     72                _printf_(true,"norm nf = %lf and norm kuold = %lf\n",nF,nKUoldF);
     73                _error_("mechanical equilibrium convergence criterion is NaN!");
    7474        }
    7575
    … …  
    8080        //print
    8181        if(res<eps_res){
    82                 ISSMPRINTF(VerboseConvergence(),"%-50s%g%s%g%s\n","   mechanical equilibrium convergence criterion",res*100," < ",eps_res*100," %");
     82                _printf_(VerboseConvergence(),"%-50s%g%s%g%s\n","   mechanical equilibrium convergence criterion",res*100," < ",eps_res*100," %");
    8383                converged=1;
    8484        }
    8585        else{
    86                 ISSMPRINTF(VerboseConvergence(),"%-50s%g%s%g%s\n","   mechanical equilibrium convergence criterion",res*100," > ",eps_res*100," %");
     86                _printf_(VerboseConvergence(),"%-50s%g%s%g%s\n","   mechanical equilibrium convergence criterion",res*100," > ",eps_res*100," %");
    8787                converged=0;
    8888        }
    … …  
    9595                VecNorm(duf,NORM_2,&ndu); VecNorm(old_uf,NORM_2,&nu);
    9696
    97                 if (isnan(ndu) || isnan(nu)) ISSMERROR("convergence criterion is NaN!");
     97                if (isnan(ndu) || isnan(nu)) _error_("convergence criterion is NaN!");
    9898
    9999                //clean up
    … …  
    103103                if (!isnan(eps_rel)){
    104104                        if((ndu/nu)<eps_rel){
    105                                 ISSMPRINTF(VerboseConvergence(),"%-50s%g%s%g%s\n","   Convergence criterion: norm(du)/norm(u)",ndu/nu*100," < ",eps_rel*100," %");
     105                                _printf_(VerboseConvergence(),"%-50s%g%s%g%s\n","   Convergence criterion: norm(du)/norm(u)",ndu/nu*100," < ",eps_rel*100," %");
    106106                        }
    107107                        else{
    108                                 ISSMPRINTF(VerboseConvergence(),"%-50s%g%s%g%s\n","   Convergence criterion: norm(du)/norm(u)",ndu/nu*100," > ",eps_rel*100," %");
     108                                _printf_(VerboseConvergence(),"%-50s%g%s%g%s\n","   Convergence criterion: norm(du)/norm(u)",ndu/nu*100," > ",eps_rel*100," %");
    109109                                converged=0;
    110110                        }
    111111                }
    112                 else _printf_("%-50s%g%s\n","   Convergence criterion: norm(du)/norm(u)",ndu/nu*100," %");
     112                else _printf_(true,"%-50s%g%s\n","   Convergence criterion: norm(du)/norm(u)",ndu/nu*100," %");
    113113
    114114        }
    … …  
    120120                VecDuplicate(old_uf,&duf);VecCopy(old_uf,duf); VecAYPX(duf,-1.0,uf);
    121121                VecNorm(duf,NORM_2,&ndu); VecNorm(duf,NORM_INFINITY,&nduinf);
    122                 if (isnan(ndu) || isnan(nu)) ISSMERROR("convergence criterion is NaN!");
     122                if (isnan(ndu) || isnan(nu)) _error_("convergence criterion is NaN!");
    123123
    124124                //clean up
    … …  
    128128                if (!isnan(eps_abs)){
    129129                        if ((nduinf*yts)<eps_abs){
    130                                 ISSMPRINTF(VerboseConvergence(),"%-50s%g%s%g%s\n","   Convergence criterion: max(du)",nduinf*yts," < ",eps_abs," m/yr");
     130                                _printf_(VerboseConvergence(),"%-50s%g%s%g%s\n","   Convergence criterion: max(du)",nduinf*yts," < ",eps_abs," m/yr");
    131131                        }
    132132                        else{
    133                                 ISSMPRINTF(VerboseConvergence(),"%-50s%g%s%g%s\n","   Convergence criterion: max(du)",nduinf*yts," > ",eps_abs," m/yr");
     133                                _printf_(VerboseConvergence(),"%-50s%g%s%g%s\n","   Convergence criterion: max(du)",nduinf*yts," > ",eps_abs," m/yr");
    134134                                converged=0;
    135135                        }
    136136                }
    137                 else  _printf_("%-50s%g%s\n","   Convergence criterion: max(du)",nduinf*yts," m/yr");
     137                else  _printf_(true,"%-50s%g%s\n","   Convergence criterion: max(du)",nduinf*yts," m/yr");
    138138
    139139        }

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

    r6323 r6412  
    5050        if(ishutter){
    5151                       
    52                 ISSMPRINTF(VerboseControl(),"%s\n","   computing hutter velocities");
     52                _printf_(VerboseControl(),"%s\n","   computing hutter velocities");
    5353
    5454                //Take the last velocity into account so that the velocity on the MacAyeal domain is not zero
    … …  
    6363        if (ismacayealpattyn^isstokes){
    6464               
    65                 ISSMPRINTF(VerboseControl(),"%s\n","   computing velocities");
     65                _printf_(VerboseControl(),"%s\n","   computing velocities");
    6666                femmodel->SetCurrentConfiguration(DiagnosticHorizAnalysisEnum);
    6767                solver_diagnostic_nonlinear(femmodel,modify_loads);
    … …  
    7070        if (ismacayealpattyn && isstokes){
    7171
    72                 ISSMPRINTF(VerboseControl(),"%s\n","   computing coupling macayealpattyn and stokes velocities and pressure ");
     72                _printf_(VerboseControl(),"%s\n","   computing coupling macayealpattyn and stokes velocities and pressure ");
    7373                solver_stokescoupling_nonlinear(femmodel,conserve_loads);
    7474        }
    … …  
    7676        if (dim==3 & (ishutter || ismacayealpattyn)){
    7777
    78                 ISSMPRINTF(VerboseControl(),"%s\n","   computing vertical velocities");
     78                _printf_(VerboseControl(),"%s\n","   computing vertical velocities");
    7979                femmodel->SetCurrentConfiguration(DiagnosticVertAnalysisEnum);
    8080                solver_linear(femmodel);
    … …  
    8383
    8484        if(solution_type==DiagnosticSolutionEnum && !control_analysis){
    85                 ISSMPRINTF(VerboseControl(),"   saving results\n");
     85                _printf_(VerboseControl(),"   saving results\n");
    8686                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum);
    8787                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum);

  • TabularUnified issm/trunk/src/c/solutions/gradient_core.cpp

    r6323 r6412  
    3636        for (int i=0;i<num_controls;i++){
    3737
    38                 ISSMPRINTF(VerboseControl(),"   compute gradient of J with respect to %s\n",EnumToString(control_type[i]));
     38                _printf_(VerboseControl(),"   compute gradient of J with respect to %s\n",EnumToString(control_type[i]));
    3939                Gradjx(&gradient, femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials,femmodel->parameters, control_type[i]);
    4040
    … …  
    4242
    4343                if (step>0 && search_scalar==0){
    44                         ISSMPRINTF(VerboseControl(),"   orthogonalization\n");
     44                        _printf_(VerboseControl(),"   orthogonalization\n");
    4545                        ControlInputGetGradientx(&old_gradient,femmodel->elements,femmodel->nodes, femmodel->vertices,femmodel->loads, femmodel->materials,femmodel->parameters,control_type[i]);
    4646                        Orthx(&new_gradient,gradient,old_gradient); VecFree(&old_gradient); VecFree(&gradient);
    4747                }
    4848                else{
    49                         ISSMPRINTF(VerboseControl(),"   normalizing directions\n");
     49                        _printf_(VerboseControl(),"   normalizing directions\n");
    5050                        Orthx(&new_gradient,gradient,NULL); VecFree(&gradient);
    5151                }
    … …  
    5353                /*Get scaling factor of current control:*/
    5454                VecNorm(new_gradient,NORM_INFINITY,&norm_grad);
    55                 if(norm_grad<=0)    ISSMERROR("||∂J/∂α||∞ = 0    gradient norm of J with respect to %s is zero",EnumToString(control_type[i]));
    56                 if(isnan(norm_grad))ISSMERROR("||∂J/∂α||∞ = NaN  gradient norm of J with respect to %s is NaN" ,EnumToString(control_type[i]));
     55                if(norm_grad<=0)    _error_("||∂J/∂α||∞ = 0    gradient norm of J with respect to %s is zero",EnumToString(control_type[i]));
     56                if(isnan(norm_grad))_error_("||∂J/∂α||∞ = NaN  gradient norm of J with respect to %s is NaN" ,EnumToString(control_type[i]));
    5757                if(i==0 || (optscal_list[num_controls*step+i]/norm_grad)<optscal) optscal=optscal_list[num_controls*step+i]/norm_grad;
    5858

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

    r6389 r6412  
    3636
    3737        #if !defined(_PARALLEL_) || (defined(_PARALLEL_) && !defined(_HAVE_PETSC_))
    38         ISSMERROR(" parallel executable was compiled without support of parallel libraries!");
     38        _error_(" parallel executable was compiled without support of parallel libraries!");
    3939        #endif
    4040
    4141        /*Initialize Petsc and get start time*/
    4242        int ierr=PetscInitialize(&argc,&argv,(char*)0,""); 
    43         if(ierr) ISSMERROR("Could not initialize Petsc");
     43        if(ierr) _error_("Could not initialize Petsc");
    4444        MPI_Barrier(MPI_COMM_WORLD); start=MPI_Wtime();
    4545
    … …  
    4848        MPI_Comm_size(MPI_COMM_WORLD,&num_procs);
    4949
    50         _printf_("Launching solution sequence\n");
     50        _printf_(true,"Launching solution sequence\n");
    5151        solution_type=StringToEnum(argv[1]);
    5252        petscoptionsfilename=argv[4];
    … …  
    7878        if(!qmu_analysis){
    7979                       
    80                 _printf_("call computational core:\n");
     80                _printf_(true,"call computational core:\n");
    8181                MPI_Barrier(MPI_COMM_WORLD); start_core=MPI_Wtime( );
    8282                solutioncore(femmodel);
    8383                MPI_Barrier(MPI_COMM_WORLD); finish_core=MPI_Wtime( );
    8484
    85                 _printf_("write results to disk:\n");
     85                _printf_(true,"write results to disk:\n");
    8686                OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,&femmodel->results);
    8787        }
    8888        else{
    8989                /*run qmu analysis: */
    90                 _printf_("calling qmu analysis on diagnostic core:\n");
     90                _printf_(true,"calling qmu analysis on diagnostic core:\n");
    9191
    9292                #ifdef _HAVE_DAKOTA_
    … …  
    9595                MPI_Barrier(MPI_COMM_WORLD); finish_core=MPI_Wtime( );
    9696                #else
    97                 ISSMERROR(" Dakota not present, cannot do qmu!");
     97                _error_(" Dakota not present, cannot do qmu!");
    9898                #endif
    9999        }
    … …  
    101101        /*Close output file and write lock file if requested*/
    102102        if (waitonlock>0){
    103                 _printf_("write lock file:\n");
     103                _printf_(true,"write lock file:\n");
    104104                WriteLockFile(lockname);
    105105        }
    … …  
    111111        /*Get finish time and close*/
    112112        MPI_Barrier(MPI_COMM_WORLD); finish = MPI_Wtime( );
    113         _printf_("\n   %-34s %f seconds  \n","FemModel initialization elapsed time:",finish_init-start_init);
    114         _printf_("   %-34s %f seconds  \n","Core solution elapsed time:",finish_core-start_core);
    115         _printf_("\n   %s %i hrs %i min %i sec\n\n","Total elapsed time:",int((finish-start)/3600),int(int(finish-start)%3600/60),int(finish-start)%60);
    116         _printf_("closing MPI and Petsc\n");
     113        _printf_(true,"\n   %-34s %f seconds  \n","FemModel initialization elapsed time:",finish_init-start_init);
     114        _printf_(true,"   %-34s %f seconds  \n","Core solution elapsed time:",finish_core-start_core);
     115        _printf_(true,"\n   %s %i hrs %i min %i sec\n\n","Total elapsed time:",int((finish-start)/3600),int(int(finish-start)%3600/60),int(finish-start)%60);
     116        _printf_(true,"closing MPI and Petsc\n");
    117117        PetscFinalize();
    118118       

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

    r6226 r6412  
    5555        }
    5656        else{
    57                 ISSMERROR("Solution %s not implemented yet",EnumToString(solution_type));
     57                _error_("Solution %s not implemented yet",EnumToString(solution_type));
    5858        }
    5959
    … …  
    7272        }
    7373        else{
    74                 ISSMERROR("Solution %s not implemented yet",EnumToString(solution_type));
     74                _error_("Solution %s not implemented yet",EnumToString(solution_type));
    7575        }
    7676

  • TabularUnified issm/trunk/src/c/solutions/prognostic_core.cpp

    r6323 r6412  
    2424        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2525
    26         ISSMPRINTF(VerboseSolution(),"   call computational core\n");
     26        _printf_(VerboseSolution(),"   call computational core\n");
    2727        solver_linear(femmodel);
    2828               
    2929        if(solution_type==PrognosticSolutionEnum && !control_analysis){
    30                 ISSMPRINTF(VerboseSolution(),"   saving results\n");
     30                _printf_(VerboseSolution(),"   saving results\n");
    3131                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,ThicknessEnum);
    3232        }

  • TabularUnified issm/trunk/src/c/solutions/steadystate_core.cpp

    r6323 r6412  
    3232        for(;;){
    3333       
    34                 ISSMPRINTF(VerboseSolution(),"%s%i\n","   computing temperature and velocity for step: ",step);
     34                _printf_(VerboseSolution(),"%s%i\n","   computing temperature and velocity for step: ",step);
    3535                thermal_core(femmodel);
    3636
    37                 ISSMPRINTF(VerboseSolution(),"%s\n","   computing new velocity");
     37                _printf_(VerboseSolution(),"%s\n","   computing new velocity");
    3838                diagnostic_core(femmodel);
    3939
    4040                if (step>1){
    41                         ISSMPRINTF(VerboseSolution(),"%s\n","   checking velocity, temperature and pressure convergence");
     41                        _printf_(VerboseSolution(),"%s\n","   checking velocity, temperature and pressure convergence");
    4242                        if(steadystateconvergence(femmodel)) break;
    4343                }
    4444               
    45                 ISSMPRINTF(VerboseSolution(),"%s\n","   saving velocity, temperature and pressure to check for convergence at next step");
     45                _printf_(VerboseSolution(),"%s\n","   saving velocity, temperature and pressure to check for convergence at next step");
    4646                InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum,VxOldEnum);
    4747                InputDuplicatex(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum,VyOldEnum);
    … …  
    5555       
    5656        if(solution_type==SteadystateSolutionEnum && !control_analysis){
    57                 ISSMPRINTF(VerboseSolution(),"   saving results\n");
     57                _printf_(VerboseSolution(),"   saving results\n");
    5858                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum);
    5959                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum);

  • TabularUnified issm/trunk/src/c/solutions/surfaceslope_core.cpp

    r6323 r6412  
    2424        femmodel->parameters->FindParam(&solution_type,SolutionTypeEnum);
    2525
    26         ISSMPRINTF(VerboseSolution(),"%s\n","computing slope...");
     26        _printf_(VerboseSolution(),"%s\n","computing slope...");
    2727
    2828        /*Call on core computations: */
    … …  
    3333       
    3434        if(solution_type==SurfaceSlopeSolutionEnum && !control_analysis){
    35                 ISSMPRINTF(VerboseSolution(),"saving results:\n");
     35                _printf_(VerboseSolution(),"saving results:\n");
    3636                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceSlopeXEnum);
    3737                InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,SurfaceSlopeYEnum);

  • TabularUnified issm/trunk/src/c/solutions/thermal_core.cpp

    r6323 r6412  
    4141        for(i=0;i<nsteps;i++){
    4242               
    43                 if(nsteps)ISSMPRINTF(VerboseSolution(),"time step: %i/%i\n",i+1,nsteps);
     43                if(nsteps)_printf_(VerboseSolution(),"time step: %i/%i\n",i+1,nsteps);
    4444                time=(i+1)*dt;
    4545
    … …  
    4848
    4949                if(solution_type==ThermalSolutionEnum && !control_analysis){
    50                         ISSMPRINTF(VerboseSolution(),"   saving results\n");
     50                        _printf_(VerboseSolution(),"   saving results\n");
    5151                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,TemperatureEnum,i+1,time);
    5252                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,MeltingRateEnum,i+1,time);

  • TabularUnified issm/trunk/src/c/solutions/thermal_core_step.cpp

    r6323 r6412  
    1414void thermal_core_step(FemModel* femmodel,int step, double time){
    1515
    16         ISSMPRINTF(VerboseSolution(),"   computing temperatures\n");
     16        _printf_(VerboseSolution(),"   computing temperatures\n");
    1717        femmodel->SetCurrentConfiguration(ThermalAnalysisEnum);
    1818        solver_thermal_nonlinear(femmodel);
    1919
    20         ISSMPRINTF(VerboseSolution(),"   computing melting\n");
     20        _printf_(VerboseSolution(),"   computing melting\n");
    2121        femmodel->SetCurrentConfiguration(MeltingAnalysisEnum);
    2222        solver_linear(femmodel);

  • TabularUnified issm/trunk/src/c/solutions/transient2d_core.cpp

    r6372 r6412  
    5050                step+=1;
    5151
    52                 ISSMPRINTF(VerboseSolution(),"%s%g%s%i%s%g%s%g\n","time [yr]: ",time/yts,"    iteration number: ",step,"/",floor(finaltime/dt)," dt [yr]: ",dt/yts);
     52                _printf_(VerboseSolution(),"%s%g%s%i%s%g%s%g\n","time [yr]: ",time/yts,"    iteration number: ",step,"/",floor(finaltime/dt)," dt [yr]: ",dt/yts);
    5353
    54                 ISSMPRINTF(VerboseSolution(),"%s\n","   computing new velocity");
     54                _printf_(VerboseSolution(),"%s\n","   computing new velocity");
    5555                diagnostic_core(femmodel);
    5656
    57                 ISSMPRINTF(VerboseSolution(),"%s\n","   computing new thickness");
     57                _printf_(VerboseSolution(),"%s\n","   computing new thickness");
    5858                prognostic_core(femmodel);
    5959       
    60                 ISSMPRINTF(VerboseSolution(),"%s\n","   updating geometry");
     60                _printf_(VerboseSolution(),"%s\n","   updating geometry");
    6161                UpdateGeometryx(femmodel->elements, femmodel->nodes,femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
    6262
    6363                if(solution_type==Transient2DSolutionEnum && !control_analysis && (step%output_frequency==0)){
    64                         ISSMPRINTF(VerboseSolution(),"%s\n","   saving results\n");
     64                        _printf_(VerboseSolution(),"%s\n","   saving results\n");
    6565                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum,step,time);
    6666                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum,step,time);
    … …  
    7272
    7373                        /*unload results*/
    74                         ISSMPRINTF(VerboseSolution(),"%s","   saving temporary results");
     74                        _printf_(VerboseSolution(),"%s","   saving temporary results");
    7575                        OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,&femmodel->results,step,time);
    7676                }

  • TabularUnified issm/trunk/src/c/solutions/transient3d_core.cpp

    r6372 r6412  
    5050                time+=dt;
    5151
    52                 ISSMPRINTF(VerboseSolution(),"%s%g%s%i%s%g%s%g\n","time [yr]: ",time/yts,"    iteration number: ",step,"/",floor(finaltime/dt)," dt [yr]: ",dt/yts);
     52                _printf_(VerboseSolution(),"%s%g%s%i%s%g%s%g\n","time [yr]: ",time/yts,"    iteration number: ",step,"/",floor(finaltime/dt)," dt [yr]: ",dt/yts);
    5353
    54                 ISSMPRINTF(VerboseSolution(),"   computing temperatures:\n");
     54                _printf_(VerboseSolution(),"   computing temperatures:\n");
    5555                thermal_core_step(femmodel,step,time);
    5656
    57                 ISSMPRINTF(VerboseSolution(),"%s\n","   computing new velocity");
     57                _printf_(VerboseSolution(),"%s\n","   computing new velocity");
    5858                diagnostic_core(femmodel);
    5959
    60                 ISSMPRINTF(VerboseSolution(),"%s\n","   computing new thickness");
     60                _printf_(VerboseSolution(),"%s\n","   computing new thickness");
    6161                prognostic_core(femmodel);
    6262       
    63                 ISSMPRINTF(VerboseSolution(),"   updating geometry\n");
     63                _printf_(VerboseSolution(),"   updating geometry\n");
    6464                UpdateGeometryx(femmodel->elements, femmodel->nodes,femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
    6565               
    66                 ISSMPRINTF(VerboseSolution(),"%s\n","   updating vertices positions");
     66                _printf_(VerboseSolution(),"%s\n","   updating vertices positions");
    6767                UpdateVertexPositionsx(femmodel->elements, femmodel->nodes,femmodel->vertices,femmodel->loads, femmodel->materials, femmodel->parameters);
    6868
    6969                if(solution_type==Transient3DSolutionEnum && !control_analysis && (step%output_frequency==0)){
    70                         ISSMPRINTF(VerboseSolution(),"%s\n","   saving results\n");
     70                        _printf_(VerboseSolution(),"%s\n","   saving results\n");
    7171                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VxEnum,step,time);
    7272                        InputToResultx(femmodel->elements,femmodel->nodes,femmodel->vertices,femmodel->loads,femmodel->materials,femmodel->parameters,VyEnum,step,time);
    … …  
    8181
    8282                        /*unload results*/
    83                         ISSMPRINTF(VerboseSolution(),"%s","   saving temporary results");
     83                        _printf_(VerboseSolution(),"%s","   saving temporary results");
    8484                        OutputResultsx(femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,&femmodel->results,step,time);
    8585                }

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

    r6323 r6412  
    6969
    7070                PenaltyConstraintsx(&constraints_converged, &num_unstable_constraints, femmodel->elements,femmodel->nodes,femmodel->vertices,loads,femmodel->materials,femmodel->parameters);
    71                 ISSMPRINTF(VerboseConvergence(),"   number of unstable constraints: %i\n",num_unstable_constraints);
     71                _printf_(VerboseConvergence(),"   number of unstable constraints: %i\n",num_unstable_constraints);
    7272
    7373                convergence(&converged,Kff,pf,uf,old_uf,femmodel->parameters); MatFree(&Kff);VecFree(&pf);
    … …  
    8787                if(converged==1)break;
    8888                if(count>=max_nonlinear_iterations){
    89                         _printf_("   maximum number of iterations (%i) exceeded\n",max_nonlinear_iterations);
     89                        _printf_(true,"   maximum number of iterations (%i) exceeded\n",max_nonlinear_iterations);
    9090                        break;
    9191                }

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

    r6323 r6412  
    9595                if(converged==1)break;
    9696                if(count>=max_nonlinear_iterations){
    97                         _printf_("   maximum number of iterations (%i) exceeded\n",max_nonlinear_iterations);
     97                        _printf_(true,"   maximum number of iterations (%i) exceeded\n",max_nonlinear_iterations);
    9898                        break;
    9999                }

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

    r6323 r6412  
    4444        converged=false;
    4545
    46         ISSMPRINTF(VerboseSolution(),"%s\n","starting direct shooting method");
     46        _printf_(VerboseSolution(),"%s\n","starting direct shooting method");
    4747        InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,reset_penalties,ResetPenaltiesEnum);
    4848        InputUpdateFromConstantx( femmodel->elements,femmodel->nodes, femmodel->vertices, femmodel->loads, femmodel->materials, femmodel->parameters,false,ConvergedEnum);
    … …  
    7171
    7272                if (!converged){
    73                         ISSMPRINTF(VerboseConvergence(),"%s%i\n","   #unstable constraints = ",num_unstable_constraints);
     73                        _printf_(VerboseConvergence(),"%s%i\n","   #unstable constraints = ",num_unstable_constraints);
    7474                        if (num_unstable_constraints <= min_thermal_constraints)converged=true;
    7575                }

  • TabularUnified issm/trunk/src/c/toolkits/petsc/patches/MatInvert.cpp

    r5895 r6412  
    2929        /*Some checks: */
    3030        MatGetSize(matrix,&M,&N);
    31         if(M!=N) ISSMERROR("trying to invert a non square matrix!");
     31        if(M!=N) _error_("trying to invert a non square matrix!");
    3232
    3333        /*Create identitiy matrix: */

  • TabularUnified issm/trunk/src/c/toolkits/petsc/patches/MatlabVectorToDoubleVector.cpp

    r4206 r6412  
    5454               
    5555                /*Check that input is actualy a vector*/
    56                 if (cols!=1) ISSMERROR("input vector of size %ix%i should have only one column",rows,cols);
     56                if (cols!=1) _error_("input vector of size %ix%i should have only one column",rows,cols);
    5757
    5858                nz=(int)((double)nnz/(double)rows);
    … …  
    8383
    8484                /*Check that input is actualy a vector*/
    85                 if (cols!=1) ISSMERROR("input vector of size %ix%i should have only one column",rows,cols);
     85                if (cols!=1) _error_("input vector of size %ix%i should have only one column",rows,cols);
    8686
    8787                /*allocate and memcpy*/

  • TabularUnified issm/trunk/src/c/toolkits/petsc/patches/PetscOptionsInsertMultipleString.cpp

    r3775 r6412  
    5555                        if(first[0]!='-'){
    5656                                /*This is not good, the option does not have '-'! Get out*/
    57                                 ISSMERROR("%s%s%s","Option ",first," should be preceded by '-'!");
     57                                _error_("%s%s%s","Option ",first," should be preceded by '-'!");
    5858                        }
    5959                        /*Reduce first to bare option value*/

  • TabularUnified issm/trunk/src/c/toolkits/petsc/patches/VecMerge.cpp

    r3775 r6412  
    3535        /*If the dimension of the partitioning vector is not the same as that of vector B, we have a problem: */
    3636        if ( (row_partition_size !=MB) ){
    37                 ISSMERROR("Dimensions of partitioning vector incompatible with dimensions of input vector\n");
     37                _error_("Dimensions of partitioning vector incompatible with dimensions of input vector\n");
    3838        }
    3939

  • TabularUnified issm/trunk/src/c/toolkits/plapack/patches/PlapackInvertMatrix.cpp

    r3775 r6412  
    5353
    5454        /*Some dimensions checks: */
    55         if (mA!=nA) ISSMERROR(" trying to take the invert of a non-square matrix!");
     55        if (mA!=nA) _error_(" trying to take the invert of a non-square matrix!");
    5656
    5757        /* Set default Plapack parameters */

  • TabularUnified issm/trunk/src/m/model/collapse.m

    r6335 r6412  
    6666
    6767%Extrusion of Neumann BC
    68 %in 2d, segmentonnumann is: [grid1 grid2 element]
    69 numberofneumann2d=size(md.pressureload,1)/md.numlayers;
    70 md.pressureload=[md.pressureload(1:numberofneumann2d,1:2) md.pressureload(1:numberofneumann2d,5:6)]; %Add two columns on the first layer
     68if ~isnan(md.pressureload),
     69        numberofneumann2d=size(md.pressureload,1)/md.numlayers;
     70        md.pressureload=[md.pressureload(1:numberofneumann2d,1:2) md.pressureload(1:numberofneumann2d,5:6)]; %Add two columns on the first layer
     71end
    7172
    7273%materials

  • TabularUnified issm/trunk/src/mex/AddExternalResult/AddExternalResult.cpp

    r4553 r6412  
    3434        }
    3535        else{
    36                 ISSMERROR("type of result not implemented yet in AddExternalResult");
     36                _error_("type of result not implemented yet in AddExternalResult");
    3737        }
    3838
    … …  
    4949void AddExternalResultUsage(void)
    5050{
    51         _printf_("\n");
    52         _printf_("   usage: [results] = %s(results,type,value);\n",__FUNCT__);
    53         _printf_("\n");
     51        _printf_(true,"\n");
     52        _printf_(true,"   usage: [results] = %s(results,type,value);\n",__FUNCT__);
     53        _printf_(true,"\n");
    5454}

  • TabularUnified issm/trunk/src/mex/BamgConvertMesh/BamgConvertMesh.cpp

    r5177 r6412  
    4444        /*Check inputs*/
    4545        if (nels<0){
    46                 ISSMERROR("Number of elements must be positive, check index number of lines");
     46                _error_("Number of elements must be positive, check index number of lines");
    4747        }
    4848        if (nods<0){
    49                 ISSMERROR("Number of nods must be positive, check x and y sizes");
     49                _error_("Number of nods must be positive, check x and y sizes");
    5050        }
    5151        if (index_rows!=3){
    52                 ISSMERROR("index should have 3 columns");
     52                _error_("index should have 3 columns");
    5353        }
    5454        if (y_rows!=nods){
    55                 ISSMERROR("x and y do not have the same length");
     55                _error_("x and y do not have the same length");
    5656        }
    5757        if (x_cols>1 || y_cols>1){
    58                 ISSMERROR("x and y should have only one column");
     58                _error_("x and y should have only one column");
    5959        }
    6060
    … …  
    7777void BamgConvertMeshUsage(void)
    7878{
    79         _printf_("BAMGCONVERTMESH - convert [x y index] to a bamg geom and mesh geom");
    80         _printf_("\n");
    81         _printf_("   Usage:\n");
    82         _printf_("      [bamggeom bamgmesh]=BamgConvertMesh(index,x,y);\n");
    83         _printf_("      index: index of the mesh\n");
    84         _printf_("      x,y: coordinates of the nodes\n");
    85         _printf_("\n");
     79        _printf_(true,"BAMGCONVERTMESH - convert [x y index] to a bamg geom and mesh geom");
     80        _printf_(true,"\n");
     81        _printf_(true,"   Usage:\n");
     82        _printf_(true,"      [bamggeom bamgmesh]=BamgConvertMesh(index,x,y);\n");
     83        _printf_(true,"      index: index of the mesh\n");
     84        _printf_(true,"      x,y: coordinates of the nodes\n");
     85        _printf_(true,"\n");
    8686}

  • TabularUnified issm/trunk/src/mex/BamgMesher/BamgMesher.cpp

    r5245 r6412  
    5151
    5252void BamgMesherUsage(void){
    53         _printf_("\n");
    54         _printf_("   usage: [bamgmesh,bamggeom]=%s(bamgmesh,bamggeom,bamgoptions);\n",__FUNCT__);
    55         _printf_("\n");
     53        _printf_(true,"\n");
     54        _printf_(true,"   usage: [bamgmesh,bamggeom]=%s(bamgmesh,bamggeom,bamgoptions);\n",__FUNCT__);
     55        _printf_(true,"\n");
    5656}

  • TabularUnified issm/trunk/src/mex/BuildNodeSets/BuildNodeSets.cpp

    r4453 r6412  
    4141void BuildNodeSetsUsage(void)
    4242{
    43         _printf_("\n");
    44         _printf_("   usage: [m.nodesets]=%s(m.nodes);\n",__FUNCT__);
    45         _printf_("\n");
     43        _printf_(true,"\n");
     44        _printf_(true,"   usage: [m.nodesets]=%s(m.nodes);\n",__FUNCT__);
     45        _printf_(true,"\n");
    4646}

  • TabularUnified issm/trunk/src/mex/Chaco/Chaco.cpp

    r4640 r6412  
    4343
    4444        #ifndef _HAVE_CHACO_ //only works if dakota library has been compiled in.
    45         ISSMERROR(" Chaco not available! Cannot carry out Chaco partitioning!");
     45        _error_(" Chaco not available! Cannot carry out Chaco partitioning!");
    4646        #endif
    4747
    … …  
    140140void ChacoUsage( void )
    141141{
    142         _printf_("\n");
    143         _printf_("Usage: [assgn] = Chaco(A,vwgts,ewgts,x,y,z,options,nparts,goal);\n");
    144         _printf_("\n");
     142        _printf_(true,"\n");
     143        _printf_(true,"Usage: [assgn] = Chaco(A,vwgts,ewgts,x,y,z,options,nparts,goal);\n");
     144        _printf_(true,"\n");
    145145}
    146146

  • TabularUnified issm/trunk/src/mex/ConfigureObjects/ConfigureObjects.cpp

    r4453 r6412  
    5454void ConfigureObjectsUsage(void)
    5555{
    56         _printf_("\n");
    57         _printf_("   usage: [elements,loads, nodes,parameters] = %s(elements,loads,nodes, materials,parameters);\n",__FUNCT__);
    58         _printf_("\n");
     56        _printf_(true,"\n");
     57        _printf_(true,"   usage: [elements,loads, nodes,parameters] = %s(elements,loads,nodes, materials,parameters);\n",__FUNCT__);
     58        _printf_(true,"\n");
    5959}

  • TabularUnified issm/trunk/src/mex/ContourToMesh/ContourToMesh.cpp

    r5685 r6412  
    5656        if((nlhs!=1 && nlhs!=2) || (nrhs!=NRHS)){
    5757                ContourToMeshUsage();
    58                 ISSMERROR(" usage. See above");
     58                _error_(" usage. See above");
    5959        }
    6060
    … …  
    110110                WriteData(PLHS1,in_elem);
    111111        }
    112         else ISSMERROR(" wrong interpolation type");
     112        else _error_(" wrong interpolation type");
    113113
    114114        /*end module: */

  • TabularUnified issm/trunk/src/mex/ControlInputGetGradient/ControlInputGetGradient.cpp

    r6200 r6412  
    5858void ControlInputGetGradientUsage(void)
    5959{
    60         _printf_("\n");
    61         _printf_("   usage: [gradient] = %s(elements,nodes,vertices,loads, materials,parameters,control_type);\n",__FUNCT__);
    62         _printf_("\n");
     60        _printf_(true,"\n");
     61        _printf_(true,"   usage: [gradient] = %s(elements,nodes,vertices,loads, materials,parameters,control_type);\n",__FUNCT__);
     62        _printf_(true,"\n");
    6363}

  • TabularUnified issm/trunk/src/mex/ControlInputScaleGradient/ControlInputScaleGradient.cpp

    r6238 r6412  
    6363void ControlInputScaleGradientUsage(void)
    6464{
    65         _printf_("\n");
    66         _printf_("   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,control_type,scaling_factor);\n",__FUNCT__);
    67         _printf_("\n");
     65        _printf_(true,"\n");
     66        _printf_(true,"   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,control_type,scaling_factor);\n",__FUNCT__);
     67        _printf_(true,"\n");
    6868}

  • TabularUnified issm/trunk/src/mex/ControlInputSetGradient/ControlInputSetGradient.cpp

    r6200 r6412  
    6363void ControlInputSetGradientUsage(void)
    6464{
    65         _printf_("\n");
    66         _printf_("   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,control_type,gradient);\n",__FUNCT__);
    67         _printf_("\n");
     65        _printf_(true,"\n");
     66        _printf_(true,"   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,control_type,gradient);\n",__FUNCT__);
     67        _printf_(true,"\n");
    6868}

  • TabularUnified issm/trunk/src/mex/ControlOptimization/ControlOptimization.cpp

    r4539 r6412  
    6767void ControlOptimizationUsage(void)
    6868{
    69         _printf_("\n");
    70         _printf_("   usage: [search_scalar J] = %s(function_name,xmin,xmax,options,femmodel,step,parameters)\n",__FUNCT__);
    71         _printf_("\n");
     69        _printf_(true,"\n");
     70        _printf_(true,"   usage: [search_scalar J] = %s(function_name,xmin,xmax,options,femmodel,step,parameters)\n",__FUNCT__);
     71        _printf_(true,"\n");
    7272}

  • TabularUnified issm/trunk/src/mex/CostFunction/CostFunction.cpp

    r5280 r6412  
    5959void CostFunctionUsage(void)
    6060{
    61         _printf_("\n");
    62         _printf_("   usage: [J] = %s(elements,nodes,vertices,loads, materials, parameters,response);\n",__FUNCT__);
    63         _printf_("\n");
     61        _printf_(true,"\n");
     62        _printf_(true,"   usage: [J] = %s(elements,nodes,vertices,loads, materials, parameters,response);\n",__FUNCT__);
     63        _printf_(true,"\n");
    6464}

  • TabularUnified issm/trunk/src/mex/CreateNodalConstraints/CreateNodalConstraints.cpp

    r5775 r6412  
    4040void CreateNodalConstraintsUsage(void)
    4141{
    42         _printf_("\n");
    43         _printf_("   usage: ys = %s(nodes,analysis_type);\n",__FUNCT__);
    44         _printf_("\n");
     42        _printf_(true,"\n");
     43        _printf_(true,"   usage: ys = %s(nodes,analysis_type);\n",__FUNCT__);
     44        _printf_(true,"\n");
    4545}

  • TabularUnified issm/trunk/src/mex/DakotaResponses/DakotaResponses.cpp

    r6231 r6412  
    8787void DakotaResponsesUsage(void)
    8888{
    89         _printf_("\n");
    90         _printf_("   usage: [responses] = %s(elements,nodes,vertices,loads,materials,parameters,responses_descritpors);\n",__FUNCT__);
    91         _printf_("\n");
     89        _printf_(true,"\n");
     90        _printf_(true,"   usage: [responses] = %s(elements,nodes,vertices,loads,materials,parameters,responses_descritpors);\n",__FUNCT__);
     91        _printf_(true,"\n");
    9292}

  • TabularUnified issm/trunk/src/mex/Echo/Echo.cpp

    r4453 r6412  
    2828void EchoUsage(void)
    2929{
    30         _printf_("\n");
    31         _printf_("   usage: %s(m.dataset);\n",__FUNCT__);
    32         _printf_("\n");
     30        _printf_(true,"\n");
     31        _printf_(true,"   usage: %s(m.dataset);\n",__FUNCT__);
     32        _printf_(true,"\n");
    3333}

  • TabularUnified issm/trunk/src/mex/ElementConnectivity/ElementConnectivity.cpp

    r2333 r6412  
    4141
    4242void ElementConnectivityUsage(void) {
    43         _printf_("\n");
    44         _printf_("   usage: elementconnectivity = %s(elements, nodeconnectivity);\n",__FUNCT__);
    45         _printf_("\n");
     43        _printf_(true,"\n");
     44        _printf_(true,"   usage: elementconnectivity = %s(elements, nodeconnectivity);\n",__FUNCT__);
     45        _printf_(true,"\n");
    4646}

  • TabularUnified issm/trunk/src/mex/GetPId/GetPId.cpp

    r5004 r6412  
    2929void GetPIdUsage(void)
    3030{
    31         _printf_("\n");
    32         _printf_("   usage: pid=%s();\n",__FUNCT__);
    33         _printf_("\n");
     31        _printf_(true,"\n");
     32        _printf_(true,"   usage: pid=%s();\n",__FUNCT__);
     33        _printf_(true,"\n");
    3434}

  • TabularUnified issm/trunk/src/mex/GetSolutionFromInputs/GetSolutionFromInputs.cpp

    r4573 r6412  
    5757void GetSolutionFromInputsUsage(void)
    5858{
    59         _printf_("\n");
    60         _printf_("   usage: [ug] = %s(elements,nodes,vertices,loads, materials,parameters);\n",__FUNCT__);
    61         _printf_("\n");
     59        _printf_(true,"\n");
     60        _printf_(true,"   usage: [ug] = %s(elements,nodes,vertices,loads, materials,parameters);\n",__FUNCT__);
     61        _printf_(true,"\n");
    6262}

  • TabularUnified issm/trunk/src/mex/GetVectorFromInputs/GetVectorFromInputs.cpp

    r4573 r6412  
    6161void GetVectorFromInputsUsage(void)
    6262{
    63         _printf_("\n");
    64         _printf_("   usage: [ug] = %s(elements,nodes,vertices,loads, materials,parameters,name_enum,type_enum);\n",__FUNCT__);
    65         _printf_("\n");
     63        _printf_(true,"\n");
     64        _printf_(true,"   usage: [ug] = %s(elements,nodes,vertices,loads, materials,parameters,name_enum,type_enum);\n",__FUNCT__);
     65        _printf_(true,"\n");
    6666}

  • TabularUnified issm/trunk/src/mex/Gradj/Gradj.cpp

    r6261 r6412  
    6060void GradjUsage(void)
    6161{
    62         _printf_("\n");
    63         _printf_("   usage: [gradient] = %s(elements,nodes,vertices,loads, materials, parameters,control_type);\n",__FUNCT__);
    64         _printf_("\n");
     62        _printf_(true,"\n");
     63        _printf_(true,"   usage: [gradient] = %s(elements,nodes,vertices,loads, materials, parameters,control_type);\n",__FUNCT__);
     64        _printf_(true,"\n");
    6565}

  • TabularUnified issm/trunk/src/mex/InputControlUpdate/InputControlUpdate.cpp

    r4967 r6412  
    6363void InputControlUpdateUsage(void)
    6464{
    65         _printf_("\n");
    66         _printf_("   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,parameters,scalar);\n",__FUNCT__);
    67         _printf_("\n");
     65        _printf_(true,"\n");
     66        _printf_(true,"   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,parameters,scalar);\n",__FUNCT__);
     67        _printf_(true,"\n");
    6868}

  • TabularUnified issm/trunk/src/mex/InputConvergence/InputConvergence.cpp

    r4778 r6412  
    8080       
    8181void InputConvergenceUsage(void) {
    82         _printf_("\n");
    83         _printf_("   usage: convergence=InputConvergence(elements,nodes,vertices,loads,materials,parameters,fieldenums,criterionenums,criterionvalue)\n");
    84         _printf_("\n");
     82        _printf_(true,"\n");
     83        _printf_(true,"   usage: convergence=InputConvergence(elements,nodes,vertices,loads,materials,parameters,fieldenums,criterionenums,criterionvalue)\n");
     84        _printf_(true,"\n");
    8585}

  • TabularUnified issm/trunk/src/mex/InputDuplicate/InputDuplicate.cpp

    r4453 r6412  
    5454void InputDuplicateUsage(void)
    5555{
    56         _printf_("\n");
    57         _printf_("   usage: [elements] = %s(elements, nodes, vertices, loads, materials, parameters, original_enum,new_enum);\n",__FUNCT__);
    58         _printf_("\n");
     56        _printf_(true,"\n");
     57        _printf_(true,"   usage: [elements] = %s(elements, nodes, vertices, loads, materials, parameters, original_enum,new_enum);\n",__FUNCT__);
     58        _printf_(true,"\n");
    5959}

  • TabularUnified issm/trunk/src/mex/InputScale/InputScale.cpp

    r4573 r6412  
    6060void InputScaleUsage(void)
    6161{
    62         _printf_("\n");
    63         _printf_("   usage: [elements] = %s(elements, nodes, vertices, loads, materials, parameters, enum_type,scale_factor);\n",__FUNCT__);
    64         _printf_("\n");
     62        _printf_(true,"\n");
     63        _printf_(true,"   usage: [elements] = %s(elements, nodes, vertices, loads, materials, parameters, enum_type,scale_factor);\n",__FUNCT__);
     64        _printf_(true,"\n");
    6565}

  • TabularUnified issm/trunk/src/mex/InputToResult/InputToResult.cpp

    r5019 r6412  
    2424        if((nlhs!=NLHS) || (nrhs!=7 && nrhs!=9)){
    2525                InputToResultUsage();
    26                 ISSMERROR(" usage. See above");
     26                _error_(" usage. See above");
    2727        }
    2828
    … …  
    7373void InputToResultUsage(void)
    7474{
    75         _printf_("\n");
    76         _printf_("   usage: [elements] = %s(elements, nodes, vertices, loads, materials, parameters, enum_type,step,time);\n",__FUNCT__);
    77         _printf_("   usage: [elements] = %s(elements, nodes, vertices, loads, materials, parameters, enum_type);\n",__FUNCT__);
    78         _printf_("\n");
     75        _printf_(true,"\n");
     76        _printf_(true,"   usage: [elements] = %s(elements, nodes, vertices, loads, materials, parameters, enum_type,step,time);\n",__FUNCT__);
     77        _printf_(true,"   usage: [elements] = %s(elements, nodes, vertices, loads, materials, parameters, enum_type);\n",__FUNCT__);
     78        _printf_(true,"\n");
    7979}

  • TabularUnified issm/trunk/src/mex/InputUpdateFromConstant/InputUpdateFromConstant.cpp

    r4573 r6412  
    5959void InputUpdateFromConstantUsage(void)
    6060{
    61         _printf_("\n");
    62         _printf_("   usage: [elements loads] = %s(elements,nodes,vertices,loads,materials,parameters,constant,name);\n",__FUNCT__);
    63         _printf_("\n");
     61        _printf_(true,"\n");
     62        _printf_(true,"   usage: [elements loads] = %s(elements,nodes,vertices,loads,materials,parameters,constant,name);\n",__FUNCT__);
     63        _printf_(true,"\n");
    6464}

  • TabularUnified issm/trunk/src/mex/InputUpdateFromDakota/InputUpdateFromDakota.cpp

    r6231 r6412  
    8484void InputUpdateFromDakotaUsage(void)
    8585{
    86         _printf_("\n");
    87         _printf_("   usage: [elements loads] = %s(elements,nodes,vertices,loads,materials,parameters,variables,variables_descriptors);\n",__FUNCT__);
    88         _printf_("\n");
     86        _printf_(true,"\n");
     87        _printf_(true,"   usage: [elements loads] = %s(elements,nodes,vertices,loads,materials,parameters,variables,variables_descriptors);\n",__FUNCT__);
     88        _printf_(true,"\n");
    8989}

  • TabularUnified issm/trunk/src/mex/InputUpdateFromSolution/InputUpdateFromSolution.cpp

    r4686 r6412  
    5858void InputUpdateFromSolutionUsage(void)
    5959{
    60         _printf_("\n");
    61         _printf_("   usage: [elements,materials] = %s(elements,nodes,vertices,loads,materials,parameters,solution);\n",__FUNCT__);
    62         _printf_("\n");
     60        _printf_(true,"\n");
     61        _printf_(true,"   usage: [elements,materials] = %s(elements,nodes,vertices,loads,materials,parameters,solution);\n",__FUNCT__);
     62        _printf_(true,"\n");
    6363}

  • TabularUnified issm/trunk/src/mex/InputUpdateFromVector/InputUpdateFromVector.cpp

    r5103 r6412  
    3838        /*Check that type is one of Constant, Vertex or Element: */
    3939        if ((TypeEnum!=ConstantEnum) && (TypeEnum!=VertexEnum) && (TypeEnum!=ElementEnum)){
    40                 ISSMERROR("%s%s%s\n","Type of input can only be a constant, a vertex or an element vector.  Right now, you input a ",EnumToString(TypeEnum)," type data for input update");
     40                _error_("%s%s%s\n","Type of input can only be a constant, a vertex or an element vector.  Right now, you input a ",EnumToString(TypeEnum)," type data for input update");
    4141        }
    4242
    … …  
    7272void InputUpdateFromVectorUsage(void)
    7373{
    74         _printf_("\n");
    75         _printf_("   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,parameters,vector,name_enum,type_enum);\n",__FUNCT__);
    76         _printf_("\n");
     74        _printf_(true,"\n");
     75        _printf_(true,"   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,parameters,vector,name_enum,type_enum);\n",__FUNCT__);
     76        _printf_(true,"\n");
    7777}

  • TabularUnified issm/trunk/src/mex/InterpFromGridToMesh/InterpFromGridToMesh.cpp

    r2627 r6412  
    7272void InterpFromGridToMeshUsage(void)
    7373{
    74         _printf_("INTERPFROMGRIDTOMESH - interpolation from a grid onto a list of points\n");
    75         _printf_("\n");
    76         _printf_("   This function is a multi-threaded mex file that interpolates a field\n");
    77         _printf_("   defined on a grid onto a list of points\n");
    78         _printf_("\n");
    79         _printf_("   Usage:\n");
    80         _printf_("      data_mesh=InterpFromGridToMesh(x,y,data,x_mesh,y_mesh,default_value);\n");
    81         _printf_("\n");
    82         _printf_("      data: matrix holding the data to be interpolated onto the mesh.\n");
    83         _printf_("      x,y: coordinates of matrix data. (x and y must be in increasing order)\n");
    84         _printf_("      x_mesh,y_mesh: coordinates of the points onto which we interpolate.\n");
    85         _printf_("      default_value: default value if no data is found (holes).\n");
    86         _printf_("      data_mesh: vector of mesh interpolated data.\n");
    87         _printf_("\n");
    88         _printf_("   Example:\n");
    89         _printf_("      load('velocities.mat');\n");
    90         _printf_("      md.vx_obs=InterpFromGridToMesh(x_n,y_m,vx,md.x,md.y,0);\n");
    91         _printf_("\n");
     74        _printf_(true,"INTERPFROMGRIDTOMESH - interpolation from a grid onto a list of points\n");
     75        _printf_(true,"\n");
     76        _printf_(true,"   This function is a multi-threaded mex file that interpolates a field\n");
     77        _printf_(true,"   defined on a grid onto a list of points\n");
     78        _printf_(true,"\n");
     79        _printf_(true,"   Usage:\n");
     80        _printf_(true,"      data_mesh=InterpFromGridToMesh(x,y,data,x_mesh,y_mesh,default_value);\n");
     81        _printf_(true,"\n");
     82        _printf_(true,"      data: matrix holding the data to be interpolated onto the mesh.\n");
     83        _printf_(true,"      x,y: coordinates of matrix data. (x and y must be in increasing order)\n");
     84        _printf_(true,"      x_mesh,y_mesh: coordinates of the points onto which we interpolate.\n");
     85        _printf_(true,"      default_value: default value if no data is found (holes).\n");
     86        _printf_(true,"      data_mesh: vector of mesh interpolated data.\n");
     87        _printf_(true,"\n");
     88        _printf_(true,"   Example:\n");
     89        _printf_(true,"      load('velocities.mat');\n");
     90        _printf_(true,"      md.vx_obs=InterpFromGridToMesh(x_n,y_m,vx,md.x,md.y,0);\n");
     91        _printf_(true,"\n");
    9292}

  • TabularUnified issm/trunk/src/mex/InterpFromMesh2d/InterpFromMesh2d.cpp

    r5032 r6412  
    6969        if(nlhs!=NLHS){
    7070                InterpFromMesh2dUsage();
    71                 ISSMERROR("InterpFromMeshToMesh2dUsage usage error");
     71                _error_("InterpFromMeshToMesh2dUsage usage error");
    7272        }
    7373        if((nrhs!=6) && (nrhs!=7) && (nrhs!=8)){
    7474                InterpFromMesh2dUsage();
    75                 ISSMERROR("InterpFromMeshToMesh2dUsage usage error");
     75                _error_("InterpFromMeshToMesh2dUsage usage error");
    7676        }
    7777
    … …  
    131131        /*some checks*/
    132132        if (x_data_rows!=y_data_rows){
    133                 ISSMERROR("vectors x and y should have the same length!");
     133                _error_("vectors x and y should have the same length!");
    134134        }
    135135        if (x_prime_rows!=y_prime_rows){
    136                 ISSMERROR("vectors x_prime and y_prime should have the same length!");
     136                _error_("vectors x_prime and y_prime should have the same length!");
    137137        }
    138138       
    … …  
    154154void InterpFromMesh2dUsage(void)
    155155{
    156         _printf_("   usage:\n");
    157         _printf_("         data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime);\n\n");
    158         _printf_("      or data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime,default_value);\n\n");
    159         _printf_("      or data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime,default_value,contourname);\n\n");
    160         _printf_("   where:\n");
    161         _printf_("      x,y: coordinates of the nodes where data is defined\n");
    162         _printf_("      index: index of the mesh where data is defined\n");
    163         _printf_("      data - vector holding the data to be interpolated onto the points.\n");
    164         _printf_("      x_prime,y_prime: coordinates of the mesh grids onto which we interpolate.\n");
    165         _printf_("      default_value: a scalar or vector of size length(x_prime).\n");
    166         _printf_("      contourname: linear interpolation will happen on all x_interp,y_interp inside the contour, default value will be adopted on the rest of the mesh.\n");
    167         _printf_("      data_prime:  vector of prime interpolated data.\n");
    168         _printf_("\n");
     156        _printf_(true,"   usage:\n");
     157        _printf_(true,"         data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime);\n\n");
     158        _printf_(true,"      or data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime,default_value);\n\n");
     159        _printf_(true,"      or data_prime=InterpFromMesh2d(index,x,y,data,x_prime,y_prime,default_value,contourname);\n\n");
     160        _printf_(true,"   where:\n");
     161        _printf_(true,"      x,y: coordinates of the nodes where data is defined\n");
     162        _printf_(true,"      index: index of the mesh where data is defined\n");
     163        _printf_(true,"      data - vector holding the data to be interpolated onto the points.\n");
     164        _printf_(true,"      x_prime,y_prime: coordinates of the mesh grids onto which we interpolate.\n");
     165        _printf_(true,"      default_value: a scalar or vector of size length(x_prime).\n");
     166        _printf_(true,"      contourname: linear interpolation will happen on all x_interp,y_interp inside the contour, default value will be adopted on the rest of the mesh.\n");
     167        _printf_(true,"      data_prime:  vector of prime interpolated data.\n");
     168        _printf_(true,"\n");
    169169}

  • TabularUnified issm/trunk/src/mex/InterpFromMeshToGrid/InterpFromMeshToGrid.cpp

    r2627 r6412  
    6464void InterpFromMeshToGridUsage(void)
    6565{
    66         _printf_("INTERPFROMMESHTOGRID - interpolation of a data defined on a mesh onto a grid\n");
    67         _printf_("\n");
    68         _printf_("   This function is a multi-threaded mex file that interpolates a field\n");
    69         _printf_("   defined on a triangular mesh onto a regular grid\n");
    70         _printf_("\n");
    71         _printf_("   Usage:\n");
    72         _printf_("      [x_m,y_m,griddata]=InterpFromMeshToGrid(index,x,y,data,cornereast,cornernorth,xposting,yposting,nlines,ncols,default_value)\n");
    73         _printf_("\n");
    74         _printf_("      index,x,y: delaunay triangulation defining the mesh.\n");
    75         _printf_("      meshdata: vertex values of data to be interpolated.\n");
    76         _printf_("      cornereast,cornernorth,posting,nlines,ncols: parameters that define the grid\n");
    77         _printf_("      default_value: value of points located out of the mesh.\n");
    78         _printf_("\n");
     66        _printf_(true,"INTERPFROMMESHTOGRID - interpolation of a data defined on a mesh onto a grid\n");
     67        _printf_(true,"\n");
     68        _printf_(true,"   This function is a multi-threaded mex file that interpolates a field\n");
     69        _printf_(true,"   defined on a triangular mesh onto a regular grid\n");
     70        _printf_(true,"\n");
     71        _printf_(true,"   Usage:\n");
     72        _printf_(true,"      [x_m,y_m,griddata]=InterpFromMeshToGrid(index,x,y,data,cornereast,cornernorth,xposting,yposting,nlines,ncols,default_value)\n");
     73        _printf_(true,"\n");
     74        _printf_(true,"      index,x,y: delaunay triangulation defining the mesh.\n");
     75        _printf_(true,"      meshdata: vertex values of data to be interpolated.\n");
     76        _printf_(true,"      cornereast,cornernorth,posting,nlines,ncols: parameters that define the grid\n");
     77        _printf_(true,"      default_value: value of points located out of the mesh.\n");
     78        _printf_(true,"\n");
    7979}

  • TabularUnified issm/trunk/src/mex/InterpFromMeshToMesh2d/InterpFromMeshToMesh2d.cpp

    r5144 r6412  
    5252        if(nlhs!=NLHS){
    5353                InterpFromMeshToMesh2dUsage();
    54                 ISSMERROR("InterpFromMeshToMesh2dUsage usage error");
     54                _error_("InterpFromMeshToMesh2dUsage usage error");
    5555        }
    5656        if((nrhs!=6) & (nrhs!=8)){
    5757                InterpFromMeshToMesh2dUsage();
    58                 ISSMERROR("InterpFromMeshToMesh2dUsage usage error");
     58                _error_("InterpFromMeshToMesh2dUsage usage error");
    5959        }
    6060
    … …  
    111111        if (verbose) printf("Checking inputs\n");
    112112        if (x_data_rows!=y_data_rows){
    113                 ISSMERROR("vectors x and y should have the same length!");
     113                _error_("vectors x and y should have the same length!");
    114114        }
    115115        if (x_interp_rows!=y_interp_rows){
    116                 ISSMERROR("vectors x_interp and y_interp should have the same length!");
     116                _error_("vectors x_interp and y_interp should have the same length!");
    117117        }
    118118        if (index_cols!=3){
    119                 ISSMERROR("index should have 3 columns (input provided has %i columns)",index_cols);
     119                _error_("index should have 3 columns (input provided has %i columns)",index_cols);
    120120        }
    121121
    … …  
    137137void InterpFromMeshToMesh2dUsage(void)
    138138{
    139         _printf_("INTERFROMMESHTOMESH2D - interpolation from a 2d triangular mesh onto a list of point\n");
    140         _printf_("\n");
    141         _printf_("   This function is a multi-threaded mex file that interpolates a field\n");
    142         _printf_("   defined on a triangular mesh onto a list of point\n");
    143         _printf_("\n");
    144         _printf_("   Usage:\n");
    145         _printf_("         data_interp=InterpFromMeshToMesh2d(index,x,y,data,x_interp,y_interp);\n");
    146         _printf_("      or data_interp=InterpFromMeshToMesh2d(index,x,y,data,x_interp,y_interp,default_value,contourname);\n");
    147         _printf_("\n");
    148         _printf_("      index: index of the mesh where data is defined\n");
    149         _printf_("      x,y: coordinates of the nodes where data is defined\n");
    150         _printf_("      data: matrix holding the data to be interpolated onto the mesh. (one column per field)\n");
    151         _printf_("      x_interp,y_interp: coordinates of the points onto which we interpolate.\n");
    152         _printf_("      if default_value and contourname not specified: linear interpolation will happen on all x_interp,y_interp.\n");
    153         _printf_("      if (default_value,contourname) specified: linear interpolation will happen on all x_interp,y_interp inside the contour, default value will be adopted on the rest of the mesh.\n");
    154         _printf_("      note that default_value is either a scalar, or a vector of size  length(x_interp)\n");
    155         _printf_("      data_interp: vector of mesh interpolated data.\n");
    156         _printf_("\n");
    157         _printf_("   Example:\n");
    158         _printf_("      load('temperature.mat');\n");
    159         _printf_("      md.temperature=InterpFromMeshToMesh2d(index,x,y,temperature,md.x,md.y);\n");
    160         _printf_("      md.temperature=InterpFromMeshToMesh2d(index,x,y,temperature,md.x,md.y,253,'Contour.exp');\n");
    161         _printf_("\n");
     139        _printf_(true,"INTERFROMMESHTOMESH2D - interpolation from a 2d triangular mesh onto a list of point\n");
     140        _printf_(true,"\n");
     141        _printf_(true,"   This function is a multi-threaded mex file that interpolates a field\n");
     142        _printf_(true,"   defined on a triangular mesh onto a list of point\n");
     143        _printf_(true,"\n");
     144        _printf_(true,"   Usage:\n");
     145        _printf_(true,"         data_interp=InterpFromMeshToMesh2d(index,x,y,data,x_interp,y_interp);\n");
     146        _printf_(true,"      or data_interp=InterpFromMeshToMesh2d(index,x,y,data,x_interp,y_interp,default_value,contourname);\n");
     147        _printf_(true,"\n");
     148        _printf_(true,"      index: index of the mesh where data is defined\n");
     149        _printf_(true,"      x,y: coordinates of the nodes where data is defined\n");
     150        _printf_(true,"      data: matrix holding the data to be interpolated onto the mesh. (one column per field)\n");
     151        _printf_(true,"      x_interp,y_interp: coordinates of the points onto which we interpolate.\n");
     152        _printf_(true,"      if default_value and contourname not specified: linear interpolation will happen on all x_interp,y_interp.\n");
     153        _printf_(true,"      if (default_value,contourname) specified: linear interpolation will happen on all x_interp,y_interp inside the contour, default value will be adopted on the rest of the mesh.\n");
     154        _printf_(true,"      note that default_value is either a scalar, or a vector of size  length(x_interp)\n");
     155        _printf_(true,"      data_interp: vector of mesh interpolated data.\n");
     156        _printf_(true,"\n");
     157        _printf_(true,"   Example:\n");
     158        _printf_(true,"      load('temperature.mat');\n");
     159        _printf_(true,"      md.temperature=InterpFromMeshToMesh2d(index,x,y,temperature,md.x,md.y);\n");
     160        _printf_(true,"      md.temperature=InterpFromMeshToMesh2d(index,x,y,temperature,md.x,md.y,253,'Contour.exp');\n");
     161        _printf_(true,"\n");
    162162}

  • TabularUnified issm/trunk/src/mex/InterpFromMeshToMesh3d/InterpFromMeshToMesh3d.cpp

    r3332 r6412  
    7676        /*some checks*/
    7777        if (x_data_rows!=y_data_rows || x_data_rows!=z_data_rows){
    78                 ISSMERROR("vectors x, y and z should have the same length!");
     78                _error_("vectors x, y and z should have the same length!");
    7979        }
    8080        if (x_prime_rows!=y_prime_rows || x_prime_rows!=z_prime_rows){
    81                 ISSMERROR("vectors x_prime, y_prime and z_prime should have the same length!");
     81                _error_("vectors x_prime, y_prime and z_prime should have the same length!");
    8282        }
    8383        /*get number of elements and number of nodes in the data*/
    … …  
    9898void InterpFromMeshToMesh3dUsage(void)
    9999{
    100         _printf_("INTERPFROMMESHTOMESH3D - interpolation from a 3d hexahedron mesh onto a list of point\n");
    101         _printf_("\n");
    102         _printf_("   This function is a multi-threaded mex file that interpolates a field\n");
    103         _printf_("   defined on a triangular mesh onto a list of point\n");
    104         _printf_("\n");
    105         _printf_("   Usage:\n");
    106         _printf_("      data_prime=InterpFromMeshToMesh3d(index,x,y,z,data,x_prime,y_prime,z_prime,default_value);\n");
    107         _printf_("\n");
    108         _printf_("      index: index of the mesh where data is defined\n");
    109         _printf_("      x,y,z: coordinates of the nodes where data is defined\n");
    110         _printf_("      data: matrix holding the data to be interpolated onto the mesh.\n");
    111         _printf_("      x_prime,y_prime,z_prime: coordinates of the points onto which we interpolate.\n");
    112         _printf_("      default_value: default value if no data is found (holes).\n");
    113         _printf_("      data_prime: vector of mesh interpolated data.\n");
    114         _printf_("\n");
    115         _printf_("   Example:\n");
    116         _printf_("      load('temperature.mat');\n");
    117         _printf_("      md.temperature=InterpFromMeshToMesh3d(index,x,y,z,temperature,md.x,md.y,md.z,253);\n");
    118         _printf_("\n");
     100        _printf_(true,"INTERPFROMMESHTOMESH3D - interpolation from a 3d hexahedron mesh onto a list of point\n");
     101        _printf_(true,"\n");
     102        _printf_(true,"   This function is a multi-threaded mex file that interpolates a field\n");
     103        _printf_(true,"   defined on a triangular mesh onto a list of point\n");
     104        _printf_(true,"\n");
     105        _printf_(true,"   Usage:\n");
     106        _printf_(true,"      data_prime=InterpFromMeshToMesh3d(index,x,y,z,data,x_prime,y_prime,z_prime,default_value);\n");
     107        _printf_(true,"\n");
     108        _printf_(true,"      index: index of the mesh where data is defined\n");
     109        _printf_(true,"      x,y,z: coordinates of the nodes where data is defined\n");
     110        _printf_(true,"      data: matrix holding the data to be interpolated onto the mesh.\n");
     111        _printf_(true,"      x_prime,y_prime,z_prime: coordinates of the points onto which we interpolate.\n");
     112        _printf_(true,"      default_value: default value if no data is found (holes).\n");
     113        _printf_(true,"      data_prime: vector of mesh interpolated data.\n");
     114        _printf_(true,"\n");
     115        _printf_(true,"   Example:\n");
     116        _printf_(true,"      load('temperature.mat');\n");
     117        _printf_(true,"      md.temperature=InterpFromMeshToMesh3d(index,x,y,z,temperature,md.x,md.y,md.z,253);\n");
     118        _printf_(true,"\n");
    119119}

  • TabularUnified issm/trunk/src/mex/Mergesolutionfromftog/Mergesolutionfromftog.cpp

    r5689 r6412  
    2323        if((nlhs!=NLHS) || (nrhs!=4 && nrhs!=5)){
    2424                MergesolutionfromftogUsage();
    25                 ISSMERROR(" usage. See above");
     25                _error_(" usage. See above");
    2626        }
    2727
    … …  
    5757void MergesolutionfromftogUsage(void)
    5858{
    59         _printf_("\n");
    60         _printf_("   usage: [ug] = %s(uf,ys,nodesets,parameters);\n",__FUNCT__);
    61         _printf_("\n");
     59        _printf_(true,"\n");
     60        _printf_(true,"   usage: [ug] = %s(uf,ys,nodesets,parameters);\n",__FUNCT__);
     61        _printf_(true,"\n");
    6262}

  • TabularUnified issm/trunk/src/mex/MeshProfileIntersection/MeshProfileIntersection.cpp

    r5031 r6412  
    5454        //index
    5555        FetchData(&double_index,&nel,&dummy,INDEX);
    56         if(dummy!=3)ISSMERROR(" element triangulation should be of 3 column width!");
     56        if(dummy!=3)_error_(" element triangulation should be of 3 column width!");
    5757        index=(int*)xmalloc(nel*3*sizeof(int));
    5858        for(i=0;i<nel;i++){

  • TabularUnified issm/trunk/src/mex/ModelProcessor/ModelProcessor.cpp

    r4773 r6412  
    6565       
    6666void ModelProcessorUsage(void) {
    67         _printf_("\n");
    68         _printf_("   usage: [elements,grids,constraints,loads,materials,parameters,part,tpart]=ModelProcessor(model,analyses)\n");
    69         _printf_("   where: model is an instance of the matlab @model class and analyses is a list of analysis types being performed.\n");
    70         _printf_("\n");
     67        _printf_(true,"\n");
     68        _printf_(true,"   usage: [elements,grids,constraints,loads,materials,parameters,part,tpart]=ModelProcessor(model,analyses)\n");
     69        _printf_(true,"   where: model is an instance of the matlab @model class and analyses is a list of analysis types being performed.\n");
     70        _printf_(true,"\n");
    7171}

  • TabularUnified issm/trunk/src/mex/NodeConnectivity/NodeConnectivity.cpp

    r2333 r6412  
    3939
    4040void NodeConnectivityUsage(void) {
    41         _printf_("\n");
    42         _printf_("   usage: connectivity = %s(elements, numnodes);\n",__FUNCT__);
    43         _printf_("\n");
     41        _printf_(true,"\n");
     42        _printf_(true,"   usage: connectivity = %s(elements, numnodes);\n",__FUNCT__);
     43        _printf_(true,"\n");
    4444}

  • TabularUnified issm/trunk/src/mex/NodesDof/NodesDof.cpp

    r4234 r6412  
    4040void NodesDofUsage(void)
    4141{
    42         _printf_("\n");
    43         _printf_("   usage: [nodes] = %s(nodes,parameters);\n",__FUNCT__);
    44         _printf_("\n");
     42        _printf_(true,"\n");
     43        _printf_(true,"   usage: [nodes] = %s(nodes,parameters);\n",__FUNCT__);
     44        _printf_(true,"\n");
    4545}

  • TabularUnified issm/trunk/src/mex/Orth/Orth.cpp

    r4453 r6412  
    4141void OrthUsage(void)
    4242{
    43         _printf_("\n");
    44         _printf_("   usage: [newgradj] = %s(gradj,oldgradj);\n",__FUNCT__);
    45         _printf_("\n");
     43        _printf_(true,"\n");
     44        _printf_(true,"   usage: [newgradj] = %s(gradj,oldgradj);\n",__FUNCT__);
     45        _printf_(true,"\n");
    4646}

  • TabularUnified issm/trunk/src/mex/OutputResults/OutputResults.cpp

    r6372 r6412  
    6363void OutputResultsUsage(void)
    6464{
    65         _printf_("\n");
    66         _printf_("   usage: [results] = %s(elements,nodes,vertices,loads,materials,parameters,results);\n",__FUNCT__);
    67         _printf_("\n");
     65        _printf_(true,"\n");
     66        _printf_(true,"   usage: [results] = %s(elements,nodes,vertices,loads,materials,parameters,results);\n",__FUNCT__);
     67        _printf_(true,"\n");
    6868}

  • TabularUnified issm/trunk/src/mex/OutputRifts/OutputRifts.cpp

    r4453 r6412  
    4343void OutputRiftsUsage(void)
    4444{
    45         _printf_("\n");
    46         _printf_("   usage: [riftproperties] = %s(loads,parameters);\n",__FUNCT__);
    47         _printf_("\n");
     45        _printf_(true,"\n");
     46        _printf_(true,"   usage: [riftproperties] = %s(loads,parameters);\n",__FUNCT__);
     47        _printf_(true,"\n");
    4848}

  • TabularUnified issm/trunk/src/mex/ParameterOutput/ParameterOutput.cpp

    r4453 r6412  
    5656void ParameterOutputUsage(void)
    5757{
    58         _printf_("\n");
    59         _printf_("   usage: [Kgg,pg] = %s(eleemnts,nodes,loads,materials,params,analysis_type);\n",__FUNCT__);
    60         _printf_("\n");
     58        _printf_(true,"\n");
     59        _printf_(true,"   usage: [Kgg,pg] = %s(eleemnts,nodes,loads,materials,params,analysis_type);\n",__FUNCT__);
     60        _printf_(true,"\n");
    6161}

  • TabularUnified issm/trunk/src/mex/PenaltyConstraints/PenaltyConstraints.cpp

    r4573 r6412  
    6060void PenaltyConstraintsUsage(void)
    6161{
    62         _printf_("\n");
    63         _printf_("   usage: [loads, constraints_converged, num_unstable_constraints] = %s(elements,nodes,vertices,loads,materials,params);\n",__FUNCT__);
    64         _printf_("\n");
     62        _printf_(true,"\n");
     63        _printf_(true,"   usage: [loads, constraints_converged, num_unstable_constraints] = %s(elements,nodes,vertices,loads,materials,params);\n",__FUNCT__);
     64        _printf_(true,"\n");
    6565}

  • TabularUnified issm/trunk/src/mex/ProcessParams/ProcessParams.cpp

    r4187 r6412  
    3131void ProcessParamsUsage(void)
    3232{
    33         _printf_("\n");
    34         _printf_("   usage: [parameters] = %s(parameters);\n",__FUNCT__);
    35         _printf_("\n");
     33        _printf_(true,"\n");
     34        _printf_(true,"   usage: [parameters] = %s(parameters);\n",__FUNCT__);
     35        _printf_(true,"\n");
    3636}

  • TabularUnified issm/trunk/src/mex/Qmu/Qmu.cpp

    r4525 r6412  
    2020
    2121        #ifndef _HAVE_DAKOTA_ //only works if dakota library has been compiled in.
    22         ISSMERROR(" Dakota not available! Cannot carry out qmu analysis!");
     22        _error_(" Dakota not available! Cannot carry out qmu analysis!");
    2323        #endif
    2424
    … …  
    4848
    4949void QmuUsage(void){
    50         _printf_("\n");
    51         _printf_("   usage: %s(femmodel,parameters);\n",__FUNCT__);
    52         _printf_("\n");
     50        _printf_(true,"\n");
     51        _printf_(true,"   usage: %s(femmodel,parameters);\n",__FUNCT__);
     52        _printf_(true,"\n");
    5353}

  • TabularUnified issm/trunk/src/mex/Reduceload/Reduceload.cpp

    r6012 r6412  
    2020        if((nlhs!=NLHS) || (nrhs!=4 && nrhs!=5)){
    2121                ReduceloadUsage();
    22                 ISSMERROR(" usage. See above");
     22                _error_(" usage. See above");
    2323        }
    2424
    … …  
    5252void ReduceloadUsage(void)
    5353{
    54         _printf_("\n");
    55         _printf_("   usage: [pf] = %s(pf,Kfs,ys,parameters);\n",__FUNCT__);
    56         _printf_("          [pf] = %s(pf,Kfs,ys,parameters,ys0_flag);\n",__FUNCT__);
    57         _printf_("\n");
     54        _printf_(true,"\n");
     55        _printf_(true,"   usage: [pf] = %s(pf,Kfs,ys,parameters);\n",__FUNCT__);
     56        _printf_(true,"          [pf] = %s(pf,Kfs,ys,parameters,ys0_flag);\n",__FUNCT__);
     57        _printf_(true,"\n");
    5858}

  • TabularUnified issm/trunk/src/mex/Reduceloadfromgtof/Reduceloadfromgtof.cpp

    r5689 r6412  
    2424        if((nlhs!=NLHS) || (nrhs!=5 && nrhs!=6)){
    2525                ReduceloadfromgtofUsage();
    26                 ISSMERROR(" usage. See above");
     26                _error_(" usage. See above");
    2727        }
    2828
    … …  
    6060void ReduceloadfromgtofUsage(void)
    6161{
    62         _printf_("\n");
    63         _printf_("   usage: [pf] = %s(pg,Kfs,ys,nodesets,parameters);\n",__FUNCT__);
    64         _printf_("\n");
     62        _printf_(true,"\n");
     63        _printf_(true,"   usage: [pf] = %s(pg,Kfs,ys,nodesets,parameters);\n",__FUNCT__);
     64        _printf_(true,"\n");
    6565}

  • TabularUnified issm/trunk/src/mex/Reducematrixfromgtof/Reducematrixfromgtof.cpp

    r5689 r6412  
    4747void ReducematrixfromgtofUsage(void)
    4848{
    49         _printf_("\n");
    50         _printf_("   usage: [Kff,Kfs] = %s(Kgg,nodesets,parameters);\n",__FUNCT__);
    51         _printf_("\n");
     49        _printf_(true,"\n");
     50        _printf_(true,"   usage: [Kff,Kfs] = %s(Kgg,nodesets,parameters);\n",__FUNCT__);
     51        _printf_(true,"\n");
    5252}

  • TabularUnified issm/trunk/src/mex/Reducevectorgtof/Reducevectorgtof.cpp

    r5787 r6412  
    4444void ReducevectorgtofUsage(void)
    4545{
    46         _printf_("\n");
    47         _printf_("   usage: uf = %s(ug,nodesets,parameters);\n",__FUNCT__);
    48         _printf_("\n");
     46        _printf_(true,"\n");
     47        _printf_(true,"   usage: uf = %s(ug,nodesets,parameters);\n",__FUNCT__);
     48        _printf_(true,"\n");
    4949}

  • TabularUnified issm/trunk/src/mex/Reducevectorgtos/Reducevectorgtos.cpp

    r5787 r6412  
    4444void ReducevectorgtosUsage(void)
    4545{
    46         _printf_("\n");
    47         _printf_("   usage: ys = %s(yg,nodesets,parameters);\n",__FUNCT__);
    48         _printf_("\n");
     46        _printf_(true,"\n");
     47        _printf_(true,"   usage: ys = %s(yg,nodesets,parameters);\n",__FUNCT__);
     48        _printf_(true,"\n");
    4949}

  • TabularUnified issm/trunk/src/mex/Scotch/Scotch.cpp

    r4711 r6412  
    2525
    2626#ifndef _HAVE_SCOTCH_ //only works if scotch library has been compiled in.
    27         ISSMERROR(" Scotch not available! Cannot carry out Scotch partitioning!");
     27        _error_(" Scotch not available! Cannot carry out Scotch partitioning!");
    2828        #else
    2929

  • TabularUnified issm/trunk/src/mex/Solver/Solver.cpp

    r6014 r6412  
    7575void SolverUsage(void)
    7676{
    77         _printf_("\n");
    78         _printf_("   usage: [uf] = %s(Kff,pf,uf0,parameters);\n",__FUNCT__);
    79         _printf_("\n");
     77        _printf_(true,"\n");
     78        _printf_(true,"   usage: [uf] = %s(Kff,pf,uf0,parameters);\n",__FUNCT__);
     79        _printf_(true,"\n");
    8080}

  • TabularUnified issm/trunk/src/mex/SpcNodes/SpcNodes.cpp

    r5775 r6412  
    4040void SpcNodesUsage(void)
    4141{
    42         _printf_("\n");
    43         _printf_("   usage: [m.node]=%s(m.nodes,m.constraints);\n",__FUNCT__);
    44         _printf_("\n");
     42        _printf_(true,"\n");
     43        _printf_(true,"   usage: [m.node]=%s(m.nodes,m.constraints);\n",__FUNCT__);
     44        _printf_(true,"\n");
    4545}

  • TabularUnified issm/trunk/src/mex/SurfaceArea/SurfaceArea.cpp

    r5413 r6412  
    5555void SurfaceAreaUsage(void)
    5656{
    57         _printf_("\n");
    58         _printf_("   usage: [elements] = %s(elements, nodes, vertices, loads, materials, parameters);\n",__FUNCT__);
    59         _printf_("\n");
     57        _printf_(true,"\n");
     58        _printf_(true,"   usage: [elements] = %s(elements, nodes, vertices, loads, materials, parameters);\n",__FUNCT__);
     59        _printf_(true,"\n");
    6060}

  • TabularUnified issm/trunk/src/mex/SystemMatrices/SystemMatrices.cpp

    r5775 r6412  
    3030        if((nlhs!=NLHS) || (nrhs!=6 && nrhs!=10)){
    3131                SystemMatricesUsage();
    32                 ISSMERROR(" usage. See above");
     32                _error_(" usage. See above");
    3333        }
    3434
    … …  
    8585void SystemMatricesUsage(void)
    8686{
    87         _printf_("\n");
    88         _printf_("   usage: [Kgg,Kff,Kfs,pg,pf,kmax] = %s(elements,nodes,vertices,loads,materials,parameters);\n",__FUNCT__);
    89         _printf_("   usage: [Kgg,Kff,Kfs,pg,pf,kmax] = %s(elements,nodes,vertices,loads,materials,parameters,kflag,pflag,penalty_kflag,penalty_pflag);\n",__FUNCT__);
    90         _printf_("\n");
     87        _printf_(true,"\n");
     88        _printf_(true,"   usage: [Kgg,Kff,Kfs,pg,pf,kmax] = %s(elements,nodes,vertices,loads,materials,parameters);\n",__FUNCT__);
     89        _printf_(true,"   usage: [Kgg,Kff,Kfs,pg,pf,kmax] = %s(elements,nodes,vertices,loads,materials,parameters,kflag,pflag,penalty_kflag,penalty_pflag);\n",__FUNCT__);
     90        _printf_(true,"\n");
    9191}

  • TabularUnified issm/trunk/src/mex/Test/Test.cpp

    r3261 r6412  
    1313void TestUsage(void)
    1414{
    15         _printf_("\n");
    16         _printf_("   usage: %s(whatever in here);\n",__FUNCT__);
    17         _printf_("\n");
     15        _printf_(true,"\n");
     16        _printf_(true,"   usage: %s(whatever in here);\n",__FUNCT__);
     17        _printf_(true,"\n");
    1818}

  • TabularUnified issm/trunk/src/mex/TimeAdapt/TimeAdapt.cpp

    r6130 r6412  
    5757void TimeAdaptUsage(void)
    5858{
    59         _printf_("\n");
    60         _printf_("   usage: dt = %s(elements,nodes,vertices,loads,materials,parameters);\n",__FUNCT__);
    61         _printf_("\n");
     59        _printf_(true,"\n");
     60        _printf_(true,"   usage: dt = %s(elements,nodes,vertices,loads,materials,parameters);\n",__FUNCT__);
     61        _printf_(true,"\n");
    6262}

  • TabularUnified issm/trunk/src/mex/TriaSearch/TriaSearch.cpp

    r5357 r6412  
    5656void TriaSearchUsage(void)
    5757{
    58         _printf_("TriaSearch- find triangle holding a point (x0,y0) in a mesh\n");
    59         _printf_("\n");
    60         _printf_("   Usage:\n");
    61         _printf_("         tria=TriaSearch(index,x,y,x0,y0);\n");
    62         _printf_("      index,x,y: mesh triangulatrion\n");
    63         _printf_("      x0,y0: coordinates of the point for which we are trying to find a triangle\n");
    64         _printf_("      x0,y0 can be an array of points\n");
    65         _printf_("\n");
     58        _printf_(true,"TriaSearch- find triangle holding a point (x0,y0) in a mesh\n");
     59        _printf_(true,"\n");
     60        _printf_(true,"   Usage:\n");
     61        _printf_(true,"         tria=TriaSearch(index,x,y,x0,y0);\n");
     62        _printf_(true,"      index,x,y: mesh triangulatrion\n");
     63        _printf_(true,"      x0,y0: coordinates of the point for which we are trying to find a triangle\n");
     64        _printf_(true,"      x0,y0 can be an array of points\n");
     65        _printf_(true,"\n");
    6666}

  • TabularUnified issm/trunk/src/mex/UpdateGeometry/UpdateGeometry.cpp

    r4573 r6412  
    5959void UpdateGeometryUsage(void)
    6060{
    61         _printf_("\n");
    62         _printf_("   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,parameters);\n",__FUNCT__);
    63         _printf_("\n");
     61        _printf_(true,"\n");
     62        _printf_(true,"   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,parameters);\n",__FUNCT__);
     63        _printf_(true,"\n");
    6464}

  • TabularUnified issm/trunk/src/mex/UpdateVertexPositions/UpdateVertexPositions.cpp

    r4573 r6412  
    5959void UpdateVertexPositionsUsage(void)
    6060{
    61         _printf_("\n");
    62         _printf_("   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,parameters);\n",__FUNCT__);
    63         _printf_("\n");
     61        _printf_(true,"\n");
     62        _printf_(true,"   usage: [elements,nodes,vertices,loads,materials,parameters] = %s(elements,nodes,vertices,loads,materials,parameters);\n",__FUNCT__);
     63        _printf_(true,"\n");
    6464}

  • TabularUnified issm/trunk/src/mex/VerticesDof/VerticesDof.cpp

    r6231 r6412  
    3737void VerticesDofUsage(void)
    3838{
    39         _printf_("\n");
    40         _printf_("   usage: [vertices] = %s(vertices,parameters);\n",__FUNCT__);
    41         _printf_("\n");
     39        _printf_(true,"\n");
     40        _printf_(true,"   usage: [vertices] = %s(vertices,parameters);\n",__FUNCT__);
     41        _printf_(true,"\n");
    4242}
Note: See TracChangeset for help on using the changeset viewer.