Changeset 3454


Ignore:
Timestamp:
04/08/10 08:14:48 (15 years ago)
Author:
Eric.Larour
Message:

Added SetClone to virtual functions of Object.

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

Legend:

Unmodified
Added
Removed

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

    r3446 r3454  
    715715}
    716716/*}}}*/
    717 /*FUNCTION DataSet::NodeRank{{{1*/
    718 void   DataSet::NodeRank(int* ranks){
    719 
    720         /*Go through a dataset, and find a Node* object. For this object,
    721          * ask it to report its cpu rank: */
    722 
    723         int node_rank;
     717/*FUNCTION DataSet::Ranks{{{1*/
     718void   DataSet::Ranks(int* ranks){
     719
     720        /*Go through a dataset, and for each object, report it cpu: */
     721
     722        int rank;
    724723        int id;
    725724        vector<Object*>::iterator object;
    … …  
    731730
    732731                        /*Ok, this object is a node, ask which rank it has: */
    733                         node_rank=(*object)->MyRank();
     732                        rank=(*object)->MyRank();
    734733
    735734                        /*Which id does it have: */
    … …  
    737736
    738737                        /*Plug rank into ranks, according to id: */
    739                         ranks[id-1]=node_rank; //Matlab ids start at 1.
     738                        ranks[id-1]=rank; //Matlab ids start at 1.
    740739                }
    741740        }
    … …  
    11491148/*}}}*/
    11501149/*FUNCTION DataSet::FlagClones{{{1*/
    1151 void  DataSet::FlagClones(int numberofnodes){
     1150void  DataSet::FlagClones(int numberofobjects){
    11521151
    11531152        int i;
    … …  
    11581157
    11591158        vector<Object*>::iterator object;
    1160         Node* node=NULL;
    11611159
    11621160        /*Allocate ranks: */
    1163         ranks=(int*)xmalloc(numberofnodes*sizeof(int));
    1164         minranks=(int*)xmalloc(numberofnodes*sizeof(int));
    1165 
    1166         for(i=0;i<numberofnodes;i++)ranks[i]=num_procs; //no cpu can have rank num_procs. This is the maximum limit.
    1167 
    1168         /*Now go through all our nodes and ask them to report to who they belong (which rank): */
    1169         NodeRank(ranks);
    1170 
    1171 #ifdef _ISSM_DEBUG_
    1172         for(i=0;i<numberofnodes;i++){
     1161        ranks=(int*)xmalloc(numberofobjects*sizeof(int));
     1162        minranks=(int*)xmalloc(numberofobjects*sizeof(int));
     1163
     1164        for(i=0;i<numberofobjects;i++)ranks[i]=num_procs; //no cpu can have rank num_procs. This is the maximum limit.
     1165
     1166        /*Now go through all our objects and ask them to report to who they belong (which rank): */
     1167        Ranks(ranks);
     1168
     1169        #ifdef _ISSM_DEBUG_
     1170        for(i=0;i<numberofobjects;i++){
    11731171                _printf_("%i\n",ranks[i]);
    11741172        }
    1175 #endif
    1176 
    1177         /*We need to take the minimum rank for each node, and every cpu needs to get that result. That way,
    1178          * when we start building the dof list for all nodes, a cpu can check whether its node already has been
     1173        #endif
     1174
     1175        /*We need to take the minimum rank for each vertex, and every cpu needs to get that result. That way,
     1176         * when we start building the dof list for all vertexs, a cpu can check whether its vertex already has been
    11791177         * dealt with by another cpu. We take the minimum because we are going to manage dof assignment in increasing
    11801178         * order of cpu rank. This is also why we initialized this array to num_procs.*/
    1181         MPI_Allreduce ( (void*)ranks,(void*)minranks,numberofnodes,MPI_INT,MPI_MIN,MPI_COMM_WORLD);
    1182 
    1183 #ifdef _ISSM_DEBUG_
    1184         for(i=0;i<numberofnodes;i++){
    1185                 _printf_("%i\n",minranks[i]);
    1186         }
    1187 #endif
    1188 
    1189         /*Now go through all nodes, and use minranks to flag which nodes are cloned: */
    1190         for ( object=objects.begin() ; object < objects.end(); object++ ){
    1191 
    1192                 /*Check this is a node: */
     1179        MPI_Allreduce ( (void*)ranks,(void*)minranks,numberofobjects,MPI_INT,MPI_MIN,MPI_COMM_WORLD);
     1180
     1181        #ifdef _ISSM_DEBUG_
     1182                for(i=0;i<numberofobjects;i++){
     1183                        _printf_("%i\n",minranks[i]);
     1184                }
     1185        #endif
     1186
     1187        /*Now go through all objects, and use minranks to flag which objects are cloned: */
     1188        for ( object=objects.begin() ; object < objects.end(); object++ ){
     1189
     1190                /*Check this is a vertex: */
    11931191                if((*object)->Enum()==NodeEnum()){
    1194 
    1195                         node=(Node*)(*object);
    1196 
    1197                         /*Ok, this object is a node, ask it to plug values into partition: */
    1198                         node->SetClone(minranks);
     1192                       
     1193                        /*For this object, decide whether it is a clone: */
     1194                        (*object)->SetClone(minranks);
    11991195
    12001196                }

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

    r3446 r3454  
    5757                int   FindResult(Vec* presult,char* name);
    5858                Object* FindParamObject(char* name);
    59                 void  NodeRank(int* ranks);
     59                void  Ranks(int* ranks);
    6060                void  DistributeDofs(int numberofnodes,int numdofspernode);
    6161                void  CreatePartitioningVector(Vec* ppartition,int numnods,int numdofspernode);

  • issm/trunk/src/c/ModelProcessorx/DiagnosticStokes/CreateConstraintsDiagnosticStokes.cpp

    r3453 r3454  
    1515        DataSet* constraints = NULL;
    1616        Spc*    spc  = NULL;
     17        int count;
    1718
    1819        /*spc intermediary data: */

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

    r3439 r3454  
    787787}
    788788/*}}}*/
     789//*FUNCTION Beam::SetClone {{{1*/
     790void  Beam::SetClone(int* minranks){
     791
     792        ISSMERROR("not implemented yet");
     793}
     794/*}}}1*/
     795

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

    r3439 r3454  
    5757                void  Configure(void* loads,void* nodes,void* materials,void* parameters);
    5858                Object* copy();
     59                void  SetClone(int* minranks);
     60
    5961                /*}}}*/
    60                 /*object management: {{{1*/
     62                /*numerics: {{{1*/
    6163                void  CreateKMatrix(Mat Kgg,void* inputs,int analysis_type,int sub_analysis_type);
    6264                void  CreatePVector(Vec pg, void* inputs, int analysis_type,int sub_analysis_type);

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

    r3332 r3454  
    418418        return vector;
    419419}
     420/*FUNCTION DofVec::SetClone {{{1*/
     421void  DofVec::SetClone(int* minranks){
     422
     423        ISSMERROR("not implemented yet");
     424}
     425/*}}}1*/

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

    r2316 r3454  
    4545                int   MyRank();
    4646                int   Size();
     47                void  SetClone(int* minranks);
     48       
    4749
    4850                Object* copy();

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

    r3180 r3454  
    2121                virtual int    MyRank()=0;
    2222                virtual void   Marshall(char** pmarshalled_dataset)=0;
     23                virtual void   SetClone(int* minranks)=0;
    2324                virtual int    MarshallSize()=0;
    2425                virtual char*  GetName()=0;

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

    r3417 r3454  
    225225Mat                 FemModel::get_Gmn(void){return Gmn;}
    226226/*}}}*/
     227/*FUNCTION FemModel::FemModel {{{1*/
     228void  FemModel::SetClone(int* minranks){
     229
     230        ISSMERROR("not implemented yet");
     231}
     232/*}}}1*/

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

    r3420 r3454  
    5555                int   Enum();
    5656                Object* copy();
     57                void  SetClone(int* minranks);
    5758               
    5859                int FindParam(double* pscalar,char* name);

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

    r3430 r3454  
    14781478}
    14791479/*}}}*/
     1480/*FUNCTION Icefront::SetClone {{{1*/
     1481void  Icefront::SetClone(int* minranks){
     1482
     1483        ISSMERROR("not implemented yet");
     1484}
     1485/*}}}1*/
    14801486/*FUNCTION Icefront UpdateFromInputs {{{1*/
    14811487void  Icefront::UpdateFromInputs(void* vinputs){

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

    r3430 r3454  
    6969                int   MarshallSize();
    7070                int   MyRank();
     71                void   SetClone(int* minranks);
     72
    7173                /*}}}*/
    7274                /*numerics: {{{1*/

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

    r3397 r3454  
    301301}
    302302/*}}}*/
    303 
    304 
    305 
    306                
    307 
     303/*FUNCTION Input::SetClone {{{1*/
     304void  Input::SetClone(int* minranks){
     305
     306        ISSMERROR("not implemented yet");
     307}
     308/*}}}1*/

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

    r3180 r3454  
    3939               
    4040                Object* copy();
     41                void  SetClone(int* minranks);
    4142
    4243                /*fill virtual routines: */

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

    r3420 r3454  
    3232                virtual void  PenaltyCreateKMatrix(Mat Kgg,void* inputs,double kmax,int analysis_type,int sub_analysis_type)=0;
    3333                virtual void  PenaltyCreatePVector(Vec pg,void* inputs,double kmax,int analysis_type,int sub_analysis_type)=0;
     34                virtual void  SetClone(int* minranks)=0;
    3435
    3536                int           Enum();

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

    r3420 r3454  
    2121                virtual int   MyRank()=0;
    2222                virtual void  Marshall(char** pmarshalled_dataset)=0;
     23                virtual void  SetClone(int* minranks)=0;
    2324                virtual int   MarshallSize()=0;
    2425                virtual char* GetName()=0;

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

    r3420 r3454  
    1313#include <string.h>
    1414#include "../shared/shared.h"
     15#include "../include/macros.h"
    1516#include "../EnumDefinitions/EnumDefinitions.h"
    1617
    … …  
    440441}
    441442/*}}}*/
     443//*FUNCTION Matice::SetClone {{{1*/
     444void  Matice::SetClone(int* minranks){
     445
     446        ISSMERROR("not implemented yet");
     447}
     448/*}}}1*/
     449

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

    r3420 r3454  
    4444                double GetB();
    4545                double GetN();
     46                void   SetClone(int* minranks);
    4647
    4748};

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

    r3420 r3454  
    1212#include "stdio.h"
    1313#include "../shared/shared.h"
     14#include "../include/macros.h"
    1415#include "./Matpar.h"
    1516#include <string.h>
    … …  
    288289}
    289290/*}}}1*/
     291/*FUNCTION Matpar::SetClone {{{1*/
     292void  Matpar::SetClone(int* minranks){
     293
     294        ISSMERROR("not implemented yet");
     295}
     296/*}}}1*/

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

    r3420 r3454  
    5757                double GetMeltingPoint();
    5858                Object* copy();
     59                void   SetClone(int* minranks);
    5960
    6061};

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

    r3409 r3454  
    751751}
    752752/*}}}*/
     753/*FUNCTION Numericalflux::SetClone {{{1*/
     754void  Numericalflux::SetClone(int* minranks){
     755
     756        ISSMERROR("not implemented yet");
     757}
     758/*}}}1*/

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

    r3378 r3454  
    4848                int   Enum();
    4949                int   GetId();
     50                void   SetClone(int* minranks);
    5051                void  GetJacobianDeterminant(double* pJdet,double xyz_list[4][3], double gauss_coord);
    5152                void  GetNodalFunctions(double* l1l4, double gauss_coord);

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

    r3332 r3454  
    245245}
    246246/*}}}*/
     247/*FUNCTION Numpar::SetClone {{{1*/
     248void  Numpar::SetClone(int* minranks){
     249
     250        ISSMERROR("not implemented yet");
     251}
     252/*}}}1*/

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

    r2354 r3454  
    4343                int   Enum();
    4444                Object* copy();
     45                void  SetClone(int* minranks);
    4546
    4647                void  Configure(void* pparametersin);

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

    r803 r3454  
    2525                virtual void  Demarshall(char** pmarshalled_dataset)=0;
    2626                virtual int   Enum()=0;
     27                virtual void  SetClone(int* minranks)=0;
    2728                virtual Object* copy()=0;
    2829

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

    r3332 r3454  
    724724}
    725725/*}}}*/
     726/*FUNCTION Param::SetClone {{{1*/
     727void  Param::SetClone(int* minranks){
     728
     729        ISSMERROR("not implemented yet");
     730}
     731/*}}}1*/

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

    r2333 r3454  
    4545                void  Demarshall(char** pmarshalled_dataset);
    4646                int   Enum();
     47                void  SetClone(int* minranks);
    4748               
    4849                void  SetDouble(double value);

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

    r3332 r3454  
    1414#include <string.h>
    1515#include "../EnumDefinitions/EnumDefinitions.h"
     16#include "../include/macros.h"
    1617#include "../shared/shared.h"
    1718#include "../include/typedefs.h"
    … …  
    635636}
    636637/*}}}1*/
     638/*FUNCTION Pengrid::SetClone {{{1*/
     639void  Pengrid::SetClone(int* minranks){
     640
     641        ISSMERROR("not implemented yet");
     642}
     643/*}}}1*/
    637644/*FUNCTION Pengrid::UpdateFromInputs {{{1*/
    638645void  Pengrid::UpdateFromInputs(void* inputs){

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

    r2212 r3454  
    6565                void  PenaltyConstrain(int* punstable,void* inputs,int analysis_type,int sub_analysis_type);
    6666                void  PenaltyConstrainThermal(int* punstable,void* inputs,int analysis_type,int sub_analysis_type);
     67                void   SetClone(int* minranks);
     68
    6769};
    6870

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

    r3430 r3454  
    1414#include <string.h>
    1515#include "../EnumDefinitions/EnumDefinitions.h"
     16#include "../include/macros.h"
    1617#include "../shared/shared.h"
    1718#include "../include/typedefs.h"
    … …  
    233234}
    234235/*}}}1*/
     236/*FUNCTION Penpair::SetClone {{{1*/
     237void  Penpair::SetClone(int* minranks){
     238
     239        ISSMERROR("not implemented yet");
     240}
     241/*}}}1*/

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

    r1897 r3454  
    4848                void  PenaltyCreatePVector(Vec pg,void* inputs,double kmax,int analysis_type,int sub_analysis_type);
    4949                Object* copy();
     50                void   SetClone(int* minranks);
     51
    5052};
    5153

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

    r3420 r3454  
    40884088}
    40894089/*}}}*/
    4090 /*FUNCTION ReduceVectorStokes {{{1*/
     4090/**FUNCTION ReduceVectorStokes {{{1*/
    40914091void Penta::ReduceVectorStokes(double* Pe_reduced, double* Ke_temp, double* Pe_temp){
    40924092
    … …  
    41304130}
    41314131/*}}}*/
     4132/*FUNCTION Penta::SetClone {{{1*/
     4133void  Penta::SetClone(int* minranks){
     4134
     4135        ISSMERROR("not implemented yet");
     4136}
     4137/*}}}1*/
    41324138/*FUNCTION SurfaceArea {{{1*/
    41334139double Penta::SurfaceArea(void* inputs,int analysis_type,int sub_analysis_type){

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

    r3420 r3454  
    6262                void  UpdateFromDakota(void* inputs);
    6363                void  UpdateFromInputs(void* inputs);
     64                void  SetClone(int* minranks);
     65
    6466                /*}}}*/
    6567                /*FUNCTION element numerical routines {{{1*/

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

    r3332 r3454  
    1414#include <string.h>
    1515#include "../EnumDefinitions/EnumDefinitions.h"
     16#include "../include/macros.h"
    1617#include "./ParameterInputs.h"
    1718#include "../shared/shared.h"
    … …  
    290291}
    291292/*}}}1*/
     293/*FUNCTION Result::SetClone {{{1*/
     294void  Result::SetClone(int* minranks){
     295
     296        ISSMERROR("not implemented yet");
     297}
     298/*}}}1*/

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

    r1271 r3454  
    4141                int   Enum();
    4242                Object* copy();
     43                void  SetClone(int* minranks);
    4344
    4445                double GetTime();

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

    r2907 r3454  
    1414#include "../EnumDefinitions/EnumDefinitions.h"
    1515#include "../DataSet/DataSet.h"
     16#include "../shared/shared.h"
     17#include "../include/macros.h"
    1618#include "./objects.h"
    1719
    … …  
    163165}
    164166/*}}}1*/
     167/*FUNCTION Rgb::SetClone {{{1*/
     168void  Rgb::SetClone(int* minranks){
     169
     170        ISSMERROR("not implemented yet");
     171}
     172/*}}}1*/

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

    r803 r3454  
    3232                int    GetId();
    3333                int    MyRank();
     34                void  SetClone(int* minranks);
    3435
    3536                /*non virtual: */

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

    r3433 r3454  
    457457}
    458458/*}}}1*/
     459/*FUNCTION Riftfront::FreezeConstraints{{{1*/
     460void   Riftfront::FreezeConstraints(void* vinputs, int analysis_type){
     461
     462        /*Just set frozen flag to 1: */
     463        this->frozen=1;
     464
     465}
     466/*}}}1*/
    459467/*FUNCTION Riftfront::GetDofList {{{1*/
    460468
    … …  
    482490char* Riftfront::GetName(void){
    483491        return "riftfront";
     492}
     493/*}}}1*/
     494/*FUNCTION Riftfront::IsFrozen{{{1*/
     495bool   Riftfront::IsFrozen(void){
     496
     497        /*Just set frozen flag to 1: */
     498        if(this->frozen)return 1;
     499        else return 0;
    484500}
    485501/*}}}1*/
    … …  
    791807}
    792808/*}}}1*/
    793 /*FUNCTION Riftfront::PotentialUnstableC
    794  * nstraint {{{1*/
     809/*FUNCTION Riftfront::PotentialUnstableConstraint {{{1*/
    795810int   Riftfront::PotentialUnstableConstraint(int* punstable, void* vinputs, int analysis_type){
    796811
    … …  
    894909}
    895910/*}}}1*/
     911/*FUNCTION Riftfront::SetClone {{{1*/
     912void  Riftfront::SetClone(int* minranks){
     913
     914        ISSMERROR("not implemented yet");
     915}
     916/*}}}1*/
    896917/*FUNCTION Riftfront::UpdateFromInputs {{{1*/
    897918void  Riftfront::UpdateFromInputs(void* vinputs){
    … …  
    908929}
    909930/*}}}1*/
    910 /*FUNCTION Riftfront::FreezeConstraints{{{1*/
    911 void   Riftfront::FreezeConstraints(void* vinputs, int analysis_type){
    912 
    913         /*Just set frozen flag to 1: */
    914         this->frozen=1;
    915 
    916 }
    917 /*}}}1*/
    918 /*FUNCTION Riftfront::IsFrozen{{{1*/
    919 bool   Riftfront::IsFrozen(void){
    920 
    921         /*Just set frozen flag to 1: */
    922         if(this->frozen)return 1;
    923         else return 0;
    924 }
    925 /*}}}1*/

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

    r3433 r3454  
    6666                /*}}}*/
    6767                /*object management: {{{1*/
     68                void  Configure(void* elements,void* nodes,void* materials);
     69                Object* copy();
     70                void  DeepEcho();
     71                void  Demarshall(char** pmarshalled_dataset);
    6872                void  Echo();
    69                 void  DeepEcho();
     73                int   Enum();
     74                int   GetId();
     75                char* GetName();
    7076                void  Marshall(char** pmarshalled_dataset);
    7177                int   MarshallSize();
    72                 char* GetName();
    73                 void  Demarshall(char** pmarshalled_dataset);
    74                 int   Enum();
    75                 int   GetId();
    7678                int   MyRank();
    77                 void  Configure(void* elements,void* nodes,void* materials);
    78                 Object* copy();
     79                void   SetClone(int* minranks);
     80
    7981                /*}}}*/
    8082                /*numerics: {{{1*/

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

    r3439 r3454  
    623623}
    624624/*}}}*/
     625/*FUNCTION Sing::SetClone {{{1*/
     626void  Sing::SetClone(int* minranks){
     627
     628        ISSMERROR("not implemented yet");
     629}
     630/*}}}1*/

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

    r3439 r3454  
    5252                void  Marshall(char** pmarshalled_dataset);
    5353                int   MarshallSize();
     54                void  SetClone(int* minranks);
    5455                int   MyRank();
    5556                /*}}}*/

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

    r2313 r3454  
    3737                int   Enum();
    3838                Object* copy();
     39                void  SetClone(int* minranks);
    3940
    4041                /*functionality: */

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

    r2908 r3454  
    1212#include "stdio.h"
    1313#include <string.h>
     14#include "../include/macros.h"
     15#include "../shared/shared.h"
    1416#include "../EnumDefinitions/EnumDefinitions.h"
    1517#include "../DataSet/DataSet.h"
    … …  
    162164}
    163165/*}}}1*/
     166/*FUNCTION Spc::SetClone {{{1*/
     167void  Spc::SetClone(int* minranks){
     168
     169        ISSMERROR("not implemented yet");
     170}
     171/*}}}1*/

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

    r803 r3454  
    3737                double GetValue();
    3838                Object* copy();
     39                void  SetClone(int* minranks);
    3940
    4041};

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

    r3420 r3454  
    52455245}
    52465246/*}}}*/
     5247/*FUNCTION Tria::SetClone {{{1*/
     5248void  Tria::SetClone(int* minranks){
     5249
     5250        ISSMERROR("not implemented yet");
     5251}
     5252/*}}}1*/
    52475253/*FUNCTION SurfaceNormal{{{1*/
    52485254

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

    r3420 r3454  
    5656                int   MarshallSize();
    5757                int   MyRank();
     58                void  SetClone(int* minranks);
    5859                void  UpdateFromDakota(void* inputs);
    5960                void  UpdateFromInputs(void* inputs);

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

    r3420 r3454  
    185185}
    186186/*}}}*/
     187/*FUNCTION SetClone {{{1*/
     188void  Vertex::SetClone(int* minranks){
     189
     190        extern int my_rank;
     191
     192        if (minranks[id-1]==my_rank){
     193                this->clone=0;
     194        }
     195        else{
     196                /*!there is a cpu with lower rank that has the same node,
     197                therefore, I am a clone*/
     198                this->clone=1; 
     199        }
     200
     201}
     202/*}}}*/
    187203/*FUNCTION UpdateFromDakota {{{1*/
    188204void  Vertex::UpdateFromDakota(void* vinputs){

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

    r3420 r3454  
    4242                int   MarshallSize();
    4343                int   MyRank();
     44                void  SetClone(int* minranks);
    4445                void  UpdateFromDakota(void* vinputs);
    4546                void  UpdateFromInputs(void* vinputs);
Note: See TracChangeset for help on using the changeset viewer.