Changeset 2112


Ignore:
Timestamp:
09/04/09 16:58:25 (16 years ago)
Author:
Eric.Larour
Message:

Heavy debugging of Mass flux capability

Location:
issm/trunk/src
Files:
29 edited

Legend:

Unmodified
Added
Removed

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

    r2110 r2112  
    1414
    1515void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes,DataSet* loads,DataSet* materials,
    16                 double* segments,int num_segments,double* vx,double* vy,double* vz){
     16                double* segments,int num_segments,double* ug){
    1717
    1818        int i,j;
    … …  
    4040                        if (element->GetId()==element_id){
    4141                                /*We found the element which owns this segment, use it to compute the mass flux: */
    42                                 mass_flux+=element->MassFlux(segments+5*i+0,vx,vy,vz);
     42                                mass_flux+=element->MassFlux(segments+5*i+0,ug);
    4343                        }
    4444                }
    … …  
    4646
    4747        #ifdef _PARALLEL_
    48                 MPI_Allreduce ( (void*)&mass_flux,(void*)&all_mass_flux,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
    49                 all_mass_flux=mass_flux;
     48        MPI_Allreduce ( (void*)&mass_flux,(void*)&all_mass_flux,1,MPI_DOUBLE,MPI_SUM,MPI_COMM_WORLD);
     49        mass_flux=all_mass_flux;
    5050        #endif
    5151

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

    r2110 r2112  
    1010
    1111/* local prototypes: */
    12 void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes,DataSet* loads,DataSet* materials,double* segments,int num_segments,double* vx,double* vy,double* vz);
     12void MassFluxx(double* pmass_flux, DataSet* elements,DataSet* nodes,DataSet* loads,DataSet* materials,double* segments,int num_segments,double* ug);
    1313
    1414

  • issm/trunk/src/c/ModelProcessorx/CreateDataSets.cpp

    r2110 r2112  
    8989                throw ErrorException(__FUNCT__,exprintf("%s%i%s%i%s"," analysis_type: ",iomodel->analysis_type," sub_analysis_type: ",iomodel->sub_analysis_type," not supported yet!"));
    9090        }
    91 
    9291        CreateParametersQmu(pparameters,iomodel,iomodel_handle);
    9392

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

    r2110 r2112  
    5252                mxArray* pfield2=NULL;
    5353        #endif
    54 
     54       
    5555        /*recover parameters : */
    5656        parameters=*pparameters;
    … …  
    100100                /*Deal with variables for qmu iomodeling: */
    101101                variabledescriptors=(char**)xmalloc(iomodel->numberofvariables*sizeof(char*));
     102
    102103
    103104                /*Fetch descriptors: logic varies if we are running parallel or serial. In parallel, qmumarshall
    … …  
    229230
    230231                                #ifdef _PARALLEL_
    231                                         /*Use the element partitioning vector from the iomodel to down select qmu_mass_flux_segments to only segments that are relevant
    232                                          * to this cpu: */
    233                                         my_num_qmu_mass_flux_segments=0;
    234                                         for(j=0;j<num_qmu_mass_flux_segments;j++){
    235                                                 if (  (*(qmu_mass_flux_segments+5*j+4))   == iomodel->epart[my_rank])my_qmu_mass_flux_segments++;
    236                                         }
    237                                         if(my_num_qmu_mass_flux_segments){
    238                                                 my_qmu_mass_flux_segments=(double*)xcalloc(5*my_num_qmu_mass_flux_segments,sizeof(double));
    239                                                 second_count=0;
     232
     233                                        /*Only if partitioning exist do we care about the segments: */
     234                                        if(iomodel->epart){
     235
     236                                                /*Use the element partitioning vector from the iomodel to down select qmu_mass_flux_segments to only segments that are relevant
     237                                                 * to this cpu: */
     238                                                my_num_qmu_mass_flux_segments=0;
    240239                                                for(j=0;j<num_qmu_mass_flux_segments;j++){
    241                                                         if (*(qmu_mass_flux_segments+5*j+4)==iomodel->epart[my_rank]){
    242                                                                 for(k=0;k<5;k++)*(my_qmu_mass_flux_segments+5*second_count+k)=*(qmu_mass_flux_segments+5*j+k);
    243                                                                 second_count++;
     240                                                        if (  iomodel->epart[(int)(*(qmu_mass_flux_segments+5*j+4))-1]   == my_rank)my_num_qmu_mass_flux_segments++;
     241                                                }
     242
     243                                       
     244                                                if(my_num_qmu_mass_flux_segments){
     245                                                        my_qmu_mass_flux_segments=(double*)xcalloc(5*my_num_qmu_mass_flux_segments,sizeof(double));
     246                                                        second_count=0;
     247                                                        for(j=0;j<num_qmu_mass_flux_segments;j++){
     248                                                                if (iomodel->epart[(int)*(qmu_mass_flux_segments+5*j+4)-1]==my_rank){
     249                                                                        for(k=0;k<5;k++)*(my_qmu_mass_flux_segments+5*second_count+k)=*(qmu_mass_flux_segments+5*j+k);
     250                                                                        second_count++;
     251                                                                }
    244252                                                        }
    245253                                                }
     254
     255                                                count++;
     256                                                param= new Param(count,"qmu_mass_flux_segments",DOUBLEMAT);
     257                                                param->SetDoubleMat(my_qmu_mass_flux_segments,my_num_qmu_mass_flux_segments,5);
     258                                                parameters->AddObject(param);
     259
    246260                                        }
    247 
    248                                         count++;
    249                                         param= new Param(count,"qmu_mass_flux_segments",DOUBLEMAT);
    250                                         param->SetDoubleMat(my_qmu_mass_flux_segments,my_num_qmu_mass_flux_segments,5);
    251                                         parameters->AddObject(param);
     261                                       
    252262                                #else
    253263
    … …  
    263273                        }
    264274                }
    265 
    266275
    267276                /*Free data: */
    … …  
    289298        }
    290299
    291 
    292300        /*Assign output pointer: */
    293301        *pparameters=parameters;

  • issm/trunk/src/c/Qmux/DakotaResponses.cpp

    r1881 r2112  
    1111#include "../DataSet/DataSet.h"   
    1212#include "../shared/shared.h"
     13#include "../EnumDefinitions/EnumDefinitions.h"
     14#include "../MassFluxx/MassFluxx.h"
    1315
    1416#undef __FUNCT__
    1517#define __FUNCT__ "DakotaResponses"
    16 void DakotaResponses(double* responses,char** responses_descriptors,int numresponses,Model* model,DataSet* results,int analysis_type,int sub_analysis_type){
     18void DakotaResponses(double* responses,char** responses_descriptors,int numresponses,Model* model,DataSet* results,DataSet* processed_results,int analysis_type,int sub_analysis_type){
    1719
    1820        int i,j;
    … …  
    2527        model->FindParam(&numberofnodes,"numberofnodes");
    2628
     29
    2730        for(i=0;i<numresponses;i++){
    2831
    2932                response_descriptor=responses_descriptors[i];
    3033
    31                 //'min_vx' 'max_vx' 'max_abs_vx' 'min_vy' 'max_vy' 'max_abs_vy' 'min_vel' 'max_vel'
     34                //'min_vx' 'max_vx' 'max_abs_vx' 'min_vy' 'max_vy' 'max_abs_vy' 'min_vel' 'max_vel, mass_flux'
    3235
    3336                if(strcmp(response_descriptor,"min_vel")==0){
    … …  
    3538                        double min_vel=0;
    3639               
    37                         found=results->FindResult((void*)&vel,"vel");
     40                        found=processed_results->FindResult((void*)&vel,"vel");
    3841                        if(!found)throw ErrorException(__FUNCT__," could not find vel to compute min_vel");
    3942
    … …  
    4447
    4548                        if(my_rank==0)responses[i]=min_vel;
     49                       
     50                        /*Free ressources:*/
     51                        xfree((void**)&vel);
     52
    4653                       
    4754                }
    … …  
    5057                        double max_vel=0;
    5158
    52                         found=results->FindResult((void*)&vel,"vel");
     59                        found=processed_results->FindResult((void*)&vel,"vel");
    5360                        if(!found)throw ErrorException(__FUNCT__," could not find vel to compute max_vel");
    5461
    … …  
    5865                        }
    5966                        if(my_rank==0)responses[i]=max_vel;
     67                       
     68                        /*Free ressources:*/
     69                        xfree((void**)&vel);
     70
    6071                }
    6172                else if(strcmp(response_descriptor,"min_vx")==0){
    … …  
    6374                        double min_vx=0;
    6475                       
    65                         found=results->FindResult((void*)&vx,"vx");
     76                        found=processed_results->FindResult((void*)&vx,"vx");
    6677                        if(!found)throw ErrorException(__FUNCT__," could not find vx to compute min_vx");
    6778
    … …  
    7182                        }
    7283                        if(my_rank==0)responses[i]=min_vx;
     84                       
     85                        /*Free ressources:*/
     86                        xfree((void**)&vx);
     87
    7388                }
    7489                else if(strcmp(response_descriptor,"max_vx")==0){
    … …  
    7691                        double max_vx=0;
    7792                       
    78                         found=results->FindResult((void*)&vx,"vx");
     93                        found=processed_results->FindResult((void*)&vx,"vx");
    7994                        if(!found)throw ErrorException(__FUNCT__," could not find vx to compute max_vx");
    8095
    … …  
    8499                        }
    85100                        if(my_rank==0)responses[i]=max_vx;
     101                       
     102                        /*Free ressources:*/
     103                        xfree((void**)&vx);
     104
    86105                }
    87106                else if(strcmp(response_descriptor,"max_abs_vx")==0){
    … …  
    89108                        double max_abs_vx=0;
    90109                       
    91                         found=results->FindResult((void*)&vx,"vx");
     110                        found=processed_results->FindResult((void*)&vx,"vx");
    92111                        if(!found)throw ErrorException(__FUNCT__," could not find vx to compute max_abs_vx");
    93112
    … …  
    97116                        }
    98117                        if(my_rank==0)responses[i]=max_abs_vx;
     118                       
     119                        /*Free ressources:*/
     120                        xfree((void**)&vx);
     121
    99122                }
    100123                else if(strcmp(response_descriptor,"min_vy")==0){
    … …  
    102125                        double min_vy=0;
    103126                       
    104                         found=results->FindResult((void*)&vy,"vy");
     127                        found=processed_results->FindResult((void*)&vy,"vy");
    105128                        if(!found)throw ErrorException(__FUNCT__," could not find vy to compute min_vy");
    106129
    … …  
    110133                        }
    111134                        if(my_rank==0)responses[i]=min_vy;
     135                       
     136                        /*Free ressources:*/
     137                        xfree((void**)&vy);
     138
    112139                }
    113140                else if(strcmp(response_descriptor,"max_vy")==0){
    … …  
    115142                        double max_vy=0;
    116143                       
    117                         found=results->FindResult((void*)&vy,"vy");
     144                        found=processed_results->FindResult((void*)&vy,"vy");
    118145                        if(!found)throw ErrorException(__FUNCT__," could not find vy to compute max_vy");
    119146
    … …  
    123150                        }
    124151                        if(my_rank==0)responses[i]=max_vy;
     152                       
     153                        /*Free ressources:*/
     154                        xfree((void**)&vy);
     155
    125156                }
    126157                else if(strcmp(response_descriptor,"max_abs_vy")==0){
    … …  
    128159                        double max_abs_vy=0;
    129160                       
    130                         found=results->FindResult((void*)&vy,"vy");
     161                        found=processed_results->FindResult((void*)&vy,"vy");
    131162                        if(!found)throw ErrorException(__FUNCT__," could not find vy to compute max_abs_vy");
    132163
    … …  
    136167                        }
    137168                        if(my_rank==0)responses[i]=max_abs_vy;
     169                       
     170                        /*Free ressources:*/
     171                        xfree((void**)&vy);
     172
    138173                }
    139174                else if(strcmp(response_descriptor,"min_vz")==0){
    … …  
    141176                        double min_vz=0;
    142177                       
    143                         found=results->FindResult((void*)&vz,"vz");
     178                        found=processed_results->FindResult((void*)&vz,"vz");
    144179                        if(!found)throw ErrorException(__FUNCT__," could not find vz to compute min_vz");
    145180
    … …  
    149184                        }
    150185                        if(my_rank==0)responses[i]=min_vz;
     186                       
     187                        /*Free ressources:*/
     188                        xfree((void**)&vz);
     189
    151190                }
    152191                else if(strcmp(response_descriptor,"max_vz")==0){
    … …  
    154193                        double max_vz=0;
    155194                       
    156                         found=results->FindResult((void*)&vz,"vz");
     195                        found=processed_results->FindResult((void*)&vz,"vz");
    157196                        if(!found)throw ErrorException(__FUNCT__," could not find vz to compute max_vz");
    158197
    … …  
    162201                        }
    163202                        if(my_rank==0)responses[i]=max_vz;
     203                       
     204                        /*Free ressources:*/
     205                        xfree((void**)&vz);
     206
    164207                }
    165208                else if(strcmp(response_descriptor,"max_abs_vz")==0){
    … …  
    167210                        double max_abs_vz=0;
    168211                       
    169                         found=results->FindResult((void*)&vz,"vz");
     212                        found=processed_results->FindResult((void*)&vz,"vz");
    170213                        if(!found)throw ErrorException(__FUNCT__," could not find vz to compute max_abs_vz");
    171214
    … …  
    175218                        }
    176219                        if(my_rank==0)responses[i]=max_abs_vz;
     220                       
     221                        /*Free ressources:*/
     222                        xfree((void**)&vz);
     223
     224                }
     225                else if(strcmp(response_descriptor,"mass_flux")==0){
     226
     227                        int isstokes,ismacayealpattyn,ishutter;
     228                        Vec       ug=NULL;
     229                        double*   ug_serial=NULL;
     230                        double    mass_flux=0;
     231                        double*   segments=NULL;
     232                        int       num_segments;
     233                        DataSet*  elements=NULL;
     234                        DataSet*  nodes=NULL;
     235                        DataSet*  materials=NULL;
     236                        DataSet*  parameters=NULL;
     237                        FemModel* femmodel=NULL;
     238                        Param*    param=NULL;
     239
     240                        /*retrieve velocities: */
     241                        found=results->FindResult(&ug,"u_g");
     242                        if(!found)throw ErrorException(__FUNCT__," could not find velocity to compute mass_flux");
     243                        VecToMPISerial(&ug_serial,ug);
     244               
     245                        /*retrieve active fem model: */
     246                        model->FindParam(&isstokes,"isstokes");
     247                        model->FindParam(&ismacayealpattyn,"ismacayealpattyn");
     248                        model->FindParam(&ishutter,"ishutter");
     249
     250                        if(isstokes){
     251                                femmodel=model->GetFormulation(DiagnosticAnalysisEnum(),StokesAnalysisEnum());
     252                        }
     253                        if(ismacayealpattyn){
     254                                femmodel=model->GetFormulation(DiagnosticAnalysisEnum(),HorizAnalysisEnum());
     255                        }
     256                        if(ishutter){
     257                                femmodel=model->GetFormulation(DiagnosticAnalysisEnum(),HutterAnalysisEnum());
     258                        }
     259
     260                        /*retrieve qmu_mass_flux_segments: */
     261                        param=(Param*)femmodel->parameters->FindParamObject("qmu_mass_flux_segments");
     262                        if(!param)throw ErrorException(__FUNCT__," could not find qmu_mass_flux_segments to compute mass_flux");
     263                       
     264                        param->GetParameterValue((void*)&segments);
     265                        num_segments=param->GetM();
     266
     267                        /*call mass flux module: */
     268                        MassFluxx(&mass_flux,femmodel->elements,femmodel->nodes,femmodel->loads,femmodel->materials,segments,num_segments,ug_serial);
     269                       
     270                        if(my_rank==0)responses[i]=mass_flux;
     271                       
     272                        if(my_rank==0)printf("mass_flux %g\n",mass_flux);
     273
     274                        /*Free ressources:*/
     275                        VecFree(&ug);
     276                        xfree((void**)&ug_serial);
     277                        xfree((void**)&segments);
    177278                }
    178279                else{

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

    r2048 r2112  
    1616void Qmux(Model* model,ParameterInputs* inputs,int analysis_type,int sub_analysis_type);
    1717void SpawnCoreParallel(double* responses, int numresponses, double* variables, char** variables_descriptors,int numvariables, Model* model,ParameterInputs* inputs,int analysis_type,int sub_analysis_type,int counter);
    18 void DakotaResponses(double* responses,char** responses_descriptors,int numresponses,Model* model, DataSet* results,int analysis_type,int sub_analysis_type);
     18void DakotaResponses(double* responses,char** responses_descriptors,int numresponses,Model* model, DataSet* results,DataSet* processed_results,int analysis_type,int sub_analysis_type);
    1919#endif
    2020

  • issm/trunk/src/c/Qmux/SpawnCoreParallel.cpp

    r1904 r2112  
    4242        /*output from core solutions: */
    4343        DataSet* results=NULL;
     44        DataSet* processed_results=NULL;
    4445
    4546        char** responses_descriptors=NULL;
    … …  
    110111        #endif
    111112
     113        /*broadcast response descriptors: */
     114        MPI_Bcast(&numresponses,1,MPI_INT,0,MPI_COMM_WORLD);
     115        if(my_rank!=0){
     116                responses_descriptors=(char**)xmalloc(numresponses*sizeof(char*));
     117        }
     118        for(i=0;i<numresponses;i++){
     119                if(my_rank==0){
     120                        string=responses_descriptors[i];
     121                        string_length=(strlen(string)+1)*sizeof(char);
     122                }
     123                MPI_Bcast(&string_length,1,MPI_INT,0,MPI_COMM_WORLD);
     124                if(my_rank!=0)string=(char*)xmalloc(string_length);
     125                MPI_Bcast(string,string_length,MPI_CHAR,0,MPI_COMM_WORLD);
     126                if(my_rank!=0)responses_descriptors[i]=string;
     127        }
     128
     129        #ifdef _ISSM_DEBUG_
     130        for(i=0;i<numresponses;i++){
     131                PetscSynchronizedPrintf(MPI_COMM_WORLD,"variable descriptor %i: %s value: %g\n",i,responses_descriptors[i],responses[i]);
     132                PetscSynchronizedFlush(MPI_COMM_WORLD);
     133        }
     134        #endif
     135
     136
    112137        _printf_("qmu iteration: %i\n",counter);
    113138
    … …  
    150175        /*Now process the outputs, before computing the dakota responses: */
    151176        if(debug)_printf_("process results:\n");
    152         ProcessResults(&results,model,analysis_type);
    153        
    154 
     177        ProcessResults(&processed_results,results,model,analysis_type);
     178       
    155179        /*compute responses on cpu 0: dummy for now! */
    156180        if(debug)_printf_("compute dakota responses:\n");
    157         DakotaResponses(responses,responses_descriptors,numresponses,model,results,analysis_type,sub_analysis_type);
     181        DakotaResponses(responses,responses_descriptors,numresponses,model,results,processed_results,analysis_type,sub_analysis_type);
    158182
    159183        /*Free ressources:*/
    160184        delete results;
     185        delete processed_results;
    161186
    162187        //variables only on cpu != 0

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

    r2110 r2112  
    667667#undef __FUNCT__
    668668#define __FUNCT__ "Beam::MassFlux"
    669 double Beam::MassFlux( double* segment,double* vx,double* vy,double* vz){
    670         throw ErrorException(__FUNCT__," not supported yet!");
    671 }
     669double Beam::MassFlux( double* segment,double* ug){
     670        throw ErrorException(__FUNCT__," not supported yet!");
     671}

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

    r2110 r2112  
    8787                void  GetParameterValue(double* pvalue, double* value_list,double gauss_coord);
    8888                void  GetJacobianDeterminant(double* pJdet,double* z_list, double gauss_coord);
    89                 double MassFlux(double* segment,double* vx,double* vy,double* vz);
     89                double MassFlux(double* segment,double* ug);
    9090
    9191};

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

    r2110 r2112  
    4040                virtual double Misfit(void* inputs,int analysis_type,int sub_analysis_type)=0;
    4141                virtual void  ComputePressure(Vec p_g)=0;
    42                 virtual double MassFlux(double* segment,double* vx,double* vy,double* vz)=0;
     42                virtual double MassFlux(double* segment,double* ug)=0;
    4343
    4444                int           Enum();

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

    r2110 r2112  
    130130       
    131131                case DOUBLEMAT:
    132                         /*printf("   double matrix. size: %i,%i\n",M,N);
     132                        printf("   double matrix. size: %i,%i\n",M,N);
    133133                        for(i=0;i<M;i++){
    134134                                for(j=0;j<N;j++){
    … …  
    136136                                }
    137137                                printf("\n");
    138                         }*/
     138                        }
    139139                        break;
    140140

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

    r2110 r2112  
    40324032#undef __FUNCT__
    40334033#define __FUNCT__ "Penta::MassFlux"
    4034 double Penta::MassFlux( double* segment,double* vx,double* vy,double* vz){
     4034double Penta::MassFlux( double* segment,double* ug){
    40354035        throw ErrorException(__FUNCT__," not supported yet!");
    40364036}

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

    r2110 r2112  
    142142                void  CreatePVectorMelting( Vec pg, void* vinputs,int analysis_type,int sub_analysis_type);
    143143                void  GetPhi(double* phi, double*  epsilon, double viscosity);
    144                 double MassFlux(double* segment,double* vx,double* vy,double* vz);
     144                double MassFlux(double* segment,double* ug);
    145145
    146146

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

    r2110 r2112  
    505505#undef __FUNCT__
    506506#define __FUNCT__ "Sing::MassFlux"
    507 double Sing::MassFlux( double* segment,double* vx,double* vy,double* vz){
    508         throw ErrorException(__FUNCT__," not supported yet!");
    509 }
     507double Sing::MassFlux( double* segment,double* ug){
     508        throw ErrorException(__FUNCT__," not supported yet!");
     509}

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

    r2110 r2112  
    7979                void  GradjB(_p_Vec*, void*, int,int);
    8080                double Misfit(void*,int,int);
    81                 double MassFlux(double* segment,double* vx,double* vy,double* vz);
     81                double MassFlux(double* segment,double* ug);
    8282
    8383

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

    r2110 r2112  
    37113711#undef __FUNCT__
    37123712#define __FUNCT__ "Tria::MassFlux"
    3713 double Tria::MassFlux( double* segment,double* vx,double* vy,double* vz){
     3713double Tria::MassFlux( double* segment,double* ug){
    37143714
    37153715        int i;
    37163716
    37173717        const int    numgrids=3;
     3718        const int    numdofs=2;
     3719        int          numberofdofspernode;
    37183720        double mass_flux=0;
    3719         int    doflist[3];
     3721        int    doflist[numgrids*numdofs];
    37203722        double vx_list[3];
    37213723        double vy_list[3];
    … …  
    37433745
    37443746        /*recover velocity at three element nodes: */
    3745         this->GetDofList1(&doflist[0]);
     3747        this->GetDofList(&doflist[0],&numberofdofspernode);
    37463748        for(i=0;i<3;i++){
    3747                 vx_list[i]=vx[doflist[i]];
    3748                 vy_list[i]=vy[doflist[i]];
     3749                vx_list[i]=ug[doflist[numberofdofspernode*i+0]];
     3750                vy_list[i]=ug[doflist[numberofdofspernode*i+1]];
    37493751        }
    37503752
    … …  
    37753777                                  (1.0/3.0*(h1-h2)*(vy1-vy2)+1.0/2.0*h2*(vy1-vy2)+1.0/2.0*(h1-h2)*vy2+h2*vy2)*normal[1]
    37763778                                );
    3777 
    37783779        return mass_flux;
    37793780}

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

    r2110 r2112  
    122122                void  CreateKMatrixPrognostic(Mat Kgg,void* vinputs,int analysis_type,int sub_analysis_type);
    123123                void  CreatePVectorPrognostic(Vec pg,void* vinputs,int analysis_type,int sub_analysis_type);
    124                 double MassFlux(double* segment,double* vx,double* vy,double* vz);
     124                double MassFlux(double* segment,double* ug);
    125125                double GetArea(void);
    126126                double GetAreaCoordinate(double x, double y, int which_one);

  • issm/trunk/src/c/parallel/ControlTemporaryResults.cpp

    r1881 r2112  
    1919        /*output: */
    2020        DataSet* temporary_results=NULL;
     21        DataSet* results=NULL;
    2122        Result*  result=NULL;
    2223        char*    outputfilename=NULL;
    … …  
    6970
    7071        //process results
    71         ProcessResults(&temporary_results,model,ControlAnalysisEnum());
     72        ProcessResults(&results,temporary_results,model,ControlAnalysisEnum());
    7273
    7374        //Write results on disk
    74         OutputResults(temporary_results,outputfilename);
     75        OutputResults(results,outputfilename);
     76       
     77       
     78        /*Free ressources:*/
     79        delete temporary_results;
     80        delete results;
     81        xfree((void**)&outputfilename);
     82        VecFree(&u_g);
     83        xfree((void**)&control_type);
     84        xfree((void**)&param_g_copy);
     85        xfree((void**)&J_copy);
    7586}

  • issm/trunk/src/c/parallel/ProcessResults.cpp

    r1964 r2112  
    2121#include "../shared/shared.h"
    2222
    23 void ProcessResults(DataSet** presults,Model* model,int analysis_type){
     23void ProcessResults(DataSet** pnewresults, DataSet* results,Model* model,int analysis_type){
    2424
    2525        int i,n;
    … …  
    2727        Result* newresult=NULL;
    2828       
    29         /*input: */
    30         DataSet* results=NULL;
    31 
    3229        /*output: */
    3330        DataSet* newresults=NULL;
    … …  
    9592
    9693        int numberofnodes;
    97 
    98         /*recover input results: */
    99         results=*presults;
    10094
    10195        /*Initialize new results: */
    … …  
    409403        }
    410404
    411         /*Delete results: */
    412         delete results;
    413 
    414 
    415405        /*Assign output pointers:*/
    416         *presults=newresults;
     406        *pnewresults=newresults;
    417407}

  • issm/trunk/src/c/parallel/diagnostic.cpp

    r2048 r2112  
    3232        /*Results: */
    3333        DataSet* results=NULL;
     34        DataSet* processed_results=NULL;
    3435        Result* result=NULL;
    3536       
    … …  
    123124                       
    124125                        _printf_("process results:\n");
    125                         ProcessResults(&results,model,DiagnosticAnalysisEnum());
     126                        ProcessResults(&processed_results,results,model,DiagnosticAnalysisEnum());
    126127                }
    127128                else{
    … …  
    135136
    136137                        _printf_("process results:\n");
    137                         ProcessResults(&results,model,ControlAnalysisEnum());
     138                        ProcessResults(&processed_results,results,model,ControlAnalysisEnum());
    138139                }
    139140
    … …  
    168169        delete model;
    169170        delete results;
     171        delete processed_results;
    170172        delete inputs;
    171173

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

    r2000 r2112  
    5252void CreateFemModel(FemModel* femmodel,ConstDataHandle MODEL,int analysis_type,int sub_analysis_type);
    5353//int BatchDebug(Mat* Kgg,Vec* pg,FemModel* femmodel,char* filename);
    54 void ProcessResults(DataSet** presults,Model* model,int analysis_type);
     54void ProcessResults(DataSet** pnewresults, DataSet* results,Model* model,int analysis_type);
    5555
    5656#endif

  • issm/trunk/src/c/parallel/prognostic.cpp

    r1887 r2112  
    4040        /*Results: */
    4141        DataSet* results=NULL;
     42        DataSet* processedresults=NULL;
    4243        Result*  result=NULL;
    4344
    … …  
    123124       
    124125        _printf_("process results:\n");
    125         ProcessResults(&results,model,PrognosticAnalysisEnum());
     126        ProcessResults(&processedresults,results,model,PrognosticAnalysisEnum());
    126127       
    127128        _printf_("write results to disk:\n");
    128         OutputResults(results,outputfilename);
     129        OutputResults(processedresults,outputfilename);
    129130
    130131        _printf_("write lock file:\n");
    … …  
    138139        /*end module: */
    139140        MODULEEND();
    140        
     141
     142        /*Free ressources:*/
     143        delete processedresults;
     144        delete results;
     145        delete model;
     146        delete inputs;
     147
    141148        return 0; //unix success return;
    142149}

  • issm/trunk/src/c/parallel/steadystate.cpp

    r2048 r2112  
    3535        /*Results: */
    3636        DataSet* results=NULL;
     37        DataSet* processed_results=NULL;
    3738        Result* result=NULL;
    3839       
    … …  
    142143
    143144                        _printf_("process results:\n");
    144                         ProcessResults(&results,model,SteadystateAnalysisEnum());
     145                        ProcessResults(&processed_results,results,model,SteadystateAnalysisEnum());
    145146                }
    146147                else{
    … …  
    154155
    155156                        _printf_("process results:\n");
    156                         ProcessResults(&results,model,ControlAnalysisEnum());
     157                        ProcessResults(&processed_results,results,model,ControlAnalysisEnum());
    157158                }
    158159
    … …  
    188189        delete model;
    189190        delete results;
     191        delete processed_results;
    190192        delete inputs;
    191193

  • issm/trunk/src/c/parallel/thermal.cpp

    r2048 r2112  
    3636        /*Results: */
    3737        DataSet* results=NULL;
     38        DataSet* processed_results=NULL;
    3839        Result*  result=NULL;
    3940       
    … …  
    104105                       
    105106                _printf_("process results:\n");
    106                 ProcessResults(&results,model,ThermalAnalysisEnum());
     107                ProcessResults(&processed_results,results,model,ThermalAnalysisEnum());
    107108               
    108109                _printf_("write results to disk:\n");
    109                 OutputResults(results,outputfilename);
     110                OutputResults(processed_results,outputfilename);
    110111        }
    111112        else{
    … …  
    136137        delete model;
    137138        delete results;
     139        delete processed_results;
    138140        delete inputs;
    139141       

  • issm/trunk/src/c/parallel/transient.cpp

    r2048 r2112  
    3232        /*Results: */
    3333        DataSet* results=NULL;
     34        DataSet* processed_results=NULL;
    3435        Result*  result=NULL;
    3536       
    … …  
    130131
    131132                _printf_("process results:\n");
    132                 ProcessResults(&results,model,TransientAnalysisEnum());
     133                ProcessResults(&processed_results,results,model,TransientAnalysisEnum());
    133134               
    134135                _printf_("write results to disk:\n");
    … …  
    151152        /*Free ressources:*/
    152153        delete results;
     154        delete processed_results;
    153155        delete model;
    154156        delete inputs;

  • issm/trunk/src/m/solutions/cielo/SpawnCore.m

    r1299 r2112  
    5454
    5555%process results
    56 results=processresults(models,results);
     56processedresults=processresults(models,results);
    5757
    5858%now process the results to get response function values
    … …  
    6060for i=1:numel(responsedescriptors),
    6161        descriptor=responsedescriptors{i};
    62         responses(i)=qmuresponse(models,results,descriptor);
     62        responses(i)=qmuresponse(models,results,processedresults,descriptor);
    6363end

  • issm/trunk/src/m/solutions/dakota/qmuresponse.m

    r2110 r2112  
    1 function response=qmuresponse(models,results,descriptor)
     1function response=qmuresponse(models,results,processedresults,descriptor)
    22%QMURESPONSE - compute response function from model results.
    33
    44if strcmpi(descriptor,'max_vel'),
    5         response=max(results.vel);
     5        response=max(processedresults.vel);
    66elseif strcmpi(descriptor,'min_vel'),
    7         response=min(results.vel);
     7        response=min(processedresults.vel);
    88elseif strcmpi(descriptor,'max_vx'),
    9         response=max(results.vx);
     9        response=max(processedresults.vx);
    1010elseif strcmpi(descriptor,'min_vx'),
    11         response=min(results.vx);
     11        response=min(processedresults.vx);
    1212elseif strcmpi(descriptor,'max_vy'),
    13         response=max(results.vy);
     13        response=max(processedresults.vy);
    1414elseif strcmpi(descriptor,'min_vy'),
    15         response=min(results.vy);
     15        response=min(processedresults.vy);
    1616elseif strcmpi(descriptor,'mass_flux'),
    1717        %call mass flux module.
    … …  
    2323        isstokes=m_ds.parameters.isstokes;
    2424        if ishutter,
    25                 response=MassFlux(m_dhu.elements,m_dhu.nodes,m_dhu.loads,m_dhu.materials,m_dhu.parameters,results);
     25                response=MassFlux(m_dhu.elements,m_dhu.nodes,m_dhu.loads,m_dhu.materials,m_dhu.parameters,results.u_g);
    2626        elseif ismacayealpattyn,
    27                 response=MassFlux(m_dh.elements,m_dh.nodes,m_dh.loads,m_dh.materials,m_dh.parameters,results);
     27                response=MassFlux(m_dh.elements,m_dh.nodes,m_dh.loads,m_dh.materials,m_dh.parameters,results.u_g);
    2828        elseif isstokes,
    29                 response=MassFlux(m_ds.elements,m_ds.nodes,m_ds.loads,m_ds.materials,m_ds.parameters,results);
     29                response=MassFlux(m_ds.elements,m_ds.nodes,m_ds.loads,m_ds.materials,m_ds.parameters,results.u_g);
    3030        else
    3131                error('qmuresponse error message: unsupported analysis type for mass_flux computation!');

  • issm/trunk/src/mex/MassFlux/MassFlux.cpp

    r2110 r2112  
    1717        double*  segments=NULL;
    1818        int      num_segments;
    19         double*  vx=NULL;
    20         double*  vy=NULL;
    21         double*  vz=NULL;
     19        double*  ug=NULL;
    2220        mxArray* pfield=NULL;
    2321
    … …  
    4139
    4240        /*results: */
    43         FetchData((void**)&vx,NULL,NULL,mxGetField(RESULTS,0,"vx"),"Matrix","Mat");
    44         FetchData((void**)&vy,NULL,NULL,mxGetField(RESULTS,0,"vy"),"Matrix","Mat");
    45         pfield=mxGetField(RESULTS,0,"vz");
    46         if(pfield)FetchData((void**)&vz,NULL,NULL,pfield,"Matrix","Mat");
     41        FetchData((void**)&ug,NULL,NULL,UG,"Matrix","Mat");
    4742
    4843        /*!Compute mass flux along the profile: */
    49         MassFluxx(&mass_flux, elements,nodes,loads,materials,segments,num_segments,vx,vy,vz);
     44        MassFluxx(&mass_flux, elements,nodes,loads,materials,segments,num_segments,ug);
    5045
    5146        /*write output datasets: */
    … …  
    5752        delete loads;
    5853        delete materials;
    59         xfree((void**)&vx);
    60         xfree((void**)&vy);
    61         xfree((void**)&vz);
     54        xfree((void**)&ug);
    6255
    6356        /*end module: */

  • issm/trunk/src/mex/MassFlux/MassFlux.h

    r2110 r2112  
    2222#define MATERIALS (mxArray*)prhs[3]
    2323#define PARAMETERS (mxArray*)prhs[4]
    24 #define RESULTS (mxArray*)prhs[5]
     24#define UG (mxArray*)prhs[5]
    2525
    2626/* serial output macros: */
Note: See TracChangeset for help on using the changeset viewer.