Changeset 23629


Ignore:
Timestamp:
01/13/19 20:48:33 (6 years ago)
Author:
Mathieu Morlighem
Message:

NEW: do not use MPISerial in InputUpdateFromSolution anymore

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

Legend:

Unmodified
Added
Removed

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

    r23585 r23629  
    23352335
    23362336        /*Get dof list: */
    2337         element->GetDofListVelocity(&vdoflist,GsetEnum);
    2338         element->GetDofListPressure(&pdoflist,GsetEnum);
     2337        element->GetDofListLocalVelocity(&vdoflist,GsetEnum);
     2338        element->GetDofListLocalPressure(&pdoflist,GsetEnum);
    23392339
    23402340        /*Use the dof list to index into the solution vector: */
    … …  
    24012401        else                                              numdof   = numnodes*1;
    24022402        /*Fetch dof list and allocate solution vectors*/
    2403         element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     2403        element->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    24042404        IssmDouble* values  = xNew<IssmDouble>(numdof);
    24052405        IssmDouble* lambdax = xNew<IssmDouble>(numnodes);

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

    r23587 r23629  
    634634
    635635        /*Fetch dof list and allocate solution vector*/
    636         element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     636        element->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    637637        IssmDouble* newdamage = xNew<IssmDouble>(numnodes);
    638638

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

    r23620 r23629  
    15281528
    15291529        /*Fetch dof list and allocate solution vector*/
    1530         element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     1530        element->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    15311531        IssmDouble* values        = xNew<IssmDouble>(numnodes);
    15321532        IssmDouble* pressure      = xNew<IssmDouble>(numnodes);

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

    r23585 r23629  
    435435        IssmDouble* eplHeads    = xNew<IssmDouble>(numnodes);
    436436        IssmDouble* basevalue    = xNew<IssmDouble>(numnodes);
    437         basalelement->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     437        basalelement->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    438438
    439439        Input* active_element_input=basalelement->GetInput(HydrologydcMaskEplactiveEltEnum); _assert_(active_element_input);

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

    r23585 r23629  
    511511
    512512        /*Fetch dof list and allocate solution vector*/
    513         basalelement->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     513        basalelement->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    514514        IssmDouble* values   = xNew<IssmDouble>(numnodes);
    515515        IssmDouble* pressure = xNew<IssmDouble>(numnodes);

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

    r23585 r23629  
    361361
    362362        /*Fetch dof list and allocate solution vector*/
    363         element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     363        element->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    364364        IssmDouble* values = xNew<IssmDouble>(numnodes);
    365365

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

    r23585 r23629  
    356356
    357357        /*Fetch dof list and allocate solution vector*/
    358         element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     358        element->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    359359        IssmDouble* values = xNew<IssmDouble>(numnodes);
    360360

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

    r23587 r23629  
    708708
    709709        /*Fetch dof list and allocate solution vector*/
    710         basalelement->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     710        basalelement->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    711711        IssmDouble* newthickness   = xNew<IssmDouble>(numnodes);
    712712        IssmDouble* cumdeltathickness = xNew<IssmDouble>(numnodes);

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

    r23585 r23629  
    19151915
    19161916        /*Fetch dof list and allocate solution vectors*/
    1917         basalelement->GetDofList(&doflist,SSAApproximationEnum,GsetEnum);
     1917        basalelement->GetDofListLocal(&doflist,SSAApproximationEnum,GsetEnum);
    19181918        IssmDouble* values    = xNew<IssmDouble>(numdof);
    19191919        IssmDouble* vx        = xNew<IssmDouble>(numnodes);
    … …  
    22442244
    22452245        /*Fetch dof list and allocate solution vectors*/
    2246         basalelement->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     2246        basalelement->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    22472247        IssmDouble* values    = xNew<IssmDouble>(numdof);
    22482248        IssmDouble* vx        = xNew<IssmDouble>(numnodes);
    … …  
    28992899
    29002900        /*Fetch dof list and allocate solution vectors*/
    2901         element->GetDofList(&doflist,HOApproximationEnum,GsetEnum);
     2901        element->GetDofListLocal(&doflist,HOApproximationEnum,GsetEnum);
    29022902        IssmDouble* values = xNew<IssmDouble>(numdof);
    29032903        IssmDouble* vx     = xNew<IssmDouble>(numnodes);
    … …  
    51825182
    51835183        /*Get dof list: */
    5184         element->GetDofListVelocity(&vdoflist,GsetEnum);
    5185         element->GetDofListPressure(&pdoflist,GsetEnum);
     5184        element->GetDofListLocalVelocity(&vdoflist,GsetEnum);
     5185        element->GetDofListLocalPressure(&pdoflist,GsetEnum);
    51865186
    51875187        /*Use the dof list to index into the solution vector: */
    … …  
    70817081
    70827082        /*Fetch dof list and allocate solution vectors*/
    7083         element->GetDofList(&doflistFSv,FSvelocityEnum,GsetEnum);
    7084         element->GetDofList(&doflistHO, HOApproximationEnum, GsetEnum);
    7085         element->GetDofListPressure(&doflistFSp,GsetEnum);
     7083        element->GetDofListLocal(&doflistFSv,FSvelocityEnum,GsetEnum);
     7084        element->GetDofListLocal(&doflistHO, HOApproximationEnum, GsetEnum);
     7085        element->GetDofListLocalPressure(&doflistFSp,GsetEnum);
    70867086        IssmDouble* HOvalues  = xNew<IssmDouble>(numdofHO);
    70877087        IssmDouble* FSvalues  = xNew<IssmDouble>(numdofFSv+numdofFSp);
    … …  
    71807180
    71817181        /*Fetch dof list and allocate solution vectors*/
    7182         element->GetDofList(&doflistFSv,FSvelocityEnum,GsetEnum);
    7183         element->GetDofListPressure(&doflistFSp,GsetEnum);
    7184         basalelement->GetDofList(&doflistSSA, SSAApproximationEnum, GsetEnum);
     7182        element->GetDofListLocal(&doflistFSv,FSvelocityEnum,GsetEnum);
     7183        element->GetDofListLocalPressure(&doflistFSp,GsetEnum);
     7184        basalelement->GetDofListLocal(&doflistSSA, SSAApproximationEnum, GsetEnum);
    71857185        IssmDouble* SSAvalues  = xNew<IssmDouble>(numdofSSA);
    71867186        IssmDouble* FSvalues  = xNew<IssmDouble>(numdofFSv+numdofFSp);
    … …  
    72817281
    72827282        /*Fetch dof list and allocate solution vectors*/
    7283         basalelement->GetDofList(&SSAdoflist,SSAApproximationEnum,GsetEnum);
    7284         element     ->GetDofList(&HOdoflist, HOApproximationEnum, GsetEnum);
     7283        basalelement->GetDofListLocal(&SSAdoflist,SSAApproximationEnum,GsetEnum);
     7284        element     ->GetDofListLocal(&HOdoflist, HOApproximationEnum, GsetEnum);
    72857285        IssmDouble* HOvalues  = xNew<IssmDouble>(numdof);
    72867286        IssmDouble* SSAvalues = xNew<IssmDouble>(numdof);

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

    r23585 r23629  
    564564
    565565        /*Fetch dof list and allocate solution vectors*/
    566         element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     566        element->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    567567        IssmDouble* values    = xNew<IssmDouble>(numdof);
    568568        IssmDouble* vx        = xNew<IssmDouble>(numdof);

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

    r23585 r23629  
    526526        /*Get dof list and vertices coordinates: */
    527527        element->GetVerticesCoordinates(&xyz_list);
    528         element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     528        element->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    529529        IssmDouble*  values    = xNew<IssmDouble>(numdof);
    530530        IssmDouble*  vx        = xNew<IssmDouble>(numnodes);

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

    r23585 r23629  
    814814
    815815        /*Fetch dof list and allocate solution vector*/
    816         element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     816        element->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    817817        IssmDouble* values    = xNew<IssmDouble>(numnodes);
    818818        IssmDouble* surface   = xNew<IssmDouble>(numnodes);

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

    r23585 r23629  
    205205
    206206        /*Fetch dof list and allocate solution vector*/
    207         element->GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     207        element->GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    208208        IssmDouble* values        = xNew<IssmDouble>(numnodes);
    209209        IssmDouble* valueslambda  = xNewZeroInit<IssmDouble>(numnodessigma);

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

    r23612 r23629  
    10041004}
    10051005/*}}}*/
     1006void       Element::GetDofListLocal(int** pdoflist,int approximation_enum,int setenum){/*{{{*/
     1007
     1008        /*Fetch number of nodes and dof for this finite element*/
     1009        int numnodes = this->GetNumberOfNodes();
     1010
     1011        /*First, figure out size of doflist and create it: */
     1012        int numberofdofs=0;
     1013        for(int i=0;i<numnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(approximation_enum,setenum);
     1014
     1015        /*Allocate output*/
     1016        int* doflist=xNew<int>(numberofdofs);
     1017
     1018        /*Populate: */
     1019        int count=0;
     1020        for(int i=0;i<numnodes;i++){
     1021                nodes[i]->GetDofListLocal(doflist+count,approximation_enum,setenum);
     1022                count+=nodes[i]->GetNumberOfDofs(approximation_enum,setenum);
     1023        }
     1024
     1025        /*Assign output pointers:*/
     1026        *pdoflist=doflist;
     1027}
     1028/*}}}*/
    10061029void       Element::GetDofListPressure(int** pdoflist,int setenum){/*{{{*/
    10071030
    … …  
    10441067        for(int i=0;i<numnodes;i++){
    10451068                nodes[i]->GetDofList(doflist+count,FSvelocityEnum,setenum);
     1069                count+=nodes[i]->GetNumberOfDofs(FSvelocityEnum,setenum);
     1070        }
     1071
     1072        /*Assign output pointers:*/
     1073        *pdoflist=doflist;
     1074}
     1075/*}}}*/
     1076void       Element::GetDofListLocalPressure(int** pdoflist,int setenum){/*{{{*/
     1077
     1078        /*Fetch number of nodes and dof for this finite element*/
     1079        int vnumnodes = this->NumberofNodesVelocity();
     1080        int pnumnodes = this->NumberofNodesPressure();
     1081
     1082        /*First, figure out size of doflist and create it: */
     1083        int numberofdofs=0;
     1084        for(int i=vnumnodes;i<vnumnodes+pnumnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(FSApproximationEnum,setenum);
     1085
     1086        /*Allocate output*/
     1087        int* doflist=xNew<int>(numberofdofs);
     1088
     1089        /*Populate: */
     1090        int count=0;
     1091        for(int i=vnumnodes;i<vnumnodes+pnumnodes;i++){
     1092                nodes[i]->GetDofListLocal(doflist+count,FSApproximationEnum,setenum);
     1093                count+=nodes[i]->GetNumberOfDofs(FSApproximationEnum,setenum);
     1094        }
     1095
     1096        /*Assign output pointers:*/
     1097        *pdoflist=doflist;
     1098}
     1099/*}}}*/
     1100void       Element::GetDofListLocalVelocity(int** pdoflist,int setenum){/*{{{*/
     1101
     1102        /*Fetch number of nodes and dof for this finite element*/
     1103        int numnodes = this->NumberofNodesVelocity();
     1104
     1105        /*First, figure out size of doflist and create it: */
     1106        int numberofdofs=0;
     1107        for(int i=0;i<numnodes;i++) numberofdofs+=nodes[i]->GetNumberOfDofs(FSvelocityEnum,setenum);
     1108
     1109        /*Allocate output*/
     1110        int* doflist=xNew<int>(numberofdofs);
     1111
     1112        /*Populate: */
     1113        int count=0;
     1114        for(int i=0;i<numnodes;i++){
     1115                nodes[i]->GetDofListLocal(doflist+count,FSvelocityEnum,setenum);
    10461116                count+=nodes[i]->GetNumberOfDofs(FSvelocityEnum,setenum);
    10471117        }

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

    r23540 r23629  
    8686                void                 GetDofListPressure(int** pdoflist,int setenum);
    8787                void                 GetDofListVelocity(int** pdoflist,int setenum);
     88                void                 GetDofListLocal(int** pdoflist,int approximation_enum,int setenum);
     89                void                 GetDofListLocalPressure(int** pdoflist,int setenum);
     90                void                 GetDofListLocalVelocity(int** pdoflist,int setenum);
    8891                Input*             GetInput(int inputenum);
    8992                void               GetInputListOnNodes(IssmDouble* pvalue,int enumtype);

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

    r23599 r23629  
    15941594
    15951595        /*Fetch dof list and allocate solution vector*/
    1596         GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     1596        GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    15971597        IssmDouble* values    = xNew<IssmDouble>(numnodes);
    15981598
    … …  
    16251625
    16261626        /*Get dof list: */
    1627         GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     1627        GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    16281628
    16291629        /*Use the dof list to index into the solution vector and extrude it */

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

    r23532 r23629  
    490490
    491491        /*Fetch dof list and allocate solution vector*/
    492         GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     492        GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    493493        IssmDouble* values    = xNew<IssmDouble>(numnodes);
    494494

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

    r23607 r23629  
    21702170
    21712171        /*Fetch dof list and allocate solution vector*/
    2172         GetDofList(&doflist,NoneApproximationEnum,GsetEnum);
     2172        GetDofListLocal(&doflist,NoneApproximationEnum,GsetEnum);
    21732173        IssmDouble* values    = xNew<IssmDouble>(numnodes);
    21742174

  • issm/trunk-jpl/src/c/classes/Node.cpp

    r23628 r23629  
    452452}
    453453/*}}}*/
     454void Node::GetDofListLocal(int* outdoflist,int approximation_enum,int setenum){/*{{{*/
     455        int i;
     456        int count=0;
     457        int count2=0;
     458
     459        _assert_(!this->indexingupdate);
     460
     461        if(approximation_enum==NoneApproximationEnum){
     462                if(setenum==GsetEnum)for(i=0;i<this->gsize;i++) outdoflist[i]=gdoflist_local[i];
     463                if(setenum==FsetEnum)for(i=0;i<this->fsize;i++) outdoflist[i]=fdoflist_local[i];
     464                if(setenum==SsetEnum)for(i=0;i<this->ssize;i++) outdoflist[i]=sdoflist_local[i];
     465        }
     466        else{
     467
     468                if(setenum==GsetEnum){
     469                        if(doftype){
     470                                count=0;
     471                                for(i=0;i<this->gsize;i++){
     472                                        if(doftype[i]==approximation_enum){
     473                                                outdoflist[count]=gdoflist_local[i];
     474                                                count++;
     475                                        }
     476                                }
     477                                _assert_(count); //at least one dof should be the approximation requested
     478                        }
     479                        else for(i=0;i<this->gsize;i++) outdoflist[i]=gdoflist_local[i];
     480                }
     481                else if(setenum==FsetEnum){
     482                        if(doftype){
     483                                count=0;
     484                                count2=0;
     485                                for(i=0;i<this->gsize;i++){
     486                                        if(f_set[i]){
     487                                                if(doftype[i]==approximation_enum){
     488                                                        outdoflist[count]=fdoflist_local[count2];
     489                                                        count++;
     490                                                }
     491                                                count2++;
     492                                        }
     493                                }
     494                        }
     495                        else for(i=0;i<this->fsize;i++) outdoflist[i]=fdoflist_local[i];
     496                }
     497                else if(setenum==SsetEnum){
     498                        if(doftype){
     499                                count=0;
     500                                count2=0;
     501                                for(i=0;i<this->gsize;i++){
     502                                        if(s_set[i]){
     503                                                if(doftype[i]==approximation_enum){
     504                                                        outdoflist[count]=sdoflist_local[count2];
     505                                                        count++;
     506                                                }
     507                                                count2++;
     508                                        }
     509                                }
     510                        }
     511                        else for(i=0;i<this->ssize;i++) outdoflist[i]=sdoflist_local[i];
     512                }
     513                else _error_("set of enum type " << EnumToStringx(setenum) << " not supported yet!");
     514        }
     515}
     516/*}}}*/
    454517void Node::GetLocalDofList(int* outdoflist,int approximation_enum,int setenum){/*{{{*/
    455518        int i;

  • issm/trunk-jpl/src/c/classes/Node.h

    r23628 r23629  
    8989                int   GetDof(int dofindex,int setenum);
    9090                void  GetDofList(int* poutdoflist,int approximation_enum,int setenum);
     91                void  GetDofListLocal(int* poutdoflist,int approximation_enum,int setenum);
    9192                void  GetLocalDofList(int* poutdoflist,int approximation_enum,int setenum);
    9293                int   GetNumberOfDofs(int approximation_enum,int setenum);

  • issm/trunk-jpl/src/c/classes/Nodes.cpp

    r23627 r23629  
    259259}
    260260/*}}}*/
     261int   Nodes::NumberOfDofsLocalAll(int setenum){/*{{{*/
     262
     263        /*go through all nodes, and get how many dofs they own, unless they are clone nodes: */
     264        int numdofs=0;
     265        for(int i=0;i<this->Size();i++){
     266                Node* node=xDynamicCast<Node*>(this->GetObjectByOffset(i));
     267                numdofs+=node->GetNumberOfDofs(NoneApproximationEnum,setenum);
     268        }
     269        return numdofs;
     270}
     271/*}}}*/
    261272int   Nodes::NumberOfNodes(void){/*{{{*/
    262273

  • issm/trunk-jpl/src/c/classes/Nodes.h

    r23587 r23629  
    3737                int   NumberOfDofs(int setenum);
    3838                int   NumberOfDofsLocal(int setenum);
     39                int   NumberOfDofsLocalAll(int setenum);
    3940                int   NumberOfNodes(void);
    4041                bool  RequiresDofReindexing(void);

  • issm/trunk-jpl/src/c/modules/InputUpdateFromSolutionx/InputUpdateFromSolutionx.cpp

    r23473 r23629  
    99void InputUpdateFromSolutionx(FemModel* femmodel,Vector<IssmDouble>* solution){
    1010
    11         /*Serialize solution, so that elements can index into it on every CPU: */
    12         femmodel->profiler->Start(MPISERIAL);
    13         IssmDouble* serial_solution=solution->ToMPISerial();
    14         femmodel->profiler->Stop(MPISERIAL);
    15 
    16         /*Call overloaded form of InputUpdateFromSolutionx: */
    17         InputUpdateFromSolutionx(femmodel,serial_solution);
    18 
    19         /*cleanup and return*/
    20         xDelete<IssmDouble>(serial_solution);
    21 }
    22 
    23 void InputUpdateFromSolutionx(FemModel* femmodel,IssmDouble* solution){
    24 
    25         /*retrive parameters: */
    26         int analysisenum;
    27         femmodel->parameters->FindParam(&analysisenum,AnalysisTypeEnum);
    28 
    2911        /*Display message*/
    3012        if(VerboseModule()) _printf0_("   Updating inputs from solution\n");
    3113
     14        /*GetAnalysis*/
     15        int analysisenum;
     16        femmodel->parameters->FindParam(&analysisenum,AnalysisTypeEnum);
    3217        Analysis* analysis = EnumToAnalysis(analysisenum);
     18
     19        /*recover my_rank:*/
     20        ISSM_MPI_Status status;
     21        int my_rank   = IssmComm::GetRank();
     22        int num_procs = IssmComm::GetSize();
     23
     24        /*retrieve node info*/
     25        int gsize              = femmodel->nodes->NumberOfDofs(GsetEnum);
     26        int glocalsize_masters = femmodel->nodes->NumberOfDofsLocal(GsetEnum);
     27        int glocalsize         = femmodel->nodes->NumberOfDofsLocalAll(GsetEnum);
     28        int maxdofspernode     = femmodel->nodes->MaxNumDofs(GsetEnum);
     29
     30        /*Get local vector of ug*/
     31        int        *indices_ug_masters = NULL;
     32        IssmDouble *local_ug_masters   = NULL;
     33        solution->GetLocalVector(&local_ug_masters,&indices_ug_masters);
     34        _assert_(glocalsize_masters==indices_ug_masters[glocalsize_masters-1] - indices_ug_masters[0]+1);
     35        xDelete<int>(indices_ug_masters);
     36
     37        /*Now, extend vectors to account for clones (make vectors longer, for clones at the end)*/
     38        IssmDouble *local_ug  = xNew<IssmDouble>(glocalsize);
     39        xMemCpy<IssmDouble>(local_ug,local_ug_masters,glocalsize_masters);
     40        xDelete<IssmDouble>(local_ug_masters);
     41
     42        /*Now send and receive ug for nodes on partition edge*/
     43        IssmDouble* buffer = xNew<IssmDouble>(femmodel->nodes->Size()*maxdofspernode); //only one alloc
     44        for(int rank=0;rank<num_procs;rank++){
     45                if(femmodel->nodes->common_send[rank]){
     46                        int  numids = femmodel->nodes->common_send[rank];
     47                        for(int i=0;i<numids;i++){
     48                                int   master_lid = femmodel->nodes->common_send_ids[rank][i];
     49                                Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(master_lid));
     50                                _assert_(!node->IsClone());
     51                                for(int j=0;j<node->gsize;j++) buffer[i*maxdofspernode+j]=local_ug[node->gdoflist_local[j]];
     52                        }
     53                        ISSM_MPI_Send(buffer,numids*maxdofspernode,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm());
     54                }
     55        }
     56        for(int rank=0;rank<num_procs;rank++){
     57                if(femmodel->nodes->common_recv[rank]){
     58                        int  numids = femmodel->nodes->common_recv[rank];
     59                        ISSM_MPI_Recv(buffer,numids*maxdofspernode,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm(),&status);
     60                        for(int i=0;i<numids;i++){
     61                                int   master_lid = femmodel->nodes->common_recv_ids[rank][i];
     62                                Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(master_lid));
     63                                for(int j=0;j<node->gsize;j++) local_ug[node->gdoflist_local[j]] = buffer[i*maxdofspernode+j];
     64                        }
     65                }
     66        }
     67        xDelete<IssmDouble>(buffer);
     68
     69        /*Now update inputs (analysis specific)*/
    3370        for(int i=0;i<femmodel->elements->Size();i++){
    3471                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    35                 analysis->InputUpdateFromSolution(solution,element);
     72                analysis->InputUpdateFromSolution(local_ug,element);
    3673        }
     74
     75        /*cleanup and return*/
    3776        delete analysis;
     77        xDelete<IssmDouble>(local_ug);
    3878}

  • issm/trunk-jpl/src/c/modules/InputUpdateFromSolutionx/InputUpdateFromSolutionx.h

    r16695 r23629  
    1111/* local prototypes: */
    1212void    InputUpdateFromSolutionx(FemModel* femmodel,Vector<IssmDouble>* solution);
    13 void  InputUpdateFromSolutionx(FemModel* femmodel,IssmDouble* solution);
    1413
    1514#endif  /* _UPDATEINPUTSFROMSOLUTIONXX_H */

  • issm/trunk-jpl/src/c/modules/Mergesolutionfromftogx/Mergesolutionfromftogx.cpp

    r23628 r23629  
    1313        /*first, get gsize, fsize and ssize: */
    1414        int gsize=nodes->NumberOfDofs(GsetEnum);
     15        int gsize_local=nodes->NumberOfDofsLocal(GsetEnum);
    1516        int fsize=nodes->NumberOfDofs(FsetEnum);
    1617        int ssize=nodes->NumberOfDofs(SsetEnum);
    … …  
    2930
    3031        /*initialize ug: */
    31         Vector<IssmDouble>* ug=new Vector<IssmDouble>(gsize);
     32        Vector<IssmDouble>* ug=new Vector<IssmDouble>(gsize_local,gsize);
    3233
    3334        /*Let nodes figure it out*/

  • issm/trunk-jpl/src/c/modules/SetActiveNodesLSMx/SetActiveNodesLSMx.cpp

    r23587 r23629  
    8585
    8686        /*Create vector on gset*/
    87         int gsize=femmodel->nodes->NumberOfDofs(GsetEnum);
     87        int gsize              = femmodel->nodes->NumberOfDofs(GsetEnum);
     88        int glocalsize_masters = femmodel->nodes->NumberOfDofsLocal(GsetEnum);
    8889        if(gsize==0)  return;
    89         Vector<IssmDouble>* vec_mask_ice=new Vector<IssmDouble>(gsize);
     90        Vector<IssmDouble>* vec_mask_ice=new Vector<IssmDouble>(glocalsize_masters,gsize);
    9091
    9192        /*Fill vector with values: */
    … …  
    107108        /*Assemble vector and serialize */
    108109        vec_mask_ice->Assemble();
    109         IssmDouble* mask_ice=vec_mask_ice->ToMPISerial();
     110
     111
     112        /*FIXME: What follows should be copied and pasted into InputUpdateFromSolution Nodes*/
     113
     114        /*recover my_rank:*/
     115        ISSM_MPI_Status status;
     116        int my_rank   = IssmComm::GetRank();
     117        int num_procs = IssmComm::GetSize();
     118
     119        /*retrieve node info*/
     120        int glocalsize         = femmodel->nodes->NumberOfDofsLocalAll(GsetEnum);
     121        int maxdofspernode     = femmodel->nodes->MaxNumDofs(GsetEnum);
     122
     123        /*Get local vector of ug*/
     124        int        *indices_ug_masters = NULL;
     125        IssmDouble *local_ug_masters   = NULL;
     126        vec_mask_ice->GetLocalVector(&local_ug_masters,&indices_ug_masters);
     127        _assert_(glocalsize_masters==indices_ug_masters[glocalsize_masters-1] - indices_ug_masters[0]+1);
     128        xDelete<int>(indices_ug_masters);
    110129        delete vec_mask_ice;
     130
     131        /*Now, extend vectors to account for clones (make vectors longer, for clones at the end)*/
     132        IssmDouble *local_ug  = xNew<IssmDouble>(glocalsize);
     133        xMemCpy<IssmDouble>(local_ug,local_ug_masters,glocalsize_masters);
     134        xDelete<IssmDouble>(local_ug_masters);
     135
     136        /*Now send and receive ug for nodes on partition edge*/
     137        IssmDouble* buffer = xNew<IssmDouble>(femmodel->nodes->Size()*maxdofspernode); //only one alloc
     138        for(int rank=0;rank<num_procs;rank++){
     139                if(femmodel->nodes->common_send[rank]){
     140                        int  numids = femmodel->nodes->common_send[rank];
     141                        for(int i=0;i<numids;i++){
     142                                int   master_lid = femmodel->nodes->common_send_ids[rank][i];
     143                                Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(master_lid));
     144                                _assert_(!node->IsClone());
     145                                for(int j=0;j<node->gsize;j++) buffer[i*maxdofspernode+j]=local_ug[node->gdoflist_local[j]];
     146                        }
     147                        ISSM_MPI_Send(buffer,numids*maxdofspernode,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm());
     148                }
     149        }
     150        for(int rank=0;rank<num_procs;rank++){
     151                if(femmodel->nodes->common_recv[rank]){
     152                        int  numids = femmodel->nodes->common_recv[rank];
     153                        ISSM_MPI_Recv(buffer,numids*maxdofspernode,ISSM_MPI_DOUBLE,rank,0,IssmComm::GetComm(),&status);
     154                        for(int i=0;i<numids;i++){
     155                                int   master_lid = femmodel->nodes->common_recv_ids[rank][i];
     156                                Node* node=xDynamicCast<Node*>(femmodel->nodes->GetObjectByOffset(master_lid));
     157                                for(int j=0;j<node->gsize;j++) local_ug[node->gdoflist_local[j]] = buffer[i*maxdofspernode+j];
     158                        }
     159                }
     160        }
     161        xDelete<IssmDouble>(buffer);
     162
     163        /*Now update inputs (analysis specific)*/
    111164        for(int i=0;i<femmodel->elements->Size();i++){
    112165                Element* element=xDynamicCast<Element*>(femmodel->elements->GetObjectByOffset(i));
    113                 element->InputUpdateFromSolutionOneDof(mask_ice,IceMaskNodeActivationEnum);
     166                element->InputUpdateFromSolutionOneDof(local_ug,IceMaskNodeActivationEnum);
    114167        }
    115168
    116         /*Clean up and return*/
    117         xDelete<IssmDouble>(mask_ice);
     169        /*cleanup and return*/
     170        xDelete<IssmDouble>(local_ug);
    118171}/*}}}*/
Note: See TracChangeset for help on using the changeset viewer.