Changeset 209


Ignore:
Timestamp:
05/04/09 11:53:43 (16 years ago)
Author:
Eric.Larour
Message:

Vector parallel fetch not supported. Had to go around it

Location:
issm/trunk
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • issm/trunk/src/c/ModelProcessorx/Control/CreateParametersControl.cpp

    r202 r209  
    2525        double* optscal=NULL;
    2626        double* maxiter=NULL;
    27         Vec    control_parameter=NULL;
    28         Vec    vx_obs=NULL;
    29         Vec    vy_obs=NULL;
     27        double* control_parameter=NULL;
     28        double* vx_obs=NULL;
     29        double* vy_obs=NULL;
    3030
    3131        /*Get counter : */
    … …  
    100100
    101101        /*Get vx_obs, vy_obs, and the parameter value: */
    102         ModelFetchData((void**)&vx_obs,NULL,NULL,model_handle,"vx_obs","Vector",NULL);
    103         ModelFetchData((void**)&vy_obs,NULL,NULL,model_handle,"vy_obs","Vector",NULL);
    104         ModelFetchData((void**)&control_parameter,NULL,NULL,model_handle,model->control_type,"Vector",NULL);
     102        ModelFetchData((void**)&vx_obs,NULL,NULL,model_handle,"vx_obs","Matrix","Mat");
     103        ModelFetchData((void**)&vy_obs,NULL,NULL,model_handle,"vy_obs","Matrix","Mat");
     104        ModelFetchData((void**)&control_parameter,NULL,NULL,model_handle,model->control_type,"Matrix","Mat");
    105105
    106         VecScale(vx_obs,1.0/model->yts);
    107         VecScale(vy_obs,1.0/model->yts);
     106        if(vx_obs)for(i=0;i<model->numberofnodes;i++)vx_obs[i]=vx_obs[i]/model->yts;
     107        if(vy_obs)for(i=0;i<model->numberofnodes;i++)vy_obs[i]=vy_obs[i]/model->yts;
    108108
    109109        count++;
    110         param= new Param(count,"vx_obs",PETSCVEC);
    111         param->SetVec(vx_obs);
     110        param= new Param(count,"vx_obs",DOUBLEVEC);
     111        if(vx_obs) param->SetDoubleVec(vx_obs,model->numberofnodes);
     112        else param->SetDoubleVec(vx_obs,0);
    112113        parameters->AddObject(param);
    113114
    114115        count++;
    115         param= new Param(count,"vy_obs",PETSCVEC);
    116         param->SetVec(vy_obs);
     116        param= new Param(count,"vy_obs",DOUBLEVEC);
     117        if(vy_obs) param->SetDoubleVec(vy_obs,model->numberofnodes);
     118        else param->SetDoubleVec(vy_obs,0);
    117119        parameters->AddObject(param);
    118120
    119121        count++;
    120         param= new Param(count,"control_parameter",PETSCVEC);
    121         param->SetVec(control_parameter);
     122        param= new Param(count,"control_parameter",DOUBLEVEC);
     123        if(control_parameter) param->SetDoubleVec(control_parameter,model->numberofnodes);
     124        else param->SetDoubleVec(control_parameter,0);
    122125        parameters->AddObject(param);
    123        
    124         VecFree(&vx_obs);
    125         VecFree(&vy_obs);
    126         VecFree(&control_parameter);
     126
     127
     128        xfree((void**)&vx_obs);
     129        xfree((void**)&vy_obs);
     130        xfree((void**)&control_parameter);
    127131
    128132

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

    r202 r209  
    2727        double* maxiter=NULL;
    2828        double* control_parameter=NULL;
    29         Vec    vx=NULL;
    30         Vec    vy=NULL;
    31         Vec    vz=NULL;
     29        double* vx=NULL;
     30        double* vy=NULL;
     31        double* vz=NULL;
    3232       
    3333        /*Initialize dataset: */
    … …  
    177177        /*Diagnostic: */
    178178        /*Get vx and vy: */
    179         ModelFetchData((void**)&vx,NULL,NULL,model_handle,"vx","Vector",NULL);
    180         ModelFetchData((void**)&vy,NULL,NULL,model_handle,"vy","Vector",NULL);
    181         ModelFetchData((void**)&vz,NULL,NULL,model_handle,"vz","Vector",NULL);
    182 
    183         if(vx)VecScale(vx,1.0/model->yts);
    184         if(vy)VecScale(vy,1.0/model->yts);
    185         if(vz)VecScale(vz,1.0/model->yts);
    186 
    187         count++;
    188         param= new Param(count,"vx",PETSCVEC);
    189         param->SetVec(vx);
    190         parameters->AddObject(param);
    191 
    192         count++;
    193         param= new Param(count,"vy",PETSCVEC);
    194         param->SetVec(vy);
    195         parameters->AddObject(param);
    196 
    197         count++;
    198         param= new Param(count,"vz",PETSCVEC);
    199         param->SetVec(vz);
    200         parameters->AddObject(param);
    201 
    202         VecFree(&vx);
    203         VecFree(&vy);
    204         VecFree(&vz);
     179        ModelFetchData((void**)&vx,NULL,NULL,model_handle,"vx","Matrix","Mat");
     180        ModelFetchData((void**)&vy,NULL,NULL,model_handle,"vy","Matrix","Mat");
     181        ModelFetchData((void**)&vz,NULL,NULL,model_handle,"vz","Matrix","Mat");
     182
     183        if(vx) for(i=0;i<model->numberofnodes;i++)vx[i]=vx[i]/model->yts;
     184        if(vy) for(i=0;i<model->numberofnodes;i++)vy[i]=vy[i]/model->yts;
     185        if(vz) for(i=0;i<model->numberofnodes;i++)vz[i]=vz[i]/model->yts;
     186
     187        count++;
     188        param= new Param(count,"vx",DOUBLEVEC);
     189        if(vx) param->SetDoubleVec(vx,model->numberofnodes);
     190        else param->SetDoubleVec(vx,0);
     191        parameters->AddObject(param);
     192
     193        count++;
     194        param= new Param(count,"vy",DOUBLEVEC);
     195        if(vy) param->SetDoubleVec(vy,model->numberofnodes);
     196        else param->SetDoubleVec(vy,0);
     197        parameters->AddObject(param);
     198
     199        count++;
     200        param= new Param(count,"vz",DOUBLEVEC);
     201        if(vz) param->SetDoubleVec(vz,model->numberofnodes);
     202        else param->SetDoubleVec(vz,0);
     203        parameters->AddObject(param);
     204
     205        xfree((void**)&vx);
     206        xfree((void**)&vy);
     207        xfree((void**)&vz);
    205208
    206209        /*All our datasets are already ordered by ids. Set presort flag so that later on, when sorting is requested on these

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

    r202 r209  
    2121
    2222        /*diagnostic: */
    23         Vec     vec_vx=NULL;
    24         Vec     vec_vy=NULL;
    25         Vec     vec_vz=NULL;
    26 
    2723        double* vx=NULL;
    2824        double* vy=NULL;
    … …  
    6460           ){
    6561
    66                 parameters->FindParam((void*)&vec_vx,"vx");
    67                 parameters->FindParam((void*)&vec_vy,"vy");
    68                 parameters->FindParam((void*)&vec_vz,"vz");
     62                parameters->FindParam((void*)&vx,"vx");
     63                parameters->FindParam((void*)&vy,"vy");
     64                parameters->FindParam((void*)&vz,"vz");
    6965
    70                 if(vec_vx)VecToMPISerial(&vx,vec_vx);
    71                 if(vec_vy)VecToMPISerial(&vy,vec_vy);
    72                 if(vec_vz)VecToMPISerial(&vz,vec_vz);
    73                        
    7466                u_g=(double*)xcalloc(numberofnodes*3,sizeof(double));
    7567
    … …  
    114106        if(analysis_type==ControlAnalysisEnum()){
    115107
    116                 parameters->FindParam((void*)&vec_vx_obs,"vx_obs");
    117                 parameters->FindParam((void*)&vec_vy_obs,"vy_obs");
    118                 parameters->FindParam((void*)&vec_control_parameter,"control_parameter");
     108                parameters->FindParam((void*)&vx_obs,"vx_obs");
     109                parameters->FindParam((void*)&vy_obs,"vy_obs");
     110                parameters->FindParam((void*)&control_parameter,"control_parameter");
    119111
    120112                /*Now, from vx_obs and vy_obs, build u_g_obs, correctly partitioned: */
    121                 VecToMPISerial(&vx_obs,vec_vx_obs);
    122                 VecToMPISerial(&vy_obs,vec_vy_obs);
    123                 VecToMPISerial(&control_parameter,vec_control_parameter);
    124113
    125114                u_g_obs=(double*)xcalloc(numberofnodes*2,sizeof(double));
    … …  
    160149        xfree((void**)&vy);
    161150        xfree((void**)&vz);
    162         VecFree(&vec_vx);
    163         VecFree(&vec_vy);
    164         VecFree(&vec_vz);
    165151        xfree((void**)&u_g);
    166152
    167153        xfree((void**)&vx_obs);
    168154        xfree((void**)&vy_obs);
    169         VecFree(&vec_vx_obs);
    170         VecFree(&vec_vy_obs);
    171         VecFree(&vec_control_parameter);
    172155        xfree((void**)&control_parameter);
    173156        xfree((void**)&u_g_obs);

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

    r202 r209  
    1919               
    2020Param::Param(){
     21        doublevec=NULL;
     22        doublemat=NULL;
     23        vec=NULL;
     24        mat=NULL;
     25
    2126        return;
    2227}
    … …  
    3439                throw ErrorException(__FUNCT__,exprintf("%s%i"," unknow parameter type ",param_type));
    3540        }
     41        doublevec=NULL;
     42        doublemat=NULL;
     43        vec=NULL;
     44        mat=NULL;
     45
    3646}
    3747
    … …  
    159169                case DOUBLEVEC:
    160170                        memcpy(marshalled_dataset,&M,sizeof(M));marshalled_dataset+=sizeof(M);
    161                         memcpy(marshalled_dataset,doublevec,M*sizeof(double));marshalled_dataset+=(M*sizeof(double));
     171                        if(M){
     172                                memcpy(marshalled_dataset,doublevec,M*sizeof(double));
     173                                marshalled_dataset+=(M*sizeof(double));
     174                        }
    162175                        break;
    163176
    … …  
    165178                        memcpy(marshalled_dataset,&M,sizeof(M));marshalled_dataset+=sizeof(M);
    166179                        memcpy(marshalled_dataset,&N,sizeof(N));marshalled_dataset+=sizeof(N);
    167                         memcpy(marshalled_dataset,doublevec,M*N*sizeof(double));marshalled_dataset+=(M*N*sizeof(double));
     180                        if(M*N){
     181                                memcpy(marshalled_dataset,doublevec,M*N*sizeof(double));
     182                                marshalled_dataset+=(M*N*sizeof(double));
     183                        }
    168184                        break;
    169185
    … …  
    294310       
    295311                        memcpy(&M,marshalled_dataset,sizeof(M));marshalled_dataset+=sizeof(M);
    296                         doublevec=(double*)xmalloc(M*sizeof(double));
    297                         memcpy(doublevec,marshalled_dataset,M*sizeof(double));marshalled_dataset+=(M*sizeof(double));
     312                        if(M){
     313                                doublevec=(double*)xmalloc(M*sizeof(double));
     314                                memcpy(doublevec,marshalled_dataset,M*sizeof(double));marshalled_dataset+=(M*sizeof(double));
     315                        }
    298316                        break;
    299317
    … …  
    301319                        memcpy(&M,marshalled_dataset,sizeof(M));marshalled_dataset+=sizeof(M);
    302320                        memcpy(&N,marshalled_dataset,sizeof(N));marshalled_dataset+=sizeof(N);
    303                         doublemat=(double*)xmalloc(M*N*sizeof(double));
    304                         memcpy(doublemat,marshalled_dataset,M*N*sizeof(double));marshalled_dataset+=(M*N*sizeof(double));
     321                        if(M*N){
     322                                doublemat=(double*)xmalloc(M*N*sizeof(double));
     323                                memcpy(doublemat,marshalled_dataset,M*N*sizeof(double));marshalled_dataset+=(M*N*sizeof(double));
     324                        }
    305325                        break;
    306326
    … …  
    390410                double** pdoublevec=(double**)pvalue;
    391411                double* outdoublevec=NULL;
    392                 outdoublevec=(double*)xmalloc(M*sizeof(double));
    393                 memcpy(outdoublevec,doublevec,M*sizeof(double));
     412                if(M){
     413                        outdoublevec=(double*)xmalloc(M*sizeof(double));
     414                        memcpy(outdoublevec,doublevec,M*sizeof(double));
     415                }
    394416                *pdoublevec=outdoublevec;
    395417        }
    … …  
    397419                double** pdoublemat=(double**)pvalue;
    398420                double* outdoublemat=NULL;
    399                 outdoublemat=(double*)xmalloc(M*N*sizeof(double));
    400                 memcpy(outdoublemat,doublemat,M*N*sizeof(double));
     421                if(M*N){
     422                        outdoublemat=(double*)xmalloc(M*N*sizeof(double));
     423                        memcpy(outdoublemat,doublemat,M*N*sizeof(double));
     424                }
    401425                *pdoublemat=outdoublemat;
    402426        }
    … …  
    478502       
    479503        M=size;
    480         doublevec=(double*)xmalloc(M*sizeof(double));
    481         memcpy(doublevec,value,M*sizeof(double));
     504        if(M){
     505                doublevec=(double*)xmalloc(M*sizeof(double));
     506                memcpy(doublevec,value,M*sizeof(double));
     507        }
    482508
    483509}

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

    r85 r209  
    2525        int     one=1;
    2626        int     gsize;
     27        int     nods;
    2728
    2829        /*serialize outputs: */
    … …  
    3132        VecShift(partition_shifted,1.0); //matlab indexing starts at 1
    3233        VecToMPISerial(&serial_partition,partition_shifted);
     34        VecGetSize(partition,&nods);
    3335       
    3436        VecToMPISerial(&serial_ug,u_g);
    … …  
    5355
    5456                /*Write parameter to disk: */
    55                 WriteDataToDisk(p_g,&gsize,&one,"Mat",fid);
     57                WriteDataToDisk(p_g,&nods,&one,"Mat",fid);
    5658
    5759                /*Write J to disk: */

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

    r85 r209  
    2727        int     one=1;
    2828        int     gsize;
     29        int     nods;
    2930
    3031        /*serialize outputs: */
    … …  
    3334        VecShift(partition_shifted,1.0); //matlab indexing starts at 1
    3435        VecToMPISerial(&serial_partition,partition_shifted);
     36        VecGetSize(partition,&nods);
    3537
    3638        VecToMPISerial(&serial_ug,u_g);
    … …  
    4951
    5052                /*Write partition: */
    51                 WriteDataToDisk(serial_partition,&gsize,&one,"Mat",fid);
     53                WriteDataToDisk(serial_partition,&nods,&one,"Mat",fid);
    5254               
    5355                /*Write solution to disk: */

  • issm/trunk/src/m/classes/public/loadresultsfromdisk.m

    r122 r209  
    3131
    3232        %Used to recover velocities
    33         indx=part(1:2:end);
    34         indy=part(2:2:end);
     33        indx=1:2:gsize;
     34        indy=2:2:gsize;
     35        indx=indx(part);
     36        indy=indy(part);
    3537
    3638        %Recover velocity

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

    r202 r209  
    4141
    4242        /*Create parameters: */
    43 
    4443        CreateParameters(&parameters,model,MODEL);
    4544

  • issm/trunk/todo

    r197 r209  
    33Define default cluster in /etc/cielo.rc
    44VelocityExtrude: debug
    5 Add vx and vy as input parameters to diagnostic.
    65FindParam(vx) then DeleteParam("vx")? Should vx be a Vec? Can we find a way of partionting vx with partition, and staying in parallel?
Note: See TracChangeset for help on using the changeset viewer.