Changeset 4249


Ignore:
Timestamp:
06/26/10 22:42:58 (15 years ago)
Author:
Eric.Larour
Message:

Reorganization of header files for element

Location:
issm/trunk/src/c/objects/Elements
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r4248 r4249  
    4040                Beam();
    4141                ~Beam();
    42                 void  Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type);
    43                 void  UpdateGeometry(void){ISSMERROR("not implemented yet");};
    4442                /*}}}*/
    4543                /*Object virtual functions definitions: {{{1*/
    … …  
    5452                Object* copy();
    5553                /*}}}*/
    56                 /*Beam management: {{{1*/
    57                 void  Configure(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
    58                 bool  IsInput(int name);
    59                 void  SetClone(int* minranks);
    60                 void  InputDepthAverageAtBase(int enum_type,int average_enum_type){ISSMERROR("not implemented yet");};
    61                 void  InputToResult(int enum_type,int step,double time);
    62                 void   ProcessResultsUnits(void);
    63                 /*}}}*/
    6454                /*Update virtual functions resolution: {{{1*/
    6555                void  InputUpdateFromVector(double* vector, int name, int type);
    … …  
    7161                void  InputUpdateFromSolution(double* solution);
    7262                /*}}}*/
    73                 /*numerics: {{{1*/
    74                 void  CreateKMatrix(Mat Kgg);
    75                 void  CreatePVector(Vec pg);
    76                 void  GetSolutionFromInputs(Vec solution);
    77                 void  GetDofList(int* doflist,int* pnumberofdofs);
    78                 void  GetDofList1(int* doflist);
    79                 void  CreateKMatrixDiagnosticHutter(Mat Kgg);
    80                 void  GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3);
    81                 void  CreatePVectorDiagnosticHutter(Vec pg);
    82                 void* GetMatPar();
    83 
    84                 void  ComputeBasalStress(Vec sigma_bg);
    85                 void  ComputePressure(Vec p_gg);
    86                 void  ComputeStrainRate(Vec epsg);
    87                 void  GetNodes(void** vpnodes);
    88                 void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
    89                 void  PatchFill(int* pcount, Patch* patch);
    90                 void  MinVel(double* pminvel, bool process_units);
    91                 void  MaxVel(double* pmaxvel, bool process_units);
    92                 void  MinVx(double* pminvx, bool process_units);
    93                 void  MaxVx(double* pmaxvx, bool process_units);
    94                 void  MaxAbsVx(double* pmaxabsvx, bool process_units);
    95                 void  MinVy(double* pminvy, bool process_units);
    96                 void  MaxVy(double* pmaxvy, bool process_units);
    97                 void  MaxAbsVy(double* pmaxabsvy, bool process_units);
    98                 void  MinVz(double* pminvz, bool process_units);
    99                 void  MaxVz(double* pmaxvz, bool process_units);
    100                 void  MaxAbsVz(double* pmaxabsvz, bool process_units);
    101                 void  InputDuplicate(int original_enum,int new_enum);
    102                 void  InputScale(int enum_type,double scale_factor);
    103                 void  InputAXPY(int YEnum, double scalar, int XEnum);
    104                 void  InputControlConstrain(int control_type,double cm_min, double cm_max);
    105                 void  InputConvergence(int* pconverged,double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums);
    106 
     63                /*Element virtual functions definitions: {{{1*/
     64                void       ComputeBasalStress(Vec sigma_b);
     65                void       ComputePressure(Vec p_g);
     66                void       ComputeStrainRate(Vec eps);
     67                void       Configure(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
     68                double     CostFunction(void);
     69                void       CreateKMatrix(Mat Kgg);
     70                void       CreatePVector(Vec pg);
     71                void       Du(Vec du_g);
     72                void       GetBedList(double* bed_list);
     73                void*      GetMatPar();
     74                void       GetNodes(void** nodes);
     75                bool       GetOnBed();
     76                bool       GetShelf();
     77                void       GetSolutionFromInputs(Vec solution);
     78                void       GetThicknessList(double* thickness_list);
     79                void       GetVectorFromInputs(Vec vector,int NameEnum);
     80                void       Gradj(Vec gradient,int control_type);
     81                void       GradjB(Vec gradient);
     82                void       GradjDrag(Vec gradient);
     83                void       InputAXPY(int YEnum, double scalar, int XEnum);
     84                void       InputControlConstrain(int control_type,double cm_min, double cm_max);
     85                void       InputConvergence(int* pconverged,double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums);
     86                void       InputDepthAverageAtBase(int enum_type,int average_enum_type){ISSMERROR("not implemented yet");}
     87                void       InputDuplicate(int original_enum,int new_enum);
     88                void       InputScale(int enum_type,double scale_factor);
     89                void       InputToResult(int enum_type,int step,double time);
     90                double     MassFlux(double* segment);
     91                void       MaxAbsVx(double* pmaxabsvx, bool process_units);
     92                void       MaxAbsVy(double* pmaxabsvy, bool process_units);
     93                void       MaxAbsVz(double* pmaxabsvz, bool process_units);
     94                void       MaxVel(double* pmaxvel, bool process_units);
     95                void       MaxVx(double* pmaxvx, bool process_units);
     96                void       MaxVy(double* pmaxvy, bool process_units);
     97                void       MaxVz(double* pmaxvz, bool process_units);
     98                void       MinVel(double* pminvel, bool process_units);
     99                void       MinVx(double* pminvx, bool process_units);
     100                void       MinVy(double* pminvy, bool process_units);
     101                void       MinVz(double* pminvz, bool process_units);
     102                double     Misfit(void);
     103                void       PatchFill(int* pcount, Patch* patch);
     104                void       PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
     105                void       ProcessResultsUnits(void);
     106                double     SurfaceArea(void);
     107                void       Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type);
     108                void       UpdateGeometry(void){ISSMERROR("not implemented yet");};
    107109                /*}}}*/
    108                 /*not implemented: {{{1*/
    109                 bool  GetShelf();
    110                 bool  GetOnBed();
    111                 void  GetBedList(double*);
    112                 void  GetThicknessList(double* thickness_list);
    113                 void  Du(Vec);
    114                 void  Gradj(Vec gradient,int control_type);
    115                 void  GradjDrag(Vec gradient);
    116                 void  GradjB(Vec gradient);
    117                 double Misfit(void);
    118                 double SurfaceArea(void);
    119                 double CostFunction(void);
    120                 void  GetNodalFunctions(double* l1l2, double gauss_coord);
    121                 void  GetParameterValue(double* pvalue, double* value_list,double gauss_coord);
    122                 void  GetJacobianDeterminant(double* pJdet,double* z_list, double gauss_coord);
    123                 double MassFlux(double* segment);
    124                 void GetVectorFromInputs(Vec vector,int NameEnum);
    125 
     110                /*Beam specific routines: {{{1*/
     111                void      CreateKMatrixDiagnosticHutter(Mat Kgg);
     112                void      CreatePVectorDiagnosticHutter(Vec pg);
     113                void      GetDofList(int* doflist,int* pnumberofdofs);
     114                void      GetDofList1(int* doflist);
     115                void      GetJacobianDeterminant(double* pJdet,double* z_list, double gauss_coord);
     116                void      GetNodalFunctions(double* l1l2, double gauss_coord);
     117                void      GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3);
     118                void      GetParameterValue(double* pvalue, double* value_list,double gauss_coord);
     119                bool      IsInput(int name);
     120                void      SetClone(int* minranks);
    126121                /*}}}*/
    127 
    128122};
    129123#endif  /* _BEAM_H */

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

    r4248 r4249  
    4444                Penta();
    4545                Penta(int penta_id,int i, IoModel* iomodel,int nummodels);
    46                 void  Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type);
    47                 void  UpdateGeometry(void);
    4846                ~Penta();
    4947                /*}}}*/
    5048                /*Object virtual functions definitions: {{{1*/
    51                 void  Echo();
    52                 void  DeepEcho();
    53                 int   Id();
    54                 int   MyRank();
    55                 void  Marshall(char** pmarshalled_dataset);
    56                 int   MarshallSize();
    57                 void  Demarshall(char** pmarshalled_dataset);
    58                 int   Enum();
    59                 Object* copy();
     49                Object*   copy();
     50                void      DeepEcho();
     51                void      Demarshall(char** pmarshalled_dataset);
     52                void      Echo();
     53                int               Enum();
     54                int               Id();
     55                void      Marshall(char** pmarshalled_dataset);
     56                int               MarshallSize();
     57                int               MyRank();
    6058                /*}}}*/
    61                 /*Penta management: {{{1*/
    62                 void  Configure(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
    63                 bool  IsInput(int name);
    64                 bool  IsOnSurface(void);
    65                 Penta* GetUpperElement(void);
    66                 void* SpawnSing(int g0);
    67                 void* SpawnBeam(int g0, int g1);
    68                 void* SpawnTria(int g0, int g1, int g2);
    69                 void  SetClone(int* minranks);
    70                 double* GaussFromNode(Node* node);
    71                 void  InputToResult(int enum_type,int step,double time);
    72                 void   ProcessResultsUnits(void);
    73                 /*}}}*/
    74                 /*Update virtual functions resolution: {{{1*/
     59                /*Update virtual functions definitions: {{{1*/
     60                void  InputUpdateFromConstant(bool constant, int name);
     61                void  InputUpdateFromConstant(double constant, int name);
     62                void  InputUpdateFromConstant(int constant, int name);
    7563                void  InputUpdateFromSolution(double* solutiong);
    76                 void  InputUpdateFromSolutionDiagnosticHoriz( double* solutiong);
    77                 void  InputUpdateFromSolutionDiagnosticStokes( double* solutiong);
    78                 void  InputUpdateFromSolutionSlopeCompute( double* solutiong);
    79                 void  InputUpdateFromSolutionPrognostic( double* solutiong);
    80                 void  InputUpdateFromSolutionPrognostic2(double* solutiong);
    8164                void  InputUpdateFromSolutionBalancedthickness( double* solutiong);
    8265                void  InputUpdateFromSolutionBalancedthickness2( double* solutiong);
    8366                void  InputUpdateFromSolutionBalancedvelocities( double* solutiong);
     67                void  InputUpdateFromSolutionDiagnosticHoriz( double* solutiong);
     68                void  InputUpdateFromSolutionDiagnosticStokes( double* solutiong);
     69                void  InputUpdateFromSolutionPrognostic( double* solutiong);
     70                void  InputUpdateFromSolutionPrognostic2(double* solutiong);
     71                void  InputUpdateFromSolutionSlopeCompute( double* solutiong);
     72                void  InputUpdateFromVector(bool* vector, int name, int type);
    8473                void  InputUpdateFromVector(double* vector, int name, int type);
    8574                void  InputUpdateFromVector(int* vector, int name, int type);
    86                 void  InputUpdateFromVector(bool* vector, int name, int type);
    87                 void  InputUpdateFromConstant(double constant, int name);
    88                 void  InputUpdateFromConstant(int constant, int name);
    89                 void  InputUpdateFromConstant(bool constant, int name);
    9075                void  UpdateFromDakota(void* inputs);
    9176                /*}}}*/
    92                 /*FUNCTION element numerical routines {{{1*/
    93                 void  CreateKMatrix(Mat Kggg);
    94                 void  CreateKMatrixDiagnosticHoriz( Mat Kgg);
    95                 void  CreateKMatrixDiagnosticHutter( Mat Kgg);
    96                 void  CreateKMatrixDiagnosticVert( Mat Kgg);
    97                 void  CreatePVector(Vec pg);
    98                 void  GetSolutionFromInputs(Vec solution);
    99                 void  GetSolutionFromInputsDiagnosticHoriz(Vec solutiong);
    100                 void  GetSolutionFromInputsDiagnosticVert(Vec solutiong);
    101                 void  GetSolutionFromInputsDiagnosticStokes(Vec solutiong);
    102                 void  GetDofList(int* doflist,int* pnumberofdofs);
    103                 void  GetDofList1(int* doflist);
    104                 void* GetMatPar();
    105                 bool   GetShelf();
    106                 void  GetNodes(void** nodes);
     77                /*Element virtual functions definitions: {{{1*/
     78                void   ComputeBasalStress(Vec sigma_b);
     79                void   ComputePressure(Vec p_g);
     80                void   ComputeStrainRate(Vec eps);
     81                void   Configure(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
     82                double CostFunction(void);
     83                void   CreateKMatrix(Mat Kgg);
     84                void   CreatePVector(Vec pg);
     85                void   Du(Vec du_g);
     86                void   GetBedList(double* bed_list);
     87                void*  GetMatPar();
     88                void   GetNodes(void** nodes);
    10789                bool   GetOnBed();
    108                 void  Du(Vec du_gg);
    109                 void  Gradj(Vec gradient,int control_type);
    110                 void  GradjDrag(Vec gradient);
    111                 void  GradjB(Vec gradient);
     90                bool   GetShelf();
     91                void   GetSolutionFromInputs(Vec solution);
     92                void   GetThicknessList(double* thickness_list);
     93                void   GetVectorFromInputs(Vec vector,int NameEnum);
     94                void   Gradj(Vec gradient,int control_type);
     95                void   GradjB(Vec gradient);
     96                void   GradjDrag(Vec gradient);
     97                void   InputAXPY(int YEnum, double scalar, int XEnum);
     98                void   InputControlConstrain(int control_type,double cm_min, double cm_max);
     99                void   InputConvergence(int* pconverged,double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums);
     100                void   InputDepthAverageAtBase(int enum_type,int average_enum_type);
     101                void   InputDuplicate(int original_enum,int new_enum);
     102                void   InputScale(int enum_type,double scale_factor);
     103                void   InputToResult(int enum_type,int step,double time);
     104                double MassFlux(double* segment);
     105                void   MaxAbsVx(double* pmaxabsvx, bool process_units);
     106                void   MaxAbsVy(double* pmaxabsvy, bool process_units);
     107                void   MaxAbsVz(double* pmaxabsvz, bool process_units);
     108                void   MaxVel(double* pmaxvel, bool process_units);
     109                void   MaxVx(double* pmaxvx, bool process_units);
     110                void   MaxVy(double* pmaxvy, bool process_units);
     111                void   MaxVz(double* pmaxvz, bool process_units);
     112                void   MinVel(double* pminvel, bool process_units);
     113                void   MinVx(double* pminvx, bool process_units);
     114                void   MinVy(double* pminvy, bool process_units);
     115                void   MinVz(double* pminvz, bool process_units);
    112116                double Misfit(void);
     117                void   PatchFill(int* pcount, Patch* patch);
     118                void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
     119                void   ProcessResultsUnits(void);
    113120                double SurfaceArea(void);
    114                 double CostFunction(void);
    115                 void  GetThicknessList(double* thickness_list);
    116                 void  GetBedList(double* bed_list);
    117                 void  GetStrainRate(double* epsilon, double* velocity, double* xyz_list, double* gauss_coord);
    118                 void  GetB(double* pB, double* xyz_list, double* gauss_coord);
    119                 void  GetBPrime(double* B, double* xyz_list, double* gauss_coord);
    120                 void  GetB_vert(double* B, double* xyz_list, double* gauss_coord);
    121                 void  GetBPrime_vert(double* B, double* xyz_list, double* gauss_coord);
    122                 void  GetJacobianDeterminant(double*  Jdet, double* xyz_list,double* gauss_coord);
    123                 void  GetNodalFunctionsDerivatives(double* dh1dh6,double* xyz_list, double* gauss_coord);
    124                 void  GetJacobian(double* J, double* xyz_list,double* gauss_coord);
    125                 void  GetNodalFunctionsDerivativesReference(double* dl1dl6,double* gauss_coord);
    126                 void  GetJacobianInvert(double*  Jinv, double* xyz_list,double* gauss_coord);
    127                 void  CreatePVectorDiagnosticHoriz( Vec pg);
    128                 void  CreatePVectorDiagnosticHutter( Vec pg);
    129                 void  CreatePVectorDiagnosticVert( Vec pg);
    130                 void  GetParameterValue(double* pvalue, double* v_list,double* gauss_coord);
    131                 void  GetParameterDerivativeValue(double* p, double* p_list,double* xyz_list, double* gauss_coord);
    132                 void  GetNodalFunctions(double* l1l6, double* gauss_coord);
    133                 void  VecExtrude(Vec vector,double* vector_serial,int iscollapsed);
    134                 void  InputExtrude(int enum_type);
    135                 void  InputDepthAverageAtBase(int enum_type,int average_enum_type);
    136                 void  ComputeBasalStress(Vec sigma_bg);
    137                 void  ComputePressure(Vec p_gg);
    138                 void  ComputeStrainRate(Vec epsg);
    139                 void  CreateKMatrixSlopeCompute(Mat Kggg);
    140                 void  CreatePVectorSlopeCompute( Vec pg);
    141                 void  CreateKMatrixPrognostic(Mat Kggg);
    142                 void  CreatePVectorPrognostic( Vec pg);
    143                 void  CreateKMatrixBalancedthickness(Mat Kggg);
    144                 void  CreateKMatrixBalancedvelocities(Mat Kggg);
    145                 void  CreateKMatrixDiagnosticStokes( Mat Kgg);
    146                 void  CreatePVectorBalancedthickness( Vec pg);
    147                 void  CreatePVectorBalancedvelocities( Vec pg);
    148                 void  CreatePVectorDiagnosticStokes( Vec pg);
    149                 void  ReduceMatrixStokes(double* Ke_reduced, double* Ke_temp);
    150                 void  GetMatrixInvert(double*  Ke_invert, double* Ke);
    151                 void  SurfaceNormal(double* surface_normal, double xyz_list[3][3]);
    152                 void  GetStrainRateStokes(double* epsilon, double* velocity, double* xyz_list, double* gauss_coord);
    153                 void  GetBStokes(double* B, double* xyz_list, double* gauss_coord);
    154                 void  GetBprimeStokes(double* B_prime, double* xyz_list, double* gauss_coord);
    155                 void  GetLStokes(double* LStokes, double* gauss_coord_tria);
    156                 void  GetLprimeStokes(double* LprimeStokes, double* xyz_list, double* gauss_coord_tria, double* gauss_coord);
    157                 void  GetNodalFunctionsDerivativesStokes(double* dh1dh7,double* xyz_list, double* gauss_coord);
    158                 void  GetNodalFunctionsDerivativesReferenceStokes(double* dl1dl7,double* gauss_coord);
    159                 void  ReduceVectorStokes(double* Pe_reduced, double* Ke_temp, double* Pe_temp);
    160                 void  GetNodalFunctionsStokes(double* l1l7, double* gauss_coord);
    161                 void  CreateKMatrixThermal(Mat Kggg);
    162                 void  GetB_conduct(double* B_conduct, double* xyz_list, double* gauss_coord);
    163                 void  GetB_advec(double* B_advec, double* xyz_list, double* gauss_coord);
    164                 void  GetBprime_advec(double* Bprime_advec, double* xyz_list, double* gauss_coord);
    165                 void  GetB_artdiff(double* B_artdiff, double* xyz_list, double* gauss_coord);
    166                 void  CreateKMatrixMelting(Mat Kggg);
    167                 void  CreatePVectorThermal( Vec pg);
    168                 void  CreatePVectorMelting( Vec pg);
    169                 void  GetPhi(double* phi, double*  epsilon, double viscosity);
    170                 double MassFlux(double* segment);
    171                 void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
    172                 void  PatchFill(int* pcount, Patch* patch);
    173                 void  MinVel(double* pminvel, bool process_units);
    174                 void  MaxVel(double* pmaxvel, bool process_units);
    175                 void  MinVx(double* pminvx, bool process_units);
    176                 void  MaxVx(double* pmaxvx, bool process_units);
    177                 void  MaxAbsVx(double* pmaxabsvx, bool process_units);
    178                 void  MinVy(double* pminvy, bool process_units);
    179                 void  MaxVy(double* pmaxvy, bool process_units);
    180                 void  MaxAbsVy(double* pmaxabsvy, bool process_units);
    181                 void  MinVz(double* pminvz, bool process_units);
    182                 void  MaxVz(double* pmaxvz, bool process_units);
    183                 void  MaxAbsVz(double* pmaxabsvz, bool process_units);
    184                 void  InputDuplicate(int original_enum,int new_enum);
    185                 void  InputScale(int enum_type,double scale_factor);
    186                 void  InputAXPY(int YEnum, double scalar, int XEnum);
    187                 void  InputControlConstrain(int control_type,double cm_min, double cm_max);
    188                 void  InputConvergence(int* pconverged,double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums);
    189                 void  GetVectorFromInputs(Vec vector,int NameEnum);
     121                void   Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type);
     122                void   UpdateGeometry(void);
    190123                /*}}}*/
    191 
    192 
     124                /*Penta specific routines:{{{1*/
     125                void      CreateKMatrixBalancedthickness(Mat Kggg);
     126                void      CreateKMatrixBalancedvelocities(Mat Kggg);
     127                void      CreateKMatrixDiagnosticHoriz( Mat Kgg);
     128                void      CreateKMatrixDiagnosticHutter( Mat Kgg);
     129                void      CreateKMatrixDiagnosticStokes( Mat Kgg);
     130                void      CreateKMatrixDiagnosticVert( Mat Kgg);
     131                void      CreateKMatrixMelting(Mat Kggg);
     132                void      CreateKMatrixPrognostic(Mat Kggg);
     133                void      CreateKMatrixSlopeCompute(Mat Kggg);
     134                void      CreateKMatrixThermal(Mat Kggg);
     135                void      CreatePVectorBalancedthickness( Vec pg);
     136                void      CreatePVectorBalancedvelocities( Vec pg);
     137                void      CreatePVectorDiagnosticHoriz( Vec pg);
     138                void      CreatePVectorDiagnosticHutter( Vec pg);
     139                void      CreatePVectorDiagnosticStokes( Vec pg);
     140                void      CreatePVectorDiagnosticVert( Vec pg);
     141                void      CreatePVectorMelting( Vec pg);
     142                void      CreatePVectorPrognostic( Vec pg);
     143                void      CreatePVectorSlopeCompute( Vec pg);
     144                void      CreatePVectorThermal( Vec pg);
     145                double*   GaussFromNode(Node* node);
     146                void      GetB(double* pB, double* xyz_list, double* gauss_coord);
     147                void      GetBPrime(double* B, double* xyz_list, double* gauss_coord);
     148                void      GetBPrime_vert(double* B, double* xyz_list, double* gauss_coord);
     149                void      GetBStokes(double* B, double* xyz_list, double* gauss_coord);
     150                void      GetB_advec(double* B_advec, double* xyz_list, double* gauss_coord);
     151                void      GetB_artdiff(double* B_artdiff, double* xyz_list, double* gauss_coord);
     152                void      GetB_conduct(double* B_conduct, double* xyz_list, double* gauss_coord);
     153                void      GetB_vert(double* B, double* xyz_list, double* gauss_coord);
     154                void      GetBprimeStokes(double* B_prime, double* xyz_list, double* gauss_coord);
     155                void      GetBprime_advec(double* Bprime_advec, double* xyz_list, double* gauss_coord);
     156                void      GetDofList(int* doflist,int* pnumberofdofs);
     157                void      GetDofList1(int* doflist);
     158                void      GetJacobian(double* J, double* xyz_list,double* gauss_coord);
     159                void      GetJacobianDeterminant(double*  Jdet, double* xyz_list,double* gauss_coord);
     160                void      GetJacobianInvert(double*  Jinv, double* xyz_list,double* gauss_coord);
     161                void      GetLStokes(double* LStokes, double* gauss_coord_tria);
     162                void      GetLprimeStokes(double* LprimeStokes, double* xyz_list, double* gauss_coord_tria, double* gauss_coord);
     163                void      GetMatrixInvert(double*  Ke_invert, double* Ke);
     164                void      GetNodalFunctions(double* l1l6, double* gauss_coord);
     165                void      GetNodalFunctionsDerivatives(double* dh1dh6,double* xyz_list, double* gauss_coord);
     166                void      GetNodalFunctionsDerivativesReference(double* dl1dl6,double* gauss_coord);
     167                void      GetNodalFunctionsDerivativesReferenceStokes(double* dl1dl7,double* gauss_coord);
     168                void      GetNodalFunctionsDerivativesStokes(double* dh1dh7,double* xyz_list, double* gauss_coord);
     169                void      GetNodalFunctionsStokes(double* l1l7, double* gauss_coord);
     170                void      GetParameterDerivativeValue(double* p, double* p_list,double* xyz_list, double* gauss_coord);
     171                void      GetParameterValue(double* pvalue, double* v_list,double* gauss_coord);
     172                void      GetPhi(double* phi, double*  epsilon, double viscosity);
     173                void      GetSolutionFromInputsDiagnosticHoriz(Vec solutiong);
     174                void      GetSolutionFromInputsDiagnosticStokes(Vec solutiong);
     175                void      GetSolutionFromInputsDiagnosticVert(Vec solutiong);
     176                void      GetStrainRate(double* epsilon, double* velocity, double* xyz_list, double* gauss_coord);
     177                void      GetStrainRateStokes(double* epsilon, double* velocity, double* xyz_list, double* gauss_coord);
     178                Penta*    GetUpperElement(void);
     179                void      InputExtrude(int enum_type);
     180                bool      IsInput(int name);
     181                bool      IsOnSurface(void);
     182                void      ReduceMatrixStokes(double* Ke_reduced, double* Ke_temp);
     183                void      ReduceVectorStokes(double* Pe_reduced, double* Ke_temp, double* Pe_temp);
     184                void      SetClone(int* minranks);
     185                void*     SpawnBeam(int g0, int g1);
     186                void*     SpawnSing(int g0);
     187                void*     SpawnTria(int g0, int g1, int g2);
     188                void      SurfaceNormal(double* surface_normal, double xyz_list[3][3]);
     189                void      VecExtrude(Vec vector,double* vector_serial,int iscollapsed);
     190                /*}}}*/
    193191};
    194192#endif  /* _PENTA_H */

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

    r3984 r4249  
    1717                Hook hneighbors; // 2 elements, first down, second up
    1818
    19 
    2019                /*FUNCTION constructors, destructors {{{1*/
    2120                PentaHook();

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

    r4248 r4249  
     1
    12/*!\file: Sing.h
    23 * \brief prototypes for Sing element
    … …  
    3637                Inputs* inputs;
    3738
    38 
    3939                /*Sing constructors, destructors: {{{1*/
    4040                Sing();
    4141                ~Sing();
    42                 void  Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type);
    43                 void  UpdateGeometry(void){ISSMERROR("not implemented yet");};
    4442                /*}}}*/
    4543                /*Object virtual functions definitions:{{{1 */
    … …  
    5452                Object* copy();
    5553                /*}}}*/
    56                 /*Sing managemnet: {{{1*/
    57                 void  Configure(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
    58                 bool  IsInput(int name);
    59                 void  SetClone(int* minranks);
    60                 void  InputDepthAverageAtBase(int enum_type,int average_enum_type){ISSMERROR("not implemented yet");};
    61                 void  InputToResult(int enum_type,int step,double time);
    62                 void   ProcessResultsUnits(void);
    63                 /*}}}*/
    6454                /*Update virtual functions resolution: {{{1*/
    6555                void  InputUpdateFromVector(double* vector, int name, int type);
    … …  
    7161                void  InputUpdateFromSolution(double* solutiong);
    7262                /*}}}*/
    73                 /*numerics: {{{1*/
    74                 void  CreateKMatrix(Mat Kggg);
    75                 void  CreatePVector(Vec pg);
    76                 void  GetDofList(int* doflist,int* pnumberofdofs);
    77                 void  GetSolutionFromInputs(Vec solution);
    78                 void  GetDofList1(int* doflist);
    79                 void  CreateKMatrixDiagnosticHutter(Mat Kggg);
    80                 void  GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3);
    81                 void  CreatePVectorDiagnosticHutter(Vec pgg);
    82                 void* GetMatPar();
    83                 void  ComputeBasalStress(Vec sigma_bg);
    84                 void  ComputePressure(Vec p_gg);
    85                 void  ComputeStrainRate(Vec epsg);
    86                 void  GetNodes(void** vpnodes);
    87                 void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
    88                 void  PatchFill(int* pcount, Patch* patch);
    89                 void  MinVel(double* pminvel, bool process_units);
    90                 void  MaxVel(double* pmaxvel, bool process_units);
    91                 void  MinVx(double* pminvx, bool process_units);
    92                 void  MaxVx(double* pmaxvx, bool process_units);
    93                 void  MaxAbsVx(double* pmaxabsvx, bool process_units);
    94                 void  MinVy(double* pminvy, bool process_units);
    95                 void  MaxVy(double* pmaxvy, bool process_units);
    96                 void  MaxAbsVy(double* pmaxabsvy, bool process_units);
    97                 void  MinVz(double* pminvz, bool process_units);
    98                 void  MaxVz(double* pmaxvz, bool process_units);
    99                 void  MaxAbsVz(double* pmaxabsvz, bool process_units);
    100                 void  InputDuplicate(int original_enum,int new_enum);
    101                 void  InputScale(int enum_type,double scale_factor);
    102                 void  InputAXPY(int YEnum, double scalar, int XEnum);
    103                 void  InputConvergence(int* pconverged,double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums);
    104                 void  InputControlConstrain(int control_type,double cm_min, double cm_max);
    105 
    106 
     63                /*Element virtual functions definitions: {{{1*/
     64                void   ComputeBasalStress(Vec sigma_b);
     65                void   ComputePressure(Vec p_g);
     66                void   ComputeStrainRate(Vec eps);
     67                void   Configure(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
     68                double CostFunction(void);
     69                void   CreateKMatrix(Mat Kgg);
     70                void   CreatePVector(Vec pg);
     71                void   Du(Vec du_g);
     72                void   GetBedList(double* bed_list);
     73                void*  GetMatPar();
     74                void   GetNodes(void** nodes);
     75                bool   GetOnBed();
     76                bool   GetShelf();
     77                void   GetSolutionFromInputs(Vec solution);
     78                void   GetThicknessList(double* thickness_list);
     79                void   GetVectorFromInputs(Vec vector,int NameEnum);
     80                void   Gradj(Vec gradient,int control_type);
     81                void   GradjB(Vec gradient);
     82                void   GradjDrag(Vec gradient);
     83                void   InputAXPY(int YEnum, double scalar, int XEnum);
     84                void   InputControlConstrain(int control_type,double cm_min, double cm_max);
     85                void   InputConvergence(int* pconverged,double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums);
     86                void   InputDepthAverageAtBase(int enum_type,int average_enum_type){ISSMERROR("not implemented yet");}
     87                void   InputDuplicate(int original_enum,int new_enum);
     88                void   InputScale(int enum_type,double scale_factor);
     89                void   InputToResult(int enum_type,int step,double time);
     90                double MassFlux(double* segment);
     91                void   MaxAbsVx(double* pmaxabsvx, bool process_units);
     92                void   MaxAbsVy(double* pmaxabsvy, bool process_units);
     93                void   MaxAbsVz(double* pmaxabsvz, bool process_units);
     94                void   MaxVel(double* pmaxvel, bool process_units);
     95                void   MaxVx(double* pmaxvx, bool process_units);
     96                void   MaxVy(double* pmaxvy, bool process_units);
     97                void   MaxVz(double* pmaxvz, bool process_units);
     98                void   MinVel(double* pminvel, bool process_units);
     99                void   MinVx(double* pminvx, bool process_units);
     100                void   MinVy(double* pminvy, bool process_units);
     101                void   MinVz(double* pminvz, bool process_units);
     102                double Misfit(void);
     103                void   PatchFill(int* pcount, Patch* patch);
     104                void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
     105                void   ProcessResultsUnits(void);
     106                double SurfaceArea(void);
     107                void   Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type);
     108                void   UpdateGeometry(void){ISSMERROR("not implemented yet");};
    107109                /*}}}*/
    108                 /*not implemented: {{{1*/
    109                 bool   GetShelf();
    110                 bool   GetOnBed();
    111                 void  GetBedList(double*);
    112                 void  GetThicknessList(double* thickness_list);
    113                 void  Du(Vec);
    114                 void  Gradj(Vec gradient,int control_type);
    115                 void  GradjDrag(Vec gradient);
    116                 void  GradjB(Vec gradient);
    117                 double Misfit(void);
    118                 double SurfaceArea(void);
    119                 double CostFunction(void);
    120                 double MassFlux(double* segment);
    121                 void  GetVectorFromInputs(Vec vector,int NameEnum);
     110                /*Sing specific routines: {{{1*/
     111                void      CreateKMatrixDiagnosticHutter(Mat Kggg);
     112                void      CreatePVectorDiagnosticHutter(Vec pgg);
     113                void      GetDofList(int* doflist,int* pnumberofdofs);
     114                void      GetDofList1(int* doflist);
     115                void      GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3);
     116                bool      IsInput(int name);
     117                void      SetClone(int* minranks);
    122118                /*}}}*/
    123 
    124119
    125120

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

    r4248 r4249  
    3939                Tria();
    4040                Tria(int tria_id,int i, IoModel* iomodel,int nummodels);
    41                 void  Update(int index,IoModel* iomodel,int analysis_counter,int analysis_type);
    42                 void  UpdateGeometry(void);
    4341                ~Tria();
    4442                /*}}}*/
    … …  
    5351                int   Enum();
    5452                Object* copy();
    55                 /*}}}*/
    56                 /*Tria management:{{{1*/
    57                 void  Configure(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
    58                 bool  IsInput(int name);
    59                 void  SetClone(int* minranks);
    60                 void  InputDepthAverageAtBase(int enum_type,int average_enum_type);
    61                 void*  SpawnSing(int g0);
    62                 void*  SpawnBeam(int g0, int g1);
    63                 void  InputToResult(int enum_type,int step,double time);
    64                 void   ProcessResultsUnits(void);
    6553                /*}}}*/
    6654                /*Update virtual functions resolution: {{{1*/
    … …  
    8169                void  UpdateFromDakota(void* inputs);
    8270                /*}}}*/
    83                 /*FUNCTION element numerical routines {{{1*/
    84                 void  CreateKMatrix(Mat Kgg);
    85                 void  CreatePVector(Vec pg);
    86                 void  GetSolutionFromInputs(Vec solution);
    87                 void  GetSolutionFromInputsDiagnosticHoriz(Vec solution);
    88                 void  GetDofList(int* doflist,int* pnumberofdofs);
    89                 void  GetDofList1(int* doflist);
    90                 void  CreateKMatrixDiagnosticHutter(Mat Kgg);
    91                 void  CreateKMatrixDiagnosticHoriz(Mat Kgg);
    92                 void  CreateKMatrixDiagnosticHorizFriction(Mat Kgg);
    93                 void  CreateKMatrixDiagnosticSurfaceVert(Mat Kgg);
    94                 void  CreateKMatrixSlopeCompute(Mat Kgg);
    95                 void  GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3);
    96                 void  GetParameterDerivativeValue(double* p, double* plist,double* xyz_list, double* gauss_l1l2l3);
    97                 void  GetJacobianDeterminant2d(double*  Jdet, double* xyz_list,double* gauss_l1l2l3);
    98                 void  GetJacobianDeterminant3d(double*  Jdet, double* xyz_list,double* gauss_l1l2l3);
    99                 void  GetB(double* B, double* xyz_list, double* gauss_l1l2l3);
    100                 void  GetBPrime(double* Bprime, double* xyz_list, double* gauss_l1l2l3);
    101                 void  GetL(double* L, double* xyz_list, double* gauss_l1l2l3,int numdof);
    102                 void  GetB_prog(double* B_prog, double* xyz_list, double* gauss_l1l2l3);
    103                 void  GetBPrime_prog(double* Bprime_prog, double* xyz_list, double* gauss_l1l2l3);
    104                 void  GetNodalFunctions(double* l1l2l3, double* gauss_l1l2l3);
    105                 void  GetNodalFunctionsDerivatives(double* dh1dh3,double* xyz_list, double* gauss_l1l2l3);
    106                 void  GetNodalFunctionsDerivativesReference(double* dl1dl3,double* gauss_l1l2l3);
    107                 void  GetJacobianInvert(double*  Jinv, double* xyz_list,double* gauss_l1l2l3);
    108                 void  GetJacobian(double* J, double* xyz_list,double* gauss_l1l2l3);
    109                 void  Du(Vec du_g);
    110                 void  Gradj(Vec gradient,int control_type);
    111                 void  GradjDrag(Vec gradient);
    112                 void  GradjDragStokes(Vec gradient);
    113                 void  GradjB(Vec gradient);
    114                 void  SurfaceNormal(double* surface_normal, double xyz_list[3][3]);
     71                /*Element virtual functions definitions: {{{1*/
     72                void   ComputeBasalStress(Vec sigma_b);
     73                void   ComputePressure(Vec p_g);
     74                void   ComputeStrainRate(Vec eps);
     75                void   Configure(Elements* elements,Loads* loads,DataSet* nodes,Materials* materials,Parameters* parameters);
     76                double CostFunction(void);
     77                void   CreateKMatrix(Mat Kgg);
     78                void   CreatePVector(Vec pg);
     79                void   Du(Vec du_g);
     80                void   GetBedList(double* bed_list);
     81                void*  GetMatPar();
     82                void   GetNodes(void** nodes);
     83                bool   GetOnBed();
     84                bool   GetShelf();
     85                void   GetSolutionFromInputs(Vec solution);
     86                void   GetThicknessList(double* thickness_list);
     87                void   GetVectorFromInputs(Vec vector,int NameEnum);
     88                void   Gradj(Vec gradient,int control_type);
     89                void   GradjB(Vec gradient);
     90                void   GradjDrag(Vec gradient);
     91                void   InputAXPY(int YEnum, double scalar, int XEnum);
     92                void   InputControlConstrain(int control_type,double cm_min, double cm_max);
     93                void   InputConvergence(int* pconverged,double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums);
     94                void   InputDepthAverageAtBase(int enum_type,int average_enum_type);
     95                void   InputDuplicate(int original_enum,int new_enum);
     96                void   InputScale(int enum_type,double scale_factor);
     97                void   InputToResult(int enum_type,int step,double time);
     98                double MassFlux(double* segment);
     99                void   MaxAbsVx(double* pmaxabsvx, bool process_units);
     100                void   MaxAbsVy(double* pmaxabsvy, bool process_units);
     101                void   MaxAbsVz(double* pmaxabsvz, bool process_units);
     102                void   MaxVel(double* pmaxvel, bool process_units);
     103                void   MaxVx(double* pmaxvx, bool process_units);
     104                void   MaxVy(double* pmaxvy, bool process_units);
     105                void   MaxVz(double* pmaxvz, bool process_units);
     106                void   MinVel(double* pminvel, bool process_units);
     107                void   MinVx(double* pminvx, bool process_units);
     108                void   MinVy(double* pminvy, bool process_units);
     109                void   MinVz(double* pminvz, bool process_units);
    115110                double Misfit(void);
     111                void   PatchFill(int* pcount, Patch* patch);
     112                void   PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
     113                void   ProcessResultsUnits(void);
    116114                double SurfaceArea(void);
    117                 double CostFunction(void);
    118                 void  CreatePVectorDiagnosticHutter(Vec pg);
    119                 void  CreatePVectorDiagnosticHoriz(Vec pg);
    120                 void  CreatePVectorDiagnosticBaseVert(Vec pg);
    121                 void  CreatePVectorSlopeCompute( Vec pg);
    122                 void* GetMatPar(void);
    123                 bool  GetShelf(void);
    124                 void  GetNodes(void** nodes);
    125                 bool  GetOnBed(void);
    126                 void  GetThicknessList(double* thickness_list);
    127                 void  GetBedList(double* bed_list);
    128                 void  ComputeBasalStress(Vec sigma_b);
    129                 void  ComputePressure(Vec p_g);
    130                 void  ComputeStrainRate(Vec eps);
    131                 void  CreateKMatrixThermal(Mat Kgg);
    132                 void  CreateKMatrixMelting(Mat Kgg);
    133                 void  CreatePVectorThermalShelf( Vec pg);
    134                 void  CreatePVectorThermalSheet( Vec pg);
    135                 void  CreateKMatrixPrognostic(Mat Kgg);
    136                 void  CreatePVectorPrognostic(Vec pg);
    137                 void  CreateKMatrixPrognostic2(Mat Kgg);
    138                 void  CreatePVectorPrognostic2(Vec pg);
    139                 void  CreateKMatrixBalancedthickness(Mat Kgg);
    140                 void  CreatePVectorBalancedthickness(Vec pg);
    141                 void  CreateKMatrixBalancedthickness2(Mat Kgg);
    142                 void  CreatePVectorBalancedthickness2(Vec pg);
    143                 void  CreateKMatrixBalancedvelocities(Mat Kgg);
    144                 void  CreatePVectorBalancedvelocities(Vec pg);
    145                 double MassFlux(double* segment);
    146                 double GetArea(void);
    147                 double GetAreaCoordinate(double x, double y, int which_one);
    148                 void  PatchSize(int* pnumrows, int* pnumvertices,int* pnumnodes);
    149                 void  PatchFill(int* pcount, Patch* patch);
    150                 void  MinVel(double* pminvel, bool process_units);
    151                 void  MaxVel(double* pmaxvel, bool process_units);
    152                 void  MinVx(double* pminvx, bool process_units);
    153                 void  MaxVx(double* pmaxvx, bool process_units);
    154                 void  MaxAbsVx(double* pmaxabsvx, bool process_units);
    155                 void  MinVy(double* pminvy, bool process_units);
    156                 void  MaxVy(double* pmaxvy, bool process_units);
    157                 void  MaxAbsVy(double* pmaxabsvy, bool process_units);
    158                 void  MinVz(double* pminvz, bool process_units);
    159                 void  MaxVz(double* pmaxvz, bool process_units);
    160                 void  MaxAbsVz(double* pmaxabsvz, bool process_units);
    161                 void  InputDuplicate(int original_enum,int new_enum);
    162                 void  InputScale(int enum_type,double scale_factor);
    163                 void  InputAXPY(int YEnum, double scalar, int XEnum);
    164                 void  InputConvergence(int* pconverged,double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums);
    165                 void  InputControlConstrain(int control_type,double cm_min, double cm_max);
    166                 void  GetVectorFromInputs(Vec vector,int NameEnum);
    167 
    168 
     115                void   Update(int index, IoModel* iomodel,int analysis_counter,int analysis_type);
     116                void   UpdateGeometry(void);
     117                /*}}}*/
     118                /*Tria specific routines:{{{1*/
     119                void      CreateKMatrixBalancedthickness(Mat Kgg);
     120                void      CreateKMatrixBalancedthickness2(Mat Kgg);
     121                void      CreateKMatrixBalancedvelocities(Mat Kgg);
     122                void      CreateKMatrixDiagnosticHoriz(Mat Kgg);
     123                void      CreateKMatrixDiagnosticHorizFriction(Mat Kgg);
     124                void      CreateKMatrixDiagnosticHutter(Mat Kgg);
     125                void      CreateKMatrixDiagnosticSurfaceVert(Mat Kgg);
     126                void      CreateKMatrixMelting(Mat Kgg);
     127                void      CreateKMatrixPrognostic(Mat Kgg);
     128                void      CreateKMatrixPrognostic2(Mat Kgg);
     129                void      CreateKMatrixSlopeCompute(Mat Kgg);
     130                void      CreateKMatrixThermal(Mat Kgg);
     131                void      CreatePVectorBalancedthickness(Vec pg);
     132                void      CreatePVectorBalancedthickness2(Vec pg);
     133                void      CreatePVectorBalancedvelocities(Vec pg);
     134                void      CreatePVectorDiagnosticBaseVert(Vec pg);
     135                void      CreatePVectorDiagnosticHoriz(Vec pg);
     136                void      CreatePVectorDiagnosticHutter(Vec pg);
     137                void      CreatePVectorPrognostic(Vec pg);
     138                void      CreatePVectorPrognostic2(Vec pg);
     139                void      CreatePVectorSlopeCompute( Vec pg);
     140                void      CreatePVectorThermalSheet( Vec pg);
     141                void      CreatePVectorThermalShelf( Vec pg);
     142                double    GetArea(void);
     143                double    GetAreaCoordinate(double x, double y, int which_one);
     144                void      GetB(double* B, double* xyz_list, double* gauss_l1l2l3);
     145                void      GetBPrime(double* Bprime, double* xyz_list, double* gauss_l1l2l3);
     146                void      GetBPrime_prog(double* Bprime_prog, double* xyz_list, double* gauss_l1l2l3);
     147                void      GetB_prog(double* B_prog, double* xyz_list, double* gauss_l1l2l3);
     148                void      GetDofList(int* doflist,int* pnumberofdofs);
     149                void      GetDofList1(int* doflist);
     150                void      GetJacobian(double* J, double* xyz_list,double* gauss_l1l2l3);
     151                void      GetJacobianDeterminant2d(double*  Jdet, double* xyz_list,double* gauss_l1l2l3);
     152                void      GetJacobianDeterminant3d(double*  Jdet, double* xyz_list,double* gauss_l1l2l3);
     153                void      GetJacobianInvert(double*  Jinv, double* xyz_list,double* gauss_l1l2l3);
     154                void      GetL(double* L, double* xyz_list, double* gauss_l1l2l3,int numdof);
     155                void      GetNodalFunctions(double* l1l2l3, double* gauss_l1l2l3);
     156                void      GetNodalFunctionsDerivatives(double* dh1dh3,double* xyz_list, double* gauss_l1l2l3);
     157                void      GetNodalFunctionsDerivativesReference(double* dl1dl3,double* gauss_l1l2l3);
     158                void      GetParameterDerivativeValue(double* p, double* plist,double* xyz_list, double* gauss_l1l2l3);
     159                void      GetParameterValue(double* pp, double* plist, double* gauss_l1l2l3);
     160                void      GetSolutionFromInputsDiagnosticHoriz(Vec solution);
     161                void      GradjDragStokes(Vec gradient);
     162                bool      IsInput(int name);
     163                void      SetClone(int* minranks);
     164                void*     SpawnBeam(int g0, int g1);
     165                void*     SpawnSing(int g0);
     166                void      SurfaceNormal(double* surface_normal, double xyz_list[3][3]);
    169167                /*}}}*/
    170168
Note: See TracChangeset for help on using the changeset viewer.