Changeset 18699


Ignore:
Timestamp:
10/28/14 13:27:40 (10 years ago)
Author:
srebuffi
Message:

CHG: added StrainRateparallel and StrainRateperpendicular

Location:
issm/trunk-jpl/src/c/classes/Elements
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/classes/Elements/Element.cpp

    r18613 r18699  
    11061106                                name==EplHeadOldEnum ||
    11071107                                name==StressIntensityFactorEnum ||
     1108                                name==StrainRateparallelEnum ||
     1109                                name==StrainRateperpendicularEnum ||
    11081110                                name==HydrologydcEplThicknessOldEnum ||
    11091111                                name==HydrologydcEplInitialThicknessEnum ||
    … …  
    12081210                                input=this->inputs->GetInput(output_enum);
    12091211                                break;
     1212                        case StrainRateparallelEnum:
     1213                                this->StrainRateparallel();
     1214                                input=this->inputs->GetInput(output_enum);
     1215                                break;
     1216                        case StrainRateperpendicularEnum:
     1217                                this->StrainRateperpendicular();
     1218                                input=this->inputs->GetInput(output_enum);
     1219                                break;
    12101220                        default:
    12111221                                _error_("input "<<EnumToStringx(output_enum)<<" not found in element");

  • issm/trunk-jpl/src/c/classes/Elements/Element.h

    r18613 r18699  
    220220                virtual void   ComputeDeviatoricStressTensor(void)=0;
    221221                virtual void    StressIntensityFactor(void)=0;
     222                virtual void    StrainRateparallel(void)=0;
     223                virtual void   StrainRateperpendicular(void)=0;
    222224
    223225                virtual void   Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finite_element)=0;

  • issm/trunk-jpl/src/c/classes/Elements/Penta.cpp

    r18613 r18699  
    422422        this->inputs->AddInput(new PentaInput(StressIntensityFactorEnum,&ki[0],P1Enum));
    423423        this->InputExtrude(StressIntensityFactorEnum,-1);
     424}
     425/*}}}*/
     426void       Penta::StrainRateparallel(){/*{{{*/
     427
     428        IssmDouble  xyz_list[NUMVERTICES][3];
     429        GaussPenta* gauss=NULL;
     430        IssmDouble  vx,vy,vel;
     431        IssmDouble  strainxx;
     432        IssmDouble  strainxy;
     433        IssmDouble  strainyy;
     434        IssmDouble  strainparallel[NUMVERTICES];
     435
     436        /* Get node coordinates and dof list: */
     437        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
     438       
     439        /*Retrieve all inputs we will need*/
     440        Input* vx_input=inputs->GetInput(VxEnum);                                  _assert_(vx_input);
     441        Input* vy_input=inputs->GetInput(VyEnum);                                  _assert_(vy_input);
     442        Input* strainxx_input=inputs->GetInput(StrainRatexxEnum);             _assert_(strainxx_input);
     443        Input* strainxy_input=inputs->GetInput(StrainRatexyEnum);             _assert_(strainxy_input);
     444        Input* strainyy_input=inputs->GetInput(StrainRateyyEnum);             _assert_(strainyy_input);
     445
     446        /* Start looping on the number of vertices: */
     447        gauss=new GaussPenta();
     448        for (int iv=0;iv<NUMVERTICES;iv++){
     449                gauss->GaussVertex(iv);
     450
     451                /* Get the value we need*/
     452                vx_input->GetInputValue(&vx,gauss);
     453                vy_input->GetInputValue(&vy,gauss);
     454                vel=vx*vx+vy*vy;
     455                strainxx_input->GetInputValue(&strainxx,gauss);
     456                strainxy_input->GetInputValue(&strainxy,gauss);
     457                strainyy_input->GetInputValue(&strainyy,gauss);
     458
     459                /*strainparallel= Strain rate along the ice flow direction */
     460                strainparallel[iv]=(vx*vx*(strainxx)+vy*vy*(strainyy)+2*vy*vx*strainxy)/(vel+1.e-6);
     461        }
     462
     463        /*Add input*/
     464        this->inputs->AddInput(new PentaInput(StrainRateparallelEnum,&strainparallel[0],P1Enum));
     465
     466        /*Clean up and return*/
     467        delete gauss;
     468}
     469/*}}}*/
     470void       Penta::StrainRateperpendicular(){/*{{{*/
     471
     472        IssmDouble  xyz_list[NUMVERTICES][3];
     473        GaussPenta* gauss=NULL;
     474        IssmDouble  vx,vy,vel;
     475        IssmDouble  strainxx;
     476        IssmDouble  strainxy;
     477        IssmDouble  strainyy;
     478        IssmDouble  strainperpendicular[NUMVERTICES];
     479
     480        /* Get node coordinates and dof list: */
     481        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
     482
     483        /*Retrieve all inputs we will need*/
     484        Input* vx_input=inputs->GetInput(VxEnum);                                  _assert_(vx_input);
     485        Input* vy_input=inputs->GetInput(VyEnum);                                  _assert_(vy_input);
     486        Input* strainxx_input=inputs->GetInput(StrainRatexxEnum);             _assert_(strainxx_input);
     487        Input* strainxy_input=inputs->GetInput(StrainRatexyEnum);             _assert_(strainxy_input);
     488        Input* strainyy_input=inputs->GetInput(StrainRateyyEnum);             _assert_(strainyy_input);
     489
     490
     491        /* Start looping on the number of vertices: */
     492        gauss=new GaussPenta();
     493        for (int iv=0;iv<NUMVERTICES;iv++){
     494                gauss->GaussVertex(iv);
     495
     496                /* Get the value we need*/
     497                vx_input->GetInputValue(&vx,gauss);
     498                vy_input->GetInputValue(&vy,gauss);
     499                vel=vx*vx+vy*vy;
     500                strainxx_input->GetInputValue(&strainxx,gauss);
     501                strainxy_input->GetInputValue(&strainxy,gauss);
     502                strainyy_input->GetInputValue(&strainyy,gauss);
     503
     504                /*strainperpendicular= Strain rate perpendicular to the ice flow direction */
     505                strainperpendicular[iv]=(vx*vx*(strainyy)+vy*vy*(strainxx)-2*vy*vx*strainxy)/(vel+1.e-6);
     506        }
     507
     508        /*Add input*/
     509        this->inputs->AddInput(new PentaInput(StrainRateperpendicularEnum,&strainperpendicular[0],P1Enum));
     510
     511        /*Clean up and return*/
     512        delete gauss;
    424513}
    425514/*}}}*/

  • issm/trunk-jpl/src/c/classes/Elements/Penta.h

    r18613 r18699  
    5858                void   ComputeDeviatoricStressTensor();
    5959                void   StressIntensityFactor();
     60                void   StrainRateparallel();
     61                void   StrainRateperpendicular();
    6062                void   Configure(Elements* elements,Loads* loads,Nodes* nodes,Vertices* vertices,Materials* materials,Parameters* parameters);
    6163                void   ElementSizes(IssmDouble* hx,IssmDouble* hy,IssmDouble* hz);

  • issm/trunk-jpl/src/c/classes/Elements/Seg.h

    r18613 r18699  
    5858                void        ComputeDeviatoricStressTensor(){_error_("not implemented yet");};
    5959                void        StressIntensityFactor(void){_error_("not implemented yet");};
     60                void                    StrainRateparallel(void){_error_("not implemented yet");};
     61                void                    StrainRateperpendicular(void){_error_("not implemented yet");};
    6062                void        Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters){_error_("not implemented yet");};
    6163                void        SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Materials* materials,Parameters* parameters){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Elements/Tetra.h

    r18613 r18699  
    5858                void        ComputeDeviatoricStressTensor(){_error_("not implemented yet");};
    5959                void        StressIntensityFactor(void){_error_("not implemented yet");};
     60                void        StrainRateparallel(void){_error_("not implemented yet");};
     61                void        StrainRateperpendicular(void){_error_("not implemented yet");};
    6062                void        Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters);
    6163                void        SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Materials* materials,Parameters* parameters);

  • issm/trunk-jpl/src/c/classes/Elements/Tria.cpp

    r18565 r18699  
    271271        this->inputs->AddInput(new TriaInput(StressTensoryzEnum,&sigma_yz[0],P1Enum));
    272272        this->inputs->AddInput(new TriaInput(StressTensorzzEnum,&sigma_zz[0],P1Enum));
     273
     274        /*Clean up and return*/
     275        delete gauss;
     276}
     277/*}}}*/
     278void       Tria::StrainRateperpendicular(){/*{{{*/
     279
     280        IssmDouble  xyz_list[NUMVERTICES][3];
     281        GaussPenta* gauss=NULL;
     282        IssmDouble  vx,vy,vel;
     283        IssmDouble  strainxx;
     284        IssmDouble  strainxy;
     285        IssmDouble  strainyy;
     286        IssmDouble  strainperpendicular[NUMVERTICES];
     287
     288        /* Get node coordinates and dof list: */
     289        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
     290
     291        /*Retrieve all inputs we will need*/
     292        Input* vx_input=inputs->GetInput(VxEnum);                                  _assert_(vx_input);
     293        Input* vy_input=inputs->GetInput(VyEnum);                                  _assert_(vy_input);
     294        Input* strainxx_input=inputs->GetInput(StrainRatexxEnum);             _assert_(strainxx_input);
     295        Input* strainxy_input=inputs->GetInput(StrainRatexyEnum);             _assert_(strainxy_input);
     296        Input* strainyy_input=inputs->GetInput(StrainRateyyEnum);             _assert_(strainyy_input);
     297
     298
     299        /* Start looping on the number of vertices: */
     300        gauss=new GaussPenta();
     301        for (int iv=0;iv<NUMVERTICES;iv++){
     302                gauss->GaussVertex(iv);
     303
     304                /* Get the value we need*/
     305                vx_input->GetInputValue(&vx,gauss);
     306                vy_input->GetInputValue(&vy,gauss);
     307                vel=vx*vx+vy*vy;
     308                strainxx_input->GetInputValue(&strainxx,gauss);
     309                strainxy_input->GetInputValue(&strainxy,gauss);
     310                strainyy_input->GetInputValue(&strainyy,gauss);
     311
     312                /*strainperpendicular= Strain rate perpendicular to the ice flow direction */
     313                strainperpendicular[iv]=(vx*vx*(strainyy)+vy*vy*(strainxx)-2*vy*vx*strainxy)/(vel+1.e-6);
     314        }
     315
     316        /*Add input*/
     317        this->inputs->AddInput(new PentaInput(StrainRateperpendicularEnum,&strainperpendicular[0],P1Enum));
     318
     319        /*Clean up and return*/
     320        delete gauss;
     321}
     322/*}}}*/
     323void       Tria::StrainRateparallel(){/*{{{*/
     324
     325        IssmDouble  xyz_list[NUMVERTICES][3];
     326        GaussPenta* gauss=NULL;
     327        IssmDouble  vx,vy,vel;
     328        IssmDouble  strainxx;
     329        IssmDouble  strainxy;
     330        IssmDouble  strainyy;
     331        IssmDouble  strainparallel[NUMVERTICES];
     332
     333        /* Get node coordinates and dof list: */
     334        ::GetVerticesCoordinates(&xyz_list[0][0],vertices,NUMVERTICES);
     335       
     336        /*Retrieve all inputs we will need*/
     337        Input* vx_input=inputs->GetInput(VxEnum);                                  _assert_(vx_input);
     338        Input* vy_input=inputs->GetInput(VyEnum);                                  _assert_(vy_input);
     339        Input* strainxx_input=inputs->GetInput(StrainRatexxEnum);             _assert_(strainxx_input);
     340        Input* strainxy_input=inputs->GetInput(StrainRatexyEnum);             _assert_(strainxy_input);
     341        Input* strainyy_input=inputs->GetInput(StrainRateyyEnum);             _assert_(strainyy_input);
     342
     343        /* Start looping on the number of vertices: */
     344        gauss=new GaussPenta();
     345        for (int iv=0;iv<NUMVERTICES;iv++){
     346                gauss->GaussVertex(iv);
     347
     348                /* Get the value we need*/
     349                vx_input->GetInputValue(&vx,gauss);
     350                vy_input->GetInputValue(&vy,gauss);
     351                vel=vx*vx+vy*vy;
     352                strainxx_input->GetInputValue(&strainxx,gauss);
     353                strainxy_input->GetInputValue(&strainxy,gauss);
     354                strainyy_input->GetInputValue(&strainyy,gauss);
     355
     356                /*strainparallel= Strain rate along the ice flow direction */
     357                strainparallel[iv]=(vx*vx*(strainxx)+vy*vy*(strainyy)+2*vy*vx*strainxy)/(vel+1.e-6);
     358        }
     359
     360        /*Add input*/
     361        this->inputs->AddInput(new PentaInput(StrainRateparallelEnum,&strainparallel[0],P1Enum));
    273362
    274363        /*Clean up and return*/

  • issm/trunk-jpl/src/c/classes/Elements/Tria.h

    r18613 r18699  
    5757                void        ComputeSurfaceNormalVelocity();
    5858                void        StressIntensityFactor(void){_error_("not implemented yet");};
     59                void                    StrainRateparallel();
     60                void                    StrainRateperpendicular();
    5961                void        Configure(Elements* elements,Loads* loads,Nodes* nodesin,Vertices* verticesin,Materials* materials,Parameters* parameters);
    6062                void        SetCurrentConfiguration(Elements* elements,Loads* loads,Nodes* nodes,Materials* materials,Parameters* parameters);
Note: See TracChangeset for help on using the changeset viewer.