Changeset 5937


Ignore:
Timestamp:
09/22/10 08:50:58 (15 years ago)
Author:
Mathieu Morlighem
Message:

more element matrices and vectors

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

Legend:

Unmodified
Added
Removed
  • issm/trunk/src/c/objects/Loads/Pengrid.cpp

    r5936 r5937  
    435435
    436436/*Pengrid management:*/
    437 /*FUNCTION Pengrid::GetDofList {{{1*/
    438 void  Pengrid::GetDofList(int** pdoflist,int approximation,int setenum){
    439 
    440         int  i,j;
    441         int  numberofdofs=0;
    442 
    443         /*output: */
    444         int* doflist=NULL;
    445 
    446         /*Some checks for debugging*/
    447         ISSMASSERT(node);
    448 
    449         /*First, figure out size of doflist: */
    450         numberofdofs=node->GetNumberOfDofs(approximation,setenum);
    451 
    452         /*Allocate: */
    453         doflist=(int*)xmalloc(numberofdofs*sizeof(int));
    454 
    455         /*Populate: */
    456         node->GetDofList(doflist,approximation,setenum);
    457 
    458         /*Assign output pointers:*/
    459         *pdoflist=doflist;
    460 }
    461 /*}}}*/
    462437/*FUNCTION Pengrid::PenaltyConstrain {{{1*/
    463438void  Pengrid::PenaltyConstrain(int* punstable){
  • issm/trunk/src/c/objects/Loads/Pengrid.h

    r5936 r5937  
    7878                /*}}}*/
    7979                /*Pengrid management {{{1*/
    80                 void  GetDofList(int** pdoflist,int approximation_enum,int setenum);
    8180                ElementMatrix* PenaltyCreateKMatrixDiagnosticStokes(double kmax);
    8281                ElementMatrix* PenaltyCreateKMatrixThermal(double kmax);
  • issm/trunk/src/c/objects/Loads/Penpair.cpp

    r5772 r5937  
    33 */
    44
    5 
     5/*Headers*/
     6/*{{{1*/
    67#ifdef HAVE_CONFIG_H
    7         #include "config.h"
     8#include "config.h"
    89#else
    910#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
     
    1617#include "../../include/include.h"
    1718#include "../../shared/shared.h"
    18                
     19/*}}}*/
     20
     21/*Element macros*/
     22#define NUMVERTICES 2
     23#define NDOF1 1
     24#define NDOF2 2
     25#define NDOF3 3
     26#define NDOF4 4
     27
    1928/*Penpair constructors and destructor*/
    2029/*FUNCTION Penpair::constructor {{{1*/
     
    201210/*FUNCTION Penpair::PenaltyCreateKMatrix {{{1*/
    202211void  Penpair::PenaltyCreateKMatrix(Mat Kgg,Mat Kff, Mat Kfs,double kmax){
     212
     213        /*Retrieve parameters: */
     214        ElementMatrix* Ke=NULL;
    203215        int analysis_type;
    204 
    205         /*Retrieve parameters: */
    206216        this->parameters->FindParam(&analysis_type,AnalysisTypeEnum);
    207217
    208         if (analysis_type==DiagnosticHorizAnalysisEnum){
    209                 Node** nodes=NULL;
    210                 int approximation0,approximation1;
    211                 nodes=(Node**)hnodes->deliverp();
    212                 approximation0=nodes[0]->GetApproximation();
    213                 approximation1=nodes[1]->GetApproximation();
    214 
    215                 switch(approximation0){
    216                         case MacAyealApproximationEnum:
    217                                 switch(approximation1){
    218                                         case MacAyealApproximationEnum: PenaltyCreateKMatrixDiagnosticHoriz(Kgg,kmax); break;
    219                                         case PattynApproximationEnum:   PenaltyCreateKMatrixDiagnosticHoriz(Kgg,kmax); break;
    220                                         default: ISSMERROR("not supported yet");
    221                                 }
    222                                 break;
    223                         case PattynApproximationEnum:
    224                                 switch(approximation1){
    225                                         case MacAyealApproximationEnum: PenaltyCreateKMatrixDiagnosticHoriz(Kgg,kmax); break;
    226                                         case PattynApproximationEnum:   PenaltyCreateKMatrixDiagnosticHoriz(Kgg,kmax); break;
    227                                         default: ISSMERROR("not supported yet");
    228                                 }
    229                                 break;
    230                         case StokesApproximationEnum:
    231                                 switch(approximation1){
    232                                         case StokesApproximationEnum: PenaltyCreateKMatrixDiagnosticStokes(Kgg,kmax); break;
    233                                         case NoneApproximationEnum: PenaltyCreateKMatrixDiagnosticStokes(Kgg,kmax); break;
    234                                         default: ISSMERROR("not supported yet");
    235                                 }
    236                                 break;
    237                         case NoneApproximationEnum:
    238                                 switch(approximation1){
    239                                         case StokesApproximationEnum: PenaltyCreateKMatrixDiagnosticStokes(Kgg,kmax); break;
    240                                         case NoneApproximationEnum: PenaltyCreateKMatrixDiagnosticStokes(Kgg,kmax); break;
    241                                         default: ISSMERROR("not supported yet");
    242                                 }
    243                                 break;
    244                         default: ISSMERROR("not supported yet");
    245                 }
     218        switch(analysis_type){
     219                case DiagnosticHorizAnalysisEnum:
     220                        Ke=PenaltyCreateKMatrixDiagnosticHoriz(kmax);
     221                        break;
     222                default:
     223                        ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
    246224        }
    247         else{
    248                 ISSMERROR("analysis %i (%s) not supported yet",analysis_type,EnumToString(analysis_type));
     225
     226        /*Add to global Vector*/
     227        if(Ke){
     228                Ke->AddToGlobal(Kgg,Kff,Kfs);
     229                delete Ke;
    249230        }
    250231}
     
    281262
    282263/*Penpair management:*/
    283 /*FUNCTION Penpair::PenaltyCreateKMatrixDiagnosticHoriz {{{1*/
    284 void  Penpair::PenaltyCreateKMatrixDiagnosticHoriz(Mat Kgg,double kmax){
    285        
    286         const int numgrids=2;
    287         const int NDOF2=2;
    288         const int numdof=numgrids*NDOF2;
    289         int*         doflist=NULL;
    290         int       numberofdofspernode;
    291 
    292         double Ke[4][4]={0.0};
     264/*FUNCTION Penpair::PenaltyCreateKMatrixDiagnosticHoriz{{{1*/
     265ElementMatrix* Penpair::PenaltyCreateKMatrixDiagnosticHoriz(double kmax){
     266
     267        Node** nodes=(Node**)hnodes->deliverp();
     268        int    approximation0=nodes[0]->GetApproximation();
     269        int    approximation1=nodes[1]->GetApproximation();
     270
     271        switch(approximation0){
     272                case MacAyealApproximationEnum:
     273                        switch(approximation1){
     274                                case MacAyealApproximationEnum: return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
     275                                case PattynApproximationEnum:   return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
     276                                default: ISSMERROR("not supported yet");
     277                        }
     278                case PattynApproximationEnum:
     279                        switch(approximation1){
     280                                case MacAyealApproximationEnum: return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
     281                                case PattynApproximationEnum:   return PenaltyCreateKMatrixDiagnosticMacAyealPattyn(kmax);
     282                                default: ISSMERROR("not supported yet");
     283                        }
     284                case StokesApproximationEnum:
     285                        switch(approximation1){
     286                                case StokesApproximationEnum: return PenaltyCreateKMatrixDiagnosticStokes(kmax);
     287                                case NoneApproximationEnum: return   PenaltyCreateKMatrixDiagnosticStokes(kmax);
     288                                default: ISSMERROR("not supported yet");
     289                        }
     290                case NoneApproximationEnum:
     291                        switch(approximation1){
     292                                case StokesApproximationEnum: return PenaltyCreateKMatrixDiagnosticStokes(kmax);
     293                                case NoneApproximationEnum: return   PenaltyCreateKMatrixDiagnosticStokes(kmax);
     294                                default: ISSMERROR("not supported yet");
     295                        }
     296                default: ISSMERROR("not supported yet");
     297        }
     298}
     299/*}}}1*/
     300/*FUNCTION Penpair::PenaltyCreateKMatrixDiagnosticMacAyealPattyn {{{1*/
     301ElementMatrix* Penpair::PenaltyCreateKMatrixDiagnosticMacAyealPattyn(double kmax){
     302       
     303        const int numdof=NUMVERTICES*NDOF2;
    293304        double penalty_offset;
    294305
    295         /*pointers: */
    296         Node** nodes=NULL;
    297 
    298         /*Get dof list: */
    299         GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
    300 
    301306        /*recover pointers: */
    302         nodes=(Node**)hnodes->deliverp();
     307        Node** nodes=(Node**)hnodes->deliverp();
     308
     309        /*Initialize Element vector and return if necessary*/
     310        ElementMatrix* Ke=NewElementMatrix(nodes,NUMVERTICES,this->parameters);
    303311
    304312        /*recover parameters: */
     
    306314
    307315        //Create elementary matrix: add penalty to
    308         Ke[0][0]=kmax*pow((double)10.0,penalty_offset);
    309         Ke[0][2]=-kmax*pow((double)10.0,penalty_offset);
    310         Ke[2][0]=-kmax*pow((double)10.0,penalty_offset);
    311         Ke[2][2]=kmax*pow((double)10.0,penalty_offset);
    312 
    313         Ke[1][1]=kmax*pow((double)10.0,penalty_offset);
    314         Ke[1][3]=-kmax*pow((double)10.0,penalty_offset);
    315         Ke[3][1]=-kmax*pow((double)10.0,penalty_offset);
    316         Ke[3][3]=kmax*pow((double)10.0,penalty_offset);
    317        
    318         /*Add Ke to global matrix Kgg: */
    319         MatSetValues(Kgg,numdof,doflist,numdof,doflist,(const double*)Ke,ADD_VALUES);
    320        
    321         /*Free ressources:*/
    322         xfree((void**)&doflist);
    323 
     316        Ke->values[0*numdof+0]=+kmax*pow((double)10.0,penalty_offset);
     317        Ke->values[0*numdof+2]=-kmax*pow((double)10.0,penalty_offset);
     318        Ke->values[2*numdof+0]=-kmax*pow((double)10.0,penalty_offset);
     319        Ke->values[2*numdof+2]=+kmax*pow((double)10.0,penalty_offset);
     320
     321        Ke->values[1*numdof+1]=+kmax*pow((double)10.0,penalty_offset);
     322        Ke->values[1*numdof+3]=-kmax*pow((double)10.0,penalty_offset);
     323        Ke->values[3*numdof+1]=-kmax*pow((double)10.0,penalty_offset);
     324        Ke->values[3*numdof+3]=+kmax*pow((double)10.0,penalty_offset);
     325
     326        /*Clean up and return*/
     327        return Ke;
    324328}
    325329/*}}}1*/
    326330/*FUNCTION Penpair::PenaltyCreateKMatrixDiagnosticStokes {{{1*/
    327 void  Penpair::PenaltyCreateKMatrixDiagnosticStokes(Mat Kgg,double kmax){
    328        
    329         const int numgrids=2;
    330         const int NDOF3=4;
    331         const int numdof=numgrids*NDOF3;
    332         int*      doflist=NULL;
    333         int       numberofdofspernode;
    334 
    335         double Ke[8][8]={0.0};
     331ElementMatrix* Penpair::PenaltyCreateKMatrixDiagnosticStokes(double kmax){
     332       
     333        const int numdof=NUMVERTICES*NDOF4;
    336334        double penalty_offset;
    337335
    338         /*pointers: */
    339         Node** nodes=NULL;
    340 
    341         /*Get dof list: */
    342         GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
    343 
    344336        /*recover pointers: */
    345         nodes=(Node**)hnodes->deliverp();
     337        Node** nodes=(Node**)hnodes->deliverp();
     338
     339        /*Initialize Element vector and return if necessary*/
     340        ElementMatrix* Ke=NewElementMatrix(nodes,NUMVERTICES,this->parameters);
    346341
    347342        /*recover parameters: */
     
    349344
    350345        //Create elementary matrix: add penalty to
    351         Ke[0][0]=kmax*pow((double)10.0,penalty_offset);
    352         Ke[0][4]=-kmax*pow((double)10.0,penalty_offset);
    353         Ke[4][0]=-kmax*pow((double)10.0,penalty_offset);
    354         Ke[4][4]=kmax*pow((double)10.0,penalty_offset);
    355 
    356         Ke[1][1]=kmax*pow((double)10.0,penalty_offset);
    357         Ke[1][5]=-kmax*pow((double)10.0,penalty_offset);
    358         Ke[5][1]=-kmax*pow((double)10.0,penalty_offset);
    359         Ke[5][5]=kmax*pow((double)10.0,penalty_offset);
    360        
    361         Ke[2][2]=kmax*pow((double)10.0,penalty_offset);
    362         Ke[2][6]=-kmax*pow((double)10.0,penalty_offset);
    363         Ke[6][2]=-kmax*pow((double)10.0,penalty_offset);
    364         Ke[6][6]=kmax*pow((double)10.0,penalty_offset);
    365 
    366         Ke[3][3]=kmax*pow((double)10.0,penalty_offset);
    367         Ke[3][7]=-kmax*pow((double)10.0,penalty_offset);
    368         Ke[7][3]=-kmax*pow((double)10.0,penalty_offset);
    369         Ke[7][7]=kmax*pow((double)10.0,penalty_offset);
    370 
    371         /*Add Ke to global matrix Kgg: */
    372         MatSetValues(Kgg,numdof,doflist,numdof,doflist,(const double*)Ke,ADD_VALUES);
    373        
    374         /*Free ressources:*/
    375         xfree((void**)&doflist);
    376 
    377 }
    378 /*}}}1*/
    379 /*FUNCTION Penpair::GetDofList {{{1*/
    380 void  Penpair::GetDofList(int** pdoflist,int approximation,int setenum){
    381 
    382         int i,j;
    383         int numberofdofs=0;
    384         int count=0;
    385 
    386         /*output: */
    387         int* doflist=NULL;
    388 
    389         /*pointers: */
    390         Node** nodes=NULL;
    391 
    392         /*recover pointers: */
    393         nodes=(Node**)hnodes->deliverp();
    394 
    395         /*Some checks for debugging*/
    396         ISSMASSERT(nodes);
    397 
    398         /*First, figure out size of doflist: */
    399         for(i=0;i<2;i++){
    400                 numberofdofs+=nodes[i]->GetNumberOfDofs(approximation,setenum);
    401         }
    402 
    403         /*Allocate: */
    404         doflist=(int*)xmalloc(numberofdofs*sizeof(int));
    405 
    406         /*Populate: */
    407         count=0;
    408         for(i=0;i<2;i++){
    409                 nodes[i]->GetDofList(doflist+count,approximation,setenum);
    410                 count+=nodes[i]->GetNumberOfDofs(approximation,setenum);
    411         }
    412 
    413         /*Assign output pointers:*/
    414         *pdoflist=doflist;
    415 }
    416 /*}}}*/
     346        Ke->values[0*numdof+0]=+kmax*pow((double)10.0,penalty_offset);
     347        Ke->values[0*numdof+4]=-kmax*pow((double)10.0,penalty_offset);
     348        Ke->values[4*numdof+0]=-kmax*pow((double)10.0,penalty_offset);
     349        Ke->values[4*numdof+4]=+kmax*pow((double)10.0,penalty_offset);
     350
     351        Ke->values[1*numdof+1]=+kmax*pow((double)10.0,penalty_offset);
     352        Ke->values[1*numdof+5]=-kmax*pow((double)10.0,penalty_offset);
     353        Ke->values[5*numdof+1]=-kmax*pow((double)10.0,penalty_offset);
     354        Ke->values[5*numdof+5]=+kmax*pow((double)10.0,penalty_offset);
     355       
     356        Ke->values[2*numdof+2]=+kmax*pow((double)10.0,penalty_offset);
     357        Ke->values[2*numdof+6]=-kmax*pow((double)10.0,penalty_offset);
     358        Ke->values[6*numdof+2]=-kmax*pow((double)10.0,penalty_offset);
     359        Ke->values[6*numdof+6]=+kmax*pow((double)10.0,penalty_offset);
     360
     361        Ke->values[3*numdof+3]=+kmax*pow((double)10.0,penalty_offset);
     362        Ke->values[3*numdof+7]=-kmax*pow((double)10.0,penalty_offset);
     363        Ke->values[7*numdof+3]=-kmax*pow((double)10.0,penalty_offset);
     364        Ke->values[7*numdof+7]=+kmax*pow((double)10.0,penalty_offset);
     365
     366        /*Clean up and return*/
     367        return Ke;
     368}
     369/*}}}1*/
  • issm/trunk/src/c/objects/Loads/Penpair.h

    r5772 r5937  
    6464                /*}}}*/
    6565                        /*Penpair management: {{{1*/
    66                 void  PenaltyCreateKMatrixDiagnosticHoriz(Mat Kgg,double kmax);
    67                 void  PenaltyCreateKMatrixDiagnosticStokes(Mat Kgg,double kmax);
    68                 void  GetDofList(int** pdoflist,int approximation_enum,int setenum);
     66                ElementMatrix* PenaltyCreateKMatrixDiagnosticHoriz(double kmax);
     67                ElementMatrix* PenaltyCreateKMatrixDiagnosticMacAyealPattyn(double kmax);
     68                ElementMatrix* PenaltyCreateKMatrixDiagnosticStokes(double kmax);
    6969                /*}}}*/
    7070};
Note: See TracChangeset for help on using the changeset viewer.