Changeset 5480

Timestamp:

08/23/10 00:31:34 (15 years ago)

Author:

Eric.Larour

Message:

Can now accomodate scaled, indexed, nodal and regular type responses!

Location:

issm/trunk/src/c/modules/DakotaResponsesx

Files:

• DakotaResponsesx.cpp (modified) (1 diff)
• DakotaResponsesx.h (modified) (1 diff)

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

@@ -18 +18 @@
 
 
-void DakotaResponsesx(double* responses,Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,char** responses_descriptors,int numresponses){
+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){
 
         int        i,j,k;
-        int        dummy;
-        int        counter;
         extern int my_rank;
         bool       process_units = true;
 
         /*intermediary: */
-        char* response_descriptor=NULL;
+        char   root[50];
+        int    index;
+        int    npart;
         double femmodel_response;
+        int    flag;
+        double* vertex_response=NULL;
+        double* partition_response=NULL;
+
+        double* responses_pointer=NULL;
+
+        /*retrieve npart: */
+        parameters->FindParam(&npart,QmuNPartEnum);
+
+        /*save the d_responses pointer: */
+        responses_pointer=d_responses;
+
+        //watch out, we have more d_numresponses than numresponsedescriptors, because the responses have been expanded if they were scaled. 
+        //because we don't know the d_responses descriptors (the scaled ones) we can't key off them, so we will key off the responses_descriptors: */
+                
+        for(i=0;i<numresponsedescriptors;i++){
+                
+                flag=DescriptorIndex(root,&index,responses_descriptors[i]);
+
+                if(flag==ScaledEnum){
+
+                        /*this response was scaled. pick up the response from the inputs: */
+                        GetVectorFromInputsx(&vertex_response,elements,nodes, vertices, loads, materials, parameters, StringToEnum(root),VertexEnum);
+
+                        /*Now, average it onto the partition grids: */
+                        AverageOntoPartitionx(&partition_response,vertex_response,vertices,parameters,node_partition);
+
+                        /*Copy onto our dakota responses: */
+                        for(i=0;i<npart;i++)responses_pointer[i]=partition_response[i];
+
+                        /*Free ressources:*/
+                        xfree((void**)&vertex_response);
+                        xfree((void**)&partition_response);
+
+                        /*increment response_pointer :*/
+                        responses_pointer+=npart;
+
+                }
+                else if (flag==IndexedEnum){
+
+                        /*indexed response: plug index into parameters and call response module: */
+                        parameters->SetParam(index,IndexEnum);
                         
-        for(i=0;i<numresponses;i++){
+                        //Responsex(responses_pointer,elements,nodes, vertices,loads,materials, parameters,root,process_units);
+                        Responsex(&femmodel_response,elements,nodes, vertices,loads,materials, parameters,root,process_units);
+                        
+                        if(my_rank==0){
+                                /*plug response: */
+                                responses_pointer[0]=femmodel_response;
 
-                response_descriptor=responses_descriptors[i];
+                                /*increment response_pointer :*/
+                                responses_pointer++;
+                        }
+                }
+                else if (flag==NodalEnum){
+                        ISSMERROR(" nodal response functions not supported yet!");
 
-                /*Compute response for this response_descriptor:*/
-                Responsex(&femmodel_response,elements,nodes, vertices,loads,materials, parameters,response_descriptor,process_units);
+                        /*increment response_pointer :*/
+                        responses_pointer++;
+                }
+                else if (flag==RegularEnum){
+                        
+                        /*perfectly normal response function: */
+                        Responsex(&femmodel_response,elements,nodes, vertices,loads,materials, parameters,root,process_units);
 
-                #ifdef _DEBUG_
-                if(my_rank==0)printf("response: %s: %g\n",response_descriptor,femmodel_response);
-                #endif
-                        
-                /*send response back to Dakota only on cpu 0: */
-                if(my_rank==0)responses[i]=femmodel_response;
+                        if(my_rank==0){
+                                /*plug response: */
+                                responses_pointer[0]=femmodel_response;
+
+                                /*increment response_pointer :*/
+                                responses_pointer++;
+                        }
+                }
+                else ISSMERROR("%s%i%s"," flag type ",flag," not supported yet for response analysis");
         }
+
 
         /*Synthesize echo: {{{*/
         if(my_rank==0){
-                printf("   responses: %i: ",numresponses);
-                for(i=0;i<numresponses-1;i++)printf("%g|",responses[i]);
-                printf("%g",responses[numresponses-1]);
+                printf("   responses: %i: ",d_numresponses);
+                for(i=0;i<d_numresponses-1;i++)printf("%g|",d_responses[i]);
+                printf("%g",d_responses[d_numresponses-1]);
                 printf("\n");
         }

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

@@ -9 +9 @@
 #include "../../Container/Container.h"
 
-void DakotaResponsesx(double* responses,Elements* elements,Nodes* nodes, Vertices* vertices,Loads* loads,Materials* materials, Parameters* parameters,char** responses_descriptors,int numresponses);
+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);
 
 #endif  /* _DAKOTARESPONSESXX_H */