Changeset 3623


Ignore:
Timestamp:
04/27/10 08:27:35 (15 years ago)
Author:
Eric.Larour
Message:

Pengrid

Location:
issm/trunk/src/c/objects
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r3621 r3623  
    3434/*}}}1*/
    3535/*FUNCTION Pengrid::Pengrid(int id, int node_ids int matpar_id){{{1*/
    36 Pengrid::Pengrid(int pengrid_id,int pengrid_node_id, int pengrid_matpar_id):
    37         hnode(pengrid_node_ids,1),
     36Pengrid::Pengrid(int pengrid_id,int pengrid_node_id, int pengrid_element_id,int pengrid_matpar_id):
     37        hnode(pengrid_node_id,1),
     38        helement(pengrid_element_id,1),
    3839        hmatice(&pengrid_matice_id,1),
    3940        hmatpar(&pengrid_matpar_id,1)
    … …  
    5253/*}}}*/
    5354/*FUNCTION Pengrid::Pengrid(int id, Hook* hnodes, Hook* hmatice, Hook* hmatpar, DataSet* parameters, Inputs* pengrid_inputs) {{{1*/
    54 Pengrid::Pengrid(int pengrid_id,Hook* pengrid_hnode, Hook* pengrid_hmatpar, Parameters* pengrid_parameters, Inputs* pengrid_inputs):
     55Pengrid::Pengrid(int pengrid_id,Hook* pengrid_hnode, Hook* pengrid_helement,Hook* pengrid_hmatpar, Parameters* pengrid_parameters, Inputs* pengrid_inputs):
    5556        hnode(pengrid_hnode),
     57        helement(pengrid_helement),
    5658        hmatpar(pengrid_hmatpar)
    5759{
    … …  
    9496}
    9597/*}}}1*/
    96 /*FUNCTION Pengrid::Pengrid(int i, IoModel* iomodel){{{1*/
    97 Pengrid::Pengrid(int index, IoModel* iomodel){ //i is the element index
     98/*FUNCTION Pengrid::Pengrid(int index, int id, IoModel* iomodel){{{1*/
     99Pengrid::Pengrid(int id, int index, IoModel* iomodel){ //i is the element index
    98100
    99101        int i,j;
    100         int tria_node_ids[3];
    101         int tria_matice_id;
    102         int tria_matpar_id;
    103         double nodeinputs[3];
     102        int pengrid_node_id;
     103        int pengrid_matpar_id;
     104        int pengrid_element_id;
    104105
    105106        /*id: */
    106         this->id=index+1;
     107        this->id=id;
    107108       
    108109        /*hooks: */
    109         //go recover node ids, needed to initialize the node hook.
    110         if (iomodel->analysis_type==Prognostic2AnalysisEnum || iomodel->analysis_type==Balancedthickness2AnalysisEnum){
    111                 /*Discontinuous Galerkin*/
    112                 tria_node_ids[0]=3*index+1;
    113                 tria_node_ids[1]=3*index+2;
    114                 tria_node_ids[2]=3*index+3;
    115         }
    116         else{
    117                 /*Continuous Galerkin*/
    118                 for(i=0;i<3;i++){
    119                         tria_node_ids[i]=(int)*(iomodel->elements+3*index+i); //ids for vertices are in the elements array from Matlab
    120                 }
    121         }
    122         tria_matice_id=index+1; //refers to the corresponding ice material object
    123         tria_matpar_id=iomodel->numberofelements+1; //refers to the constant material parameters object
    124 
    125         this->hnodes.Init(tria_node_ids,3);
    126         this->hmatice.Init(&tria_matice_id,1);
    127         this->hmatpar.Init(&tria_matpar_id,1);
    128 
    129         //intialize inputs, and add as many inputs per element as requested:
     110        pengrid_node_id=index+1;
     111        pengrid_element_id=iomodel->singlenodetoelementconnectivity[index];
     112        pengrid_matpar_id=iomodel->numberofelements+1; //refers to the constant material parameters object
     113
     114        this->hnode.Init(pengrid_node_ids,1);
     115        this->helement.Init(pengrid_element_id,1);
     116        this->hmatpar.Init(&pengrid_matpar_id,1);
     117
     118        //initialize inputs: none needed
    130119        this->inputs=new Inputs();
    131        
    132         if (iomodel->thickness) {
    133                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->thickness[tria_node_ids[i]-1];
    134                 this->inputs->AddInput(new PengridVertexInput(ThicknessEnum,nodeinputs));
    135         }
    136         if (iomodel->surface) {
    137                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->surface[tria_node_ids[i]-1];
    138                 this->inputs->AddInput(new PengridVertexInput(SurfaceEnum,nodeinputs));
    139         }
    140         if (iomodel->bed) {
    141                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->bed[tria_node_ids[i]-1];
    142                 this->inputs->AddInput(new PengridVertexInput(BedEnum,nodeinputs));
    143         }
    144         if (iomodel->drag_coefficient) {
    145                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->drag_coefficient[tria_node_ids[i]-1];
    146                 this->inputs->AddInput(new PengridVertexInput(DragCoefficientEnum,nodeinputs));
    147 
    148                 if (iomodel->drag_p) this->inputs->AddInput(new DoubleInput(DragPEnum,iomodel->drag_p[index]));
    149                 if (iomodel->drag_q) this->inputs->AddInput(new DoubleInput(DragQEnum,iomodel->drag_q[index]));
    150                 this->inputs->AddInput(new IntInput(DragTypeEnum,iomodel->drag_type));
    151 
    152         }
    153         if (iomodel->melting_rate) {
    154                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->melting_rate[tria_node_ids[i]-1];
    155                 this->inputs->AddInput(new PengridVertexInput(MeltingRateEnum,nodeinputs));
    156         }
    157         if (iomodel->accumulation_rate) {
    158                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->accumulation_rate[tria_node_ids[i]-1];
    159                 this->inputs->AddInput(new PengridVertexInput(AccumulationRateEnum,nodeinputs));
    160         }
    161         if (iomodel->geothermalflux) {
    162                 for(i=0;i<3;i++)nodeinputs[i]=iomodel->geothermalflux[tria_node_ids[i]-1];
    163                 this->inputs->AddInput(new PengridVertexInput(GeothermalFluxEnum,nodeinputs));
    164         }       
    165 
    166         if (iomodel->elementoniceshelf) this->inputs->AddInput(new BoolInput(ElementOnIceShelfEnum,(IssmBool)iomodel->elementoniceshelf[index]));
    167         if (iomodel->elementonbed) this->inputs->AddInput(new BoolInput(ElementOnBedEnum,(IssmBool)iomodel->elementonbed[index]));
    168         if (iomodel->elementonwater) this->inputs->AddInput(new BoolInput(ElementOnWaterEnum,(IssmBool)iomodel->elementonwater[index]));
    169         if (iomodel->elementonsurface) this->inputs->AddInput(new BoolInput(ElementOnSurfaceEnum,(IssmBool)iomodel->elementonsurface[index]));
    170120
    171121        //this->parameters: we still can't point to it, it may not even exist. Configure will handle this.
    172122        this->parameters=NULL;
    173123
     124        //let's not forget internals
     125        this->active=0;
     126        this->zigzag_counter=0;
    174127
    175128}
    … …  
    181134/*}}}1*/
    182135               
    183 /*Object marshall*/
    184 /*FUNCTION Pengrid::Marshall {{{1*/
    185 void  Pengrid::Marshall(char** pmarshalled_dataset){
     136/*Object management*/
     137/*FUNCTION Pengrid::Configure {{{1*/
     138void  Pengrid::Configure(DataSet* elementsin, DataSet* nodesin, DataSet* materialsin, Parameters* parametersin){
     139
     140        /*Take care of hooking up all objects for this load, ie links the objects in the hooks to their respective
     141         * datasets, using internal ids and offsets hidden in hooks: */
     142        hnode.configure(nodesin);
     143        helement.configure(elementsin);
     144        hmatpar.configure(materialsin);
     145
     146        /*point parameters to real dataset: */
     147        this->parameters=parametersin;
     148}
     149/*}}}1*/
     150/*FUNCTION Pengrid::copy {{{1*/
     151Object* Pengrid::copy() {
     152        return new Pengrid(this->id,&this->hnode,&this->helement,&this->hmatpar,this->parameters,this->inputs);
     153}
     154/*}}}1*/
     155/*FUNCTION Pengrid::DeepEcho{{{1*/
     156void Pengrid::DeepEcho(void){
     157
     158        printf("Pengrid:\n");
     159        printf("   id: %i\n",id);
     160        hnode.DeepEcho();
     161        helement.DeepEcho();
     162        hmatpar.DeepEcho();
     163        printf("   active %i\n",this->active);
     164        printf("   zigzag_counter %i\n",this->zigzag_counter);
     165        printf("   parameters\n");
     166        parameters->DeepEcho();
     167        printf("   inputs\n");
     168        inputs->DeepEcho();
     169}
     170/*}}}*/
     171/*FUNCTION Pengrid::Demarshall {{{1*/
     172void  Pengrid::Demarshall(char** pmarshalled_dataset){
    186173
    187174        char* marshalled_dataset=NULL;
    188         int   enum_type=0;
     175        int   i;
    189176
    190177        /*recover marshalled_dataset: */
    191178        marshalled_dataset=*pmarshalled_dataset;
    192179
    193         /*get enum type of Pengrid: */
    194         enum_type=PengridEnum;
    195        
    196         /*marshall enum: */
    197         memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
    198        
    199         /*marshall Pengrid data: */
    200         memcpy(marshalled_dataset,&id,sizeof(id));marshalled_dataset+=sizeof(id);
    201         memcpy(marshalled_dataset,&mparid,sizeof(mparid));marshalled_dataset+=sizeof(mparid);
    202         memcpy(marshalled_dataset,&dof,sizeof(dof));marshalled_dataset+=sizeof(dof);
    203         memcpy(marshalled_dataset,&active,sizeof(active));marshalled_dataset+=sizeof(active);
    204         memcpy(marshalled_dataset,&penalty_offset,sizeof(penalty_offset));marshalled_dataset+=sizeof(penalty_offset);
    205         memcpy(marshalled_dataset,&thermal_steadystate,sizeof(thermal_steadystate));marshalled_dataset+=sizeof(thermal_steadystate);
    206         memcpy(marshalled_dataset,&node_id,sizeof(node_id));marshalled_dataset+=sizeof(node_id);
    207         memcpy(marshalled_dataset,&node_offset,sizeof(node_offset));marshalled_dataset+=sizeof(node_offset);
    208         memcpy(marshalled_dataset,&matpar,sizeof(matpar));marshalled_dataset+=sizeof(matpar);
    209         memcpy(marshalled_dataset,&matpar_offset,sizeof(matpar_offset));marshalled_dataset+=sizeof(matpar_offset);
    210         memcpy(marshalled_dataset,&stabilize_constraints,sizeof(stabilize_constraints));marshalled_dataset+=sizeof(stabilize_constraints);
    211         memcpy(marshalled_dataset,&zigzag_counter,sizeof(zigzag_counter));marshalled_dataset+=sizeof(zigzag_counter);
    212 
    213         *pmarshalled_dataset=marshalled_dataset;
    214         return;
    215 }
    216 /*}}}1*/
    217 /*FUNCTION Pengrid::MarshallSize {{{1*/
    218 int   Pengrid::MarshallSize(){
    219 
    220         return sizeof(id)+
    221                 sizeof(mparid)+
    222                 sizeof(dof)+
    223                 sizeof(active)+
    224                 sizeof(penalty_offset)+
    225                 sizeof(thermal_steadystate)+
    226                 sizeof(node_id)+
    227                 sizeof(node_offset)+
    228                 sizeof(matpar)+
    229                 sizeof(matpar_offset)+
    230                 sizeof(stabilize_constraints)+
    231                 sizeof(zigzag_counter)+
    232                 sizeof(int); //sizeof(int) for enum type
    233 }
    234 /*}}}1*/
    235 /*FUNCTION Pengrid::Demarshall {{{1*/
    236 void  Pengrid::Demarshall(char** pmarshalled_dataset){
    237 
    238         char* marshalled_dataset=NULL;
    239 
    240         /*recover marshalled_dataset: */
    241         marshalled_dataset=*pmarshalled_dataset;
    242 
    243180        /*this time, no need to get enum type, the pointer directly points to the beginning of the
    244181         *object data (thanks to DataSet::Demarshall):*/
    245182
    246183        memcpy(&id,marshalled_dataset,sizeof(id));marshalled_dataset+=sizeof(id);
    247         memcpy(&mparid,marshalled_dataset,sizeof(mparid));marshalled_dataset+=sizeof(mparid);
    248         memcpy(&dof,marshalled_dataset,sizeof(dof));marshalled_dataset+=sizeof(dof);
    249184        memcpy(&active,marshalled_dataset,sizeof(active));marshalled_dataset+=sizeof(active);
    250         memcpy(&penalty_offset,marshalled_dataset,sizeof(penalty_offset));marshalled_dataset+=sizeof(penalty_offset);
    251         memcpy(&thermal_steadystate,marshalled_dataset,sizeof(thermal_steadystate));marshalled_dataset+=sizeof(thermal_steadystate);
    252         memcpy(&node_id,marshalled_dataset,sizeof(node_id));marshalled_dataset+=sizeof(node_id);
    253         memcpy(&node_offset,marshalled_dataset,sizeof(node_offset));marshalled_dataset+=sizeof(node_offset);
    254         memcpy(&matpar,marshalled_dataset,sizeof(matpar));marshalled_dataset+=sizeof(matpar);
    255         memcpy(&matpar_offset,marshalled_dataset,sizeof(matpar_offset));marshalled_dataset+=sizeof(matpar_offset);
    256         memcpy(&stabilize_constraints,marshalled_dataset,sizeof(stabilize_constraints));marshalled_dataset+=sizeof(stabilize_constraints);
    257185        memcpy(&zigzag_counter,marshalled_dataset,sizeof(zigzag_counter));marshalled_dataset+=sizeof(zigzag_counter);
    258186
    259         node=NULL;
    260         matpar=NULL;
     187        /*demarshall hooks: */
     188        hnode.Demarshall(&marshalled_dataset);
     189        helement.Demarshall(&marshalled_dataset);
     190        hmatpar.Demarshall(&marshalled_dataset);
     191       
     192        /*demarshall inputs: */
     193        inputs=(Inputs*)DataSetDemarshallRaw(&marshalled_dataset);
     194
     195        /*parameters: may not exist even yet, so let Configure handle it: */
     196        this->parameters=NULL;
    261197
    262198        /*return: */
    … …  
    264200        return;
    265201}
    266 /*}}}1*/
    267 
    268 /*Object functions*/
    269 /*FUNCTION Pengrid::copy {{{1*/
    270 Object* Pengrid::copy() {
    271         return new Pengrid(*this);
    272 }
    273 /*}}}1*/
    274 /*FUNCTION Pengrid::Configure {{{1*/
    275 
    276 void  Pengrid::Configure(void* pelementsin,void* pnodesin,void* pmaterialsin){
    277 
    278         DataSet* nodesin=NULL;
    279         DataSet* materialsin=NULL;
    280 
    281         /*Recover pointers :*/
    282         nodesin=(DataSet*)pnodesin;
    283         materialsin=(DataSet*)pmaterialsin;
    284 
    285         /*Link this load with its nodes: */
    286         ResolvePointers((Object**)&node,&node_id,&node_offset,1,nodesin);
    287         ResolvePointers((Object**)&matpar,&mparid,&matpar_offset,1,materialsin);
    288 }
    289 /*}}}1*/
    290 /*FUNCTION Pengrid::CreateKMatrix {{{1*/
    291 
    292 void  Pengrid::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
    293 
    294         /*No loads applied, do nothing: */
    295         return;
    296 
    297 }
    298 /*}}}1*/
    299 /*FUNCTION Pengrid::CreatePVector {{{1*/
    300 void  Pengrid::CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type){
    301 
    302         /*No loads applied, do nothing: */
    303         return;
    304 
    305 }
    306 /*}}}1*/
    307 /*FUNCTION Pengrid::DeepEcho {{{1*/
    308 void Pengrid::DeepEcho(void){
    309 
    310         printf("Pengrid:\n");
    311         printf("   id: %i\n",id);
    312         printf("   mparid: %i\n",mparid);
    313         printf("   dof: %i\n",dof);
    314         printf("   active: %i\n",active);
    315         printf("   penalty_offset: %g\n",penalty_offset);
    316         printf("   thermal_steadystate: %i\n",thermal_steadystate);
    317         printf("   node_id: [%i]\n",node_id);
    318         printf("   node_offset: [%i]\n",node_offset);
    319         printf("   matpar_offset=%i\n",matpar_offset);
    320        
    321         if(node)node->Echo();
    322         if(matpar)matpar->Echo();
    323         return;
    324 }               
    325 /*}}}1*/
    326 /*FUNCTION Pengrid::DistributenumDofs {{{1*/
    327 void  Pengrid::DistributeNumDofs(int* numdofpernode,int analysis_type,int sub_analysis_type){return;}
    328 /*}}}1*/
     202/*}}}*/
    329203/*FUNCTION Pengrid::Echo {{{1*/
    330204void Pengrid::Echo(void){
    331 
    332         printf("Pengrid:\n");
    333         printf("   id: %i\n",id);
    334         printf("   mparid: %i\n",mparid);
    335         printf("   dof: %i\n",dof);
    336         printf("   active: %i\n",active);
    337         printf("   penalty_offset: %g\n",penalty_offset);
    338         printf("   thermal_steadystate: %i\n",thermal_steadystate);
    339         printf("   node_id: [%i]\n",node_id);
    340         printf("   node_offset: [%i]\n",node_offset);
    341         printf("   matpar_offset=%i\n",matpar_offset);
    342        
    343         return;
     205        this->DeepEcho();
    344206}
    345207/*}}}1*/
    … …  
    348210
    349211        return PengridEnum;
    350 }
    351 /*}}}1*/
    352 /*FUNCTION Pengrid::GetDofList {{{1*/
    353 void  Pengrid::GetDofList(int* doflist,int* pnumberofdofspernode){
    354 
    355         int j;
    356         int doflist_per_node[MAXDOFSPERNODE];
    357         int numberofdofspernode;
    358        
    359         node->GetDofList(&doflist_per_node[0],&numberofdofspernode);
    360         for(j=0;j<numberofdofspernode;j++){
    361                 doflist[j]=doflist_per_node[j];
    362         }
    363 
    364         /*Assign output pointers:*/
    365         *pnumberofdofspernode=numberofdofspernode;
    366212}
    367213/*}}}1*/
    … …  
    374220}
    375221/*}}}1*/
     222/*FUNCTION Pengrid::Marshall {{{1*/
     223void  Pengrid::Marshall(char** pmarshalled_dataset){
     224
     225        char* marshalled_dataset=NULL;
     226        int   enum_type=0;
     227        char* marshalled_inputs=NULL;
     228        int   marshalled_inputs_size;
     229
     230        /*recover marshalled_dataset: */
     231        marshalled_dataset=*pmarshalled_dataset;
     232
     233        /*get enum type of Tria: */
     234        enum_type=PengridEnum;
     235
     236        /*marshall enum: */
     237        memcpy(marshalled_dataset,&enum_type,sizeof(enum_type));marshalled_dataset+=sizeof(enum_type);
     238
     239        /*marshall Tria data: */
     240        memcpy(marshalled_dataset,&id,sizeof(id));marshalled_dataset+=sizeof(id);
     241        memcpy(marshalled_dataset,&active,sizeof(active));marshalled_dataset+=sizeof(active);
     242        memcpy(marshalled_dataset,&zigzag_counter,sizeof(zigzag_counter));marshalled_dataset+=sizeof(zigzag_counter);
     243
     244        /*Marshall hooks: */
     245        hnode.Marshall(&marshalled_dataset);
     246        helement.Marshall(&marshalled_dataset);
     247        hmatpar.Marshall(&marshalled_dataset);
     248
     249        /*Marshall inputs: */
     250        marshalled_inputs_size=inputs->MarshallSize();
     251        marshalled_inputs=inputs->Marshall();
     252        memcpy(marshalled_dataset,marshalled_inputs,marshalled_inputs_size*sizeof(char));
     253        marshalled_dataset+=marshalled_inputs_size;
     254
     255        /*parameters: don't do anything about it. parameters are marshalled somewhere else!*/
     256
     257        xfree((void**)&marshalled_inputs);
     258
     259        *pmarshalled_dataset=marshalled_dataset;
     260        return;
     261}
     262/*}}}*/
     263/*FUNCTION Pengrid::MarshallSize {{{1*/
     264int   Pengrid::MarshallSize(){
     265       
     266        return sizeof(id)
     267                +sizeof(active)
     268                +sizeof(zigzag_counter)
     269                +hnode.MarshallSize()
     270                +helement.MarshallSize()
     271                +hmatpar.MarshallSize()
     272                +inputs->MarshallSize()
     273                +sizeof(int); //sizeof(int) for enum type
     274}
     275/*}}}*/
    376276/*FUNCTION Pengrid::MyRank {{{1*/
    377277int    Pengrid::MyRank(void){
    … …  
    380280}
    381281/*}}}1*/
     282
     283/*Object functions*/
     284/*FUNCTION Pengrid::CreateKMatrix {{{1*/
     285
     286void  Pengrid::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
     287
     288        /*No loads applied, do nothing: */
     289        return;
     290
     291}
     292/*}}}1*/
     293/*FUNCTION Pengrid::CreatePVector {{{1*/
     294void  Pengrid::CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type){
     295
     296        /*No loads applied, do nothing: */
     297        return;
     298
     299}
     300/*}}}1*/
     301/*FUNCTION Pengrid::DistributenumDofs {{{1*/
     302void  Pengrid::DistributeNumDofs(int* numdofpernode,int analysis_type,int sub_analysis_type){return;}
     303/*}}}1*/
     304/*FUNCTION Pengrid::GetDofList {{{1*/
     305void  Pengrid::GetDofList(int* doflist,int* pnumberofdofspernode){
     306
     307        int i,j;
     308        int doflist_per_node[MAXDOFSPERNODE];
     309        int numberofdofspernode;
     310
     311        /*dynamic objects pointed to by hooks: */
     312        Node node=NULL;
     313
     314        /*recover objects from hooks: */
     315        node=(Node**)hnode.deliverp();
     316       
     317        node->GetDofList(&doflist_per_node[0],&numberofdofspernode);
     318        for(j=0;j<numberofdofspernode;j++){
     319                doflist[j]=doflist_per_node[j];
     320        }
     321
     322        /*Assign output pointers:*/
     323        *pnumberofdofspernode=numberofdofspernode;
     324
     325}
     326/*}}}*/
    382327/*FUNCTION Pengrid::PenaltyConstrain {{{1*/
    383328void  Pengrid::PenaltyConstrain(int* punstable,int analysis_type,int sub_analysis_type){
    … …  
    432377                return;
    433378        }
    434 
    435         /*recover pointers: */
    436         inputs=(ParameterInputs*)vinputs;
    437379
    438380        //First recover beta, pressure and temperature vectors;
    … …  
    764706}
    765707/*}}}1*/
    766 /*FUNCTION Pengrid::UpdateFromInputs {{{1*/
    767 void  Pengrid::UpdateFromInputs(void* inputs){
    768        
    769 }
    770 /*}}}1*/
     708
     709/*Updates: */
     710/*FUNCTION Pengrid::UpdateFromDakota {{{1*/
     711void  Pengrid::UpdateFromDakota(void* inputs){
     712        ISSMERROR("not supported yet!");
     713}
     714/*}}}1*/
     715/*FUNCTION Pengrid::UpdateInputs {{{1*/
     716void  Pengrid::UpdateInputs(double* solution, int analysis_type, int sub_analysis_type){
     717        ISSMERROR("not supported yet!");
     718}
     719/*}}}1*/

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

    r3621 r3623  
    1818               
    1919                Hook hnode;  //hook to 1 node
     20                Hook helement;  //hook to 1 element
    2021                Hook hmatpar; //hook to 1 matpar
    2122
    … …  
    3132                /*FUNCTION constructors, destructors {{{1*/
    3233                Pengrid();
    33                 Pengrid(int pengrid_id,int pengrid_node_id int pengrid_matpar_id);
    34                 Pengrid(int pengrid_id,Hook* pengrid_hnode, Hook* pengrid_hmatpar, Parameters* pengrid_parameters, Inputs* pengrid_inputs);
    35                 Pengrid(int i, IoModel* iomodel);
     34                Pengrid(int pengrid_id,int pengrid_node_id, int pengrid_element_id,int pengrid_matpar_id);
     35                Pengrid(int pengrid_id,Hook* pengrid_hnode, Hook* pengrid_helement,Hook* pengrid_hmatpar, Parameters* pengrid_parameters, Inputs* pengrid_inputs);
     36                Pengrid(int index, int id, IoModel* iomodel);
    3637                ~Pengrid();
    3738                /*}}}*/
Note: See TracChangeset for help on using the changeset viewer.