Changeset 3565


Ignore:
Timestamp:
04/16/10 16:12:02 (15 years ago)
Author:
Mathieu Morlighem
Message:

Fixed Discontinuous Galerkin speed problem

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

Legend:

Unmodified
Added
Removed

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

    r3529 r3565  
    4242                int            Enum();
    4343
    44                
    4544};
    4645#endif

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

    r3463 r3565  
    154154void  Numericalflux::CreateKMatrix(Mat Kgg,void* inputs,int analysis_type,int sub_analysis_type){
    155155
    156         /*No stiffness loads applied, do nothing: */
    157         return;
    158 
    159 }
    160 /*}}}*/
    161 /*FUNCTION Numericalflux::CreatePVector {{{1*/
    162 void  Numericalflux::CreatePVector(Vec pg, void* inputs, int analysis_type,int sub_analysis_type){
    163 
    164         /*No stiffness loads applied, do nothing: */
    165         return;
    166 }
    167 /*}}}*/
    168 /*FUNCTION Numericalflux::DeepEcho {{{1*/
    169 void Numericalflux::DeepEcho(void){
    170 
    171         int i;
    172        
    173         printf("Numericalflux:\n");
    174         printf("   type: %s\n",type);
    175         printf("   id: %i\n",id);
    176        
    177         printf("   element_id=%i\n",element_id);
    178         printf("   element_offset=%i\n",element_offset);
    179         if(element)element->Echo();
    180156        if (strcmp(type,"internal")==0){
    181                 printf("   node_ids=[%i,%i,%i,%i]\n",node_ids[0],node_ids[1],node_ids[2],node_ids[3]);
    182                 printf("   node_offsets=[%i,%i,%i,%i]\n",node_offsets[0],node_offsets[1],node_offsets[2],node_offsets[3]);
    183                 for(i=0;i<4;i++){
    184                         if(nodes[i])nodes[i]->Echo();
    185                 }
    186         }
    187         else{
    188                 printf("   node_ids=[%i,%i,%i,%i]\n",node_ids[0],node_ids[1],node_ids[2],node_ids[3]);
    189                 printf("   node_offsets=[%i,%i,%i,%i]\n",node_offsets[0],node_offsets[1],node_offsets[2],node_offsets[3]);
    190                 for(i=0;i<2;i++){
    191                         if(nodes[i])nodes[i]->Echo();
    192                 }
    193         }
    194         return;
    195 }               
    196 /*}}}*/
    197 /*FUNCTION Numericalflux::DistributeNumDofs {{{1*/
    198 void  Numericalflux::DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type){
    199         return;
    200 }
    201 /*}}}*/
    202 /*FUNCTION Numericalflux::Echo {{{1*/
    203 void Numericalflux::Echo(void){
    204 
    205         printf("Numericalflux:\n");
    206         printf("   type: %s\n",type);
    207         printf("   id: %i\n",id);
    208 
    209         printf("   element_id=%i\n",element_id);
    210         printf("   element_offset=%i]\n",element_offset);
    211 
    212         if (strcmp(type,"internal")==0){
    213                 printf("   node_ids=[%i,%i,%i,%i]\n",node_ids[0],node_ids[1],node_ids[2],node_ids[3]);
    214                 printf("   node_offsets=[%i,%i,%i,%i]\n",node_offsets[0],node_offsets[1],node_offsets[2],node_offsets[3]);
    215         }
    216         else{
    217                 printf("   node_ids=[%i,%i]\n",node_ids[0],node_ids[1]);
    218                 printf("   node_offsets=[%i,%i]\n",node_offsets[0],node_offsets[1]);
    219         }
    220 
    221         return;
    222 }
    223 /*}}}*/
    224 /*FUNCTION Numericalflux::Enum {{{1*/
    225 int Numericalflux::Enum(void){
    226 
    227         return NumericalfluxEnum();
    228 
    229 }
    230 /*}}}*/
    231 /*FUNCTION Numericalflux::GetB {{{1*/
    232 void Numericalflux::GetB(double* B, double gauss_coord){
    233 
    234         const int numgrids=4;
    235         double l1l4[numgrids];
    236 
    237         /*Get nodal functions: */
    238         GetNodalFunctions(&l1l4[0],gauss_coord);
    239 
    240         /*Build B: */
    241         B[0] = +l1l4[0];
    242         B[1] = +l1l4[1];
    243         B[2] = -l1l4[0];
    244         B[3] = -l1l4[1];
    245 }
    246 /*}}}*/
    247 /*FUNCTION Numericalflux::GetDofList{{{1*/
    248 
    249 void  Numericalflux::GetDofList(int* doflist,int* pnumberofdofspernode){
    250 
    251         int i,j;
    252         int doflist_per_node[MAXDOFSPERNODE];
    253         int numberofdofspernode;
    254        
    255         if (strcmp(type,"internal")==0){
    256                 for(i=0;i<4;i++){
    257                         nodes[i]->GetDofList(&doflist_per_node[0],&numberofdofspernode);
    258                         for(j=0;j<numberofdofspernode;j++){
    259                                 doflist[i*numberofdofspernode+j]=doflist_per_node[j];
    260                         }
    261                 }
     157
     158                CreateKMatrixInternal(Kgg,inputs,analysis_type,sub_analysis_type);
    262159        }
    263160        else if (strcmp(type,"boundary")==0){
    264                 for(i=0;i<2;i++){
    265                         nodes[i]->GetDofList(&doflist_per_node[0],&numberofdofspernode);
    266                         for(j=0;j<numberofdofspernode;j++){
    267                                 doflist[i*numberofdofspernode+j]=doflist_per_node[j];
    268                         }
    269                 }
    270         }
    271         else ISSMERROR(exprintf("type %s not supported yet",type));
    272 
    273         /*Assign output pointers:*/
    274         *pnumberofdofspernode=numberofdofspernode;
    275 }
    276 /*}}}*/
    277 /*FUNCTION Numericalflux::GetId {{{1*/
    278 int    Numericalflux::GetId(void){
    279         return id;
    280 }
    281 /*}}}*/
    282 /*FUNCTION Numericalflux::GetJacobianDeterminant{{{1*/
    283 void Numericalflux::GetJacobianDeterminant(double* pJdet,double xyz_list[4][3], double gauss_coord){
    284 
    285         double Jdet,length;
    286 
    287         length=sqrt(pow(xyz_list[1][0] - xyz_list[0][0],2.0) + pow(xyz_list[1][1] - xyz_list[0][1],2.0));
    288         Jdet=1.0/2.0*length;
    289 
    290         if(Jdet<0){
    291                 ISSMERROR(" negative jacobian determinant!");
    292         }
    293 
    294         *pJdet=Jdet;
    295 }
    296 /*}}}*/
    297 /*FUNCTION Numericalflux::GetL {{{1*/
    298 void Numericalflux::GetL(double* L, double gauss_coord, int numdof){
    299 
    300         const int numgrids=4;
    301         double l1l4[numgrids];
    302 
    303         /*Check numdof*/
    304         ISSMASSERT(numdof==2 || numdof==4);
    305 
    306         /*Get nodal functions: */
    307         GetNodalFunctions(&l1l4[0],gauss_coord);
    308 
    309         /*Luild L: */
    310         L[0] = l1l4[0];
    311         L[1] = l1l4[1];
    312         if (numdof==4){
    313                 L[2] = l1l4[2];
    314                 L[3] = l1l4[3];
    315         }
    316 }
    317 /*}}}*/
    318 /*FUNCTION Numericalflux::GetName {{{1*/
    319 char* Numericalflux::GetName(void){
    320         return "numericalflux";
    321 }
    322 /*}}}*/
    323 /*FUNCTION Numericalflux::GetNodalFunctions{{{1*/
    324 void Numericalflux::GetNodalFunctions(double* l1l4, double gauss_coord){
    325 
    326         /*This routine returns the values of the nodal functions  at the gaussian point.*/
    327 
    328         l1l4[0]=-0.5*gauss_coord+0.5;
    329         l1l4[1]=+0.5*gauss_coord+0.5;
    330         l1l4[2]=-0.5*gauss_coord+0.5;
    331         l1l4[3]=+0.5*gauss_coord+0.5;
    332 
    333 }
    334 /*}}}*/
    335 /*FUNCTION Numericalflux::GetNormal {{{1*/
    336 void Numericalflux:: GetNormal(double* normal,double xyz_list[4][3]){
    337 
    338         /*Build unit outward pointing vector*/
    339         const int numgrids=4;
    340         double vector[2];
    341         double norm;
    342 
    343         vector[0]=xyz_list[1][0] - xyz_list[0][0];
    344         vector[1]=xyz_list[1][1] - xyz_list[0][1];
    345 
    346         norm=sqrt(pow(vector[0],2.0)+pow(vector[1],2.0));
    347 
    348         normal[0]= + vector[1]/norm;
    349         normal[1]= - vector[0]/norm;
    350 }
    351 /*}}}*/
    352 /*FUNCTION Numericalflux::GetParameterValue {{{1*/
    353 void Numericalflux::GetParameterValue(double* pp, double* plist, double gauss_coord){
    354 
    355         /*From node values of parameter p (plist[0],plist[1],plist[2]), return parameter value at gaussian
    356          * point specifie by gauss_l1l2l3: */
    357 
    358         /*nodal functions: */
    359         double l1l4[4];
    360 
    361         /*output: */
    362         double p;
    363 
    364         GetNodalFunctions(&l1l4[0],gauss_coord);
    365 
    366         p=l1l4[0]*plist[0]+l1l4[1]*plist[1];
    367 
    368         /*Assign output pointers:*/
    369         *pp=p;
    370 }
    371 /*}}}*/
    372 /*FUNCTION Numericalflux::MyRank {{{1*/
    373 int    Numericalflux::MyRank(void){
    374         extern int my_rank;
    375         return my_rank;
    376 }
    377 /*}}}*/
    378 /*FUNCTION Numericalflux::PenaltyCreateKMatrix {{{1*/
    379 void  Numericalflux::PenaltyCreateKMatrix(Mat Kgg,void* inputs,double kmax,int analysis_type,int sub_analysis_type){
    380 
    381         if (strcmp(type,"internal")==0){
    382 
    383                 PenaltyCreateKMatrixInternal(Kgg,inputs,kmax,analysis_type,sub_analysis_type);
    384         }
    385         else if (strcmp(type,"boundary")==0){
    386 
    387                 PenaltyCreateKMatrixBoundary(Kgg,inputs,kmax,analysis_type,sub_analysis_type);
     161
     162                CreateKMatrixBoundary(Kgg,inputs,analysis_type,sub_analysis_type);
    388163        }
    389164        else ISSMERROR("type not supported yet");
    390 }
    391 /*}}}*/
    392 /*FUNCTION Numericalflux::PenaltyCreateKMatrixInternal {{{1*/
    393 void  Numericalflux::PenaltyCreateKMatrixInternal(Mat Kgg,void* vinputs,double kmax,int analysis_type,int sub_analysis_type){
    394         double   start, finish;
    395         start=MPI_Wtime();
     165
     166}
     167/*}}}*/
     168/*FUNCTION Numericalflux::CreateKMatrixInternal {{{1*/
     169void  Numericalflux::CreateKMatrixInternal(Mat Kgg,void* vinputs,int analysis_type,int sub_analysis_type){
    396170
    397171        /* local declarations */
    … …  
    494268
    495269        /*Add Ke_gg to global matrix Kgg: */
    496         start=MPI_Wtime();
    497270        MatSetValues(Kgg,numdof,doflist,numdof,doflist,(const double*)Ke_gg,ADD_VALUES);
    498         finish=MPI_Wtime();
    499         //printf("internal inserting K of edge %i matrix: %g\n",id,finish-start);
    500271
    501272        xfree((void**)&gauss_coords);
    … …  
    503274}
    504275/*}}}*/
    505 /*FUNCTION Numericalflux::PenaltyCreateKMatrixBoundary {{{1*/
    506 void  Numericalflux::PenaltyCreateKMatrixBoundary(Mat Kgg,void* vinputs,double kmax,int analysis_type,int sub_analysis_type){
    507         double   start, finish;
    508         start=MPI_Wtime();
     276/*FUNCTION Numericalflux::CreateKMatrixBoundary {{{1*/
     277void  Numericalflux::CreateKMatrixBoundary(Mat Kgg,void* vinputs,int analysis_type,int sub_analysis_type){
    509278
    510279        /* local declarations */
    … …  
    609378
    610379        /*Add Ke_gg to global matrix Kgg: */
    611         start=MPI_Wtime();
    612380        MatSetValues(Kgg,numdof,doflist,numdof,doflist,(const double*)Ke_gg,ADD_VALUES);
    613         finish=MPI_Wtime();
    614         //printf("boundary inserting K of edge %i matrix: %g\n",id,finish-start);
    615381
    616382        xfree((void**)&gauss_coords);
    … …  
    619385}
    620386/*}}}*/
    621 /*FUNCTION Numericalflux::PenaltyCreatePVector{{{1*/
    622 void  Numericalflux::PenaltyCreatePVector(Vec pg,void* inputs,double kmax,int analysis_type,int sub_analysis_type){
     387/*FUNCTION Numericalflux::CreatePVector {{{1*/
     388void  Numericalflux::CreatePVector(Vec pg, void* inputs, int analysis_type,int sub_analysis_type){
    623389
    624390        if (strcmp(type,"internal")==0){
    625391
    626                 PenaltyCreatePVectorInternal(pg,inputs,kmax,analysis_type,sub_analysis_type);
     392                CreatePVectorInternal(pg,inputs,analysis_type,sub_analysis_type);
    627393        }
    628394        else if (strcmp(type,"boundary")==0){
    629395
    630                 PenaltyCreatePVectorBoundary(pg,inputs,kmax,analysis_type,sub_analysis_type);
     396                CreatePVectorBoundary(pg,inputs,analysis_type,sub_analysis_type);
    631397        }
    632398        else ISSMERROR("type not supported yet");
    633 }
    634 /*}}}*/
    635 /*FUNCTION Numericalflux::PenaltyCreatePVectorInternal{{{1*/
    636 void  Numericalflux::PenaltyCreatePVectorInternal(Vec pg,void* inputs,double kmax,int analysis_type,int sub_analysis_type){
     399
     400}
     401/*}}}*/
     402/*FUNCTION Numericalflux::CreatePVectorInternal{{{1*/
     403void  Numericalflux::CreatePVectorInternal(Vec pg,void* inputs,int analysis_type,int sub_analysis_type){
    637404
    638405        /*Nothing added to PVector*/
    … …  
    641408}
    642409/*}}}*/
    643 /*FUNCTION Numericalflux::PenaltyCreatePVectorBoundary{{{1*/
    644 void  Numericalflux::PenaltyCreatePVectorBoundary(Vec pg,void* vinputs,double kmax,int analysis_type,int sub_analysis_type){
     410/*FUNCTION Numericalflux::CreatePVectorBoundary{{{1*/
     411void  Numericalflux::CreatePVectorBoundary(Vec pg,void* vinputs,int analysis_type,int sub_analysis_type){
    645412
    646413        /* local declarations */
    … …  
    745512}
    746513/*}}}*/
     514/*FUNCTION Numericalflux::DeepEcho {{{1*/
     515void Numericalflux::DeepEcho(void){
     516
     517        int i;
     518       
     519        printf("Numericalflux:\n");
     520        printf("   type: %s\n",type);
     521        printf("   id: %i\n",id);
     522       
     523        printf("   element_id=%i\n",element_id);
     524        printf("   element_offset=%i\n",element_offset);
     525        if(element)element->Echo();
     526        if (strcmp(type,"internal")==0){
     527                printf("   node_ids=[%i,%i,%i,%i]\n",node_ids[0],node_ids[1],node_ids[2],node_ids[3]);
     528                printf("   node_offsets=[%i,%i,%i,%i]\n",node_offsets[0],node_offsets[1],node_offsets[2],node_offsets[3]);
     529                for(i=0;i<4;i++){
     530                        if(nodes[i])nodes[i]->Echo();
     531                }
     532        }
     533        else{
     534                printf("   node_ids=[%i,%i,%i,%i]\n",node_ids[0],node_ids[1],node_ids[2],node_ids[3]);
     535                printf("   node_offsets=[%i,%i,%i,%i]\n",node_offsets[0],node_offsets[1],node_offsets[2],node_offsets[3]);
     536                for(i=0;i<2;i++){
     537                        if(nodes[i])nodes[i]->Echo();
     538                }
     539        }
     540        return;
     541}               
     542/*}}}*/
     543/*FUNCTION Numericalflux::DistributeNumDofs {{{1*/
     544void  Numericalflux::DistributeNumDofs(int* numdofspernode,int analysis_type,int sub_analysis_type){
     545        return;
     546}
     547/*}}}*/
     548/*FUNCTION Numericalflux::Echo {{{1*/
     549void Numericalflux::Echo(void){
     550
     551        printf("Numericalflux:\n");
     552        printf("   type: %s\n",type);
     553        printf("   id: %i\n",id);
     554
     555        printf("   element_id=%i\n",element_id);
     556        printf("   element_offset=%i]\n",element_offset);
     557
     558        if (strcmp(type,"internal")==0){
     559                printf("   node_ids=[%i,%i,%i,%i]\n",node_ids[0],node_ids[1],node_ids[2],node_ids[3]);
     560                printf("   node_offsets=[%i,%i,%i,%i]\n",node_offsets[0],node_offsets[1],node_offsets[2],node_offsets[3]);
     561        }
     562        else{
     563                printf("   node_ids=[%i,%i]\n",node_ids[0],node_ids[1]);
     564                printf("   node_offsets=[%i,%i]\n",node_offsets[0],node_offsets[1]);
     565        }
     566
     567        return;
     568}
     569/*}}}*/
     570/*FUNCTION Numericalflux::Enum {{{1*/
     571int Numericalflux::Enum(void){
     572
     573        return NumericalfluxEnum();
     574
     575}
     576/*}}}*/
     577/*FUNCTION Numericalflux::GetB {{{1*/
     578void Numericalflux::GetB(double* B, double gauss_coord){
     579
     580        const int numgrids=4;
     581        double l1l4[numgrids];
     582
     583        /*Get nodal functions: */
     584        GetNodalFunctions(&l1l4[0],gauss_coord);
     585
     586        /*Build B: */
     587        B[0] = +l1l4[0];
     588        B[1] = +l1l4[1];
     589        B[2] = -l1l4[0];
     590        B[3] = -l1l4[1];
     591}
     592/*}}}*/
     593/*FUNCTION Numericalflux::GetDofList{{{1*/
     594
     595void  Numericalflux::GetDofList(int* doflist,int* pnumberofdofspernode){
     596
     597        int i,j;
     598        int doflist_per_node[MAXDOFSPERNODE];
     599        int numberofdofspernode;
     600       
     601        if (strcmp(type,"internal")==0){
     602                for(i=0;i<4;i++){
     603                        nodes[i]->GetDofList(&doflist_per_node[0],&numberofdofspernode);
     604                        for(j=0;j<numberofdofspernode;j++){
     605                                doflist[i*numberofdofspernode+j]=doflist_per_node[j];
     606                        }
     607                }
     608        }
     609        else if (strcmp(type,"boundary")==0){
     610                for(i=0;i<2;i++){
     611                        nodes[i]->GetDofList(&doflist_per_node[0],&numberofdofspernode);
     612                        for(j=0;j<numberofdofspernode;j++){
     613                                doflist[i*numberofdofspernode+j]=doflist_per_node[j];
     614                        }
     615                }
     616        }
     617        else ISSMERROR(exprintf("type %s not supported yet",type));
     618
     619        /*Assign output pointers:*/
     620        *pnumberofdofspernode=numberofdofspernode;
     621}
     622/*}}}*/
     623/*FUNCTION Numericalflux::GetId {{{1*/
     624int    Numericalflux::GetId(void){
     625        return id;
     626}
     627/*}}}*/
     628/*FUNCTION Numericalflux::GetJacobianDeterminant{{{1*/
     629void Numericalflux::GetJacobianDeterminant(double* pJdet,double xyz_list[4][3], double gauss_coord){
     630
     631        double Jdet,length;
     632
     633        length=sqrt(pow(xyz_list[1][0] - xyz_list[0][0],2.0) + pow(xyz_list[1][1] - xyz_list[0][1],2.0));
     634        Jdet=1.0/2.0*length;
     635
     636        if(Jdet<0){
     637                ISSMERROR(" negative jacobian determinant!");
     638        }
     639
     640        *pJdet=Jdet;
     641}
     642/*}}}*/
     643/*FUNCTION Numericalflux::GetL {{{1*/
     644void Numericalflux::GetL(double* L, double gauss_coord, int numdof){
     645
     646        const int numgrids=4;
     647        double l1l4[numgrids];
     648
     649        /*Check numdof*/
     650        ISSMASSERT(numdof==2 || numdof==4);
     651
     652        /*Get nodal functions: */
     653        GetNodalFunctions(&l1l4[0],gauss_coord);
     654
     655        /*Luild L: */
     656        L[0] = l1l4[0];
     657        L[1] = l1l4[1];
     658        if (numdof==4){
     659                L[2] = l1l4[2];
     660                L[3] = l1l4[3];
     661        }
     662}
     663/*}}}*/
     664/*FUNCTION Numericalflux::GetName {{{1*/
     665char* Numericalflux::GetName(void){
     666        return "numericalflux";
     667}
     668/*}}}*/
     669/*FUNCTION Numericalflux::GetNodalFunctions{{{1*/
     670void Numericalflux::GetNodalFunctions(double* l1l4, double gauss_coord){
     671
     672        /*This routine returns the values of the nodal functions  at the gaussian point.*/
     673
     674        l1l4[0]=-0.5*gauss_coord+0.5;
     675        l1l4[1]=+0.5*gauss_coord+0.5;
     676        l1l4[2]=-0.5*gauss_coord+0.5;
     677        l1l4[3]=+0.5*gauss_coord+0.5;
     678
     679}
     680/*}}}*/
     681/*FUNCTION Numericalflux::GetNormal {{{1*/
     682void Numericalflux:: GetNormal(double* normal,double xyz_list[4][3]){
     683
     684        /*Build unit outward pointing vector*/
     685        const int numgrids=4;
     686        double vector[2];
     687        double norm;
     688
     689        vector[0]=xyz_list[1][0] - xyz_list[0][0];
     690        vector[1]=xyz_list[1][1] - xyz_list[0][1];
     691
     692        norm=sqrt(pow(vector[0],2.0)+pow(vector[1],2.0));
     693
     694        normal[0]= + vector[1]/norm;
     695        normal[1]= - vector[0]/norm;
     696}
     697/*}}}*/
     698/*FUNCTION Numericalflux::GetParameterValue {{{1*/
     699void Numericalflux::GetParameterValue(double* pp, double* plist, double gauss_coord){
     700
     701        /*From node values of parameter p (plist[0],plist[1],plist[2]), return parameter value at gaussian
     702         * point specifie by gauss_l1l2l3: */
     703
     704        /*nodal functions: */
     705        double l1l4[4];
     706
     707        /*output: */
     708        double p;
     709
     710        GetNodalFunctions(&l1l4[0],gauss_coord);
     711
     712        p=l1l4[0]*plist[0]+l1l4[1]*plist[1];
     713
     714        /*Assign output pointers:*/
     715        *pp=p;
     716}
     717/*}}}*/
     718/*FUNCTION Numericalflux::MyRank {{{1*/
     719int    Numericalflux::MyRank(void){
     720        extern int my_rank;
     721        return my_rank;
     722}
     723/*}}}*/
     724/*FUNCTION Numericalflux::PenaltyCreateKMatrix {{{1*/
     725void  Numericalflux::PenaltyCreateKMatrix(Mat Kgg,void* inputs,double kmax,int analysis_type,int sub_analysis_type){
     726
     727        /*No stiffness loads applied, do nothing: */
     728        return;
     729
     730}
     731/*}}}*/
     732/*FUNCTION Numericalflux::PenaltyCreatePVector{{{1*/
     733void  Numericalflux::PenaltyCreatePVector(Vec pg,void* inputs,double kmax,int analysis_type,int sub_analysis_type){
     734
     735        /*No penalty loads applied, do nothing: */
     736        return;
     737
     738}
     739/*}}}*/
    747740/*FUNCTION Numericalflux::UpdateFromInputs {{{1*/
    748741void  Numericalflux::UpdateFromInputs(void* vinputs){

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

    r3463 r3565  
    6161               
    6262                void  CreateKMatrix(Mat Kgg,void* inputs,int analysis_type,int sub_analysis_type);
     63                void  CreateKMatrixInternal(Mat Kgg,void* inputs,int analysis_type,int sub_analysis_type);
     64                void  CreateKMatrixBoundary(Mat Kgg,void* inputs,int analysis_type,int sub_analysis_type);
    6365                void  CreatePVector(Vec pg, void* inputs, int analysis_type,int sub_analysis_type);
     66                void  CreatePVectorInternal(Vec pg,void* inputs,int analysis_type,int sub_analysis_type);
     67                void  CreatePVectorBoundary(Vec pg,void* inputs,int analysis_type,int sub_analysis_type);
    6468                void  PenaltyCreateKMatrix(Mat Kgg,void* inputs,double kmax,int analysis_type,int sub_analysis_type);
    65                 void  PenaltyCreateKMatrixInternal(Mat Kgg,void* inputs,double kmax,int analysis_type,int sub_analysis_type);
    66                 void  PenaltyCreateKMatrixBoundary(Mat Kgg,void* inputs,double kmax,int analysis_type,int sub_analysis_type);
    6769                void  PenaltyCreatePVector(Vec pg,void* inputs,double kmax,int analysis_type,int sub_analysis_type);
    68                 void  PenaltyCreatePVectorInternal(Vec pg,void* inputs,double kmax,int analysis_type,int sub_analysis_type);
    69                 void  PenaltyCreatePVectorBoundary(Vec pg,void* inputs,double kmax,int analysis_type,int sub_analysis_type);
     70
    7071};
    7172
Note: See TracChangeset for help on using the changeset viewer.