Changeset 5477


Ignore:
Timestamp:
08/23/10 00:28:00 (15 years ago)
Author:
Eric.Larour
Message:

We now have a different number of responses and responses descriptors. Same thing
for variables. Makes processing of Qmu inputs a lot simpler.
Had to adapt CreateParametersQmu to this new scenario. We now have DescriptorIndex
that tells us whether a variable is scaled, indexed, nodal or regular.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/modules/ModelProcessorx/Qmu/CreateParametersQmu.cpp

    r5281 r5477  
    2727        char**  variabledescriptors=NULL;
    2828        char*   descriptor=NULL;
    29         char*   root=NULL;
    3029        double* dakota_parameter=NULL;
    3130
    … …  
    3433        char* qmuerrname=NULL;
    3534        char* qmuoutname=NULL;
    36         extern int my_rank;
    37        
    38         //tags
    39         char variabledescriptors_tag[30]; //strlen("variabledescriptor"+number)+1
    40         char responsedescriptors_tag[30]; //strlen("responsedescriptors"+number)+1
    41         char massflux_tag[35];            //strlen("qmu_mass_flux_segments"+number)+1
     35       
     36        //descriptors:
     37        char tag[50];
    4238       
    4339        /*parameters for mass flux: */
    … …  
    5349        int      count;
    5450
    55         /*fetching of parameters: */
    56         int    found=0;
    57         char** strings=NULL;
    58         char*  string=NULL;
    59 
    6051        #ifdef _SERIAL_
    6152                mxArray* pfield=NULL;
    … …  
    8576
    8677                /*Deal with variable descriptors: {{{1*/
    87                 variabledescriptors=(char**)xmalloc(iomodel->numberofvariables*sizeof(char*));
    88 
     78                variabledescriptors=(char**)xmalloc(iomodel->numvariabledescriptors*sizeof(char*));
    8979
    9080                /*Fetch descriptors: logic varies if we are running parallel or serial. In parallel, qmumarshall
    … …  
    9484                #ifdef _SERIAL_
    9585                pfield=mxGetField(iomodel_handle,0,"variabledescriptors");
    96                 for(i=0;i<iomodel->numberofvariables;i++){
     86                for(i=0;i<iomodel->numvariabledescriptors;i++){
    9787                        pfield2=mxGetCell(pfield,i);
    9888                        FetchData(&descriptor,pfield2);
    … …  
    10090                }
    10191                #else
    102                 for(i=0;i<iomodel->numberofvariables;i++){
    103                         sprintf(variabledescriptors_tag,"%s%i","variabledescriptor",i+1);
    104                         IoModelFetchData(&descriptor,iomodel_handle,variabledescriptors_tag);
     92                for(i=0;i<iomodel->numvariabledescriptors;i++){
     93                        sprintf(tag,"%s%i","variabledescriptor",i+1);
     94                        IoModelFetchData(&descriptor,iomodel_handle,tag);
    10595                        variabledescriptors[i]=descriptor;
    10696                }
    … …  
    10898
    10999                /*Ok, we have all the variable descriptors. Build a parameter with it: */
    110                 parameters->AddObject(new StringArrayParam(VariableDescriptorsEnum,variabledescriptors,iomodel->numberofvariables));
    111 
    112                 /*}}}*/
    113 
    114                 /*Deal with responses: {{{1*/
    115                 responsedescriptors=(char**)xmalloc(iomodel->numberofresponses*sizeof(char*));
     100                parameters->AddObject(new StringArrayParam(VariableDescriptorsEnum,variabledescriptors,iomodel->numvariabledescriptors));
     101
     102                /*}}}*/
     103
     104                /*Deal with response descriptors: {{{1*/
     105                responsedescriptors=(char**)xmalloc(iomodel->numresponsedescriptors*sizeof(char*));
    116106
    117107                /*Fetch descriptors: */
    118108                #ifdef _SERIAL_
    119109                pfield=mxGetField(iomodel_handle,0,"responsedescriptors");
    120                 for(i=0;i<iomodel->numberofresponses;i++){
     110                for(i=0;i<iomodel->numresponsedescriptors;i++){
    121111                        pfield2=mxGetCell(pfield,i);
    122112                        FetchData(&descriptor,pfield2);
    … …  
    124114                }
    125115                #else
    126                 for(i=0;i<iomodel->numberofresponses;i++){
    127                         sprintf(responsedescriptors_tag,"%s%i","responsedescriptor",i+1);
    128                         IoModelFetchData(&descriptor,iomodel_handle,responsedescriptors_tag);
     116                for(i=0;i<iomodel->numresponsedescriptors;i++){
     117                        sprintf(tag,"%s%i","responsedescriptor",i+1);
     118                        IoModelFetchData(&descriptor,iomodel_handle,tag);
    129119                        responsedescriptors[i]=descriptor;
    130120                }
    … …  
    132122
    133123                /*Ok, we have all the response descriptors. Build a parameter with it: */
    134                 parameters->AddObject(new StringArrayParam(ResponseDescriptorsEnum,responsedescriptors,iomodel->numberofresponses));
     124                parameters->AddObject(new StringArrayParam(ResponseDescriptorsEnum,responsedescriptors,iomodel->numresponsedescriptors));
     125                parameters->AddObject(new    IntParam(QmuNumberOfResponsesEnum,iomodel->numberofresponses));
    135126                /*}}}*/
    136127
    … …  
    152143                /*}}}*/
    153144
    154                 /*Deal with data needed because of qmu variable inputs: {{{1*/
    155                
    156                 /*First, build a list of strings, used to make sure we don't deal with the same descriptor twice: */
    157                 if(iomodel->numberofvariables){
    158                         strings=(char**)xmalloc(iomodel->numberofvariables*sizeof(char*));
    159                         for(i=0;i<iomodel->numberofvariables;i++)strings[i]=NULL;
    160                 }
     145                /*Deal with data needed because of qmu variables: {{{1*/
     146               
     147                for(i=0;i<iomodel->numvariabledescriptors;i++){
     148
     149                        if (strncmp(variabledescriptors[i],"scaled_",7)==0){
     150                                /*Ok, we are dealing with a variable that is distributed over grids. Recover the name of the variable (ex: scaled_Thickness): */
     151                                sscanf(variabledescriptors[i],"scaled_%s",tag);
     152                               
     153                                /*Recover data: */
     154                                IoModelFetchData(&dakota_parameter,NULL,NULL,iomodel_handle,EnumToModelField(StringToEnum(tag)));
    161155                                       
    162                 /*Now, go through all our needed variables, and fetch the corresponding data: */
    163                 for(i=0;i<iomodel->numberofvariables;i++){
    164 
    165                         /*recover root of descriptor. Descriptors can come in 2 forms: Letters+Number or just letters (ex: Thickness1, RhoIce, Surface3). Strip the number
    166                          * from the descriptor (root), so that we key off of this: */
    167                         descriptor=variabledescriptors[i];
    168                         if(isdistributed(&root,descriptor)){
    169 
    170                                 //now, check that this root was not already processed, ie we did not already fetch the corresponding data!
    171                                 found=0;
    172                                 for(j=0;j<iomodel->numberofvariables;j++){
    173                                         if (strings[j]) if (strcmp(strings[j],root)==0)found=1;
    174                                 }
    175 
    176                                 /*If we did not, fetch data and add it to the parameters: */
    177                                 if(!found){
    178 
    179                                         /*Recover: */
    180                                         IoModelFetchData(&dakota_parameter,NULL,NULL,iomodel_handle,EnumToModelField(StringToEnum(root)));
    181                                        
    182                                         /*Add to parameters: */
    183                                         parameters->AddObject(new DoubleVecParam(StringToEnum(root),dakota_parameter,iomodel->numberofvertices));
     156                                /*Add to parameters: */
     157                                parameters->AddObject(new DoubleVecParam(StringToEnum(tag),dakota_parameter,iomodel->numberofvertices));
    184158                               
    185                                         /*Free ressources:*/
    186                                         xfree((void**)&dakota_parameter);
    187 
    188                                         /*Ensure we won't process this variable anymore: */
    189                                         string=(char*)xmalloc((strlen(root)+1)*sizeof(char)); strcpy(string,root); strings[i]=string;
    190                                 }
    191                         }
    192                         xfree((void**)&root);
    193                 }
    194                 /*Free strings: not needed anymore */
    195                 for(i=0;i<iomodel->numberofvariables;i++){
    196                         string=strings[i];
    197                         xfree((void**)&string);
    198                 }
    199                 xfree((void**)&strings);
     159                                /*Free ressources:*/
     160                                xfree((void**)&dakota_parameter);
     161                        }
     162                }
    200163                /*}}}*/
    201164
    202165                /*Deal with data needed to compute qmu responses: {{{1*/
    203                 for(i=0;i<iomodel->numberofresponses;i++){
    204                         char* descriptor=responsedescriptors[i];
     166                for(i=0;i<iomodel->numresponsedescriptors;i++){
    205167                       
    206                         if(strncmp(descriptor,"MassFlux",8)==0){
     168                        if(strncmp(responsedescriptors[i],"indexed_MassFlux",16)==0){
    207169                                qmu_mass_flux_present=true;
    208170                        }
    … …  
    231193                        #else
    232194                        for(i=0;i<M;i++){
    233                                 sprintf(massflux_tag,"%s%i","qmu_mass_flux_segments",i+1); //names were created using Matlab indexing convention
    234                                 IoModelFetchData(&temp_matrix,&temp_m,&temp_n,iomodel_handle,massflux_tag);
     195                                sprintf(tag,"%s%i","qmu_mass_flux_segments",i+1); //names were created using Matlab indexing convention
     196                                IoModelFetchData(&temp_matrix,&temp_m,&temp_n,iomodel_handle,tag);
    235197
    236198                                /*This temp_matrix represents all the segments, for all elements. On this cpu, we only have a subset of these
    … …  
    279241
    280242                /*Free data: {{{1*/
    281                 for(i=0;i<iomodel->numberofresponses;i++){
    282                         char* descriptor=responsedescriptors[i];
     243                for(i=0;i<iomodel->numresponsedescriptors;i++){
     244                        descriptor=responsedescriptors[i];
    283245                        xfree((void**)&descriptor);
    284246                }
    285247                xfree((void**)&responsedescriptors);
    286248
    287                 for(i=0;i<iomodel->numberofvariables;i++){
    288                         char* descriptor=variabledescriptors[i];
     249                for(i=0;i<iomodel->numvariabledescriptors;i++){
     250                        descriptor=variabledescriptors[i];
    289251                        xfree((void**)&descriptor);
    290252                }
Note: See TracChangeset for help on using the changeset viewer.