Changeset 3647


Ignore:
Timestamp:
04/30/10 12:38:29 (15 years ago)
Author:
Eric.Larour
Message:

Objects compile

Location:
issm/trunk/src/c
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/DataSet/Inputs.cpp

    r3633 r3647  
    102102}
    103103/*}}}*/
    104 /*FUNCTION Inputs::GetParameterValueAtNode(double* pvalue, Node* node, int enum_type){{{1*/
    105 void Inputs::GetParameterValueAtNode(double* pvalue,Node* node,int enum_type){
     104/*FUNCTION Inputs::GetParameterValue(double* pvalue, Node* node, int enum_type){{{1*/
     105void Inputs::GetParameterValue(double* pvalue,Node* node,int enum_type){
    106106
    107107        /*given a node, instead of a gauss point, we want to recover a value: probably in an element!: */
    … …  
    124124
    125125        /*Ok, we have an input if we made it here, request the input to return the values: */
    126         input->GetParameterValueAtNode(pvalue,node);
     126        input->GetParameterValue(pvalue,node);
     127}
     128/*}}}*/
     129/*FUNCTION Inputs::GetParameterValue(double* pvalue, Node* node1, Node* node2,int enum_type){{{1*/
     130void Inputs::GetParameterValue(double* pvalue,Node* node1, Node* node2,double gauss_coord,int enum_type){
     131
     132        /*given a node, instead of a gauss point, we want to recover a value: probably in an element!: */
     133
     134        vector<Object*>::iterator object;
     135        Input* input=NULL;
     136
     137        /*Go through inputs and check whether any input with the same name is already in: */
     138        for ( object=objects.begin() ; object < objects.end(); object++ ){
     139
     140                input=(Input*)(*object);
     141                if (input->EnumType()==enum_type)break;
     142        }
     143
     144        if (!input){
     145                /*we could not find an input with the correct enum type. No defaults values were provided,
     146                 * error out: */
     147                ISSMERROR("%s%i"," could not find input with enum type ",enum_type);
     148        }
     149
     150        /*Ok, we have an input if we made it here, request the input to return the values: */
     151        input->GetParameterValue(pvalue,node1,node2,gauss_coord);
    127152}
    128153/*}}}*/

  • issm/trunk/src/c/DataSet/Inputs.h

    r3633 r3647  
    2121                /*}}}*/
    2222                /*numerics: {{{1*/
     23                int  AddInput(Input* in_input);
     24               
    2325                void GetParameterValue(bool* pvalue,int enum_type);
    2426                void GetParameterValue(int* pvalue,int enum_type);
    2527                void GetParameterValue(double* pvalue,int enum_type);
    26                 void GetParameterValueAtNode(double* pvalue,Node* node,int enum_type);
     28                void GetParameterValue(double* pvalue,Node* node,int enum_type);
     29                void GetParameterValue(double* pvalue,Node* node1,Node* node2,double gauss_coord,int enum_type);
    2730                void GetParameterValue(double* pvalue,double* gauss,int enum_type);
    2831                void GetParameterValue(double* pvalue,double* gauss,int enum_type,double defaultvalue);
     32               
    2933                void GetParameterValues(double* values,double* gauss_pointers, int numgauss,int enum_type);
    3034                void GetParameterValues(double* values,double* gauss_pointers, int numgauss,int enum_type,double* defaultvalues);
    31                 int  AddInput(Input* in_input);
     35       
    3236                void GetParameterDerivativeValue(double* derivativevalues, double* xyz_list, double* gauss,int enum_type);
    3337                void GetStrainRate(double* epsilon,double* xyz_list, double* gauss, int xenum, int yenum);

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

    r3642 r3647  
    185185        ConvergedEnum,
    186186        SegmentOnIceShelfEnum,
    187         FillEnum
     187        FillEnum,
     188        InternalEnum,
     189        BoundaryEnum
    188190        /*}}}*/
    189191

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

    r3645 r3647  
    5454        this->parameters=numericalflux_parameters;
    5555}
    56 /*}}}*/
    57 /*FUNCTION Numericalflux::Numericalflux(int id, int i, IoModel* iomodel) {{{1*/
     56/*}}}*//*FUNCTION Numericalflux::Numericalflux(int id, int i, IoModel* iomodel) {{{1*/
    5857Numericalflux::Numericalflux(int numericalflux_id,int i, IoModel* iomodel){
    5958
    … …  
    148147}
    149148/*}}}*/
     149
    150150/*FUNCTION Numericalflux::~Numericalflux(){{{1*/
    151151Numericalflux::~Numericalflux(){
    … …  
    288288void  Numericalflux::CreateKMatrix(Mat Kgg,int analysis_type,int sub_analysis_type){
    289289
    290         if (strcmp(type,"internal")==0){
    291 
    292                 CreateKMatrixInternal(Kgg,inputs,analysis_type,sub_analysis_type);
    293         }
    294         else if (strcmp(type,"boundary")==0){
    295 
    296                 CreateKMatrixBoundary(Kgg,inputs,analysis_type,sub_analysis_type);
     290        int type;
     291
     292        /*recover type: */
     293        inputs->GetParameterValue(&type,TypeEnum);
     294
     295        if (type==InternalEnum){
     296
     297                CreateKMatrixInternal(Kgg,analysis_type,sub_analysis_type);
     298        }
     299        else if (type==BoundaryEnum){
     300
     301                CreateKMatrixBoundary(Kgg,analysis_type,sub_analysis_type);
    297302        }
    298303        else ISSMERROR("type not supported yet");
    … …  
    332337
    333338        /*input parameters for structural analysis (diagnostic): */
    334         double vx_list[numgrids]={0.0};
    335         double vy_list[numgrids]={0.0};
    336339        double vx,vy;
    337340        double UdotN;
    338341        double dt;
    339         int    dofs[1]={0};
    340342        int    found;
    341343
    342         ParameterInputs* inputs=NULL;
    343 
    344         /*recover pointers: */
    345         inputs=(ParameterInputs*)vinputs;
    346 
    347         /*recover extra inputs from users, at current convergence iteration: */
    348         found=inputs->Recover("vx_average",&vx_list[0],1,dofs,numgrids,(void**)nodes);
    349         if(!found)ISSMERROR(" could not find vx_average in inputs!");
    350         found=inputs->Recover("vy_average",&vy_list[0],1,dofs,numgrids,(void**)nodes);
    351         if(!found)ISSMERROR(" could not find vy_average in inputs!");
     344        /*dynamic objects pointed to by hooks: */
     345        Node**  nodes=NULL;
     346        Tria**  trias=NULL;
     347
     348        /*recover objects from hooks: */
     349        nodes=(Node**)hnodes.deliverp();
     350        trias=(Tria**)helements.deliverp();
     351
     352        /*recover parameters: */
    352353        if (analysis_type==Prognostic2AnalysisEnum){
    353                 if(!inputs->Recover("dt",&dt))ISSMERROR(" could not find dt in inputs!");
     354                parameters->FindParam(&dt,"dt");
    354355        }
    355356        else if (analysis_type==Balancedthickness2AnalysisEnum){
    … …  
    381382
    382383                //Get vx, vy and v.n
    383                 GetParameterValue(&vx, &vx_list[0],gauss_coord);
    384                 GetParameterValue(&vy, &vy_list[0],gauss_coord);
     384                trias[0]->inputs->GetParameterValue(&vx, nodes[0],nodes[1],gauss_coord,VxAverageEnum);
     385                trias[0]->inputs->GetParameterValue(&vy, nodes[0],nodes[1],gauss_coord,VyAverageEnum);
     386               
    385387                UdotN=vx*normal[0]+vy*normal[1];
    386388                if (fabs(UdotN)<1.0e-9 && analysis_type==Balancedthickness2AnalysisEnum) printf("Edge number %i has a flux very small (u.n = %g ), which could lead to unaccurate results\n",id,UdotN);
    … …  
    447449
    448450        /*input parameters for structural analysis (diagnostic): */
    449         double vx_list[numgrids]={0.0};
    450         double vy_list[numgrids]={0.0};
    451451        double vx,vy;
    452452        double mean_vx;
    … …  
    457457        int    found;
    458458
    459         ParameterInputs* inputs=NULL;
    460 
    461         /*recover pointers: */
    462         inputs=(ParameterInputs*)vinputs;
    463 
    464         /*recover extra inputs from users, at current convergence iteration: */
    465         found=inputs->Recover("vx_average",&vx_list[0],1,dofs,numgrids,(void**)nodes);
    466         if(!found)ISSMERROR(" could not find vx_average in inputs!");
    467         found=inputs->Recover("vy_average",&vy_list[0],1,dofs,numgrids,(void**)nodes);
    468         if(!found)ISSMERROR(" could not find vy_average in inputs!");
     459        /*dynamic objects pointed to by hooks: */
     460        Node**  nodes=NULL;
     461        Tria**  trias=NULL;
     462
     463        /*recover objects from hooks: */
     464        nodes=(Node**)hnodes.deliverp();
     465        trias=(Tria**)helements.deliverp();
     466
     467        /*recover parameters: */
    469468        if (analysis_type==Prognostic2AnalysisEnum){
    470                 if(!inputs->Recover("dt",&dt))ISSMERROR(" could not find dt in inputs!");
     469                parameters->FindParam(&dt,"dt");
    471470        }
    472471        else if (analysis_type==Balancedthickness2AnalysisEnum){
    … …  
    477476                ISSMERROR("analysis_type %i not supported yet");
    478477        }
    479 
     478       
    480479        /* Get node coordinates, dof list and normal vector: */
    481480        GetVerticesCoordinates(&xyz_list[0][0], nodes, numgrids);
    … …  
    484483
    485484        /*Check wether it is an inflow or outflow BC*/
    486         mean_vx=(vx_list[0]+vx_list[1])/2.0;
    487         mean_vy=(vy_list[0]+vy_list[1])/2.0;
     485        trias[0]->inputs->GetParameterValue(&mean_vx, nodes[0],nodes[1],.5,VxAverageEnum);
     486        trias[0]->inputs->GetParameterValue(&mean_vy, nodes[0],nodes[1],.5,VyAverageEnum);
    488487        UdotN=mean_vx*normal[0]+mean_vy*normal[1];
    489488        if (UdotN<=0){
    … …  
    507506
    508507                //Get vx, vy and v.n
    509                 GetParameterValue(&vx, &vx_list[0],gauss_coord);
    510                 GetParameterValue(&vy, &vy_list[0],gauss_coord);
     508                trias[0]->inputs->GetParameterValue(&vx, nodes[0],nodes[1],gauss_coord,VxAverageEnum);
     509                trias[0]->inputs->GetParameterValue(&vy, nodes[0],nodes[1],gauss_coord,VyAverageEnum);
     510
    511511                UdotN=vx*normal[0]+vy*normal[1];
    512512
    … …  
    539539void  Numericalflux::CreatePVector(Vec pg,  int analysis_type,int sub_analysis_type){
    540540
    541         if (strcmp(type,"internal")==0){
    542 
    543                 CreatePVectorInternal(pg,inputs,analysis_type,sub_analysis_type);
    544         }
    545         else if (strcmp(type,"boundary")==0){
    546 
    547                 CreatePVectorBoundary(pg,inputs,analysis_type,sub_analysis_type);
     541        int type;
     542
     543        /*recover type: */
     544        inputs->GetParameterValue(&type,TypeEnum);
     545
     546        if (type==InternalEnum){
     547
     548                CreatePVectorInternal(pg,analysis_type,sub_analysis_type);
     549        }
     550        else if (type==BoundaryEnum){
     551
     552                CreatePVectorBoundary(pg,analysis_type,sub_analysis_type);
    548553        }
    549554        else ISSMERROR("type not supported yet");
    … …  
    588593
    589594        /*input parameters for structural analysis (diagnostic): */
    590         double vx_list[numgrids]={0.0};
    591         double vy_list[numgrids]={0.0};
    592595        double vx,vy;
    593596        double mean_vx;
    … …  
    599602        int    found;
    600603
    601         ParameterInputs* inputs=NULL;
    602 
    603         /*recover pointers: */
    604         inputs=(ParameterInputs*)vinputs;
    605 
    606         /*recover extra inputs from users, at current convergence iteration: */
    607         found=inputs->Recover("vx_average",&vx_list[0],1,dofs,numgrids,(void**)nodes);
    608         if(!found)ISSMERROR(" could not find vx_average in inputs!");
    609         found=inputs->Recover("vy_average",&vy_list[0],1,dofs,numgrids,(void**)nodes);
    610         if(!found)ISSMERROR(" could not find vy_average in inputs!");
     604        /*dynamic objects pointed to by hooks: */
     605        Node**  nodes=NULL;
     606        Tria**  trias=NULL;
     607
     608        /*recover objects from hooks: */
     609        nodes=(Node**)hnodes.deliverp();
     610        trias=(Tria**)helements.deliverp();
     611
     612        /*recover parameters: */
    611613        if (analysis_type==Prognostic2AnalysisEnum){
    612                 if(!inputs->Recover("dt",&dt))ISSMERROR(" could not find dt in inputs!");
     614                parameters->FindParam(&dt,"dt");
    613615        }
    614616        else if (analysis_type==Balancedthickness2AnalysisEnum){
    … …  
    619621                ISSMERROR("analysis_type %i not supported yet");
    620622        }
    621 
     623       
    622624        /* Get node coordinates, dof list and normal vector: */
    623625        GetVerticesCoordinates(&xyz_list[0][0], nodes, numgrids);
    … …  
    626628
    627629        /*Check wether it is an inflow or outflow BC*/
    628         mean_vx=(vx_list[0]+vx_list[1])/2.0;
    629         mean_vy=(vy_list[0]+vy_list[1])/2.0;
     630        trias[0]->inputs->GetParameterValue(&mean_vx, nodes[0],nodes[1],.5,VxAverageEnum);
     631        trias[0]->inputs->GetParameterValue(&mean_vy, nodes[0],nodes[1],.5,VyAverageEnum);
    630632        UdotN=mean_vx*normal[0]+mean_vy*normal[1];
    631633        if (UdotN>0){
    … …  
    649651
    650652                //Get vx, vy and v.n
    651                 GetParameterValue(&vx,       &vx_list[0],gauss_coord);
    652                 GetParameterValue(&vy,       &vy_list[0],gauss_coord);
    653                 GetParameterValue(&thickness,&h[0],      gauss_coord);
     653                trias[0]->inputs->GetParameterValue(&vx, nodes[0],nodes[1],gauss_coord,VxAverageEnum);
     654                trias[0]->inputs->GetParameterValue(&vy, nodes[0],nodes[1],gauss_coord,VyAverageEnum);
     655                trias[0]->inputs->GetParameterValue(&thickness, nodes[0],nodes[1],gauss_coord,ThicknessEnum);
     656
    654657                UdotN=vx*normal[0]+vy*normal[1];
    655658
    … …  
    701704        int doflist_per_node[MAXDOFSPERNODE];
    702705        int numberofdofspernode;
     706
     707        /*dynamic objects pointed to by hooks: */
     708        Node**  nodes=NULL;
     709        int type;
     710
     711        /*recover objects from hooks: */
     712        nodes=(Node**)hnodes.deliverp();
    703713       
    704         if (strcmp(type,"internal")==0){
     714        /*recover type: */
     715        inputs->GetParameterValue(&type,TypeEnum);
     716
     717        if (type==InternalEnum){
    705718                for(i=0;i<4;i++){
    706719                        nodes[i]->GetDofList(&doflist_per_node[0],&numberofdofspernode);
    … …  
    710723                }
    711724        }
    712         else if (strcmp(type,"boundary")==0){
     725        else if (type==BoundaryEnum){
    713726                for(i=0;i<2;i++){
    714727                        nodes[i]->GetDofList(&doflist_per_node[0],&numberofdofspernode);

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

    r3642 r3647  
    2828                Numericalflux(int numericalflux_id,int* numericalflux_node_ids,int numnodes, int* numericalflux_element_ids, int numelements);
    2929                Numericalflux(int numericalflux_id,Hook* numericalflux_hnodes, Hook* numericalflux_helements, Parameters* parameters, Inputs* numericalflux_inputs);
     30                Numericalflux::Numericalflux(int numericalflux_id,int i, IoModel* iomodel);
    3031                ~Numericalflux();
    3132                /*}}}*/

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

    r3632 r3647  
    364364
    365365        //First recover pressure and temperature values, using the element: */
    366         penta->inputs->GetParameterValueAtNode(&pressure,node,PressureEnum);
    367         penta->inputs->GetParameterValueAtNode(&temperature,node,TemperatureEnum);
     366        penta->inputs->GetParameterValue(&pressure,node,PressureEnum);
     367        penta->inputs->GetParameterValue(&temperature,node,TemperatureEnum);
    368368
    369369        //Recover our data:
    … …  
    463463
    464464        //recover slope: */
    465         penta->inputs->GetParameterValueAtNode(&slope[0],node,BedSlopexEnum);
    466         penta->inputs->GetParameterValueAtNode(&slope[1],node,BedSlopeyEnum);
     465        penta->inputs->GetParameterValue(&slope[0],node,BedSlopexEnum);
     466        penta->inputs->GetParameterValue(&slope[1],node,BedSlopeyEnum);
    467467       
    468468        /*recover parameters: */
    … …  
    511511
    512512        //First recover pressure and temperature values, using the element: */
    513         penta->inputs->GetParameterValueAtNode(&pressure,node,PressureEnum);
    514         penta->inputs->GetParameterValueAtNode(&temperature,node,TemperatureEnum);
     513        penta->inputs->GetParameterValue(&pressure,node,PressureEnum);
     514        penta->inputs->GetParameterValue(&temperature,node,TemperatureEnum);
    515515
    516516        /*recover parameters: */
    … …  
    622622
    623623        //First recover pressure and temperature values, using the element: */
    624         penta->inputs->GetParameterValueAtNode(&pressure,node,PressureEnum);
    625         penta->inputs->GetParameterValueAtNode(&temperature,node,TemperatureEnum);
     624        penta->inputs->GetParameterValue(&pressure,node,PressureEnum);
     625        penta->inputs->GetParameterValue(&temperature,node,TemperatureEnum);
    626626        inputs->GetParameterValue(&melting_offset,MeltingOffsetEnum);
    627627        parameters->FindParam(&dt,"dt");
    … …  
    689689
    690690        //First recover pressure  and penalty_offset
    691         penta->inputs->GetParameterValueAtNode(&pressure,node,PressureEnum);
     691        penta->inputs->GetParameterValue(&pressure,node,PressureEnum);
    692692        parameters->FindParam(&penalty_offset,"penalty_offset");
    693693

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

    r3637 r3647  
    338338
    339339        /*First recover velocity: */
    340         tria1->inputs->GetParameterValueAtNode(&vx1,nodes[0],VxEnum);
    341         tria2->inputs->GetParameterValueAtNode(&vx2,nodes[1],VxEnum);
    342         tria1->inputs->GetParameterValueAtNode(&vy1,nodes[0],VyEnum);
    343         tria2->inputs->GetParameterValueAtNode(&vy2,nodes[1],VyEnum);
     340        tria1->inputs->GetParameterValue(&vx1,nodes[0],VxEnum);
     341        tria2->inputs->GetParameterValue(&vx2,nodes[1],VxEnum);
     342        tria1->inputs->GetParameterValue(&vy1,nodes[0],VyEnum);
     343        tria2->inputs->GetParameterValue(&vy2,nodes[1],VyEnum);
    344344
    345345        /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */
    … …  
    478478
    479479        /*recover velocity: */
    480         tria1->inputs->GetParameterValueAtNode(&vx1,nodes[0],VxEnum);
    481         tria2->inputs->GetParameterValueAtNode(&vx2,nodes[1],VxEnum);
    482         tria1->inputs->GetParameterValueAtNode(&vy1,nodes[0],VyEnum);
    483         tria2->inputs->GetParameterValueAtNode(&vy2,nodes[1],VyEnum);
     480        tria1->inputs->GetParameterValue(&vx1,nodes[0],VxEnum);
     481        tria2->inputs->GetParameterValue(&vx2,nodes[1],VxEnum);
     482        tria1->inputs->GetParameterValue(&vy1,nodes[0],VyEnum);
     483        tria2->inputs->GetParameterValue(&vy2,nodes[1],VyEnum);
    484484
    485485        /*Grid 1 faces grid2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */
    … …  
    561561                 
    562562                /*Recover thickness: */
    563                 tria1->inputs->GetParameterValueAtNode(&h[0],nodes[0],ThicknessEnum);
    564                 tria2->inputs->GetParameterValueAtNode(&h[1],nodes[1],ThicknessEnum);
     563                tria1->inputs->GetParameterValue(&h[0],nodes[0],ThicknessEnum);
     564                tria2->inputs->GetParameterValue(&h[1],nodes[1],ThicknessEnum);
    565565
    566566                if (h[0]!=h[1])ISSMERROR(" different thicknesses not supported for rift fronts");
    … …  
    688688
    689689                /*get thickness: */
    690                 tria1->inputs->GetParameterValueAtNode(&h[0],nodes[0],ThicknessEnum);
    691                 tria2->inputs->GetParameterValueAtNode(&h[1],nodes[1],ThicknessEnum);
     690                tria1->inputs->GetParameterValue(&h[0],nodes[0],ThicknessEnum);
     691                tria2->inputs->GetParameterValue(&h[1],nodes[1],ThicknessEnum);
    692692
    693693                if (h[0]!=h[1])ISSMERROR(" different thicknesses not supported for rift fronts");
    694694                thickness=h[0];
    695695
    696                 tria1->inputs->GetParameterValueAtNode(&b[0],nodes[0],BedEnum);
    697                 tria2->inputs->GetParameterValueAtNode(&b[1],nodes[1],BedEnum);
     696                tria1->inputs->GetParameterValue(&b[0],nodes[0],BedEnum);
     697                tria2->inputs->GetParameterValue(&b[1],nodes[1],BedEnum);
    698698
    699699                if (b[0]!=b[1])ISSMERROR(" different beds not supported for rift fronts");
    … …  
    779779
    780780        /*First recover velocity: */
    781         tria1->inputs->GetParameterValueAtNode(&vx1,nodes[0],VxEnum);
    782         tria2->inputs->GetParameterValueAtNode(&vx2,nodes[1],VxEnum);
    783         tria1->inputs->GetParameterValueAtNode(&vy1,nodes[0],VyEnum);
    784         tria2->inputs->GetParameterValueAtNode(&vy2,nodes[1],VyEnum);
     781        tria1->inputs->GetParameterValue(&vx1,nodes[0],VxEnum);
     782        tria2->inputs->GetParameterValue(&vx2,nodes[1],VxEnum);
     783        tria1->inputs->GetParameterValue(&vy1,nodes[0],VyEnum);
     784        tria2->inputs->GetParameterValue(&vy2,nodes[1],VyEnum);
    785785
    786786        /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */
    … …  
    829829
    830830        /*First recover velocity: */
    831         tria1->inputs->GetParameterValueAtNode(&vx1,nodes[0],VxEnum);
    832         tria2->inputs->GetParameterValueAtNode(&vx2,nodes[1],VxEnum);
    833         tria1->inputs->GetParameterValueAtNode(&vy1,nodes[0],VyEnum);
    834         tria2->inputs->GetParameterValueAtNode(&vy2,nodes[1],VyEnum);
     831        tria1->inputs->GetParameterValue(&vx1,nodes[0],VxEnum);
     832        tria2->inputs->GetParameterValue(&vx2,nodes[1],VxEnum);
     833        tria1->inputs->GetParameterValue(&vy1,nodes[0],VyEnum);
     834        tria2->inputs->GetParameterValue(&vy2,nodes[1],VyEnum);
    835835
    836836        /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */
    … …  
    885885
    886886        /*First recover velocity: */
    887         tria1->inputs->GetParameterValueAtNode(&vx1,nodes[0],VxEnum);
    888         tria2->inputs->GetParameterValueAtNode(&vx2,nodes[1],VxEnum);
    889         tria1->inputs->GetParameterValueAtNode(&vy1,nodes[0],VyEnum);
    890         tria2->inputs->GetParameterValueAtNode(&vy2,nodes[1],VyEnum);
     887        tria1->inputs->GetParameterValue(&vx1,nodes[0],VxEnum);
     888        tria2->inputs->GetParameterValue(&vx2,nodes[1],VxEnum);
     889        tria1->inputs->GetParameterValue(&vy1,nodes[0],VyEnum);
     890        tria2->inputs->GetParameterValue(&vy2,nodes[1],VyEnum);
    891891
    892892        /*Node 1 faces node 2, compute penetration of 2 into 1 (V2-V1).N (with N normal vector, and V velocity vector: */
Note: See TracChangeset for help on using the changeset viewer.