Changeset 4007


Ignore:
Timestamp:
06/03/10 08:13:27 (15 years ago)
Author:
seroussi
Message:

added analysis_type in loads

Location:
issm/trunk/src/c/objects/Loads
Files:
10 edited

Legend:

Unmodified
Added
Removed

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

    r3833 r4007  
    2727}
    2828/*}}}*/
    29 /*FUNCTION Friction::Friction(char* element_type, Inputs* inputs,Matpar* matpar){{{1*/
    30 Friction::Friction(char* element_type_in,Inputs* inputs_in,Matpar* matpar_in){
     29/*FUNCTION Friction::Friction(char* element_type, Inputs* inputs,Matpar* matpar,int analysis_type){{{1*/
     30Friction::Friction(char* element_type_in,Inputs* inputs_in,Matpar* matpar_in, int in_analysis_type){
    3131
     32        this->analysis_type=in_analysis_type;
    3233        this->inputs=inputs_in;
    3334        this->element_type=(char*)xmalloc((strlen(element_type_in)+1)*sizeof(char));
    … …  
    4546void Friction::Echo(void){
    4647        printf("Friction:\n");
     48        printf("   analysis_type: %s\n",EnumAsString(analysis_type));
    4749        printf("   element_type: %s\n",this->element_type);
    4850        inputs->Echo();

  • issm/trunk/src/c/objects/Loads/Friction.h

    r3833 r4007  
    1515
    1616        public:
     17                int analysis_type;
    1718
    1819                char* element_type;
    … …  
    2223                /*methods: */
    2324                Friction();
    24                 Friction(char* element_type, Inputs* inputs,Matpar* matpar);
     25                Friction(char* element_type, Inputs* inputs,Matpar* matpar, int analysis_type);
    2526                ~Friction();
    2627       

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

    r4003 r4007  
    179179        /*this time, no need to get enum type, the pointer directly points to the beginning of the
    180180         *object data (thanks to DataSet::Demarshall):*/
    181 
    182181        memcpy(&id,marshalled_dataset,sizeof(id));marshalled_dataset+=sizeof(id);
    183182        memcpy(&analysis_type,marshalled_dataset,sizeof(analysis_type));marshalled_dataset+=sizeof(analysis_type);

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

    r4003 r4007  
    5757                void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type);
    5858                bool  InAnalysis(int analysis_type);
    59 
    60 
    61 
    6259                /*}}}*/
    6360                /*numerics: {{{1*/

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

    r4004 r4007  
    2525}
    2626/*}}}*/
    27 /*FUNCTION Numericalflux::Numericalflux(int numericalflux_id,int* numericalflux_node_ids,...){{{1*/
    28 Numericalflux::Numericalflux(int numericalflux_id,int* numericalflux_node_ids,int numnodes,int* numericalflux_element_ids, int numelements):
    29         hnodes(numericalflux_node_ids,numnodes),
    30         helements(numericalflux_element_ids,numelements)
    31 {
    32 
    33         id=numericalflux_id;
    34         this->parameters=NULL;
    35         this->inputs=new Inputs();
    36 }
    37 /*}}}*/
    38 /*FUNCTION Numericalflux::Numericalflux(int id, Hook* hnodes, Hook* helements, Parameters* parameters, Inputs* numericalflux_inputs) {{{1*/
    39 Numericalflux::Numericalflux(int numericalflux_id,Hook* numericalflux_hnodes, Hook* numericalflux_helements, Parameters* numericalflux_parameters, Inputs* numericalflux_inputs):
    40         hnodes(numericalflux_hnodes),
    41         helements(numericalflux_helements)
    42 {
    43 
    44         /*all the initialization has been done by the initializer, just fill in the id: */
    45         this->id=numericalflux_id;
    46         if(numericalflux_inputs){
    47                 this->inputs=(Inputs*)numericalflux_inputs->Copy();
    48         }
    49         else{
    50                 this->inputs=new Inputs();
    51         }
    52         /*point parameters: */
    53         this->parameters=numericalflux_parameters;
    54 }
    55 /*}}}*//*FUNCTION Numericalflux::Numericalflux(int id, int i, IoModel* iomodel) {{{1*/
    56 Numericalflux::Numericalflux(int numericalflux_id,int i, IoModel* iomodel){
     27/*}}}*//*FUNCTION Numericalflux::Numericalflux(int id, int i, IoModel* iomodel, int analysis_type) {{{1*/
     28Numericalflux::Numericalflux(int numericalflux_id,int i, IoModel* iomodel, int in_analysis_type){
    5729
    5830        /* Intermediary */
    … …  
    134106        /*Ok, we have everything to build the object: */
    135107        this->id=numericalflux_id;
     108        this->analysis_type=in_analysis_type;
    136109
    137110        /*Hooks: */
    … …  
    145118        //this->parameters: we still can't point to it, it may not even exist. Configure will handle this.
    146119        this->parameters=NULL;
     120}
     121/*}}}*/
     122/*FUNCTION Numericalflux::copy {{{1*/
     123Object* Numericalflux::copy() {
     124       
     125        Numericalflux* numericalflux=NULL;
     126
     127        numericalflux=new Numericalflux();
     128
     129        /*copy fields: */
     130        numericalflux->id=this->id;
     131        numericalflux->analysis=this->analysis;
     132        if(this->inputs){
     133                numericalflux->inputs=(Inputs*)this->inputs->Copy();
     134        }
     135        else{
     136                numericalflux->inputs=new Inputs();
     137        }
     138        /*point parameters: */
     139        numericalflux->parameters=this->parameters;
     140
     141        /*now deal with hooks and objects: */
     142        numericalflux->hnodes.copy(&this->hnodes);
     143        numericalflux->helement.copy(&this->helement);
     144
     145        /*recover objects: */
     146        numericalflux->nodes=(Node**)numericalflux->hnodes.deliverp();
     147        numericalflux->element=(Element*)numericalflux->helement.delivers();
     148
     149        return numericalflux;
     150
    147151}
    148152/*}}}*/
    … …  
    168172}
    169173/*}}}*/
    170 /*FUNCTION Numericalflux::copy {{{1*/
    171 Object* Numericalflux::copy() {
    172         return new Numericalflux(this->id,&this->hnodes,&this->helements,this->parameters,this->inputs);
    173 }
    174 /*}}}*/
    175174/*FUNCTION Numericalflux::DeepEcho {{{1*/
    176175void Numericalflux::DeepEcho(void){
    … …  
    178177        printf("Numericalflux:\n");
    179178        printf("   id: %i\n",id);
     179        printf("   analysis_type: %s\n",EnumAsString(analysis_type));
    180180        hnodes.DeepEcho();
    181181        helements.DeepEcho();
    … …  
    198198        /*this time, no need to get enum type, the pointer directly points to the beginning of the
    199199         *object data (thanks to DataSet::Demarshall):*/
    200 
    201200        memcpy(&id,marshalled_dataset,sizeof(id));marshalled_dataset+=sizeof(id);
     201        memcpy(&analysis_type,marshalled_dataset,sizeof(analysis_type));marshalled_dataset+=sizeof(analysis_type);
    202202
    203203        /*demarshall hooks: */
    … …  
    247247        /*marshall Numericalflux data: */
    248248        memcpy(marshalled_dataset,&id,sizeof(id));marshalled_dataset+=sizeof(id);
     249        memcpy(marshalled_dataset,&analysis_type,sizeof(analysis_type));marshalled_dataset+=sizeof(analysis_type);
    249250
    250251        /*Marshall hooks: */
    … …  
    270271
    271272        return sizeof(id)
     273                +sizeof(analysis_type)
    272274                +hnodes.MarshallSize()
    273275                +helements.MarshallSize()

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

    r4004 r4007  
    2020        public:
    2121                int         id;
     22                int analysis_type;
    2223
    2324                Hook        helements;
    … …  
    2930                /*Constructors {{{1*/
    3031                Numericalflux();
    31                 Numericalflux(int numericalflux_id,int* numericalflux_node_ids,int numnodes, int* numericalflux_element_ids, int numelements);
    32                 Numericalflux(int numericalflux_id,Hook* numericalflux_hnodes, Hook* numericalflux_helements, Parameters* parameters, Inputs* numericalflux_inputs);
    33                 Numericalflux(int numericalflux_id,int i, IoModel* iomodel);
     32                Numericalflux(int numericalflux_id,int i, IoModel* iomodel,int analysis_type);
    3433                ~Numericalflux();
     34                Object* copy();
    3535                /*}}}*/
    3636                /*Object management: {{{1*/
    37                 Object* copy();
    3837                void  Configure(DataSet* elements,DataSet* loads,DataSet* nodes,DataSet* vertices,DataSet* materials,Parameters* parameters);
    3938                void  DeepEcho();

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

    r4004 r4007  
    3030}
    3131/*}}}1*/
    32 /*FUNCTION Pengrid::Pengrid(int id, int node_ids int matpar_id){{{1*/
    33 Pengrid::Pengrid(int pengrid_id,int pengrid_node_id, int pengrid_element_id,int pengrid_matpar_id):
    34         hnode(&pengrid_node_id,1),
    35         helement(&pengrid_element_id,1),
    36         hmatpar(&pengrid_matpar_id,1)
    37 {
    38 
    39         /*all the initialization has been done by the initializer, just fill in the id: */
    40         this->id=pengrid_id;
    41         this->parameters=NULL;
    42         this->inputs=new Inputs();
    43 
    44         /*not active, not zigzagging: */
    45         active=0;
    46         zigzag_counter=0;
    47 
    48 }
    49 /*}}}*/
    50 /*FUNCTION Pengrid::Pengrid(int id, Hook* hnodes, Hook* hmatice, Hook* hmatpar, Parameters* parameters, Inputs* pengrid_inputs) {{{1*/
    51 Pengrid::Pengrid(int pengrid_id,Hook* pengrid_hnode, Hook* pengrid_helement,Hook* pengrid_hmatpar, Parameters* pengrid_parameters, Inputs* pengrid_inputs):
    52         hnode(pengrid_hnode),
    53         helement(pengrid_helement),
    54         hmatpar(pengrid_hmatpar)
    55 {
    56 
    57         /*all the initialization has been done by the initializer, just fill in the id: */
    58         this->id=pengrid_id;
    59         if(pengrid_inputs){
    60                 this->inputs=(Inputs*)pengrid_inputs->Copy();
    61         }
    62         else{
    63                 this->inputs=new Inputs();
    64         }
    65         /*point parameters: */
    66         this->parameters=pengrid_parameters;
    67        
    68         /*not active, not zigzagging: */
    69         active=0;
    70         zigzag_counter=0;
    71 
    72 }
    73 /*}}}*/
    74 /*FUNCTION Pengrid::Pengrid(int index, int id, IoModel* iomodel){{{1*/
    75 Pengrid::Pengrid(int id, int index, IoModel* iomodel){ //i is the element index
     32/*FUNCTION Pengrid::Pengrid(int index, int id, IoModel* iomodel,int analysis_type){{{1*/
     33Pengrid::Pengrid(int id, int index, IoModel* iomodel, int in_analysis_type){ //i is the element index
    7634
    7735        int i,j;
    … …  
    8644        /*id: */
    8745        this->id=id;
     46        this->analysis_type=in_analysis_type;
    8847       
    8948        /*hooks: */
    … …  
    10564        this->active=0;
    10665        this->zigzag_counter=0;
     66
     67}
     68/*}}}*/
     69/*FUNCTION Icefront::copy {{{1*/
     70Object* Pengrid::copy() {
     71       
     72        Pengrid* pengrid=NULL;
     73
     74        pengrid=new Pengrid();
     75
     76        /*copy fields: */
     77        pengrid->id=this->id;
     78        pengrid->analysis=this->analysis;
     79        if(this->inputs){
     80                pengrid->inputs=(Inputs*)this->inputs->Copy();
     81        }
     82        else{
     83                pengrid->inputs=new Inputs();
     84        }
     85        /*point parameters: */
     86        pengrid->parameters=this->parameters;
     87
     88        /*now deal with hooks and objects: */
     89        pengrid->hnode.copy(&this->hnodes);
     90        pengrid->helement.copy(&this->helement);
     91        pengrid->hmatpar.copy(&this->hmatpar);
     92
     93        /*recover objects: */
     94        pengrid->node=(Node**)pengrid->hnode.deliverp();
     95        pengrid->element=(Element*)pengrid->helement.delivers();
     96        pengrid->matpar=(Matpar*)pengrid->hmatpar.delivers();
     97
     98        //let's not forget internals
     99        pengrid->active=this->active=0;
     100        pengrid->zigzag_counter=this->zigzag_counter=0;
     101
     102        return pengrid;
    107103
    108104}
    … …  
    128124}
    129125/*}}}1*/
    130 /*FUNCTION Pengrid::copy {{{1*/
    131 Object* Pengrid::copy() {
    132         return new Pengrid(this->id,&this->hnode,&this->helement,&this->hmatpar,this->parameters,this->inputs);
    133 }
    134 /*}}}1*/
    135126/*FUNCTION Pengrid::DeepEcho{{{1*/
    136127void Pengrid::DeepEcho(void){
    … …  
    138129        printf("Pengrid:\n");
    139130        printf("   id: %i\n",id);
     131        printf("   analysis_type: %s\n",EnumAsString(analysis_type));
    140132        hnode.DeepEcho();
    141133        helement.DeepEcho();
    … …  
    162154
    163155        memcpy(&id,marshalled_dataset,sizeof(id));marshalled_dataset+=sizeof(id);
     156        memcpy(&analysis_type,marshalled_dataset,sizeof(analysis_type));marshalled_dataset+=sizeof(analysis_type);
    164157        memcpy(&active,marshalled_dataset,sizeof(active));marshalled_dataset+=sizeof(active);
    165158        memcpy(&zigzag_counter,marshalled_dataset,sizeof(zigzag_counter));marshalled_dataset+=sizeof(zigzag_counter);
    … …  
    214207        /*marshall Tria data: */
    215208        memcpy(marshalled_dataset,&id,sizeof(id));marshalled_dataset+=sizeof(id);
     209        memcpy(marshalled_dataset,&analysis_type,sizeof(analysis_type));marshalled_dataset+=sizeof(analysis_type);
    216210        memcpy(marshalled_dataset,&active,sizeof(active));marshalled_dataset+=sizeof(active);
    217211        memcpy(marshalled_dataset,&zigzag_counter,sizeof(zigzag_counter));marshalled_dataset+=sizeof(zigzag_counter);
    … …  
    240234       
    241235        return sizeof(id)
     236                +sizeof(analysis_type)
    242237                +sizeof(active)
    243238                +sizeof(zigzag_counter)

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

    r4004 r4007  
    1919
    2020                int             id;
     21                int analysis_type;
    2122               
    2223                Hook hnode;  //hook to 1 node
    … …  
    3536                /*FUNCTION constructors, destructors {{{1*/
    3637                Pengrid();
    37                 Pengrid(int pengrid_id,int pengrid_node_id, int pengrid_element_id,int pengrid_matpar_id);
    38                 Pengrid(int pengrid_id,Hook* pengrid_hnode, Hook* pengrid_helement,Hook* pengrid_hmatpar, Parameters* pengrid_parameters, Inputs* pengrid_inputs);
    39                 Pengrid(int index, int id, IoModel* iomodel);
     38                Pengrid(int index, int id, IoModel* iomodel,int analysis_type);
    4039                ~Pengrid();
     40                Object* copy();
    4141                /*}}}*/
    4242                /*FUNCTION object management {{{1*/
    4343                void  Configure(DataSet* elementsin,DataSet* loadsin,DataSet* nodesin,DataSet* verticesin,DataSet* materialsin,Parameters* parametersin);
    44                 Object* copy();
    4544                void  DeepEcho();
    4645                void  Demarshall(char** pmarshalled_dataset);

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

    r4004 r4007  
    2424/*}}}1*/
    2525/*FUNCTION Penpair::creation {{{1*/
    26 Penpair::Penpair(int penpair_id, int* penpair_node_ids):
     26Penpair::Penpair(int penpair_id, int* penpair_node_ids,int in_analysis_type):
    2727        hnodes(penpair_node_ids,2)
    2828{
    … …  
    3030        /*all the initialization has been done by the initializer, just fill in the id: */
    3131        this->id=penpair_id;
     32        this->analysis_type=in_analysis_type;
    3233       
    3334        return;
    … …  
    3536/*}}}1*/
    3637/*FUNCTION Penpair::creation {{{1*/
    37 Penpair::Penpair(int penpair_id, Hook* penpair_hnodes):
     38Penpair::Penpair(int penpair_id, Hook* penpair_hnodes,int in_analysis_type):
    3839        hnodes(penpair_hnodes)
    3940{
    … …  
    4142        /*all the initialization has been done by the initializer, just fill in the id: */
    4243        this->id=penpair_id;
    43        
    44         return;
    45 }
    46 /*}}}1*/
     44        this->analysis_type=in_analysis_type;
     45       
     46        return;
     47}
     48/*}}}1*/
     49/*FUNCTION Penpair::copy {{{1*/
     50Object* Penpair::copy() {
     51       
     52        Penpair* penpair=NULL;
     53
     54        penpair=new Penpair();
     55
     56        /*copy fields: */
     57        penpair->id=this->id;
     58        penpair->analysis=this->analysis;
     59
     60        /*now deal with hooks and objects: */
     61        penpair->hnodes.copy(&this->hnodes);
     62
     63        /*recover objects: */
     64        penpair->nodes=(Node**)penpair->hnodes.deliverp();
     65
     66        return penpair;
     67
     68}
     69/*}}}*/
    4770/*FUNCTION Penpair::destructor {{{1*/
    4871Penpair::~Penpair(){
    … …  
    6184}
    6285/*}}}1*/
    63 /*FUNCTION Penpair::copy {{{1*/
    64 Object* Penpair::copy() {
    65         return new Penpair(this->id,&this->hnodes);
    66 }
    67 /*}}}1*/
    6886/*FUNCTION Penpair::DeepEcho {{{1*/
    6987void Penpair::DeepEcho(void){
    … …  
    7189        printf("Penpair:\n");
    7290        printf("   id: %i\n",id);
     91        printf("   analysis_type: %s\n",EnumAsString(analysis_type));
    7392        hnodes.DeepEcho();
    7493
    7594        return;
    7695}               
     96/*}}}1*/
     97/*FUNCTION Penpair::Demarshall {{{1*/
     98void  Penpair::Demarshall(char** pmarshalled_dataset){
     99
     100        int i;
     101        char* marshalled_dataset=NULL;
     102
     103        /*recover marshalled_dataset: */
     104        marshalled_dataset=*pmarshalled_dataset;
     105
     106        /*this time, no need to get enum type, the pointer directly points to the beginning of the
     107         *object data (thanks to DataSet::Demarshall):*/
     108        memcpy(&id,marshalled_dataset,sizeof(id));marshalled_dataset+=sizeof(id);
     109        memcpy(&analysis_type,marshalled_dataset,sizeof(analysis_type));marshalled_dataset+=sizeof(analysis_type);
     110
     111        /*demarshall hooks: */
     112        hnodes.Demarshall(&marshalled_dataset);
     113
     114        /*return: */
     115        *pmarshalled_dataset=marshalled_dataset;
     116        return;
     117}
    77118/*}}}1*/
    78119/*FUNCTION Penpair::Echo {{{1*/
    … …  
    83124        printf("Penpair:\n");
    84125        printf("   id: %i\n",id);
     126        printf("   analysis_type: %s\n",EnumAsString(analysis_type));
    85127        hnodes.Echo();
    86128       
    87129        return;
    88130}
     131/*}}}1*/
     132/*FUNCTION Penpair::Enum {{{1*/
     133int Penpair::Enum(void){
     134
     135        return PenpairEnum;
     136}
     137/*}}}1*/
     138/*FUNCTION Penpair::Id {{{1*/
     139int    Penpair::Id(void){ return id; }
    89140/*}}}1*/
    90141/*FUNCTION Penpair::Marshall {{{1*/
    … …  
    105156        /*marshall Penpair data: */
    106157        memcpy(marshalled_dataset,&id,sizeof(id));marshalled_dataset+=sizeof(id);
     158        memcpy(marshalled_dataset,&analysis_type,sizeof(analysis_type));marshalled_dataset+=sizeof(analysis_type);
    107159
    108160        /*Marshall hooks*/
    … …  
    117169
    118170        return sizeof(id)+
     171                +sizeof(analysis_type)
    119172                +hnodes.MarshallSize()
    120173                +sizeof(int); //sizeof(int) for enum type
    121174}
    122 /*}}}1*/
    123 /*FUNCTION Penpair::Demarshall {{{1*/
    124 void  Penpair::Demarshall(char** pmarshalled_dataset){
    125 
    126         int i;
    127         char* marshalled_dataset=NULL;
    128 
    129         /*recover marshalled_dataset: */
    130         marshalled_dataset=*pmarshalled_dataset;
    131 
    132         /*this time, no need to get enum type, the pointer directly points to the beginning of the
    133          *object data (thanks to DataSet::Demarshall):*/
    134 
    135         memcpy(&id,marshalled_dataset,sizeof(id));marshalled_dataset+=sizeof(id);
    136 
    137         /*demarshall hooks: */
    138         hnodes.Demarshall(&marshalled_dataset);
    139 
    140         /*return: */
    141         *pmarshalled_dataset=marshalled_dataset;
    142         return;
    143 }
    144 /*}}}1*/
    145 
    146 /*Object functions*/
    147 /*FUNCTION Penpair::CreateKMatrix {{{1*/
    148 
    149 void  Penpair::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
    150 
    151         /*No loads applied, do nothing: */
    152         return;
    153 
    154 }
    155 /*}}}1*/
    156 /*FUNCTION Penpair::CreatePVector {{{1*/
    157 void  Penpair::CreatePVector(Vec pg, int analysis_type,int sub_analysis_type){
    158 
    159         /*No loads applied, do nothing: */
    160         return;
    161 
    162 }
    163 /*}}}1*/
    164 /*FUNCTION Penpair::Enum {{{1*/
    165 int Penpair::Enum(void){
    166 
    167         return PenpairEnum;
    168 }
    169 /*}}}1*/
    170 /*FUNCTION Penpair::Id {{{1*/
    171 int    Penpair::Id(void){ return id; }
    172175/*}}}1*/
    173176/*FUNCTION Penpair::MyRank {{{1*/
    … …  
    177180}
    178181/*}}}1*/
     182
     183/*Object functions*/
     184/*FUNCTION Penpair::CreateKMatrix {{{1*/
     185
     186void  Penpair::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     187
     188        /*No loads applied, do nothing: */
     189        return;
     190
     191}
     192/*}}}1*/
     193/*FUNCTION Penpair::CreatePVector {{{1*/
     194void  Penpair::CreatePVector(Vec pg, int analysis_type,int sub_analysis_type){
     195
     196        /*No loads applied, do nothing: */
     197        return;
     198
     199}
     200/*}}}1*/
    179201/*FUNCTION Penpair::PenaltyCreateKMatrix {{{1*/
    180202void  Penpair::PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type){

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

    r4004 r4007  
    1717
    1818        private:
    19 
    2019                int             id;
     20                int analysis_type;
    2121               
    2222                Hook hnodes;  //hook to 2 nodes
    … …  
    2424        public:
    2525
     26                /*constructors: {{{1*/
    2627                Penpair();
    27                 Penpair(int penpair_id,int* penpair_node_ids);
    28                 Penpair(int penpair_id,Hook* penpair_hnodes);
     28                Penpair(int penpair_id,int* penpair_node_ids,int analysis_type);
     29                Penpair(int penpair_id,Hook* penpair_hnodes,int analysis_type);
    2930                ~Penpair();
    30 
     31                Object* copy();
     32                /*}}}*/
     33                /*object management: {{{1*/
     34                void  Configure(DataSet* elements,DataSet* loads,DataSet* nodes,DataSet* vertices,DataSet* materials,Parameters* parameters);
     35                void  DeepEcho();
     36                void  Demarshall(char** pmarshalled_dataset);
    3137                void  Echo();
    32                 void  DeepEcho();
     38                int   Enum();
     39                int   Id();
    3340                void  Marshall(char** pmarshalled_dataset);
    3441                int   MarshallSize();
    35                 void  Demarshall(char** pmarshalled_dataset);
    36                 int   Enum();
    37                 int   Id();
    3842                int   MyRank();
    39                 void  Configure(DataSet* elements,DataSet* loads,DataSet* nodes,DataSet* vertices,DataSet* materials,Parameters* parameters);
     43                void  UpdateInputsFromVector(double* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     44                void  UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     45                void  UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
     46                void  UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
     47                void  UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
     48                void  UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
     49                void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
     50                bool  InAnalysis(int analysis_type);
     51                /*}}}*/
     52                /*numerics: {{{1*/
    4053                void  CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type);
    4154                void  CreatePVector(Vec pg, int analysis_type,int sub_analysis_type);
    4255                void  PenaltyCreateKMatrix(Mat Kgg,double kmax,int analysis_type,int sub_analysis_type);
    4356                void  PenaltyCreatePVector(Vec pg,double kmax,int analysis_type,int sub_analysis_type);
    44                 Object* copy();
    45                 void    UpdateInputsFromVector(double* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    46                 void    UpdateInputsFromVector(int* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    47                 void    UpdateInputsFromVector(bool* vector, int name, int type){ISSMERROR("Not implemented yet!");}
    48                 void    UpdateInputsFromConstant(double constant, int name){ISSMERROR("Not implemented yet!");}
    49                 void    UpdateInputsFromConstant(int constant, int name){ISSMERROR("Not implemented yet!");}
    50                 void    UpdateInputsFromConstant(bool constant, int name){ISSMERROR("Not implemented yet!");}
    51                 void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    52                 bool    InAnalysis(int analysis_type);
    53 
    54 
     57                /*}}}*/
    5558};
    5659
Note: See TracChangeset for help on using the changeset viewer.