Changeset 3642


Ignore:
Timestamp:
Apr 30, 2010, 11:36:26 AM (16 years ago)
Author:
Eric.Larour
Message:

temporary commit

Location:
issm/trunk/src
Files:
63 edited

Legend:

Unmodified
Added
Removed

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

    r3633 r3642  
    8787        LoadEnum,
    8888        IcefrontEnum,
     89        SegmentIcefrontEnum,
     90        QuadIceFrontEnum,
    8991        RiftfrontEnum,
     92        SegmentRiftfrontEnum,
     93        QuadRiftFrontEnum,
    9094        PenpairEnum,
    9195        PengridEnum,
    … …  
    175179        NodeOnIceSheetEnum,
    176180        ResetPenaltiesEnum,
    177         MeltingOffsetEnum
     181        MeltingOffsetEnum,
     182        TypeEnum,
     183        FrictionEnum,
     184        FractionIncrementEnum,
     185        ConvergedEnum,
     186        SegmentOnIceShelfEnum,
     187        FillEnum
    178188        /*}}}*/
    179189

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

    r3633 r3642  
    5555                                        ./objects/DofIndexing.h\
    5656                                        ./objects/DofIndexing.cpp\
    57                                         ./objects/NodeProperties.h\
    58                                         ./objects/NodeProperties.cpp\
    5957                                        ./objects/Node.h\
    6058                                        ./objects/Node.cpp\
    … …  
    468466                                        ./objects/DofIndexing.h\
    469467                                        ./objects/DofIndexing.cpp\
    470                                         ./objects/NodeProperties.h\
    471                                         ./objects/NodeProperties.cpp\
    472468                                        ./objects/Node.h\
    473469                                        ./objects/Node.cpp\

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

    r3595 r3642  
    2222/*FUNCTION Numericalflux::Numericalflux(){{{1*/
    2323Numericalflux::Numericalflux(){
    24         return;
    25 }
    26 /*}}}*/
    27 /*FUNCTION Numericalflux::Numericalflux(char numericalflux_type[NUMERICALFLUXSTRING],int numericalflux_fill...){{{1*/
    28 Numericalflux::Numericalflux(int numericalflux_id,char numericalflux_type[NUMERICALFLUXSTRING], int numericalflux_node_ids[MAX_NUMERICALFLUX_NODES],int numericalflux_element_id, double numericalflux_h[MAX_NUMERICALFLUX_NODES]){
    29 
    30         int i;
    31        
    32         strcpy(type,numericalflux_type);
     24        this->inputs=NULL;
     25        this->parameters=NULL;
     26}
     27/*}}}*/
     28/*FUNCTION Numericalflux::Numericalflux(int numericalflux_id,int* numericalflux_node_ids,...){{{1*/
     29Numericalflux::Numericalflux(int numericalflux_id,int* numericalflux_node_ids,int numnodes,int* numericalflux_element_ids, int numelements):
     30        hnodes(numericalflux_node_ids,numnodes),
     31        helements(numericalflux_element_ids,numelements)
     32{
     33
    3334        id=numericalflux_id;
    34 
    35         element_id=numericalflux_element_id;
    36         element_offset=UNDEF;
    37         element=NULL;
    38 
    39         for(i=0;i<MAX_NUMERICALFLUX_NODES;i++){
    40                 node_ids[i]=numericalflux_node_ids[i];
    41                 node_offsets[i]=UNDEF;
    42                 nodes[i]=NULL;
    43                 h[i]=numericalflux_h[i];
    44         }
    45 
    46         return;
     35        this->parameters=NULL;
     36        this->inputs=new Inputs();
     37}
     38/*}}}*/
     39/*FUNCTION Numericalflux::Numericalflux(int id, Hook* hnodes, Hook* helements, DataSet* parameters, Inputs* numericalflux_inputs) {{{1*/
     40Numericalflux::Numericalflux(int numericalflux_id,Hook* numericalflux_hnodes, Hook* numericalflux_helements, Parameters* numericalflux_parameters, Inputs* numericalflux_inputs):
     41        hnodes(numericalflux_hnodes),
     42        helements(numericalflux_helements)
     43{
     44
     45        /*all the initialization has been done by the initializer, just fill in the id: */
     46        this->id=numericalflux_id;
     47        if(numericalflux_inputs){
     48                this->inputs=(Inputs*)numericalflux_inputs->Copy();
     49        }
     50        else{
     51                this->inputs=new Inputs();
     52        }
     53        /*point parameters: */
     54        this->parameters=numericalflux_parameters;
    4755}
    4856/*}}}*/
    4957/*FUNCTION Numericalflux::~Numericalflux(){{{1*/
    5058Numericalflux::~Numericalflux(){
    51         return;
     59        delete inputs;
     60        this->parameters=NULL;
     61}
     62/*}}}*/
     63
     64/*Object marshall*/
     65/*FUNCTION Numericalflux::Configure {{{1*/
     66void  Numericalflux::Configure(DataSet* elementsin,DataSet* loadsin,DataSet* nodesin,DataSet* verticesin,DataSet* materialsin,Parameters* parametersin){
     67
     68        /*Take care of hooking up all objects for this element, ie links the objects in the hooks to their respective
     69         * datasets, using internal ids and offsets hidden in hooks: */
     70        hnodes.configure(nodesin);
     71        helements.configure(elementsin);
     72
     73        /*point parameters to real dataset: */
     74        this->parameters=parametersin;
     75
    5276}
    5377/*}}}*/
    5478/*FUNCTION Numericalflux::copy {{{1*/
    5579Object* Numericalflux::copy() {
    56         return new Numericalflux(*this);
    57 }
    58 /*}}}*/
    59 
    60 /*Object marshall*/
     80        return new Numericalflux(this->id,&this->hnodes,&this->helements,this->parameters,this->inputs);
     81}
     82/*}}}*/
     83/*FUNCTION Numericalflux::DeepEcho {{{1*/
     84void Numericalflux::DeepEcho(void){
     85
     86        printf("Numericalflux:\n");
     87        printf("   id: %i\n",id);
     88        hnodes.DeepEcho();
     89        helements.DeepEcho();
     90        printf("   parameters\n");
     91        parameters->DeepEcho();
     92        printf("   inputs\n");
     93        inputs->DeepEcho();
     94       
     95}               
     96/*}}}*/
    6197/*FUNCTION Numericalflux::Demarshall {{{1*/
    6298void  Numericalflux::Demarshall(char** pmarshalled_dataset){
    6399
    64         int i;
    65100        char* marshalled_dataset=NULL;
     101        int   i;
    66102
    67103        /*recover marshalled_dataset: */
    … …  
    71107         *object data (thanks to DataSet::Demarshall):*/
    72108
    73         memcpy(&type,marshalled_dataset,sizeof(type));marshalled_dataset+=sizeof(type);
    74109        memcpy(&id,marshalled_dataset,sizeof(id));marshalled_dataset+=sizeof(id);
    75110
    76         memcpy(&element_id,marshalled_dataset,sizeof(element_id));marshalled_dataset+=sizeof(element_id);
    77         memcpy(&element_offset,marshalled_dataset,sizeof(element_offset));marshalled_dataset+=sizeof(element_offset);
    78         element=NULL;
     111        /*demarshall hooks: */
     112        hnodes.Demarshall(&marshalled_dataset);
     113        helements.Demarshall(&marshalled_dataset);
    79114       
    80         memcpy(&node_ids,marshalled_dataset,sizeof(node_ids));marshalled_dataset+=sizeof(node_ids);
    81         memcpy(&node_offsets,marshalled_dataset,sizeof(node_offsets));marshalled_dataset+=sizeof(node_offsets);
    82         for(i=0;i<MAX_NUMERICALFLUX_NODES;i++)nodes[i]=NULL;
    83 
    84         memcpy(&h,marshalled_dataset,sizeof(h));marshalled_dataset+=sizeof(h);
     115        /*demarshall inputs: */
     116        inputs=(Inputs*)DataSetDemarshallRaw(&marshalled_dataset);
     117
     118        /*parameters: may not exist even yet, so let Configure handle it: */
     119        this->parameters=NULL;
    85120
    86121        /*return: */
    … …  
    89124}
    90125/*}}}*/
     126/*FUNCTION Numericalflux::Echo {{{1*/
     127void Numericalflux::Echo(void){
     128        this->DeepEcho();
     129}
     130/*}}}*/
     131/*FUNCTION Numericalflux::Enum {{{1*/
     132int Numericalflux::Enum(void){
     133
     134        return NumericalfluxEnum;
     135
     136}
     137/*}}}*/
    91138/*FUNCTION Numericalflux::Marshall {{{1*/
    92139void  Numericalflux::Marshall(char** pmarshalled_dataset){
    … …  
    94141        char* marshalled_dataset=NULL;
    95142        int   enum_type=0;
     143        char* marshalled_inputs=NULL;
     144        int   marshalled_inputs_size;
    96145
    97146        /*recover marshalled_dataset: */
    … …  
    100149        /*get enum type of Numericalflux: */
    101150        enum_type=NumericalfluxEnum;
    102        
     151
    103152        /*marshall enum: */
    104153        memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
    105        
     154
    106155        /*marshall Numericalflux data: */
    107         memcpy(marshalled_dataset,&type,sizeof(type));marshalled_dataset+=sizeof(type);
    108156        memcpy(marshalled_dataset,&id,sizeof(id));marshalled_dataset+=sizeof(id);
    109        
    110         memcpy(marshalled_dataset,&element_id,sizeof(element_id));marshalled_dataset+=sizeof(element_id);
    111         memcpy(marshalled_dataset,&element_offset,sizeof(element_offset));marshalled_dataset+=sizeof(element_offset);
    112 
    113         memcpy(marshalled_dataset,&node_ids,sizeof(node_ids));marshalled_dataset+=sizeof(node_ids);
    114         memcpy(marshalled_dataset,&node_offsets,sizeof(node_offsets));marshalled_dataset+=sizeof(node_offsets);
    115 
    116         memcpy(marshalled_dataset,&h,sizeof(h));marshalled_dataset+=sizeof(h);
     157
     158        /*Marshall hooks: */
     159        hnodes.Marshall(&marshalled_dataset);
     160        helements.Marshall(&marshalled_dataset);
     161
     162        /*Marshall inputs: */
     163        marshalled_inputs_size=inputs->MarshallSize();
     164        marshalled_inputs=inputs->Marshall();
     165        memcpy(marshalled_dataset,marshalled_inputs,marshalled_inputs_size*sizeof(char));
     166        marshalled_dataset+=marshalled_inputs_size;
     167
     168        /*parameters: don't do anything about it. parameters are marshalled somewhere else!*/
     169
     170        xfree((void**)&marshalled_inputs);
    117171
    118172        *pmarshalled_dataset=marshalled_dataset;
    … …  
    123177int   Numericalflux::MarshallSize(){
    124178
    125         return sizeof(type)+
    126                 sizeof(id)+
    127                 sizeof(element_id)+
    128                 sizeof(element_offset)+
    129                 sizeof(node_ids)+
    130                 sizeof(node_offsets)+
    131                 sizeof(h)+
    132                 sizeof(int); //sizeof(int) for enum type
     179        return sizeof(id)
     180                +hnodes.MarshallSize()
     181                +helements.MarshallSize()
     182                +inputs->MarshallSize()
     183                +sizeof(int); //sizeof(int) for enum type
     184}
     185/*}}}*/
     186/*FUNCTION Numericalflux::MyRank {{{1*/
     187int    Numericalflux::MyRank(void){
     188        extern int my_rank;
     189        return my_rank;
    133190}
    134191/*}}}*/
    135192
    136193/*Object functions*/
    137 /*FUNCTION Numericalflux::Configure {{{1*/
    138 void  Numericalflux::Configure(void* pelementsin,void* pnodesin,void* pmaterialsin){
    139 
    140         DataSet* elementsin=NULL;
    141         DataSet* nodesin=NULL;
    142 
    143         /*Recover pointers :*/
    144         elementsin=(DataSet*)pelementsin;
    145         nodesin=(DataSet*)pnodesin;
    146        
    147         /*Link this load with its nodes: */
     194/*FUNCTION Numericalflux::CreateKMatrix {{{1*/
     195void  Numericalflux::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     196
    148197        if (strcmp(type,"internal")==0){
    149                 ResolvePointers((Object**)nodes,node_ids,node_offsets,4,nodesin);
     198
     199                CreateKMatrixInternal(Kgg,inputs,analysis_type,sub_analysis_type);
    150200        }
    151201        else if (strcmp(type,"boundary")==0){
    152                 ResolvePointers((Object**)nodes,node_ids,node_offsets,2,nodesin);
     202
     203                CreateKMatrixBoundary(Kgg,inputs,analysis_type,sub_analysis_type);
    153204        }
    154205        else ISSMERROR("type not supported yet");
    155         ResolvePointers((Object**)&element,&element_id,&element_offset,1,elementsin);
    156 
    157 }
    158 /*}}}*/
    159 /*FUNCTION Numericalflux::CreateKMatrix {{{1*/
    160 void  Numericalflux::CreateKMatrix(Mat Kgg,void* inputs,int analysis_type,int sub_analysis_type){
    161 
    162         if (strcmp(type,"internal")==0){
    163 
    164                 CreateKMatrixInternal(Kgg,inputs,analysis_type,sub_analysis_type);
    165         }
    166         else if (strcmp(type,"boundary")==0){
    167 
    168                 CreateKMatrixBoundary(Kgg,inputs,analysis_type,sub_analysis_type);
    169         }
    170         else ISSMERROR("type not supported yet");
    171206
    172207}
    173208/*}}}*/
    174209/*FUNCTION Numericalflux::CreateKMatrixInternal {{{1*/
    175 void  Numericalflux::CreateKMatrixInternal(Mat Kgg,void* vinputs,int analysis_type,int sub_analysis_type){
     210void  Numericalflux::CreateKMatrixInternal(Mat Kgg,int analysis_type,int sub_analysis_type){
    176211
    177212        /* local declarations */
    … …  
    290325/*}}}*/
    291326/*FUNCTION Numericalflux::CreateKMatrixBoundary {{{1*/
    292 void  Numericalflux::CreateKMatrixBoundary(Mat Kgg,void* vinputs,int analysis_type,int sub_analysis_type){
     327void  Numericalflux::CreateKMatrixBoundary(Mat Kgg,int analysis_type,int sub_analysis_type){
    293328
    294329        /* local declarations */
    … …  
    409444/*}}}*/
    410445/*FUNCTION Numericalflux::CreatePVector {{{1*/
    411 void  Numericalflux::CreatePVector(Vec pg, void* inputs, int analysis_type,int sub_analysis_type){
     446void  Numericalflux::CreatePVector(Vec pg, int analysis_type,int sub_analysis_type){
    412447
    413448        if (strcmp(type,"internal")==0){
    … …  
    424459/*}}}*/
    425460/*FUNCTION Numericalflux::CreatePVectorInternal{{{1*/
    426 void  Numericalflux::CreatePVectorInternal(Vec pg,void* inputs,int analysis_type,int sub_analysis_type){
     461void  Numericalflux::CreatePVectorInternal(Vec pg,int analysis_type,int sub_analysis_type){
    427462
    428463        /*Nothing added to PVector*/
    … …  
    432467/*}}}*/
    433468/*FUNCTION Numericalflux::CreatePVectorBoundary{{{1*/
    434 void  Numericalflux::CreatePVectorBoundary(Vec pg,void* vinputs,int analysis_type,int sub_analysis_type){
     469void  Numericalflux::CreatePVectorBoundary(Vec pg,int analysis_type,int sub_analysis_type){
    435470
    436471        /* local declarations */
    … …  
    545580}
    546581/*}}}*/
    547 /*FUNCTION Numericalflux::DeepEcho {{{1*/
    548 void Numericalflux::DeepEcho(void){
    549 
    550         int i;
    551        
    552         printf("Numericalflux:\n");
    553         printf("   type: %s\n",type);
    554         printf("   id: %i\n",id);
    555        
    556         printf("   element_id=%i\n",element_id);
    557         printf("   element_offset=%i\n",element_offset);
    558         if(element)element->Echo();
    559         if (strcmp(type,"internal")==0){
    560                 printf("   node_ids=[%i,%i,%i,%i]\n",node_ids[0],node_ids[1],node_ids[2],node_ids[3]);
    561                 printf("   node_offsets=[%i,%i,%i,%i]\n",node_offsets[0],node_offsets[1],node_offsets[2],node_offsets[3]);
    562                 for(i=0;i<4;i++){
    563                         if(nodes[i])nodes[i]->Echo();
    564                 }
    565                 printf("   h=[%i,%i,%i,%i]\n",h[0],h[1],h[2],h[3]);
    566         }
    567         else{
    568                 printf("   node_ids=[%i,%i]\n",node_ids[0],node_ids[1]);
    569                 printf("   node_offsets=[%i,%i]\n",node_offsets[0],node_offsets[1]);
    570                 for(i=0;i<2;i++){
    571                         if(nodes[i])nodes[i]->Echo();
    572                 }
    573                 printf("   h=[%i,%i]\n",h[0],h[1]);
    574         }
    575         return;
    576 }               
    577 /*}}}*/
    578582/*FUNCTION Numericalflux::DistributeNumDofs {{{1*/
    579583void  Numericalflux::DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type){
    580584        return;
    581 }
    582 /*}}}*/
    583 /*FUNCTION Numericalflux::Echo {{{1*/
    584 void Numericalflux::Echo(void){
    585 
    586         printf("Numericalflux:\n");
    587         printf("   type: %s\n",type);
    588         printf("   id: %i\n",id);
    589 
    590         printf("   element_id=%i\n",element_id);
    591         printf("   element_offset=%i]\n",element_offset);
    592 
    593         if (strcmp(type,"internal")==0){
    594                 printf("   node_ids=[%i,%i,%i,%i]\n",node_ids[0],node_ids[1],node_ids[2],node_ids[3]);
    595                 printf("   node_offsets=[%i,%i,%i,%i]\n",node_offsets[0],node_offsets[1],node_offsets[2],node_offsets[3]);
    596                 printf("   h=[%g,%g,%g,%g]\n",h[0],h[1],h[2],h[3]);
    597         }
    598         else{
    599                 printf("   node_ids=[%i,%i]\n",node_ids[0],node_ids[1]);
    600                 printf("   node_offsets=[%i,%i]\n",node_offsets[0],node_offsets[1]);
    601                 printf("   h=[%g,%g]\n",h[0],h[1]);
    602         }
    603 
    604         return;
    605 }
    606 /*}}}*/
    607 /*FUNCTION Numericalflux::Enum {{{1*/
    608 int Numericalflux::Enum(void){
    609 
    610         return NumericalfluxEnum;
    611 
    612585}
    613586/*}}}*/
    … …  
    753726}
    754727/*}}}*/
    755 /*FUNCTION Numericalflux::MyRank {{{1*/
    756 int    Numericalflux::MyRank(void){
    757         extern int my_rank;
    758         return my_rank;
    759 }
    760 /*}}}*/
    761728/*FUNCTION Numericalflux::PenaltyCreateKMatrix {{{1*/
    762 void  Numericalflux::PenaltyCreateKMatrix(Mat Kgg,void* inputs,double kmax,int analysis_type,int sub_analysis_type){
     729void  Numericalflux::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){
    763730
    764731        /*No stiffness loads applied, do nothing: */
    … …  
    768735/*}}}*/
    769736/*FUNCTION Numericalflux::PenaltyCreatePVector{{{1*/
    770 void  Numericalflux::PenaltyCreatePVector(Vec pg,void* inputs,double kmax,int analysis_type,int sub_analysis_type){
     737void  Numericalflux::PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type){
    771738
    772739        /*No penalty loads applied, do nothing: */
    … …  
    775742}
    776743/*}}}*/
    777 /*FUNCTION Numericalflux::UpdateFromInputs {{{1*/
    778 void  Numericalflux::UpdateFromInputs(void* vinputs){
    779 
    780         /*Do nothing FOR NOW...*/
    781 }
    782 /*}}}*/

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

    r3637 r3642  
    1010#include "./Load.h"
    1111#include "./Matpar.h"
    12 #include "./Element.h"
    13 #include "./Node.h"
    14 class Element;
    15 
    16 #define NUMERICALFLUXSTRING 20    //max string length
    17 #define MAX_NUMERICALFLUX_NODES 4 //max number of grids for a certain load
    18 #define MAX_NUMERICALFLUX_ELEMS 2 //max number of elements for a certain load
     12#include "./Hook.h"
    1913/*}}}*/
    2014
    2115class Numericalflux: public Load {
    2216
    23         private:
    24                 /*Type of numerical flux*/
    25                 int  id;
    26                 char type[NUMERICALFLUXSTRING];
    27        
    28                 /*elements: */
    29                 Element* element;
    30                 int      element_id;
    31                 int      element_offset;
     17        public:
     18                int         id;
    3219
    33                 /*nodes: */
    34                 Node* nodes[MAX_NUMERICALFLUX_NODES];
    35                 int   node_ids[MAX_NUMERICALFLUX_NODES];
    36                 int   node_offsets[MAX_NUMERICALFLUX_NODES];
     20                Hook        helements;
     21                Hook        hnodes;
     22                Parameters *parameters;
     23                Inputs     *inputs;
    3724
    38                 /*properties: */
    39                 double h[MAX_NUMERICALFLUX_NODES]; //thickness
    4025
    41         public:
    42 
     26                /*Constructors {{{1*/
    4327                Numericalflux();
    44                 Numericalflux(int numericalflux_id,char numericalflux_type[NUMERICALFLUXSTRING], int numericalflux_node_ids[MAX_NUMERICALFLUX_NODES],int numericalflux_element_id,double numericalflux_h[MAX_NUMERICALFLUX_NODES]);
     28                Numericalflux(int numericalflux_id,int* numericalflux_node_ids,int numnodes, int* numericalflux_element_ids, int numelements);
     29                Numericalflux(int numericalflux_id,Hook* numericalflux_hnodes, Hook* numericalflux_helements, Parameters* parameters, Inputs* numericalflux_inputs);
     30                ~Numericalflux();
     31                /*}}}*/
     32                /*Object management: {{{1*/
    4533                Object* copy();
    46                 ~Numericalflux();
    47 
     34                void  Configure(DataSet* elements,DataSet* loads,DataSet* nodes,DataSet* vertices,DataSet* materials,Parameters* parameters);
     35                void  DeepEcho();
     36                void  Demarshall(char** pmarshalled_dataset);
    4837                void  Echo();
    49                 void  DeepEcho();
     38                int   Enum();
     39                int   GetId();
     40                char* GetName();
    5041                void  Marshall(char** pmarshalled_dataset);
    5142                int   MarshallSize();
    52                 char* GetName();
    53                 void  Demarshall(char** pmarshalled_dataset);
    54                 int   Enum();
    55                 int   GetId();
     43                int   MyRank();
     44                /*}}}*/
     45                /*Numerics: {{{1*/
    5646                void  GetJacobianDeterminant(double* pJdet,double xyz_list[4][3], double gauss_coord);
    5747                void  GetNodalFunctions(double* l1l4, double gauss_coord);
    58                 int   MyRank();
    5948                void  DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type);
    60                 void  Configure(void* elements,void* nodes,void* materials);
    6149                void  GetB(double* B, double gauss_coord);
    6250                void  GetL(double* L, double gauss_coord,int numdof);
    … …  
    6654                void  UpdateFromInputs(void* inputs);
    6755               
    68                 void  CreateKMatrix(Mat Kgg,void* inputs,int analysis_type,int sub_analysis_type);
    69                 void  CreateKMatrixInternal(Mat Kgg,void* inputs,int analysis_type,int sub_analysis_type);
    70                 void  CreateKMatrixBoundary(Mat Kgg,void* inputs,int analysis_type,int sub_analysis_type);
    71                 void  CreatePVector(Vec pg, void* inputs, int analysis_type,int sub_analysis_type);
    72                 void  CreatePVectorInternal(Vec pg,void* inputs,int analysis_type,int sub_analysis_type);
    73                 void  CreatePVectorBoundary(Vec pg,void* inputs,int analysis_type,int sub_analysis_type);
    74                 void  PenaltyCreateKMatrix(Mat Kgg,void* inputs,double kmax,int analysis_type,int sub_analysis_type);
    75                 void  PenaltyCreatePVector(Vec pg,void* inputs,double kmax,int analysis_type,int sub_analysis_type);
     56                void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type);
     57                void  CreateKMatrixInternal(Mat Kgg,int analysis_type,int sub_analysis_type);
     58                void  CreateKMatrixBoundary(Mat Kgg,int analysis_type,int sub_analysis_type);
     59                void  CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type);
     60                void  CreatePVectorInternal(Vec pg,int analysis_type,int sub_analysis_type);
     61                void  CreatePVectorBoundary(Vec pg,int analysis_type,int sub_analysis_type);
     62                void  PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type);
     63                void  PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type);
     64                /*}}}*/
    7665
    7766};

  • issm/trunk/src/m/enum/AccumulationRateEnum.m

    r3612 r3642  
    77%      macro=AccumulationRateEnum()
    88
    9 macro=105;
     9macro=112;

  • issm/trunk/src/m/enum/AdjointxEnum.m

    r3612 r3642  
    77%      macro=AdjointxEnum()
    88
    9 macro=114;
     9macro=125;

  • issm/trunk/src/m/enum/AdjointyEnum.m

    r3612 r3642  
    77%      macro=AdjointyEnum()
    88
    9 macro=115;
     9macro=126;

  • issm/trunk/src/m/enum/AirEnum.m

    r3612 r3642  
    77%      macro=AirEnum()
    88
    9 macro=80;
     9macro=87;

  • issm/trunk/src/m/enum/BedEnum.m

    r3612 r3642  
    77%      macro=BedEnum()
    88
    9 macro=97;
     9macro=104;

  • issm/trunk/src/m/enum/BoolInputEnum.m

    r3612 r3642  
    77%      macro=BoolInputEnum()
    88
    9 macro=67;
     9macro=74;

  • issm/trunk/src/m/enum/DhDtEnum.m

    r3612 r3642  
    77%      macro=DhDtEnum()
    88
    9 macro=94;
     9macro=101;

  • issm/trunk/src/m/enum/DofVecEnum.m

    r3612 r3642  
    77%      macro=DofVecEnum()
    88
    9 macro=74;
     9macro=81;

  • issm/trunk/src/m/enum/DoubleInputEnum.m

    r3612 r3642  
    77%      macro=DoubleInputEnum()
    88
    9 macro=69;
     9macro=76;

  • issm/trunk/src/m/enum/DragCoefficientEnum.m

    r3612 r3642  
    77%      macro=DragCoefficientEnum()
    88
    9 macro=98;
     9macro=105;

  • issm/trunk/src/m/enum/DragPEnum.m

    r3612 r3642  
    77%      macro=DragPEnum()
    88
    9 macro=99;
     9macro=106;

  • issm/trunk/src/m/enum/DragQEnum.m

    r3612 r3642  
    77%      macro=DragQEnum()
    88
    9 macro=100;
     9macro=107;

  • issm/trunk/src/m/enum/DragTypeEnum.m

    r3612 r3642  
    77%      macro=DragTypeEnum()
    88
    9 macro=101;
     9macro=108;

  • issm/trunk/src/m/enum/ElementOnBedEnum.m

    r3612 r3642  
    77%      macro=ElementOnBedEnum()
    88
    9 macro=108;
     9macro=115;

  • issm/trunk/src/m/enum/ElementOnIceShelfEnum.m

    r3612 r3642  
    77%      macro=ElementOnIceShelfEnum()
    88
    9 macro=107;
     9macro=114;

  • issm/trunk/src/m/enum/ElementOnSurfaceEnum.m

    r3612 r3642  
    77%      macro=ElementOnSurfaceEnum()
    88
    9 macro=110;
     9macro=117;

  • issm/trunk/src/m/enum/ElementOnWaterEnum.m

    r3612 r3642  
    77%      macro=ElementOnWaterEnum()
    88
    9 macro=109;
     9macro=116;

  • issm/trunk/src/m/enum/FitEnum.m

    r3612 r3642  
    77%      macro=FitEnum()
    88
    9 macro=113;
     9macro=124;

  • issm/trunk/src/m/enum/GeographyEnum.m

    r3612 r3642  
    77%      macro=GeographyEnum()
    88
    9 macro=75;
     9macro=82;

  • issm/trunk/src/m/enum/GeothermalFluxEnum.m

    r3612 r3642  
    77%      macro=GeothermalFluxEnum()
    88
    9 macro=106;
     9macro=113;

  • issm/trunk/src/m/enum/IceEnum.m

    r3612 r3642  
    77%      macro=IceEnum()
    88
    9 macro=79;
     9macro=86;

  • issm/trunk/src/m/enum/IceSheetEnum.m

    r3612 r3642  
    77%      macro=IceSheetEnum()
    88
    9 macro=76;
     9macro=83;

  • issm/trunk/src/m/enum/IceShelfEnum.m

    r3612 r3642  
    77%      macro=IceShelfEnum()
    88
    9 macro=77;
     9macro=84;

  • issm/trunk/src/m/enum/InputEnum.m

    r3589 r3642  
    77%      macro=InputEnum()
    88
    9 macro=65;
     9macro=69;

  • issm/trunk/src/m/enum/IntInputEnum.m

    r3612 r3642  
    77%      macro=IntInputEnum()
    88
    9 macro=68;
     9macro=75;

  • issm/trunk/src/m/enum/MaterialEnum.m

    r3589 r3642  
    77%      macro=MaterialEnum()
    88
    9 macro=61;
     9macro=65;

  • issm/trunk/src/m/enum/MaticeEnum.m

    r3589 r3642  
    77%      macro=MaticeEnum()
    88
    9 macro=62;
     9macro=66;

  • issm/trunk/src/m/enum/MatparEnum.m

    r3589 r3642  
    77%      macro=MatparEnum()
    88
    9 macro=63;
     9macro=67;

  • issm/trunk/src/m/enum/MelangeEnum.m

    r3612 r3642  
    77%      macro=MelangeEnum()
    88
    9 macro=81;
     9macro=88;

  • issm/trunk/src/m/enum/MeltingRateEnum.m

    r3612 r3642  
    77%      macro=MeltingRateEnum()
    88
    9 macro=104;
     9macro=111;

  • issm/trunk/src/m/enum/NumericalfluxEnum.m

    r3589 r3642  
    77%      macro=NumericalfluxEnum()
    88
    9 macro=60;
     9macro=64;

  • issm/trunk/src/m/enum/NumparEnum.m

    r3589 r3642  
    77%      macro=NumparEnum()
    88
    9 macro=64;
     9macro=68;

  • issm/trunk/src/m/enum/ParamEnum.m

    r3612 r3642  
    77%      macro=ParamEnum()
    88
    9 macro=70;
     9macro=77;

  • issm/trunk/src/m/enum/PengridEnum.m

    r3589 r3642  
    77%      macro=PengridEnum()
    88
    9 macro=59;
     9macro=63;

  • issm/trunk/src/m/enum/PenpairEnum.m

    r3589 r3642  
    77%      macro=PenpairEnum()
    88
    9 macro=58;
     9macro=62;

  • issm/trunk/src/m/enum/ResultEnum.m

    r3612 r3642  
    77%      macro=ResultEnum()
    88
    9 macro=71;
     9macro=78;

  • issm/trunk/src/m/enum/RgbEnum.m

    r3612 r3642  
    77%      macro=RgbEnum()
    88
    9 macro=72;
     9macro=79;

  • issm/trunk/src/m/enum/RheologyBEnum.m

    r3612 r3642  
    77%      macro=RheologyBEnum()
    88
    9 macro=102;
     9macro=109;

  • issm/trunk/src/m/enum/RheologyNEnum.m

    r3612 r3642  
    77%      macro=RheologyNEnum()
    88
    9 macro=103;
     9macro=110;

  • issm/trunk/src/m/enum/RiftfrontEnum.m

    r3589 r3642  
    77%      macro=RiftfrontEnum()
    88
    9 macro=57;
     9macro=59;

  • issm/trunk/src/m/enum/SpcEnum.m

    r3612 r3642  
    77%      macro=SpcEnum()
    88
    9 macro=73;
     9macro=80;

  • issm/trunk/src/m/enum/SurfaceAreaEnum.m

    r3612 r3642  
    77%      macro=SurfaceAreaEnum()
    88
    9 macro=111;
     9macro=118;

  • issm/trunk/src/m/enum/SurfaceEnum.m

    r3612 r3642  
    77%      macro=SurfaceEnum()
    88
    9 macro=96;
     9macro=103;

  • issm/trunk/src/m/enum/ThicknessEnum.m

    r3612 r3642  
    77%      macro=ThicknessEnum()
    88
    9 macro=95;
     9macro=102;

  • issm/trunk/src/m/enum/TriaVertexInputEnum.m

    r3599 r3642  
    77%      macro=TriaVertexInputEnum()
    88
    9 macro=66;
     9macro=70;

  • issm/trunk/src/m/enum/VxAverageEnum.m

    r3612 r3642  
    77%      macro=VxAverageEnum()
    88
    9 macro=85;
     9macro=92;

  • issm/trunk/src/m/enum/VxEnum.m

    r3612 r3642  
    77%      macro=VxEnum()
    88
    9 macro=82;
     9macro=89;

  • issm/trunk/src/m/enum/VxObsEnum.m

    r3612 r3642  
    77%      macro=VxObsEnum()
    88
    9 macro=88;
     9macro=95;

  • issm/trunk/src/m/enum/VxOldEnum.m

    r3612 r3642  
    77%      macro=VxOldEnum()
    88
    9 macro=91;
     9macro=98;

  • issm/trunk/src/m/enum/VyAverageEnum.m

    r3612 r3642  
    77%      macro=VyAverageEnum()
    88
    9 macro=86;
     9macro=93;

  • issm/trunk/src/m/enum/VyEnum.m

    r3612 r3642  
    77%      macro=VyEnum()
    88
    9 macro=83;
     9macro=90;

  • issm/trunk/src/m/enum/VyObsEnum.m

    r3612 r3642  
    77%      macro=VyObsEnum()
    88
    9 macro=89;
     9macro=96;

  • issm/trunk/src/m/enum/VyOldEnum.m

    r3612 r3642  
    77%      macro=VyOldEnum()
    88
    9 macro=92;
     9macro=99;

  • issm/trunk/src/m/enum/VzAverageEnum.m

    r3612 r3642  
    77%      macro=VzAverageEnum()
    88
    9 macro=87;
     9macro=94;

  • issm/trunk/src/m/enum/VzEnum.m

    r3612 r3642  
    77%      macro=VzEnum()
    88
    9 macro=84;
     9macro=91;

  • issm/trunk/src/m/enum/VzObsEnum.m

    r3612 r3642  
    77%      macro=VzObsEnum()
    88
    9 macro=90;
     9macro=97;

  • issm/trunk/src/m/enum/VzOldEnum.m

    r3612 r3642  
    77%      macro=VzOldEnum()
    88
    9 macro=93;
     9macro=100;

  • issm/trunk/src/m/enum/WaterEnum.m

    r3612 r3642  
    77%      macro=WaterEnum()
    88
    9 macro=78;
     9macro=85;

  • issm/trunk/src/m/enum/WeightsEnum.m

    r3612 r3642  
    77%      macro=WeightsEnum()
    88
    9 macro=112;
     9macro=123;
Note: See TracChangeset for help on using the changeset viewer.