Changeset 3946


Ignore:
Timestamp:
05/26/10 09:26:27 (15 years ago)
Author:
Mathieu Morlighem
Message:

Added SpawnSing for Hutter 2d

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

Legend:

Unmodified
Added
Removed

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

    r3938 r3946  
    132132                Inputs* SpawnTriaInputs(int* indices);
    133133                Inputs* SpawnBeamInputs(int* indices);
     134                Inputs* SpawnSingInputs(int  index  );
    134135               
    135136                void GetParameterValue(bool* pvalue,int enum_type);

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

    r3938 r3946  
    602602}
    603603/*}}}*/
     604/*FUNCTION Inputs::SpawnSingInputs{{{1*/
     605Inputs* Inputs::SpawnSingInputs(int index){
     606
     607        /*Intermediary*/
     608        vector<Object*>::iterator object;
     609        Input* inputin=NULL;
     610        Input* inputout=NULL;
     611
     612        /*Output*/
     613        Inputs* newinputs=new Inputs();
     614
     615        /*Go through inputs and call Spawn function*/
     616        for ( object=objects.begin() ; object < objects.end(); object++ ){
     617
     618                /*Create new input*/
     619                inputin=(Input*)(*object);
     620                inputout=inputin->SpawnSingInput(index);
     621
     622                /*Add input to new inputs*/
     623                newinputs->AddObject(inputout);
     624        }
     625
     626        /*Assign output pointer*/
     627        return newinputs;
     628}
     629/*}}}*/
    604630/*FUNCTION Inputs::SpawnTriaInputs{{{1*/
    605631Inputs* Inputs::SpawnTriaInputs(int* indices){

  • issm/trunk/src/c/objects/Elements/Penta.cpp

    r3938 r3946  
    503503
    504504        return beam;
     505}
     506/*}}}*/
     507/*FUNCTION Penta::SpawnSing {{{1*/
     508void* Penta::SpawnSing(int index){
     509
     510        Sing* sing=NULL;
     511        int zero=0;
     512        Hook       *sing_hnodes     = NULL;
     513        Hook       *sing_hmatice    = NULL;
     514        Hook       *sing_hmatpar    = NULL;
     515        Parameters *sing_parameters = NULL;
     516        Inputs     *sing_inputs     = NULL;
     517
     518        sing_hnodes =this->hnodes.Spawn(&index,1);
     519        sing_hmatice=this->hmatice.Spawn(&zero,1);
     520        sing_hmatpar=this->hmatpar.Spawn(&zero,1);
     521        sing_parameters=this->parameters;
     522        sing_inputs=(Inputs*)this->inputs->SpawnSingInputs(index);
     523
     524        sing=new Sing();
     525        sing->id=this->id;
     526        sing->inputs=sing_inputs;
     527        sing->parameters=sing_parameters;
     528
     529        /*now deal with hooks and objects: */
     530        sing->hnodes.copy(sing_hnodes);
     531        sing->hmatice.copy(sing_hmatice);
     532        sing->hmatpar.copy(sing_hmatpar);
     533
     534        /*recover objects: */
     535        //sing->nodes=(Node**)sing->hnodes.deliverp();
     536        //sing->matice=(Matice*)sing->hmatice.delivers();
     537        //sing->matpar=(Matpar*)sing->hmatpar.delivers();
     538
     539        delete sing_hnodes;
     540        delete sing_hmatice;
     541        delete sing_hmatpar;
     542
     543        return sing;
    505544}
    506545/*}}}*/

  • issm/trunk/src/c/objects/Elements/Penta.h

    r3938 r3946  
    5656                int   MarshallSize();
    5757                int   MyRank();
     58                void*  SpawnSing(int g0);
    5859                void*  SpawnBeam(int g0, int g1);
    5960                void*  SpawnTria(int g0, int g1, int g2);

  • issm/trunk/src/c/objects/Elements/Tria.cpp

    r3944 r3946  
    368368}
    369369/*}}}*/
     370/*FUNCTION Tria::SpawnBeam {{{1*/
     371void* Tria::SpawnBeam(int g0, int g1){
     372
     373        /*out of grids g0,g1 and g2 from Tria, build a beam element: */
     374        Beam* beam=NULL;
     375        int indices[2];
     376        int zero=0;
     377        Hook       *beam_hnodes     = NULL;
     378        Hook       *beam_hmatice    = NULL;
     379        Hook       *beam_hmatpar    = NULL;
     380        Parameters *beam_parameters = NULL;
     381        Inputs     *beam_inputs     = NULL;
     382
     383        indices[0]=g0;
     384        indices[1]=g1;
     385
     386        beam_hnodes =this->hnodes.Spawn(indices,2);
     387        beam_hmatice=this->hmatice.Spawn(&zero,1);
     388        beam_hmatpar=this->hmatpar.Spawn(&zero,1);
     389        beam_parameters=this->parameters;
     390        beam_inputs=(Inputs*)this->inputs->SpawnBeamInputs(indices);
     391
     392        beam=new Beam();
     393        beam->id=this->id;
     394        beam->inputs=beam_inputs;
     395        beam->parameters=beam_parameters;
     396
     397        /*now deal with hooks and objects: */
     398        beam->hnodes.copy(beam_hnodes);
     399        beam->hmatice.copy(beam_hmatice);
     400        beam->hmatpar.copy(beam_hmatpar);
     401
     402        /*recover objects: */
     403        //beam->nodes=(Node**)beam->hnodes.deliverp();
     404        //beam->matice=(Matice*)beam->hmatice.delivers();
     405        //beam->matpar=(Matpar*)beam->hmatpar.delivers();
     406
     407        delete beam_hnodes;
     408        delete beam_hmatice;
     409        delete beam_hmatpar;
     410
     411        return beam;
     412}
     413/*}}}*/
     414/*FUNCTION Tria::SpawnSing {{{1*/
     415void* Tria::SpawnSing(int index){
     416
     417        Sing* sing=NULL;
     418        int zero=0;
     419        Hook       *sing_hnodes     = NULL;
     420        Hook       *sing_hmatice    = NULL;
     421        Hook       *sing_hmatpar    = NULL;
     422        Parameters *sing_parameters = NULL;
     423        Inputs     *sing_inputs     = NULL;
     424
     425        sing_hnodes =this->hnodes.Spawn(&index,1);
     426        sing_hmatice=this->hmatice.Spawn(&zero,1);
     427        sing_hmatpar=this->hmatpar.Spawn(&zero,1);
     428        sing_parameters=this->parameters;
     429        sing_inputs=(Inputs*)this->inputs->SpawnSingInputs(index);
     430
     431        sing=new Sing();
     432        sing->id=this->id;
     433        sing->inputs=sing_inputs;
     434        sing->parameters=sing_parameters;
     435
     436        /*now deal with hooks and objects: */
     437        sing->hnodes.copy(sing_hnodes);
     438        sing->hmatice.copy(sing_hmatice);
     439        sing->hmatpar.copy(sing_hmatpar);
     440
     441        /*recover objects: */
     442        //sing->nodes=(Node**)sing->hnodes.deliverp();
     443        //sing->matice=(Matice*)sing->hmatice.delivers();
     444        //sing->matpar=(Matpar*)sing->hmatpar.delivers();
     445
     446        delete sing_hnodes;
     447        delete sing_hmatice;
     448        delete sing_hmatpar;
     449
     450        return sing;
     451}
     452/*}}}*/
    370453
    371454/*Updates: */
    … …  
    748831        /*Just branch to the correct element stiffness matrix generator, according to the type of analysis we are carrying out: */
    749832        if (analysis_type==ControlAnalysisEnum){
    750                
    751833                CreateKMatrixDiagnosticHoriz( Kgg,analysis_type,sub_analysis_type);
    752834        }
    753835        else if (analysis_type==DiagnosticAnalysisEnum){
    754        
    755836                if (sub_analysis_type==HorizAnalysisEnum){
    756 
    757837                        CreateKMatrixDiagnosticHoriz( Kgg,analysis_type,sub_analysis_type);
    758838                }
     839                else if (sub_analysis_type==HutterAnalysisEnum){
     840                        CreateKMatrixDiagnosticHutter( Kgg,analysis_type,sub_analysis_type);
     841                }
    759842                else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet");
    760 
    761843        }
    762844        else if (analysis_type==SlopecomputeAnalysisEnum){
    763 
    764845                CreateKMatrixSlopeCompute( Kgg,analysis_type,sub_analysis_type);
    765846        }
    766847        else if (analysis_type==PrognosticAnalysisEnum){
    767 
    768848                CreateKMatrixPrognostic( Kgg,analysis_type,sub_analysis_type);
    769849        }
    770850        else if (analysis_type==Prognostic2AnalysisEnum){
    771 
    772851                CreateKMatrixPrognostic2(Kgg,analysis_type,sub_analysis_type);
    773852        }
    774853        else if (analysis_type==BalancedthicknessAnalysisEnum){
    775 
    776854                CreateKMatrixBalancedthickness( Kgg,analysis_type,sub_analysis_type);
    777855        }
    778856        else if (analysis_type==Balancedthickness2AnalysisEnum){
    779 
    780857                CreateKMatrixBalancedthickness2( Kgg,analysis_type,sub_analysis_type);
    781858        }
    782859        else if (analysis_type==BalancedvelocitiesAnalysisEnum){
    783 
    784860                CreateKMatrixBalancedvelocities( Kgg,analysis_type,sub_analysis_type);
    785861        }
    786862        else{
    787 
    788863                ISSMERROR("%s%i%s\n","analysis: ",analysis_type," not supported yet");
    789864        }
    … …  
    14621537
    14631538}       
     1539/*}}}*/
     1540/*FUNCTION Tria::CreateKMatrixDiagnosticHutter{{{1*/
     1541void  Tria::CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type){
     1542
     1543        /*Collapsed formulation: */
     1544        Sing*  sing=NULL;
     1545        int    i;
     1546
     1547        /*flags: */
     1548        bool onwater;
     1549
     1550        /*recover some inputs: */
     1551        inputs->GetParameterValue(&onwater,ElementOnWaterEnum);
     1552
     1553        /*If on water, skip: */
     1554        if(onwater)return;
     1555
     1556        /*Spawn 3 sing elements: */
     1557        for(i=0;i<3;i++){
     1558                sing=(Sing*)SpawnSing(i);
     1559                sing->CreateKMatrix(Kgg,analysis_type,sub_analysis_type);
     1560        }
     1561
     1562        /*clean up*/
     1563        delete sing;
     1564
     1565}
    14641566/*}}}*/
    14651567/*FUNCTION Tria::CreateKMatrixDiagnosticSurfaceVert {{{1*/
    … …  
    21322234        /*Just branch to the correct load generator, according to the type of analysis we are carrying out: */
    21332235        if (analysis_type==ControlAnalysisEnum){
    2134                
    21352236                CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type);
    2136        
    21372237        }
    21382238        else if (analysis_type==DiagnosticAnalysisEnum){
    21392239                if (sub_analysis_type==HorizAnalysisEnum){
    2140                
    21412240                        CreatePVectorDiagnosticHoriz( pg,analysis_type,sub_analysis_type);
    21422241                }
     2242                else if (sub_analysis_type==HutterAnalysisEnum){
     2243                        CreatePVectorDiagnosticHutter( pg,analysis_type,sub_analysis_type);
     2244                }
    21432245                else ISSMERROR("%s%i%s\n","sub_analysis: ",sub_analysis_type," not supported yet");
    21442246        }
    21452247        else if (analysis_type==SlopecomputeAnalysisEnum){
    2146                
    21472248                CreatePVectorSlopeCompute( pg,analysis_type,sub_analysis_type);
    21482249        }
    21492250        else if (analysis_type==PrognosticAnalysisEnum){
    2150 
    21512251                CreatePVectorPrognostic( pg,analysis_type,sub_analysis_type);
    21522252        }
    21532253        else if (analysis_type==Prognostic2AnalysisEnum){
    2154 
    21552254                CreatePVectorPrognostic2( pg,analysis_type,sub_analysis_type);
    21562255        }
    21572256        else if (analysis_type==BalancedthicknessAnalysisEnum){
    2158 
    21592257                CreatePVectorBalancedthickness( pg,analysis_type,sub_analysis_type);
    21602258        }
    21612259        else if (analysis_type==Balancedthickness2AnalysisEnum){
    2162 
    21632260                CreatePVectorBalancedthickness2( pg,analysis_type,sub_analysis_type);
    21642261        }
    21652262        else if (analysis_type==BalancedvelocitiesAnalysisEnum){
    2166 
    21672263                CreatePVectorBalancedvelocities( pg,analysis_type,sub_analysis_type);
    21682264        }
    … …  
    26102706        xfree((void**)&third_gauss_area_coord);
    26112707        xfree((void**)&gauss_weights);
     2708
     2709}
     2710/*}}}*/
     2711/*FUNCTION Tria::CreatePVectorDiagnosticHutter{{{1*/
     2712void  Tria::CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type){
     2713
     2714        /*Collapsed formulation: */
     2715        Sing*  sing=NULL;
     2716        int    i;
     2717
     2718        /*flags: */
     2719        bool onwater;
     2720
     2721        /*recover some inputs: */
     2722        inputs->GetParameterValue(&onwater,ElementOnWaterEnum);
     2723
     2724        /*If on water, skip: */
     2725        if(onwater)return;
     2726
     2727        /*Spawn 3 sing elements: */
     2728        for(i=0;i<3;i++){
     2729                sing=(Sing*)SpawnSing(i);
     2730                sing->CreatePVector(pg,analysis_type,sub_analysis_type);
     2731        }
     2732
     2733        /*clean up*/
     2734        delete sing;
    26122735
    26132736}

  • issm/trunk/src/c/objects/Elements/Tria.h

    r3938 r3946  
    5454                void  SetClone(int* minranks);
    5555                void  DepthAverageInputAtBase(int enum_type);
     56                void*  SpawnSing(int g0);
     57                void*  SpawnBeam(int g0, int g1);
    5658                /*}}}*/
    5759                /*FUNCTION element numerical routines {{{1*/
    … …  
    6264                void  GetDofList(int* doflist,int* pnumberofdofs);
    6365                void  GetDofList1(int* doflist);
     66                void  CreateKMatrixDiagnosticHutter(Mat Kgg,int analysis_type,int sub_analysis_type);
    6467                void  CreateKMatrixDiagnosticHoriz(Mat Kgg,int analysis_type,int sub_analysis_type);
    6568                void  CreateKMatrixDiagnosticHorizFriction(Mat Kgg,int analysis_type,int sub_analysis_type);
    … …  
    8992                double SurfaceArea(int analysis_type,int sub_analysis_type);
    9093                double CostFunction(int analysis_type,int sub_analysis_type);
     94                void  CreatePVectorDiagnosticHutter(Vec pg,int analysis_type,int sub_analysis_type);
    9195                void  CreatePVectorDiagnosticHoriz(Vec pg,int analysis_type,int sub_analysis_type);
    9296                void  CreatePVectorDiagnosticBaseVert(Vec pg,int analysis_type,int sub_analysis_type);

  • issm/trunk/src/c/objects/Inputs/BeamVertexInput.cpp

    r3938 r3946  
    131131}
    132132/*}}}*/
     133/*FUNCTION BeamVertexInput::SpawnSingInput{{{1*/
     134Input* BeamVertexInput::SpawnSingInput(int index){
     135
     136        /*output*/
     137        SingVertexInput* outinput=NULL;
     138
     139        /*Create new Sing input (copy of current input)*/
     140        ISSMASSERT(index<2 && index>=0);
     141        outinput=new SingVertexInput(this->enum_type,this->values[index]);
     142
     143        /*Assign output*/
     144        return outinput;
     145
     146}
     147/*}}}*/
    133148/*FUNCTION BeamVertexInput::SpawnBeamInput{{{1*/
    134149Input* BeamVertexInput::SpawnBeamInput(int* indices){

  • issm/trunk/src/c/objects/Inputs/BeamVertexInput.h

    r3938 r3946  
    4747                void  UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4848
     49                Input* SpawnSingInput(int  index);
    4950                Input* SpawnBeamInput(int* indices);
    5051                Input* SpawnTriaInput(int* indices);

  • issm/trunk/src/c/objects/Inputs/BoolInput.cpp

    r3938 r3946  
    130130}
    131131/*}}}*/
     132/*FUNCTION BoolInput::SpawnSingInput{{{1*/
     133Input* BoolInput::SpawnSingInput(int index){
     134
     135        /*output*/
     136        BoolInput* outinput=new BoolInput();
     137
     138        /*only copy current value*/
     139        outinput->enum_type=this->enum_type;
     140        outinput->value=this->value;
     141
     142        /*Assign output*/
     143        return outinput;
     144
     145}
     146/*}}}*/
    132147/*FUNCTION BoolInput::SpawnBeamInput{{{1*/
    133148Input* BoolInput::SpawnBeamInput(int* indices){

  • issm/trunk/src/c/objects/Inputs/BoolInput.h

    r3938 r3946  
    4747                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4848
     49                Input* SpawnSingInput(int  index);
    4950                Input* SpawnBeamInput(int* indices);
    5051                Input* SpawnTriaInput(int* indices);

  • issm/trunk/src/c/objects/Inputs/DoubleInput.cpp

    r3938 r3946  
    130130}
    131131/*}}}*/
    132 /*FUNCTION DoubleInput::SpawnBeamInput{{{1*/
    133 Input* DoubleInput::SpawnBeamInput(int* indices){
     132/*FUNCTION DoubleInput::SpawnSingInput{{{1*/
     133Input* DoubleInput::SpawnSingInput(int index){
    134134
    135135        /*output*/
    … …  
    145145}
    146146/*}}}*/
    147 /*FUNCTION DoubleInput::SpawnTriaInput{{{1*/
    148 Input* DoubleInput::SpawnTriaInput(int* indices){
     147/*FUNCTION DoubleInput::SpawnBeamInput{{{1*/
     148Input* DoubleInput::SpawnBeamInput(int* indices){
    149149
    150150        /*output*/
    … …  
    160160}
    161161/*}}}*/
     162/*FUNCTION DoubleInput::SpawnTriaInput{{{1*/
     163Input* DoubleInput::SpawnTriaInput(int* indices){
     164
     165        /*output*/
     166        DoubleInput* outinput=new DoubleInput();
     167
     168        /*only copy current value*/
     169        outinput->enum_type=this->enum_type;
     170        outinput->value=this->value;
     171
     172        /*Assign output*/
     173        return outinput;
     174
     175}
     176/*}}}*/
    162177
    163178/*Object functions*/

  • issm/trunk/src/c/objects/Inputs/DoubleInput.h

    r3938 r3946  
    4747                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4848
     49                Input* SpawnSingInput(int  index);
    4950                Input* SpawnBeamInput(int* indices);
    5051                Input* SpawnTriaInput(int* indices);

  • issm/trunk/src/c/objects/Inputs/Input.h

    r3938 r3946  
    4444                virtual void GetVyStrainRate3dPattyn(double* epsilonvy,double* xyz_list, double* gauss)=0;
    4545                virtual void ChangeEnum(int newenumtype)=0;
     46                virtual Input* SpawnSingInput(int  index)=0;
    4647                virtual Input* SpawnBeamInput(int* indices)=0;
    4748                virtual Input* SpawnTriaInput(int* indices)=0;

  • issm/trunk/src/c/objects/Inputs/IntInput.cpp

    r3938 r3946  
    130130}
    131131/*}}}*/
    132 /*FUNCTION IntInput::SpawnBeamInput{{{1*/
    133 Input* IntInput::SpawnBeamInput(int* indices){
     132/*FUNCTION IntInput::SpawnSingInput{{{1*/
     133Input* IntInput::SpawnSingInput(int index){
    134134
    135135        /*output*/
    … …  
    144144}
    145145/*}}}*/
    146 /*FUNCTION IntInput::SpawnTriaInput{{{1*/
    147 Input* IntInput::SpawnTriaInput(int* indices){
     146/*FUNCTION IntInput::SpawnBeamInput{{{1*/
     147Input* IntInput::SpawnBeamInput(int* indices){
    148148
    149149        /*output*/
    … …  
    158158}
    159159/*}}}*/
     160/*FUNCTION IntInput::SpawnTriaInput{{{1*/
     161Input* IntInput::SpawnTriaInput(int* indices){
     162
     163        /*output*/
     164        IntInput* outinput=new IntInput();
     165
     166        /*only copy current value*/
     167        outinput->enum_type=this->enum_type;
     168        outinput->value=this->value;
     169
     170        /*Assign output*/
     171        return outinput;
     172}
     173/*}}}*/
    160174
    161175/*Object functions*/

  • issm/trunk/src/c/objects/Inputs/IntInput.h

    r3938 r3946  
    4747                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4848
     49                Input* SpawnSingInput(int  index);
    4950                Input* SpawnBeamInput(int* indices);
    5051                Input* SpawnTriaInput(int* indices);

  • issm/trunk/src/c/objects/Inputs/PentaVertexInput.cpp

    r3938 r3946  
    133133        extern int my_rank;
    134134        return my_rank;
     135}
     136/*}}}*/
     137/*FUNCTION PentaVertexInput::SpawnSingInput{{{1*/
     138Input* PentaVertexInput::SpawnSingInput(int index){
     139
     140        /*output*/
     141        SingVertexInput* outinput=NULL;
     142
     143        /*Create new Sing input (copy of current input)*/
     144        ISSMASSERT(index<6 && index>=0);
     145        outinput=new SingVertexInput(this->enum_type,this->values[index]);
     146
     147        /*Assign output*/
     148        return outinput;
     149
    135150}
    136151/*}}}*/

  • issm/trunk/src/c/objects/Inputs/PentaVertexInput.h

    r3938 r3946  
    4646                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4747
     48                Input* SpawnSingInput(int  index);
    4849                Input* SpawnBeamInput(int* indices);
    4950                Input* SpawnTriaInput(int* indices);

  • issm/trunk/src/c/objects/Inputs/SingVertexInput.cpp

    r3938 r3946  
    2424}
    2525/*}}}*/
    26 /*FUNCTION SingVertexInput::SingVertexInput(double* values){{{1*/
     26/*FUNCTION SingVertexInput::SingVertexInput(int in_enum_type,double in_value){{{1*/
    2727SingVertexInput::SingVertexInput(int in_enum_type,double in_value){
    2828
    … …  
    130130}
    131131/*}}}*/
     132/*FUNCTION SingVertexInput::SpawnSingInput{{{1*/
     133Input* SingVertexInput::SpawnSingInput(int index){
     134
     135        /*output*/
     136        SingVertexInput* outinput=NULL;
     137
     138        /*Create new Sing input (copy of current input)*/
     139        outinput=new SingVertexInput(this->enum_type,this->value);
     140
     141        /*Assign output*/
     142        return outinput;
     143
     144}
     145/*}}}*/
    132146/*FUNCTION SingVertexInput::SpawnBeamInput{{{1*/
    133147Input* SingVertexInput::SpawnBeamInput(int* indices){

  • issm/trunk/src/c/objects/Inputs/SingVertexInput.h

    r3938 r3946  
    4646                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4747
     48                Input* SpawnSingInput(int  index);
    4849                Input* SpawnBeamInput(int* indices);
    4950                Input* SpawnTriaInput(int* indices);

  • issm/trunk/src/c/objects/Inputs/TriaVertexInput.cpp

    r3938 r3946  
    130130        extern int my_rank;
    131131        return my_rank;
     132}
     133/*}}}*/
     134/*FUNCTION TriaVertexInput::SpawnSingInput{{{1*/
     135Input* TriaVertexInput::SpawnSingInput(int index){
     136
     137        /*output*/
     138        SingVertexInput* outinput=NULL;
     139
     140        /*Create new Sing input (copy of current input)*/
     141        ISSMASSERT(index<3 && index>=0);
     142        outinput=new SingVertexInput(this->enum_type,this->values[index]);
     143
     144        /*Assign output*/
     145        return outinput;
     146
    132147}
    133148/*}}}*/

  • issm/trunk/src/c/objects/Inputs/TriaVertexInput.h

    r3938 r3946  
    4747                void    UpdateInputsFromSolution(double* solution, int analysis_type, int sub_analysis_type){ISSMERROR("Not implemented yet!");}
    4848
     49                Input* SpawnSingInput(int  index);
    4950                Input* SpawnBeamInput(int* indices);
    5051                Input* SpawnTriaInput(int* indices);
Note: See TracChangeset for help on using the changeset viewer.