source: issm/oecreview/Archive/19101-20495/ISSM-20037-20038.diff@ 20498

Last change on this file since 20498 was 20498, checked in by Mathieu Morlighem, 9 years ago

CHG: done with Archive/19101-20495
File size: 30.9 KB

  • ../trunk-jpl/src/c/shared/Enum/EnumDefinitions.h

     
    895895        MassfluxatgateNameEnum,
    896896        MassfluxatgateDefinitionenumEnum,
    897897        MassfluxatgateSegmentsEnum,
     898        NodalvalueEnum,
     899        NodalvalueNameEnum,
     900        NodalvalueDefinitionenumEnum,
     901        NodalvalueModelEnumEnum,
     902        NodalvalueNodeEnum,
    898903        MisfitNameEnum,
    899904        MisfitDefinitionenumEnum,
    900905        MisfitModelEnumEnum,

  • ../trunk-jpl/src/c/shared/Enum/EnumToStringx.cpp

     
    875875                case MassfluxatgateNameEnum : return "MassfluxatgateName";
    876876                case MassfluxatgateDefinitionenumEnum : return "MassfluxatgateDefinitionenum";
    877877                case MassfluxatgateSegmentsEnum : return "MassfluxatgateSegments";
     878                case NodalvalueEnum : return "Nodalvalue";
     879                case NodalvalueNameEnum : return "NodalvalueName";
     880                case NodalvalueDefinitionenumEnum : return "NodalvalueDefinitionenum";
     881                case NodalvalueModelEnumEnum : return "NodalvalueModelEnum";
     882                case NodalvalueNodeEnum : return "NodalvalueNode";
    878883                case MisfitNameEnum : return "MisfitName";
    879884                case MisfitDefinitionenumEnum : return "MisfitDefinitionenum";
    880885                case MisfitModelEnumEnum : return "MisfitModelEnum";

  • ../trunk-jpl/src/c/shared/Enum/StringToEnumx.cpp

     
    896896              else if (strcmp(name,"MassfluxatgateName")==0) return MassfluxatgateNameEnum;
    897897              else if (strcmp(name,"MassfluxatgateDefinitionenum")==0) return MassfluxatgateDefinitionenumEnum;
    898898              else if (strcmp(name,"MassfluxatgateSegments")==0) return MassfluxatgateSegmentsEnum;
     899              else if (strcmp(name,"Nodalvalue")==0) return NodalvalueEnum;
     900              else if (strcmp(name,"NodalvalueName")==0) return NodalvalueNameEnum;
     901              else if (strcmp(name,"NodalvalueDefinitionenum")==0) return NodalvalueDefinitionenumEnum;
     902              else if (strcmp(name,"NodalvalueModelEnum")==0) return NodalvalueModelEnumEnum;
     903              else if (strcmp(name,"NodalvalueNode")==0) return NodalvalueNodeEnum;
    899904              else if (strcmp(name,"MisfitName")==0) return MisfitNameEnum;
    900905              else if (strcmp(name,"MisfitDefinitionenum")==0) return MisfitDefinitionenumEnum;
    901906              else if (strcmp(name,"MisfitModelEnum")==0) return MisfitModelEnumEnum;
    … …  
    992997              else if (strcmp(name,"MpiSparse")==0) return MpiSparseEnum;
    993998              else if (strcmp(name,"Seq")==0) return SeqEnum;
    994999              else if (strcmp(name,"Mpi")==0) return MpiEnum;
    995               else if (strcmp(name,"Mumps")==0) return MumpsEnum;
     1000         else stage=9;
     1001   }
     1002   if(stage==9){
     1003              if (strcmp(name,"Mumps")==0) return MumpsEnum;
    9961004              else if (strcmp(name,"Gsl")==0) return GslEnum;
    9971005              else if (strcmp(name,"Option")==0) return OptionEnum;
    9981006              else if (strcmp(name,"GenericOption")==0) return GenericOptionEnum;
    9991007              else if (strcmp(name,"OptionCell")==0) return OptionCellEnum;
    1000          else stage=9;
    1001    }
    1002    if(stage==9){
    1003               if (strcmp(name,"OptionStruct")==0) return OptionStructEnum;
     1008              else if (strcmp(name,"OptionStruct")==0) return OptionStructEnum;
    10041009              else if (strcmp(name,"Cuffey")==0) return CuffeyEnum;
    10051010              else if (strcmp(name,"Paterson")==0) return PatersonEnum;
    10061011              else if (strcmp(name,"Arrhenius")==0) return ArrheniusEnum;

  • ../trunk-jpl/src/c/modules/modules.h

     
    2020#include "./CreateNodalConstraintsx/CreateNodalConstraintsx.h"
    2121#include "./CreateJacobianMatrixx/CreateJacobianMatrixx.h"
    2222#include "./Damagex/Damagex.h"
     23#include "./DistanceToMaskBoundaryx/DistanceToMaskBoundaryx.h"
    2324#include "./DragCoefficientAbsGradientx/DragCoefficientAbsGradientx.h"
    2425#include "./ExpToLevelSetx/ExpToLevelSetx.h"
    2526#include "./ElementConnectivityx/ElementConnectivityx.h"

  • ../trunk-jpl/src/c/modules/NodalValuex/NodalValuex.cpp

     
    1111
    1212        IssmDouble value;
    1313        int        index;
    14         int        found,sumfound,cpu_found;
     14        int        found,sumfound,cpu_found,cpu;
    1515
    1616        /*retrieve element we are interested in: */
    1717        parameters->FindParam(&index,IndexEnum);
    1818
    1919        /*This is the vertex id for which we want to collect the data. Go through elements, and for each
    2020         *element, figure out  if they hold the vertex, and the data. If so, return it: */
     21        cpu_found=-1;
     22        found=0;
     23       
    2124        for(int i=0;i<elements->Size();i++){
    2225                Element* element=xDynamicCast<Element*>(elements->GetObjectByOffset(i));
    2326                found=element->NodalValue(&value,index,natureofdataenum);
    … …  
    2932
    3033        /*Broadcast whether we found the element: */
    3134        ISSM_MPI_Allreduce(&found,&sumfound,1,ISSM_MPI_INT,ISSM_MPI_SUM,IssmComm::GetComm());
    32         if(!sumfound)_error_("could not find element with vertex with id" << index << " to compute nodal value " << EnumToStringx(natureofdataenum));
     35        if(!sumfound)_error_("could not find element with vertex with id " << index << " to compute nodal value " << EnumToStringx(natureofdataenum));
    3336
    3437        /*Broadcast and plug into response: */
    35         ISSM_MPI_Allreduce ( &cpu_found,&cpu_found,1,ISSM_MPI_INT,ISSM_MPI_MAX,IssmComm::GetComm());
    36         ISSM_MPI_Bcast(&value,1,ISSM_MPI_DOUBLE,cpu_found,IssmComm::GetComm());
     38        ISSM_MPI_Allreduce ( &cpu_found,&cpu,1,ISSM_MPI_INT,ISSM_MPI_MAX,IssmComm::GetComm());
     39        ISSM_MPI_Bcast(&value,1,ISSM_MPI_DOUBLE,cpu,IssmComm::GetComm());
    3740
    3841        *pnodalvalue=value;
    3942}

  • ../trunk-jpl/src/c/modules/ModelProcessorx/CreateOutputDefinitions.cpp

     
    122122                                xDelete<int>(misfit_weights_enum_s);
    123123                                /*}}}*/
    124124                        }
     125                        else if (output_definition_enums[i]==NodalvalueEnum){
     126                                /*Deal with nodal values: {{{*/
     127                               
     128                                /*nodal value variables: */
     129                                int          numnodalvalues;
     130                                char**       nodalvalue_name_s             = NULL;   
     131                                int*         nodalvalue_definitionenums_s             = NULL;   
     132                                int*         nodalvalue_model_enum_s        = NULL;
     133                                int*         nodalvalue_node_s = NULL;
     134
     135                                /*Fetch name, model_enum, etc ... (see src/m/classes/nodalvalue.m): */
     136                                iomodel->FetchMultipleData(&nodalvalue_name_s,&numnodalvalues,NodalvalueNameEnum);
     137                                iomodel->FetchMultipleData(&nodalvalue_definitionenums_s,&numnodalvalues,NodalvalueDefinitionenumEnum);
     138                                iomodel->FetchMultipleData(&nodalvalue_model_enum_s,&numnodalvalues,NodalvalueModelEnumEnum);
     139                                iomodel->FetchMultipleData(&nodalvalue_node_s,&numnodalvalues,NodalvalueNodeEnum);
     140
     141                                for(j=0;j<numnodalvalues;j++){
     142
     143                                        /*First create a nodalvalue object for that specific enum (nodalvalue_model_enum_s[j]):*/
     144                                        output_definitions->AddObject(new Nodalvalue(nodalvalue_name_s[j],nodalvalue_definitionenums_s[j],nodalvalue_model_enum_s[j],nodalvalue_node_s[j]-1)); //-1 because matlab to c indexing.
     145                                }
     146                                       
     147                                /*Free ressources:*/
     148                                for(j=0;j<numnodalvalues;j++){
     149                                        char* string=NULL;
     150                                        IssmDouble* matrix = NULL;
     151                                        string = nodalvalue_name_s[j];    xDelete<char>(string);
     152                                }
     153                                xDelete<char*>(nodalvalue_name_s);
     154                                xDelete<int>(nodalvalue_model_enum_s);
     155                                xDelete<int>(nodalvalue_definitionenums_s);
     156                                xDelete<int>(nodalvalue_node_s);
     157                                /*}}}*/
     158                        }
    125159                        else if (output_definition_enums[i]==MassconEnum){
    126160                                /*Deal with masscons: {{{*/
    127161                               

  • ../trunk-jpl/src/c/classes/classes.h

     
    1818#include "./Segment.h"
    1919#include "./Massfluxatgate.h"
    2020#include "./Misfit.h"
     21#include "./Nodalvalue.h"
    2122#include "./Masscon.h"
    2223#include "./Massconaxpby.h"
    2324

  • ../trunk-jpl/src/c/classes/Nodalvalue.h

     
     1/*!\file Nodalvalue.h
     2 * \brief: header file for Nodalvalue object
     3 */
     4
     5#ifndef _NODALVALUE_H_
     6#define _NODALVALUE_H_
     7
     8/*Headers:*/
     9/*{{{*/
     10#include "./Definition.h"
     11#include "../datastructures/datastructures.h"
     12#include "./Elements/Element.h"
     13#include "./Elements/Elements.h"
     14#include "./FemModel.h"
     15#include "../modules/SurfaceAreax/SurfaceAreax.h"
     16#include "../classes/Params/Parameters.h"
     17#include "../classes/Inputs/Input.h"
     18#include "../classes/gauss/Gauss.h"
     19/*}}}*/
     20
     21void NodalValuex( IssmDouble* pnodalvalue, int natureofdataenum,Elements* elements,Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters);
     22IssmDouble OutputDefinitionsResponsex(FemModel* femmodel,int output_enum);
     23
     24class Nodalvalue: public Object, public Definition{
     25
     26        public:
     27
     28                int         definitionenum;
     29                char*       name;
     30                int         model_enum;
     31                int         node;
     32               
     33                /*Nodalvalue constructors, destructors :*/
     34                Nodalvalue(){/*{{{*/
     35
     36                        this->definitionenum = -1;
     37                        this->name = NULL;
     38                        this->model_enum = UNDEF;
     39                        this->node = -1;
     40
     41                }
     42                /*}}}*/
     43                Nodalvalue(char* in_name, int in_definitionenum, int in_model_enum, int in_node){/*{{{*/
     44
     45                        this->definitionenum=in_definitionenum;
     46                        this->name   = xNew<char>(strlen(in_name)+1);
     47                        xMemCpy<char>(this->name,in_name,strlen(in_name)+1);
     48
     49                        this->model_enum=in_model_enum;
     50                        this->node=in_node;
     51                }
     52                /*}}}*/
     53                ~Nodalvalue(){/*{{{*/
     54                        if(this->name)xDelete(this->name);
     55                }
     56                /*}}}*/
     57                /*Object virtual function resolutoin: */
     58                void Echo(void){/*{{{*/
     59                        _printf_(" Nodalvalue: " << name << " " << this->definitionenum << "\n");
     60                        _printf_("    model_enum: " << model_enum << " " << EnumToStringx(model_enum) << "\n");
     61                        _printf_("    node: " << node << "\n");
     62                }
     63                /*}}}*/
     64                void DeepEcho(void){/*{{{*/
     65                        this->Echo();
     66                }
     67                /*}}}*/
     68                int Id(void){/*{{{*/
     69                        return -1;
     70                }
     71                /*}}}*/
     72                int ObjectEnum(void){/*{{{*/
     73                        return NodalvalueEnum;
     74                }
     75                /*}}}*/
     76                Object* copy() {/*{{{*/
     77                        Nodalvalue* mf = new Nodalvalue(this->name,this->definitionenum, this->model_enum,this->node);
     78                        return (Object*) mf;
     79                }
     80                /*}}}*/
     81                void Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
     82                        _error_("not implemented yet!");
     83                }
     84                /*}}}*/
     85                /*Definition virtual function resolutoin: */
     86                char* Name(){/*{{{*/
     87
     88                        char* name2=xNew<char>(strlen(this->name)+1);
     89                        xMemCpy(name2,this->name,strlen(this->name)+1);
     90
     91                        return name2;
     92                }
     93                /*}}}*/
     94                int DefinitionEnum(){/*{{{*/
     95
     96                        return this->definitionenum;
     97                }
     98                /*}}}*/
     99                 IssmDouble Response(FemModel* femmodel){/*{{{*/
     100                       
     101                         /*output:*/
     102                         IssmDouble value;
     103
     104                         /*set index, which will be used by the NodalValue module: */
     105                         femmodel->parameters->SetParam(node,IndexEnum);
     106
     107                         /*call Nodalvalue:*/
     108                         NodalValuex(&value, model_enum, femmodel->elements, femmodel->nodes, femmodel->vertices, femmodel->loads,
     109                                         femmodel->materials, femmodel->parameters);
     110
     111                         /*done:*/
     112                         return value;
     113                 }
     114                 /*}}}*/
     115};
     116
     117#endif  /* _NODALVALUE_H_ */

  • ../trunk-jpl/src/m/plot/applyoptions.m

     
    9898        basinzoom(options);
    9999end
    100100
     101%Zoom
     102if exist(options,'zoom');
     103        zoom(getfieldvalue(options,'zoom',2));
     104end
     105
    101106%ShowBasins
    102107if strcmpi(getfieldvalue(options,'showbasins','off'),'on')
    103108        showbasins(options);

  • ../trunk-jpl/src/m/classes/nodalvalue.m

     
     1%NODALVALUE class definition
     2%
     3%   Usage:
     4%      nodalvalue=nodalvalue();
     5%      nodalvalue=nodalvalue('name','SealevelriseSNodalValue',...
     6%                    'definitionenum',Outputdefinition1Enum,
     7%                    'model_enum',SealevelriseSEnum,...
     8%                    'node',1);
     9
     10classdef nodalvalue
     11        properties (SetAccess=public)
     12                %nodalvalue
     13                name              = '';
     14                definitionenum   = NaN; %enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum
     15                model_enum       = NaN; %enum for field that is being retrieved
     16                node             = NaN; %for which node are we retrieving the value?
     17        end
     18       
     19        methods
     20                function self = nodalvalue(varargin) % {{{
     21                        if nargin==0,
     22                                self=setdefaultparameters(self);
     23                        else
     24                                %use provided options to change fields
     25                                options=pairoptions(varargin{:});
     26
     27                                %get name
     28                                self.name=getfieldvalue(options,'name','');
     29                                self.definitionenum=getfieldvalue(options,'definitionenum');
     30                                self.model_enum=getfieldvalue(options,'model_enum');
     31                                self.node=getfieldvalue(options,'node',NaN);
     32
     33                        end
     34                end % }}}
     35                function self = setdefaultparameters(self) % {{{
     36                end % }}}
     37                function md = checkconsistency(self,md,solution,analyses) % {{{
     38
     39                        if ~ischar(self.name),
     40                                error('nodalvalue error message: ''name'' field should be a string!');
     41                        end
     42                        md = checkfield(md,'fieldname','self.definitionenum','field',self.definitionenum,'values',[Outputdefinition1Enum:Outputdefinition100Enum]);
     43
     44                        md = checkfield(md,'fieldname','self.node','field',self.node,'values',[1:md.mesh.numberofvertices]);
     45
     46                end % }}}
     47                function md = disp(self) % {{{
     48               
     49                        disp(sprintf('   Nodalvalue:\n'));
     50
     51                        fielddisplay(self,'name','identifier for this nodalvalue response');
     52                        fielddisplay(self,'definitionenum','enum that identifies this output definition uniquely, from Outputdefinition[1-10]Enum');
     53                        fielddisplay(self,'model_enum','enum for field that is being retrieved');
     54                        fielddisplay(self,'node','vertex index at which we retrieve the value');
     55
     56                end % }}}
     57                function md = marshall(self,md,fid) % {{{
     58
     59                WriteData(fid,'object',self,'fieldname','name','format','String');
     60                WriteData(fid,'object',self,'fieldname','definitionenum','format','Integer');
     61                WriteData(fid,'object',self,'fieldname','model_enum','format','Integer');
     62                WriteData(fid,'object',self,'fieldname','node','format','Integer');
     63
     64                end % }}}
     65        end
     66end

  • ../trunk-jpl/src/m/enum/NodalvalueEnum.m

     
     1function macro=NodalvalueEnum()
     2%NODALVALUEENUM - Enum of Nodalvalue
     3%
     4%   WARNING: DO NOT MODIFY THIS FILE
     5%            this file has been automatically generated by src/c/shared/Enum/Synchronize.sh
     6%            Please read src/c/shared/Enum/README for more information
     7%
     8%   Usage:
     9%      macro=NodalvalueEnum()
     10
     11macro=StringToEnum('Nodalvalue');

  • ../trunk-jpl/src/m/enum/NodalvalueNodeEnum.m

     
     1function macro=NodalvalueNodeEnum()
     2%NODALVALUENODEENUM - Enum of NodalvalueNode
     3%
     4%   WARNING: DO NOT MODIFY THIS FILE
     5%            this file has been automatically generated by src/c/shared/Enum/Synchronize.sh
     6%            Please read src/c/shared/Enum/README for more information
     7%
     8%   Usage:
     9%      macro=NodalvalueNodeEnum()
     10
     11macro=StringToEnum('NodalvalueNode');

  • ../trunk-jpl/src/m/enum/EnumDefinitions.js

     
    860860function MassfluxatgateNameEnum(){ return 856;}
    861861function MassfluxatgateDefinitionenumEnum(){ return 857;}
    862862function MassfluxatgateSegmentsEnum(){ return 858;}
    863 function MisfitNameEnum(){ return 859;}
    864 function MisfitDefinitionenumEnum(){ return 860;}
    865 function MisfitModelEnum(){ return 861;}
    866 function MisfitObservationEnum(){ return 862;}
    867 function MisfitObservationEnum(){ return 863;}
    868 function MisfitLocalEnum(){ return 864;}
    869 function MisfitTimeinterpolationEnum(){ return 865;}
    870 function MisfitWeightsEnum(){ return 866;}
    871 function MisfitWeightsEnum(){ return 867;}
    872 function SurfaceObservationEnum(){ return 868;}
    873 function WeightsSurfaceObservationEnum(){ return 869;}
    874 function VxObsEnum(){ return 870;}
    875 function WeightsVxObsEnum(){ return 871;}
    876 function VyObsEnum(){ return 872;}
    877 function WeightsVyObsEnum(){ return 873;}
    878 function MinVelEnum(){ return 874;}
    879 function MaxVelEnum(){ return 875;}
    880 function MinVxEnum(){ return 876;}
    881 function MaxVxEnum(){ return 877;}
    882 function MaxAbsVxEnum(){ return 878;}
    883 function MinVyEnum(){ return 879;}
    884 function MaxVyEnum(){ return 880;}
    885 function MaxAbsVyEnum(){ return 881;}
    886 function MinVzEnum(){ return 882;}
    887 function MaxVzEnum(){ return 883;}
    888 function MaxAbsVzEnum(){ return 884;}
    889 function FloatingAreaEnum(){ return 885;}
    890 function GroundedAreaEnum(){ return 886;}
    891 function IceMassEnum(){ return 887;}
    892 function IceVolumeEnum(){ return 888;}
    893 function IceVolumeAboveFloatationEnum(){ return 889;}
    894 function TotalSmbEnum(){ return 890;}
    895 function AbsoluteEnum(){ return 891;}
    896 function IncrementalEnum(){ return 892;}
    897 function AugmentedLagrangianREnum(){ return 893;}
    898 function AugmentedLagrangianRhopEnum(){ return 894;}
    899 function AugmentedLagrangianRlambdaEnum(){ return 895;}
    900 function AugmentedLagrangianRholambdaEnum(){ return 896;}
    901 function AugmentedLagrangianThetaEnum(){ return 897;}
    902 function NoneEnum(){ return 898;}
    903 function AggressiveMigrationEnum(){ return 899;}
    904 function SoftMigrationEnum(){ return 900;}
    905 function SubelementMigrationEnum(){ return 901;}
    906 function SubelementMigration2Enum(){ return 902;}
    907 function ContactEnum(){ return 903;}
    908 function GroundingOnlyEnum(){ return 904;}
    909 function MaskGroundediceLevelsetEnum(){ return 905;}
    910 function GaussSegEnum(){ return 906;}
    911 function GaussTriaEnum(){ return 907;}
    912 function GaussTetraEnum(){ return 908;}
    913 function GaussPentaEnum(){ return 909;}
    914 function FSSolverEnum(){ return 910;}
    915 function AdjointEnum(){ return 911;}
    916 function ColinearEnum(){ return 912;}
    917 function ControlSteadyEnum(){ return 913;}
    918 function FsetEnum(){ return 914;}
    919 function Gradient1Enum(){ return 915;}
    920 function Gradient2Enum(){ return 916;}
    921 function Gradient3Enum(){ return 917;}
    922 function GradientEnum(){ return 918;}
    923 function GroundinglineMigrationEnum(){ return 919;}
    924 function GsetEnum(){ return 920;}
    925 function IndexEnum(){ return 921;}
    926 function IndexedEnum(){ return 922;}
    927 function IntersectEnum(){ return 923;}
    928 function NodalEnum(){ return 924;}
    929 function OldGradientEnum(){ return 925;}
    930 function OutputBufferPointerEnum(){ return 926;}
    931 function OutputBufferSizePointerEnum(){ return 927;}
    932 function OutputFilePointerEnum(){ return 928;}
    933 function ToolkitsFileNameEnum(){ return 929;}
    934 function RootPathEnum(){ return 930;}
    935 function OutputFileNameEnum(){ return 931;}
    936 function InputFileNameEnum(){ return 932;}
    937 function LockFileNameEnum(){ return 933;}
    938 function RestartFileNameEnum(){ return 934;}
    939 function ToolkitsOptionsAnalysesEnum(){ return 935;}
    940 function ToolkitsOptionsStringsEnum(){ return 936;}
    941 function QmuErrNameEnum(){ return 937;}
    942 function QmuInNameEnum(){ return 938;}
    943 function QmuOutNameEnum(){ return 939;}
    944 function RegularEnum(){ return 940;}
    945 function ScaledEnum(){ return 941;}
    946 function SeparateEnum(){ return 942;}
    947 function SsetEnum(){ return 943;}
    948 function VerboseEnum(){ return 944;}
    949 function TriangleInterpEnum(){ return 945;}
    950 function BilinearInterpEnum(){ return 946;}
    951 function NearestInterpEnum(){ return 947;}
    952 function XYEnum(){ return 948;}
    953 function XYZEnum(){ return 949;}
    954 function DenseEnum(){ return 950;}
    955 function MpiDenseEnum(){ return 951;}
    956 function MpiSparseEnum(){ return 952;}
    957 function SeqEnum(){ return 953;}
    958 function MpiEnum(){ return 954;}
    959 function MumpsEnum(){ return 955;}
    960 function GslEnum(){ return 956;}
    961 function OptionEnum(){ return 957;}
    962 function GenericOptionEnum(){ return 958;}
    963 function OptionCellEnum(){ return 959;}
    964 function OptionStructEnum(){ return 960;}
    965 function CuffeyEnum(){ return 961;}
    966 function PatersonEnum(){ return 962;}
    967 function ArrheniusEnum(){ return 963;}
    968 function LliboutryDuvalEnum(){ return 964;}
    969 function TransientIslevelsetEnum(){ return 965;}
    970 function SpcLevelsetEnum(){ return 966;}
    971 function ExtrapolationVariableEnum(){ return 967;}
    972 function IceMaskNodeActivationEnum(){ return 968;}
    973 function LevelsetfunctionSlopeXEnum(){ return 969;}
    974 function LevelsetfunctionSlopeYEnum(){ return 970;}
    975 function LevelsetfunctionPicardEnum(){ return 971;}
    976 function SealevelriseSolutionEnum(){ return 972;}
    977 function SealevelriseAnalysisEnum(){ return 973;}
    978 function SealevelriseSEnum(){ return 974;}
    979 function SealevelriseDeltathicknessEnum(){ return 975;}
    980 function SealevelriseMaxiterEnum(){ return 976;}
    981 function SealevelriseReltolEnum(){ return 977;}
    982 function SealevelriseAbstolEnum(){ return 978;}
    983 function SealevelriseLoveHEnum(){ return 979;}
    984 function SealevelriseLoveKEnum(){ return 980;}
    985 function SealevelriseRigidEnum(){ return 981;}
    986 function SealevelriseElasticEnum(){ return 982;}
    987 function SealevelriseEustaticEnum(){ return 983;}
    988 function SealevelriseGElasticEnum(){ return 984;}
    989 function SealevelriseDegaccEnum(){ return 985;}
    990 function SealevelriseRequestedOutputsEnum(){ return 986;}
    991 function SealevelriseNumRequestedOutputsEnum(){ return 987;}
    992 function MaximumNumberOfDefinitionsEnum(){ return 988;}
     863function NodalvalueEnum(){ return 859;}
     864function NodalvalueNameEnum(){ return 860;}
     865function NodalvalueDefinitionenumEnum(){ return 861;}
     866function NodalvalueModelEnum(){ return 862;}
     867function NodalvalueNodeEnum(){ return 863;}
     868function MisfitNameEnum(){ return 864;}
     869function MisfitDefinitionenumEnum(){ return 865;}
     870function MisfitModelEnum(){ return 866;}
     871function MisfitObservationEnum(){ return 867;}
     872function MisfitObservationEnum(){ return 868;}
     873function MisfitLocalEnum(){ return 869;}
     874function MisfitTimeinterpolationEnum(){ return 870;}
     875function MisfitWeightsEnum(){ return 871;}
     876function MisfitWeightsEnum(){ return 872;}
     877function SurfaceObservationEnum(){ return 873;}
     878function WeightsSurfaceObservationEnum(){ return 874;}
     879function VxObsEnum(){ return 875;}
     880function WeightsVxObsEnum(){ return 876;}
     881function VyObsEnum(){ return 877;}
     882function WeightsVyObsEnum(){ return 878;}
     883function MinVelEnum(){ return 879;}
     884function MaxVelEnum(){ return 880;}
     885function MinVxEnum(){ return 881;}
     886function MaxVxEnum(){ return 882;}
     887function MaxAbsVxEnum(){ return 883;}
     888function MinVyEnum(){ return 884;}
     889function MaxVyEnum(){ return 885;}
     890function MaxAbsVyEnum(){ return 886;}
     891function MinVzEnum(){ return 887;}
     892function MaxVzEnum(){ return 888;}
     893function MaxAbsVzEnum(){ return 889;}
     894function FloatingAreaEnum(){ return 890;}
     895function GroundedAreaEnum(){ return 891;}
     896function IceMassEnum(){ return 892;}
     897function IceVolumeEnum(){ return 893;}
     898function IceVolumeAboveFloatationEnum(){ return 894;}
     899function TotalSmbEnum(){ return 895;}
     900function AbsoluteEnum(){ return 896;}
     901function IncrementalEnum(){ return 897;}
     902function AugmentedLagrangianREnum(){ return 898;}
     903function AugmentedLagrangianRhopEnum(){ return 899;}
     904function AugmentedLagrangianRlambdaEnum(){ return 900;}
     905function AugmentedLagrangianRholambdaEnum(){ return 901;}
     906function AugmentedLagrangianThetaEnum(){ return 902;}
     907function NoneEnum(){ return 903;}
     908function AggressiveMigrationEnum(){ return 904;}
     909function SoftMigrationEnum(){ return 905;}
     910function SubelementMigrationEnum(){ return 906;}
     911function SubelementMigration2Enum(){ return 907;}
     912function ContactEnum(){ return 908;}
     913function GroundingOnlyEnum(){ return 909;}
     914function MaskGroundediceLevelsetEnum(){ return 910;}
     915function GaussSegEnum(){ return 911;}
     916function GaussTriaEnum(){ return 912;}
     917function GaussTetraEnum(){ return 913;}
     918function GaussPentaEnum(){ return 914;}
     919function FSSolverEnum(){ return 915;}
     920function AdjointEnum(){ return 916;}
     921function ColinearEnum(){ return 917;}
     922function ControlSteadyEnum(){ return 918;}
     923function FsetEnum(){ return 919;}
     924function Gradient1Enum(){ return 920;}
     925function Gradient2Enum(){ return 921;}
     926function Gradient3Enum(){ return 922;}
     927function GradientEnum(){ return 923;}
     928function GroundinglineMigrationEnum(){ return 924;}
     929function GsetEnum(){ return 925;}
     930function IndexEnum(){ return 926;}
     931function IndexedEnum(){ return 927;}
     932function IntersectEnum(){ return 928;}
     933function NodalEnum(){ return 929;}
     934function OldGradientEnum(){ return 930;}
     935function OutputBufferPointerEnum(){ return 931;}
     936function OutputBufferSizePointerEnum(){ return 932;}
     937function OutputFilePointerEnum(){ return 933;}
     938function ToolkitsFileNameEnum(){ return 934;}
     939function RootPathEnum(){ return 935;}
     940function OutputFileNameEnum(){ return 936;}
     941function InputFileNameEnum(){ return 937;}
     942function LockFileNameEnum(){ return 938;}
     943function RestartFileNameEnum(){ return 939;}
     944function ToolkitsOptionsAnalysesEnum(){ return 940;}
     945function ToolkitsOptionsStringsEnum(){ return 941;}
     946function QmuErrNameEnum(){ return 942;}
     947function QmuInNameEnum(){ return 943;}
     948function QmuOutNameEnum(){ return 944;}
     949function RegularEnum(){ return 945;}
     950function ScaledEnum(){ return 946;}
     951function SeparateEnum(){ return 947;}
     952function SsetEnum(){ return 948;}
     953function VerboseEnum(){ return 949;}
     954function TriangleInterpEnum(){ return 950;}
     955function BilinearInterpEnum(){ return 951;}
     956function NearestInterpEnum(){ return 952;}
     957function XYEnum(){ return 953;}
     958function XYZEnum(){ return 954;}
     959function DenseEnum(){ return 955;}
     960function MpiDenseEnum(){ return 956;}
     961function MpiSparseEnum(){ return 957;}
     962function SeqEnum(){ return 958;}
     963function MpiEnum(){ return 959;}
     964function MumpsEnum(){ return 960;}
     965function GslEnum(){ return 961;}
     966function OptionEnum(){ return 962;}
     967function GenericOptionEnum(){ return 963;}
     968function OptionCellEnum(){ return 964;}
     969function OptionStructEnum(){ return 965;}
     970function CuffeyEnum(){ return 966;}
     971function PatersonEnum(){ return 967;}
     972function ArrheniusEnum(){ return 968;}
     973function LliboutryDuvalEnum(){ return 969;}
     974function TransientIslevelsetEnum(){ return 970;}
     975function SpcLevelsetEnum(){ return 971;}
     976function ExtrapolationVariableEnum(){ return 972;}
     977function IceMaskNodeActivationEnum(){ return 973;}
     978function LevelsetfunctionSlopeXEnum(){ return 974;}
     979function LevelsetfunctionSlopeYEnum(){ return 975;}
     980function LevelsetfunctionPicardEnum(){ return 976;}
     981function SealevelriseSolutionEnum(){ return 977;}
     982function SealevelriseAnalysisEnum(){ return 978;}
     983function SealevelriseSEnum(){ return 979;}
     984function SealevelriseDeltathicknessEnum(){ return 980;}
     985function SealevelriseMaxiterEnum(){ return 981;}
     986function SealevelriseReltolEnum(){ return 982;}
     987function SealevelriseAbstolEnum(){ return 983;}
     988function SealevelriseLoveHEnum(){ return 984;}
     989function SealevelriseLoveKEnum(){ return 985;}
     990function SealevelriseRigidEnum(){ return 986;}
     991function SealevelriseElasticEnum(){ return 987;}
     992function SealevelriseEustaticEnum(){ return 988;}
     993function SealevelriseGElasticEnum(){ return 989;}
     994function SealevelriseDegaccEnum(){ return 990;}
     995function SealevelriseRequestedOutputsEnum(){ return 991;}
     996function SealevelriseNumRequestedOutputsEnum(){ return 992;}
     997function MaximumNumberOfDefinitionsEnum(){ return 993;}

  • ../trunk-jpl/src/m/enum/NodalvalueDefinitionenumEnum.m

     
     1function macro=NodalvalueDefinitionenumEnum()
     2%NODALVALUEDEFINITIONENUMENUM - Enum of NodalvalueDefinitionenum
     3%
     4%   WARNING: DO NOT MODIFY THIS FILE
     5%            this file has been automatically generated by src/c/shared/Enum/Synchronize.sh
     6%            Please read src/c/shared/Enum/README for more information
     7%
     8%   Usage:
     9%      macro=NodalvalueDefinitionenumEnum()
     10
     11macro=StringToEnum('NodalvalueDefinitionenum');

  • ../trunk-jpl/src/m/enum/EnumDefinitions.py

     
    867867def MassfluxatgateNameEnum(): return StringToEnum("MassfluxatgateName")[0]
    868868def MassfluxatgateDefinitionenumEnum(): return StringToEnum("MassfluxatgateDefinitionenum")[0]
    869869def MassfluxatgateSegmentsEnum(): return StringToEnum("MassfluxatgateSegments")[0]
     870def NodalvalueEnum(): return StringToEnum("Nodalvalue")[0]
     871def NodalvalueNameEnum(): return StringToEnum("NodalvalueName")[0]
     872def NodalvalueDefinitionenumEnum(): return StringToEnum("NodalvalueDefinitionenum")[0]
     873def NodalvalueModelEnumEnum(): return StringToEnum("NodalvalueModelEnum")[0]
     874def NodalvalueNodeEnum(): return StringToEnum("NodalvalueNode")[0]
    870875def MisfitNameEnum(): return StringToEnum("MisfitName")[0]
    871876def MisfitDefinitionenumEnum(): return StringToEnum("MisfitDefinitionenum")[0]
    872877def MisfitModelEnumEnum(): return StringToEnum("MisfitModelEnum")[0]

  • ../trunk-jpl/src/m/enum/NodalvalueModelEnumEnum.m

     
     1function macro=NodalvalueModelEnumEnum()
     2%NODALVALUEMODELENUMENUM - Enum of NodalvalueModel
     3%
     4%   WARNING: DO NOT MODIFY THIS FILE
     5%            this file has been automatically generated by src/c/shared/Enum/Synchronize.sh
     6%            Please read src/c/shared/Enum/README for more information
     7%
     8%   Usage:
     9%      macro=NodalvalueModelEnumEnum()
     10
     11macro=StringToEnum('NodalvalueModel');

  • ../trunk-jpl/src/m/enum/NodalvalueNameEnum.m

     
     1function macro=NodalvalueNameEnum()
     2%NODALVALUENAMEENUM - Enum of NodalvalueName
     3%
     4%   WARNING: DO NOT MODIFY THIS FILE
     5%            this file has been automatically generated by src/c/shared/Enum/Synchronize.sh
     6%            Please read src/c/shared/Enum/README for more information
     7%
     8%   Usage:
     9%      macro=NodalvalueNameEnum()
     10
     11macro=StringToEnum('NodalvalueName');
Note: See TracBrowser for help on using the repository browser.