Changeset 5518


Ignore:
Timestamp:
08/23/10 14:27:43 (15 years ago)
Author:
Eric.Larour
Message:

completed AverageOntoPartitionx module.
fixed segfault in DakotaResponsesx for scaled responses.

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

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/modules/AverageOntoPartitionx/AverageOntoPartitionx.cpp

    r5478 r5518  
    1919
    2020                       
    21 void AverageOntoPartitionx(double** average, double* vertex_response, Vertices* vertices, Parameters* parameters,Vec node_partition){
     21void AverageOntoPartitionx(double** paverage, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,double* vertex_response,Vec vertex_cluster_partition){
    2222
    2323        int     i,j,k;
    … …  
    2525
    2626        int     qmu_npart;
    27         double *qmu_part_serial = NULL;
     27        double *qmu_part_nocluster = NULL;
    2828        double *qmu_part  = NULL;
    29         double* partition=NULL; //serial version of node_partition
     29        double* partition=NULL; //serial version of vertex_cluster_partition
    3030        int     numberofvertices;
    3131
    32         /*First, recover qmu partition of vertices. Careful, do not confuse with node_partition, which is just used to distribute vertices
     32        /*output: */
     33        Vec partition_contributions=NULL;
     34        Vec partition_areas=NULL;
     35        Vec vec_average=NULL;
     36        double* average=NULL;
     37
     38        /*First, recover qmu partition of vertices. Careful, do not confuse with vertex_cluster_partition, which is just used to distribute vertices
    3339         * onto cpus in a cluter: */
    34         if(!parameters->FindParam(&qmu_part_serial,&dummy,QmuPartEnum))ISSMERROR(" could not find qmu partition vector");
     40        if(!parameters->FindParam(&qmu_part_nocluster,&dummy,QmuPartEnum))ISSMERROR(" could not find qmu partition vector");
    3541
    3642        /*Some parameters: */
    … …  
    3844        parameters->FindParam(&qmu_npart,QmuNPartEnum);
    3945
    40         /*serialize nodal partition vector: */
    41         VecToMPISerial(&partition,node_partition);
     46        /*serialize vertex_cluster_partition: */
     47        VecToMPISerial(&partition,vertex_cluster_partition);
    4248
    43         /*Use partition vector to repartition qmu_part_serial, which is ordered in a serial way: */
     49        /*Use partition vector to repartition qmu_part_nocluster, which is ordered for use on a serial machine, not a cluster: */
    4450        qmu_part=(double*)xmalloc(numberofvertices*sizeof(double));
    45         for(k=0;k<numberofvertices;k++) qmu_part[(int)(partition[k])]=qmu_part_serial[k];
     51        for(k=0;k<numberofvertices;k++) qmu_part[(int)(partition[k])]=qmu_part_nocluster[k];
    4652
    4753        /*Ok, now we have a qmu partition (into separate areas) that takes into account the parallelism of the cluster.
    … …  
    4955         be a npart sized vector. */
    5056
    51         ISSMERROR(" not supported yet!");
     57        /*allocate: */
     58        partition_contributions=NewVec(qmu_npart);
     59        partition_areas=NewVec(qmu_npart);
     60        vec_average=NewVec(qmu_npart);
    5261
     62        /*loop on each element, and add contribution of the element to the partition (surface weighted average): */
     63        for(i=0;i<elements->Size();i++){
     64                Element* element=(Element*)elements->GetObjectByOffset(i);
     65                element->AverageOntoPartition(partition_contributions,partition_areas,vertex_response,qmu_part);
     66        }
    5367
     68        /*Assemble: */
     69        VecAssemblyBegin(partition_contributions);
     70        VecAssemblyEnd(partition_contributions);
     71
     72        VecAssemblyBegin(partition_areas);
     73        VecAssemblyEnd(partition_areas);
     74
     75        /*We have the partition_areas and the partition_contributions for each partition -> compute the surfae weighted average: */
     76        VecPointwiseDivide(vec_average,partition_contributions,partition_areas);
     77
     78        /*serialize:*/
     79        VecToMPISerial(&average,vec_average);
     80
     81        /*Free ressources:*/
     82        xfree((void**)&partition);
     83        xfree((void**)&qmu_part_nocluster);
     84        xfree((void**)&qmu_part);
     85        VecFree(&partition_contributions);
     86        VecFree(&partition_areas);
     87        VecFree(&vec_average);
     88
     89        /*Assign output pointers:*/
     90        *paverage=average;
    5491}

  • issm/trunk/src/c/modules/AverageOntoPartitionx/AverageOntoPartitionx.h

    r5478 r5518  
    99#include "../../Container/Container.h"
    1010
    11 void AverageOntoPartitionx(double** average, double* vertex_response, Vertices* vertices,Parameters* parameters,Vec node_partition);
     11void AverageOntoPartitionx(double** average, Elements* elements, Nodes* nodes, Vertices* vertices, Loads* loads, Materials* materials, Parameters* parameters,double* vertex_response,Vec vertex_cluster_partition);
    1212
    1313#endif  /* _AVERAGEONTOPARTITIONXX_H */

  • issm/trunk/src/c/modules/DakotaResponsesx/DakotaResponsesx.cpp

    r5480 r5518  
    1818
    1919
    20 void DakotaResponsesx(double* d_responses,Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,Vec node_partition,char** responses_descriptors,int numresponsedescriptors,int d_numresponses){
     20void DakotaResponsesx(double* d_responses,Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,Vec vertex_cluster_partition,char** responses_descriptors,int numresponsedescriptors,int d_numresponses){
    2121
    2222        int        i,j,k;
    … …  
    3131        int    flag;
    3232        double* vertex_response=NULL;
    33         double* partition_response=NULL;
     33        double* qmu_response=NULL;
    3434
    3535        double* responses_pointer=NULL;
    … …  
    5454
    5555                        /*Now, average it onto the partition grids: */
    56                         AverageOntoPartitionx(&partition_response,vertex_response,vertices,parameters,node_partition);
     56                        AverageOntoPartitionx(&qmu_response,elements,nodes,vertices,loads,materials,parameters,vertex_response,vertex_cluster_partition);
    5757
    5858                        /*Copy onto our dakota responses: */
    59                         for(i=0;i<npart;i++)responses_pointer[i]=partition_response[i];
     59                        if(my_rank==0){
     60                                /*plug response: */
     61                                for(i=0;i<npart;i++)responses_pointer[i]=qmu_response[i];
     62
     63                                /*increment response_pointer :*/
     64                                responses_pointer+=npart;
     65                        }
    6066
    6167                        /*Free ressources:*/
    6268                        xfree((void**)&vertex_response);
    63                         xfree((void**)&partition_response);
    64 
    65                         /*increment response_pointer :*/
    66                         responses_pointer+=npart;
     69                        xfree((void**)&qmu_response);
    6770
    6871                }

  • issm/trunk/src/c/modules/DakotaResponsesx/DakotaResponsesx.h

    r5480 r5518  
    99#include "../../Container/Container.h"
    1010
    11 void DakotaResponsesx(double* d_responses,Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,Vec node_partition,char** responses_descriptors,int numresponsedescriptors,int d_numresponses);
     11void DakotaResponsesx(double* d_responses,Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,Vec vertex_cluster_partition,char** responses_descriptors,int numresponsedescriptors,int d_numresponses);
    1212
    1313#endif  /* _DAKOTARESPONSESXX_H */

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

    r5286 r5518  
    7878                virtual void   InputControlUpdate(double scalar,bool save_parameter)=0;
    7979                virtual bool   InputConvergence(double* eps, int* enums,int num_enums,int* criterionenums,double* criterionvalues,int num_criterionenums)=0;
     80                virtual void   AverageOntoPartition(Vec partition_contributions,Vec partition_areas,double* vertex_response,double* qmu_part)=0;
    8081
    8182                /*Implementation: */

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

    r5510 r5518  
    465465
    466466/*Element virtual functions definitions: */
     467/*FUNCTION Penta::AverageOntoPartition {{{1*/
     468void  Penta::AverageOntoPartition(Vec partition_contributions,Vec partition_areas,double* vertex_response,double* qmu_part){
     469        ISSMERROR("Not supported yet!");
     470}
     471/*}}}*/
    467472/*FUNCTION Penta::ComputeBasalStress {{{1*/
    468473void  Penta::ComputeBasalStress(Vec sigma_b){

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

    r5311 r5518  
    6969                /*}}}*/
    7070                /*Element virtual functions definitions: {{{1*/
     71                void   AverageOntoPartition(Vec partition_contributions,Vec partition_areas,double* vertex_response,double* qmu_part);
    7172                void   ComputeBasalStress(Vec sigma_b);
    7273                void   ComputePressure(Vec p_g);

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

    r5414 r5518  
    529529
    530530/*Element virtual functions definitions: */
     531/*FUNCTION Tria::AverageOntoPartition {{{1*/
     532void  Tria::AverageOntoPartition(Vec partition_contributions,Vec partition_areas,double* vertex_response,double* qmu_part){
     533
     534        int       i,j;
     535        const int numvertices=3;
     536        double    area;
     537        double    mean;
     538        int       partition[numvertices];
     539        int       offset[numvertices];
     540        double    values[3];
     541        bool      already=false;
     542
     543        /*First, get the area: */
     544        area=this->GetArea();
     545
     546        /*Figure out the average for this element: */
     547        this->GetDofList1(&offset[0]);
     548        mean=0;
     549        for(i=0;i<numvertices;i++){
     550                partition[i]=(int)qmu_part[offset[i]];
     551                mean=mean+1.0/numvertices*vertex_response[offset[i]];
     552        }
     553
     554        /*Add contribution: */
     555        for(i=0;i<numvertices;i++){
     556                already=false;
     557                for(j=0;j<i;j++){
     558                        if (partition[i]==partition[j]){
     559                                already=true;
     560                                break;
     561                        }
     562                }
     563                if(!already){
     564                        VecSetValue(partition_contributions,partition[i],mean*area,ADD_VALUES);
     565                        VecSetValue(partition_areas,partition[i],area,ADD_VALUES);
     566                };
     567        }
     568}
     569/*}}}*/
    531570/*FUNCTION Tria::ComputeBasalStress {{{1*/
    532571void  Tria::ComputeBasalStress(Vec eps){
    … …  
    63786417        x3=xyz_list[2][0]; y3=xyz_list[2][1];
    63796418 
    6380         return x2*y3 - y2*x3 + x1*y2 - y1*x2 + x3*y1 - y3*x1;
     6419        return (x2*y3 - y2*x3 + x1*y2 - y1*x2 + x3*y1 - y3*x1)/2;
    63816420}
    63826421/*}}}*/

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

    r5387 r5518  
    6666                /*}}}*/
    6767                /*Element virtual functions definitions: {{{1*/
     68                void   AverageOntoPartition(Vec partition_contributions,Vec partition_areas,double* vertex_response,double* qmu_part);
    6869                void   ComputeBasalStress(Vec sigma_b);
    6970                void   ComputePressure(Vec p_g);
Note: See TracChangeset for help on using the changeset viewer.