Changeset 16799


Ignore:
Timestamp:
11/16/13 08:44:57 (11 years ago)
Author:
seroussi
Message:

CHG: moving Pvector in Analysis

Location:
issm/trunk-jpl/src/c
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.cpp

    r16782 r16799  
    806806}/*}}}*/
    807807ElementVector* StressbalanceAnalysis::CreatePVector(Element* element){/*{{{*/
    808 _error_("not implemented yet");
     808
     809        int approximation;
     810        element->GetInputValue(&approximation,ApproximationEnum);
     811        switch(approximation){
     812                case SSAApproximationEnum:
     813                        return CreatePVectorSSA(element);
     814                default:
     815                        _error_("Approximation "<<EnumToStringx(approximation)<<" not supported");
     816        }
     817}/*}}}*/
     818ElementVector* StressbalanceAnalysis::CreatePVectorSSA(Element* element){/*{{{*/
     819
     820        /*compute all load vectors for this element*/
     821        ElementVector* pe1=CreatePVectorSSADrivingStress(element);
     822        ElementVector* pe2=CreatePVectorSSAFront(element);
     823        ElementVector* pe =new ElementVector(pe1,pe2);
     824
     825        /*clean-up and return*/
     826        delete pe1;
     827        delete pe2;
     828        return pe;
     829}/*}}}*/
     830ElementVector* StressbalanceAnalysis::CreatePVectorSSADrivingStress(Element* element){/*{{{*/
     831
     832        /*Intermediaries */
     833        int         i;
     834        IssmDouble  driving_stress_baseline,thickness;
     835        IssmDouble  Jdet;
     836        IssmDouble* xyz_list=NULL;
     837        IssmDouble  slope[2];
     838
     839        /*Fetch number of nodes and dof for this finite element*/
     840        int numnodes = element->GetNumberOfNodes();
     841        IssmDouble* icefrontlevel= xNew<IssmDouble>(numnodes);
     842
     843        /*Initialize Element vector and vectors*/
     844        ElementVector* pe=element->NewElementVector(SSAApproximationEnum);
     845        IssmDouble*    basis = xNew<IssmDouble>(numnodes);
     846
     847        /*Retrieve all inputs and parameters*/
     848        element->GetVerticesCoordinates(&xyz_list);
     849        Input* thickness_input=element->GetInput(ThicknessEnum);          _assert_(thickness_input);
     850        Input* surface_input  =element->GetInput(SurfaceEnum);            _assert_(surface_input);
     851        Input* drag_input     =element->GetInput(FrictionCoefficientEnum);_assert_(drag_input);
     852        element->GetInputListOnVertices(icefrontlevel,BedEnum);
     853
     854        /* Start  looping on the number of gaussian points: */
     855        Gauss* gauss=element->NewGauss(2);
     856        for(int ig=gauss->begin();ig<gauss->end();ig++){
     857
     858                gauss->GaussPoint(ig);
     859
     860                element->JacobianDeterminant(&Jdet,xyz_list,gauss);
     861                element->NodalFunctions(basis, gauss);
     862
     863                thickness_input->GetInputValue(&thickness,gauss);
     864                surface_input->GetInputDerivativeValue(&slope[0],xyz_list,gauss);
     865                driving_stress_baseline=element->GetMaterialParameter(MaterialsRhoIceEnum)*element->GetMaterialParameter(ConstantsGEnum)*thickness;
     866
     867                /*Build load vector: */
     868                for(i=0;i<numnodes;i++){
     869                        pe->values[i*NDOF2+0]+=-driving_stress_baseline*slope[0]*Jdet*gauss->weight*basis[i];
     870                        pe->values[i*NDOF2+1]+=-driving_stress_baseline*slope[1]*Jdet*gauss->weight*basis[i];
     871                }
     872        }
     873
     874        /*Transform coordinate system*/
     875        element->TransformLoadVectorCoord(pe,XYEnum);
     876
     877        /*Clean up and return*/
     878        xDelete<IssmDouble>(basis);
     879        delete gauss;
     880        return pe;
     881}/*}}}*/
     882ElementVector* StressbalanceAnalysis::CreatePVectorSSAFront(Element* element){/*{{{*/
     883
    809884}/*}}}*/
    810885void StressbalanceAnalysis::GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element){/*{{{*/
    … …  
    9521027                        return;
    9531028                case L1L2ApproximationEnum:
    954                         InputUpdateFromSolutionSSA(solution,element);
     1029                        InputUpdateFromSolutionL1L2(solution,element);
    9551030                        return;
    9561031                case SSAHOApproximationEnum:

  • issm/trunk-jpl/src/c/analyses/StressbalanceAnalysis.h

    r16782 r16799  
    2323                ElementMatrix* CreateKMatrix(Element* element);
    2424                ElementVector* CreatePVector(Element* element);
     25                ElementVector* CreatePVectorSSA(Element* element);
     26                ElementVector* CreatePVectorSSADrivingStress(Element* element);
     27                ElementVector* CreatePVectorSSAFront(Element* element);
    2528                void GetSolutionFromInputs(Vector<IssmDouble>* solution,Element* element);
    2629                void GetSolutionFromInputsFS(Vector<IssmDouble>* solution,Element* element);

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

    r16789 r16799  
    2424class Input;
    2525class Gauss;
     26class ElementVector;
    2627template <class doublematrix> class Matrix;
    2728template <class doubletype> class Vector;
    … …  
    5455                virtual int    FiniteElement(void)=0;
    5556                virtual IssmDouble GetMaterialParameter(int enum_in)=0;
     57                virtual void   NodalFunctions(IssmDouble* basis,Gauss* gauss)=0;
     58                virtual void   TransformLoadVectorCoord(ElementVector* pe,int transformenum)=0;
     59                virtual void   TransformLoadVectorCoord(ElementVector* pe,int* transformenum_list)=0;
     60                virtual void   TransformLoadVectorCoord(ElementVector* pe,int numnodes,int transformenum)=0;
     61                virtual void   TransformLoadVectorCoord(ElementVector* pe,int numnodes,int* transformenum_list)=0;
    5662                virtual void   TransformSolutionCoord(IssmDouble* values,int transformenum)=0;
    5763                virtual void   TransformSolutionCoord(IssmDouble* values,int* transformenum_list)=0;
    … …  
    6268                virtual void    GetDofListVelocity(int** pdoflist,int setenum)=0;
    6369                virtual void    GetDofListPressure(int** pdoflist,int setenum)=0;
     70                virtual void   JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss)=0;
    6471                virtual void   GetSolutionFromInputsOneDof(Vector<IssmDouble>* solution,int solutionenum)=0;
    6572                virtual int    GetNodeIndex(Node* node)=0;
    … …  
    104111                virtual int    NumberofNodesPressure(void)=0;
    105112                virtual Gauss* NewGauss(void)=0;
     113                virtual Gauss* NewGauss(int order)=0;
     114                virtual ElementVector*  NewElementVector(int approximation_enum)=0;
    106115                virtual void   InputScale(int enum_type,IssmDouble scale_factor)=0;
    107116                virtual void   GetVectorFromInputs(Vector<IssmDouble>* vector, int name_enum)=0;

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

    r16790 r16799  
    25192519}
    25202520/*}}}*/
     2521/*FUNCTION Penta::JacobianDeterminant{{{*/
     2522void Penta::JacobianDeterminant(IssmDouble* pJdet,IssmDouble* xyz_list,Gauss* gauss){
     2523
     2524        _assert_(gauss->Enum()==GaussPentaEnum);
     2525        this->GetJacobianDeterminant(pJdet,xyz_list,(GaussPenta*)gauss);
     2526
     2527}
     2528/*}}}*/
    25212529/*FUNCTION Penta::NoIceInElement {{{*/
    25222530bool   Penta::NoIceInElement(){
    … …  
    25872595}
    25882596/*}}}*/
    2589 /*FUNCTION Penta::NewGauss{{{*/
     2597/*FUNCTION Penta::NewGauss(){{{*/
    25902598Gauss* Penta::NewGauss(void){
    25912599        return new GaussPenta();
     2600}
     2601/*}}}*/
     2602/*FUNCTION Penta::NewGauss(int order){{{*/
     2603Gauss* Penta::NewGauss(int order){
     2604        return new GaussPenta(order,order);
    25922605}
    25932606/*}}}*/
    … …  
    80218034
    80228035        /*Transform coordinate system*/
    8023         TransformLoadVectorCoord(pe,nodes,vnumnodes+pnumnodes,cs_list);
     8036        ::TransformLoadVectorCoord(pe,nodes,vnumnodes+pnumnodes,cs_list);
    80248037
    80258038        /*Clean up and return*/
    … …  
    80998112
    81008113        /*Transform coordinate system*/
    8101         TransformLoadVectorCoord(pe,nodes,(vnumnodes+pnumnodes),cs_list);
     8114        ::TransformLoadVectorCoord(pe,nodes,(vnumnodes+pnumnodes),cs_list);
    81028115
    81038116        /*Clean up and return*/
    … …  
    81838196
    81848197        /*Transform coordinate system*/
    8185         TransformLoadVectorCoord(pe,nodes,vnumnodes+pnumnodes,cs_list);
     8198        ::TransformLoadVectorCoord(pe,nodes,vnumnodes+pnumnodes,cs_list);
    81868199
    81878200        /*Clean up and return*/
    … …  
    82648277
    82658278        /*Transform coordinate system*/
    8266         TransformLoadVectorCoord(pe,nodes,vnumnodes+pnumnodes,cs_list);
     8279        ::TransformLoadVectorCoord(pe,nodes,vnumnodes+pnumnodes,cs_list);
    82678280
    82688281        /*Clean up and return*/
    … …  
    85428555
    85438556        /*Transform coordinate system*/
    8544         TransformLoadVectorCoord(pe,nodes,numnodes,XYEnum);
     8557        ::TransformLoadVectorCoord(pe,nodes,numnodes,XYEnum);
    85458558
    85468559        /*Clean up and return*/
    … …  
    86258638
    86268639        /*Transform coordinate system*/
    8627         TransformLoadVectorCoord(pe,nodes,numnodes,XYEnum);
     8640        ::TransformLoadVectorCoord(pe,nodes,numnodes,XYEnum);
    86288641
    86298642        /*Clean up and return*/
    … …  
    87338746
    87348747        /*Transform coordinate system*/
    8735         TransformLoadVectorCoord(pe,nodes,(vnumnodes+pnumnodes),cs_list);
     8748        ::TransformLoadVectorCoord(pe,nodes,(vnumnodes+pnumnodes),cs_list);
    87368749
    87378750        /*Clean up and return*/
    … …  
    88878900
    88888901        /*Transform coordinate system*/
    8889         TransformLoadVectorCoord(pe,nodes,vnumnodes+pnumnodes,cs_list);
     8902        ::TransformLoadVectorCoord(pe,nodes,vnumnodes+pnumnodes,cs_list);
    88908903
    88918904        /*Clean up and return*/
    … …  
    89728985
    89738986        /*Transform coordinate system*/
    8974         TransformLoadVectorCoord(pe,nodes,(vnumnodes+pnumnodes),cs_list);
     8987        ::TransformLoadVectorCoord(pe,nodes,(vnumnodes+pnumnodes),cs_list);
    89758988
    89768989        /*Clean up and return*/

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

    r16789 r16799  
    240240                bool           IsFloating(void);
    241241                bool           IsNodeOnShelfFromFlags(IssmDouble* flags);
     242                void           JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss);
    242243                bool           NoIceInElement(void);
    243244                Gauss*         NewGauss(void);
     245                Gauss*         NewGauss(int order);
     246                ElementVector* NewElementVector(int approximation_enum){_error_("not implemented yet");};
     247                void           NodalFunctions(IssmDouble* basis,Gauss* gauss){_error_("not implemented yet");};
    244248                IssmDouble     MinEdgeLength(IssmDouble xyz_list[6][3]);
    245249                void             SetClone(int* minranks);
    246250                Tria*            SpawnTria(int location);
    247251                void             SurfaceNormal(IssmDouble* surface_normal, IssmDouble xyz_list[3][3]);
     252                void           TransformLoadVectorCoord(ElementVector* pe,int transformenum){_error_("not implemented yet");};
     253                void           TransformLoadVectorCoord(ElementVector* pe,int* transformenum_list){_error_("not implemented yet");};
     254                void           TransformLoadVectorCoord(ElementVector* pe,int numnodes,int transformenum){_error_("not implemented yet");};      /*Tiling only*/
     255                void           TransformLoadVectorCoord(ElementVector* pe,int numnodes,int* transformenum_list){_error_("not implemented yet");};/*Tiling only*/
    248256                void           TransformSolutionCoord(IssmDouble* values,int transformenum);
    249257                void           TransformSolutionCoord(IssmDouble* values,int* transformenum_list);

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

    r16789 r16799  
    109109                bool        IsFloating(){_error_("not implemented yet");};
    110110                bool        IsNodeOnShelfFromFlags(IssmDouble* flags){_error_("not implemented yet");};
     111                void        JacobianDeterminant(IssmDouble*  Jdet, IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};
     112                void        NodalFunctions(IssmDouble* basis,Gauss* gauss){_error_("not implemented yet");};
    111113                bool        NoIceInElement(){_error_("not implemented yet");};
    112114                int         NumberofNodesVelocity(void){_error_("not implemented yet");};
    … …  
    124126                void        GetMaterialInputValue(IssmDouble* pvalue,Node* node,int enumtype){_error_("not implemented yet");};
    125127                Gauss*      NewGauss(void){_error_("not implemented yet");};
     128                Gauss*      NewGauss(int order){_error_("not implemented yet");};
     129                ElementVector* NewElementVector(int approximation_enum){_error_("not implemented yet");};
    126130                #ifdef _HAVE_THERMAL_
    127131                void UpdateBasalConstraintsEnthalpy(void){_error_("not implemented yet");};
    … …  
    155159                void        Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type,int finitelement){_error_("not implemented yet");};
    156160                IssmDouble  TimeAdapt(){_error_("not implemented yet");};
     161                void        TransformLoadVectorCoord(ElementVector* pe,int transformenum){_error_("not implemented yet");};
     162                void        TransformLoadVectorCoord(ElementVector* pe,int* transformenum_list){_error_("not implemented yet");};
     163                void        TransformLoadVectorCoord(ElementVector* pe,int numnodes,int transformenum){_error_("not implemented yet");};
     164                void        TransformLoadVectorCoord(ElementVector* pe,int numnodes,int* transformenum_list){_error_("not implemented yet");};
    157165                void        TransformSolutionCoord(IssmDouble* values,int transformenum){_error_("not implemented yet");};
    158166                void        TransformSolutionCoord(IssmDouble* values,int* transformenum_list){_error_("not implemented yet");};

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

    r16789 r16799  
    20442044}
    20452045/*}}}*/
     2046/*FUNCTION Tria::JacobianDeterminant{{{*/
     2047void Tria::JacobianDeterminant(IssmDouble* pJdet,IssmDouble* xyz_list,Gauss* gauss){
     2048
     2049        _assert_(gauss->Enum()==GaussTriaEnum);
     2050        this->JacobianDeterminant(pJdet,xyz_list,(GaussTria*)gauss);
     2051
     2052}
     2053/*}}}*/
    20462054/*FUNCTION Tria::HasEdgeOnBed {{{*/
    20472055bool Tria::HasEdgeOnBed(){
    … …  
    22292237}
    22302238/*}}}*/
    2231 /*FUNCTION Tria::NewGauss{{{*/
     2239/*FUNCTION Tria::NewGauss(){{{*/
    22322240Gauss* Tria::NewGauss(void){
    22332241        return new GaussTria();
     2242}
     2243/*}}}*/
     2244/*FUNCTION Tria::NewGauss(int order){{{*/
     2245Gauss* Tria::NewGauss(int order){
     2246        return new GaussTria(order);
     2247}
     2248/*}}}*/
     2249/*FUNCTION Tria::NewElementVector{{{*/
     2250ElementVector* Tria::NewElementVector(int approximation_enum){
     2251        return new ElementVector(nodes,this->NumberofNodes(),this->parameters,approximation_enum);
    22342252}
    22352253/*}}}*/
    … …  
    22462264        /*If the level set is awlays <=0, there is no ice here*/
    22472265        return true;
     2266}
     2267/*}}}*/
     2268/*FUNCTION Tria::NodalFunctions{{{*/
     2269void Tria::NodalFunctions(IssmDouble* basis, Gauss* gauss){
     2270
     2271        _assert_(gauss->Enum()==GaussTriaEnum);
     2272        this->GetNodalFunctions(basis,(GaussTria*)gauss);
     2273
    22482274}
    22492275/*}}}*/
    … …  
    27312757
    27322758        ::TransformSolutionCoord(values,this->nodes,this->NumberofNodes(),transformenum_list);
     2759
     2760}
     2761/*}}}*/
     2762/*FUNCTION Tria::TransformLoadVectorCoord{{{*/
     2763void Tria::TransformLoadVectorCoord(ElementVector* pe,int transformenum){
     2764
     2765        ::TransformLoadVectorCoord(pe,this->nodes,this->NumberofNodes(),transformenum);
     2766
     2767}
     2768/*}}}*/
     2769/*FUNCTION Tria::TransformLoadVectorCoord{{{*/
     2770void Tria::TransformLoadVectorCoord(ElementVector* pe,int* transformenum_list){
     2771
     2772        ::TransformLoadVectorCoord(pe,this->nodes,this->NumberofNodes(),transformenum_list);
    27332773
    27342774}
    … …  
    39113951
    39123952        /*Transform coordinate system*/
    3913         TransformLoadVectorCoord(pe,nodes,(vnumnodes+pnumnodes),cs_list);
     3953        ::TransformLoadVectorCoord(pe,nodes,(vnumnodes+pnumnodes),cs_list);
    39143954
    39153955        /*Clean up and return*/
    … …  
    39724012
    39734013        /*Transform coordinate system*/
    3974         TransformLoadVectorCoord(pe,nodes,vnumnodes+pnumnodes,cs_list);
     4014        ::TransformLoadVectorCoord(pe,nodes,vnumnodes+pnumnodes,cs_list);
    39754015
    39764016        /*Clean up and return*/
    … …  
    40424082
    40434083        /*Transform coordinate system*/
    4044         TransformLoadVectorCoord(pe,nodes,(vnumnodes+pnumnodes),cs_list);
     4084        ::TransformLoadVectorCoord(pe,nodes,(vnumnodes+pnumnodes),cs_list);
    40454085
    40464086        /*Clean up and return*/
    … …  
    41114151
    41124152        /*Transform coordinate system*/
    4113         TransformLoadVectorCoord(pe,nodes,numnodes,XYEnum);
     4153        ::TransformLoadVectorCoord(pe,nodes,numnodes,XYEnum);
    41144154
    41154155        /*Clean up and return*/
    … …  
    41914231
    41924232        /*Transform coordinate system*/
    4193         TransformLoadVectorCoord(pe,nodes,numnodes,XYEnum);
     4233        ::TransformLoadVectorCoord(pe,nodes,numnodes,XYEnum);
    41944234
    41954235        /*Clean up and return*/

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

    r16789 r16799  
    268268                void             InputUpdateFromSolutionOneDofCollapsed(IssmDouble* solution,int enum_type){_error_("not implemented yet");};
    269269                bool             IsInput(int name);
     270                void           JacobianDeterminant(IssmDouble*  pJdet, IssmDouble* xyz_list,Gauss* gauss);
    270271                Gauss*         NewGauss(void);
     272                Gauss*         NewGauss(int order);
     273                ElementVector* NewElementVector(int approximation_enum);
     274                void           NodalFunctions(IssmDouble* basis,Gauss* gauss);
    271275                void             SetClone(int* minranks);
    272276                Seg*             SpawnSeg(int index1,int index2);
    273277                void             SurfaceNormal(IssmDouble* surface_normal, IssmDouble xyz_list[3][3]);
     278                void           TransformLoadVectorCoord(ElementVector* pe,int transformenum);
     279                void           TransformLoadVectorCoord(ElementVector* pe,int* transformenum_list);
     280                void           TransformLoadVectorCoord(ElementVector* pe,int numnodes,int transformenum){_error_("not implemented yet");};
     281                void           TransformLoadVectorCoord(ElementVector* pe,int numnodes,int* transformenum_list){_error_("not implemented yet");};
    274282                void           TransformSolutionCoord(IssmDouble* values,int transformenum);
    275283                void           TransformSolutionCoord(IssmDouble* values,int* transformenum_list);

  • issm/trunk-jpl/src/c/classes/Inputs/BoolInput.cpp

    r16675 r16799  
    115115void BoolInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){_error_("not supported yet!");}
    116116/*}}}*/
    117 /*FUNCTION BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){{{*/
    118 void BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not supported yet!");}
    119 /*}}}*/
    120 /*FUNCTION BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){{{*/
    121 void BoolInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not supported yet!");}
    122 /*}}}*/
    123117/*FUNCTION BoolInput::ChangeEnum{{{*/
    124118void BoolInput::ChangeEnum(int newenumtype){

  • issm/trunk-jpl/src/c/classes/Inputs/BoolInput.h

    r16675 r16799  
    5050                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
    5151                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    52                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    53                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
    54                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss);
     52                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, Gauss* gauss){_error_("not implemented yet");};
    5553                void GetInputAverage(IssmDouble* pvalue){_error_("not implemented yet");};
    5654                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/ControlInput.cpp

    r16675 r16799  
    247247        gradient->GetInputValue(pvalue,gauss);
    248248}/*}}}*/
    249 /*FUNCTION ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){{{*/
    250 void ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){
    251         values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss);
    252 }/*}}}*/
    253 /*FUNCTION ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){{{*/
    254 void ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){
     249/*FUNCTION ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, Gauss* gauss){{{*/
     250void ControlInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, Gauss* gauss){
    255251        values->GetInputDerivativeValue(derivativevalues,xyz_list,gauss);
    256252}/*}}}*/

  • issm/trunk-jpl/src/c/classes/Inputs/ControlInput.h

    r16675 r16799  
    5656                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
    5757                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    58                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    59                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
    60                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss);
     58                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list,Gauss* gauss);
    6159                void GetInputAverage(IssmDouble* pvalue);
    6260                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/DatasetInput.h

    r16675 r16799  
    5151                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
    5252                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index);
    53                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    54                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    55                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     53                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};
    5654                void GetInputAverage(IssmDouble* pvalue){_error_("not implemented yet");};
    5755                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/DoubleInput.cpp

    r16675 r16799  
    123123void DoubleInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){*pvalue=this->value;}
    124124/*}}}*/
    125 /*FUNCTION DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){{{*/
    126 void DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not supported yet!");}
    127 /*}}}*/
    128 /*FUNCTION DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){{{*/
    129 void DoubleInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not supported yet!");}
    130 /*}}}*/
    131125/*FUNCTION DoubleInput::GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){{{*/
    132126void DoubleInput::GetVxStrainRate2d(IssmDouble* epsilonvx,IssmDouble* xyz_list, GaussTria* gauss){

  • issm/trunk-jpl/src/c/classes/Inputs/DoubleInput.h

    r16675 r16799  
    4949                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
    5050                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    51                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    52                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
    53                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss);
     51                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};
    5452                void GetInputAverage(IssmDouble* pvalue);
    5553                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/Input.h

    r16675 r16799  
    3232                virtual void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time)=0;
    3333                virtual void GetInputValue(IssmDouble* pvalue,Gauss* gauss,int index)=0;
    34                 virtual void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss)=0;
    35                 virtual void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss)=0;
    36                 virtual void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss)=0;
     34                virtual void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, Gauss* gauss)=0;
    3735                virtual void GetInputAverage(IssmDouble* pvalue)=0;
    3836                virtual void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes)=0;

  • issm/trunk-jpl/src/c/classes/Inputs/IntInput.cpp

    r16675 r16799  
    115115void IntInput::GetInputValue(IssmDouble* pvalue,Gauss* gauss){_error_("not supported yet!");}
    116116/*}}}*/
    117 /*FUNCTION IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){{{*/
    118 void IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not supported yet!");}
    119 /*}}}*/
    120 /*FUNCTION IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){{{*/
    121 void IntInput::GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not supported yet!");}
    122 /*}}}*/
    123117/*FUNCTION IntInput::ChangeEnum{{{*/
    124118void IntInput::ChangeEnum(int newenumtype){

  • issm/trunk-jpl/src/c/classes/Inputs/IntInput.h

    r16675 r16799  
    5050                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
    5151                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    52                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    53                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
    54                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss);
     52                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list,Gauss* gauss){_error_("not implemented yet");};
    5553                void GetInputAverage(IssmDouble* pvalue){_error_("not implemented yet");};
    5654                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/PentaInput.cpp

    r16675 r16799  
    146146}
    147147/*}}}*/
    148 /*FUNCTION PentaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, GaussPenta* gauss){{{*/
    149 void PentaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, GaussPenta* gauss){
     148/*FUNCTION PentaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){{{*/
     149void PentaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list,Gauss* gauss){
    150150
    151151        /*Call PentaRef function*/
    152         PentaRef::GetInputDerivativeValue(p,&values[0],xyz_list,gauss);
     152        _assert_(gauss->Enum()==GaussPentaEnum);
     153        PentaRef::GetInputDerivativeValue(p,&values[0],xyz_list,(GaussPenta*)gauss);
    153154}
    154155/*}}}*/

  • issm/trunk-jpl/src/c/classes/Inputs/PentaInput.h

    r16675 r16799  
    4949                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
    5050                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    51                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    52                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    53                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss);
     51                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list,Gauss* gauss);
    5452                void GetInputAverage(IssmDouble* pvalue);
    5553                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/SegInput.cpp

    r16675 r16799  
    105105}
    106106/*}}}*/
    107 /*FUNCTION SegInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, GaussSeg* gauss){{{*/
    108 void SegInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, GaussSeg* gauss){
     107/*FUNCTION SegInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){{{*/
     108void SegInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list,Gauss* gauss){
    109109
    110110        /*Call SegRef function*/
    111         SegRef::GetInputDerivativeValue(p,&values[0],xyz_list,gauss);
     111        _assert_(gauss->Enum()==GaussSegEnum);
     112        SegRef::GetInputDerivativeValue(p,&values[0],xyz_list,(GaussSeg*)gauss);
    112113}
    113114/*}}}*/

  • issm/trunk-jpl/src/c/classes/Inputs/SegInput.h

    r16675 r16799  
    4848                void GetInputValue(IssmDouble* pvalue){_error_("not implemented yet");}
    4949                void GetInputValue(IssmDouble* pvalue,Gauss* gauss);
    50                 void GetInputValue(IssmDouble* pvalue,GaussTria* gauss){_error_("not implemented yet");};
    5150                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
    5251                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    53                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss);
    54                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss){_error_("not implemented yet");};
    55                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     52                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list,Gauss* gauss);
    5653                void GetInputAverage(IssmDouble* pvalue);
    5754                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes){_error_("not implemented yet");};

  • issm/trunk-jpl/src/c/classes/Inputs/TransientInput.cpp

    r16744 r16799  
    192192}
    193193/*}}}*/
    194 /*FUNCTION TransientInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, GaussTria* gauss){{{*/
    195 void TransientInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, GaussTria* gauss){
     194/*FUNCTION TransientInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){{{*/
     195void TransientInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){
    196196
    197197        IssmDouble time;
    … …  
    207207
    208208        delete input;
    209 
    210209}
    211210/*}}}*/

  • issm/trunk-jpl/src/c/classes/Inputs/TransientInput.h

    r16740 r16799  
    5555                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time);
    5656                void GetInputValue(IssmDouble* pvalue,Gauss* gauss ,int index){_error_("not implemented yet");};
    57                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    58                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
    59                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     57                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list,Gauss* gauss);
    6058                void GetInputAverage(IssmDouble* pvalue);
    6159                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes);

  • issm/trunk-jpl/src/c/classes/Inputs/TriaInput.cpp

    r16675 r16799  
    133133}
    134134/*}}}*/
    135 /*FUNCTION TriaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, GaussTria* gauss){{{*/
    136 void TriaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, GaussTria* gauss){
     135/*FUNCTION TriaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){{{*/
     136void TriaInput::GetInputDerivativeValue(IssmDouble* p, IssmDouble* xyz_list, Gauss* gauss){
    137137
    138138        /*Call TriaRef function*/
    139         TriaRef::GetInputDerivativeValue(p,&values[0],xyz_list,gauss);
     139        _assert_(gauss->Enum()==GaussTriaEnum);
     140        TriaRef::GetInputDerivativeValue(p,&values[0],xyz_list,(GaussTria*)gauss);
    140141}
    141142/*}}}*/

  • issm/trunk-jpl/src/c/classes/Inputs/TriaInput.h

    r16675 r16799  
    5050                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,IssmDouble time){_error_("not implemented yet");};
    5151                void GetInputValue(IssmDouble* pvalue,Gauss* gauss,int index){_error_("not implemented yet");};
    52                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussSeg* gauss){_error_("not implemented yet");};
    53                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussTria* gauss);
    54                 void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list, GaussPenta* gauss){_error_("not implemented yet");};
     52                void GetInputDerivativeValue(IssmDouble* derivativevalues, IssmDouble* xyz_list,Gauss* gauss);
    5553                void GetInputAverage(IssmDouble* pvalue);
    5654                void GetInputAllTimeAverages(IssmDouble** pvalues,IssmDouble** ptimes, int* pnumtimes);

  • issm/trunk-jpl/src/c/classes/gauss/Gauss.h

    r16675 r16799  
    99
    1010        public:
     11                IssmDouble   weight;
     12
    1113                virtual        ~Gauss(){};
    12 
    1314                virtual int  begin(void)=0;
    1415                virtual int  end(void)=0;
Note: See TracChangeset for help on using the changeset viewer.