Changeset 25495


Ignore:
Timestamp:
08/27/20 17:27:08 (5 years ago)
Author:
Eric.Larour
Message:

CHG: finalizing, validating.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • issm/branches/trunk-larour-SLPS2020/src/c/main/issm_post.cpp

    r25494 r25495  
    631631                                        }
    632632                                        else if (xtype[counter]==3){
    633                                                 maxxs[counter]=doublemat;
    634                                                 minxs[counter]=doublemat;
     633                                                maxxs[counter]=xNew<IssmDouble>(doublematsize);
     634                                                xMemCpy<IssmDouble>(maxxs[counter],doublemat,doublematsize);
     635                                                minxs[counter]=xNew<IssmDouble>(doublematsize);
     636                                                xMemCpy<IssmDouble>(minxs[counter],doublemat,doublematsize);
    635637                                                xsize[counter]=doublematsize;
    636638                                        }
     
    643645                                        }
    644646                                        else if (xtype[counter]==3){
    645                                                 IssmDouble* newmax=minxs[counter];
    646                                                 IssmDouble* newmin=maxxs[counter];
     647                                                IssmDouble* newmax=maxxs[counter];
     648                                                IssmDouble* newmin=minxs[counter];
    647649                                                for(int k=0;k<doublematsize;k++){
    648                                                         newmax[k]=max(newmax[k],doublemat[k]);
    649                                                         newmin[k]=min(newmin[k],doublemat[k]);
     650                                                        if(doublemat[k]>newmax[k])newmax[k]=doublemat[k];
     651                                                        if(doublemat[k]<newmin[k])newmin[k]=doublemat[k];
    650652                                                }
    651                                                 maxxs[counter]=newmax;
    652                                                 minxs[counter]=newmin;
     653                                        }
     654                                        else _error_("cannot carry out statistics on type " << xtype[counter]);
     655                                }
     656                        }
     657                }
     658                _printf0_("    average in time:\n");
     659
     660                /*Deal with average in time: */
     661                fseek(fid,0,SEEK_SET);
     662                for (int f=0;f<nfields;f++){
     663                        char* field=fields[f];
     664                        meanxtype[f]=readdata(&doublemat, &doublematsize, &scalar, fid,field,steps[0]);
     665                       
     666                        if(meanxtype[f]==1){
     667                                meanxsize[f]=1;
     668                                IssmDouble timemean=0;
     669                                fseek(fid,0,SEEK_SET);
     670                                for (int j=0;j<nsteps;j++){
     671                                        readdata(&doublemat, &doublematsize, &scalar, fid,field,steps[j]);
     672                                        timemean+=scalar/nsteps;
     673                                }
     674                                       
     675                                /*Figure out max and min of time means: */
     676                                if(i==(lower_row+1)){
     677                                        maxmeans[f]=xNewZeroInit<IssmDouble>(1);
     678                                        minmeans[f]=xNewZeroInit<IssmDouble>(1);
     679                                        *maxmeans[f]=timemean;
     680                                        *minmeans[f]=timemean;
     681                                }
     682                                else{
     683                                        *maxmeans[f]=max(*maxmeans[f],timemean);
     684                                        *minmeans[f]=min(*minmeans[f],timemean);
     685                                }
     686                        }
     687                        else{
     688                                meanxsize[f]=doublematsize;
     689                                fseek(fid,0,SEEK_SET);
     690                                IssmDouble* timemean=xNewZeroInit<IssmDouble>(doublematsize);
     691                                for (int j=0;j<nsteps;j++){
     692                                        readdata(&doublemat, &doublematsize, &scalar, fid,field,steps[j]);
     693                                        for (int k=0;k<doublematsize;k++){
     694                                                timemean[k]+=doublemat[k]/nsteps;
     695                                        }
     696                                }
     697
     698                                if(i==(lower_row+1)){
     699                                        maxmeans[f]=xNew<IssmDouble>(doublematsize);
     700                                        xMemCpy<IssmDouble>(maxmeans[f],timemean,doublematsize);
     701                                        minmeans[f]=xNew<IssmDouble>(doublematsize);
     702                                        xMemCpy<IssmDouble>(minmeans[f],timemean,doublematsize);
     703                                }
     704                                else{
     705                                        IssmDouble* maxx=maxmeans[f];
     706                                        IssmDouble* minx=minmeans[f];
     707
     708                                        for(int k=0;k<doublematsize;k++){
     709                                                maxx[k]=max(maxx[k],timemean[k]);
     710                                                minx[k]=min(minx[k],timemean[k]);
     711                                        }
     712                                        maxmeans[f]=maxx;
     713                                        minmeans[f]=minx;
     714                                }
     715                        }
     716                }
     717                fclose(fid);
     718
     719                /*delete buffer:*/
     720                xDelete<char>(buffer);
     721        }
     722        ISSM_MPI_Barrier(ISSM_MPI_COMM_WORLD);
     723        _printf0_("Done reading files, now computing min and max.\n");
     724
     725        /*We have agregated minx and max across the cluster, now gather across the cluster onto
     726         *cpu0 and then compute statistics:*/
     727        for (int f=0;f<nfields;f++){
     728                int counter0=f*nsteps+0;
     729                if (xtype[counter0]==1){ /*deal with scalars {{{*/
     730                        for (int j=0;j<nsteps;j++){
     731                                int counter=f*nsteps+j;
     732
     733                                /*we are broadcasting doubles:*/
     734                                IssmDouble maxscalar=*maxxs[counter];
     735                                IssmDouble minscalar=*minxs[counter];
     736                                IssmDouble allmaxscalar;
     737                                IssmDouble allminscalar;
     738                                IssmDouble sumscalar_alltimes=0;
     739
     740                                ISSM_MPI_Allreduce(&maxscalar,&allmaxscalar,1,ISSM_MPI_PDOUBLE,ISSM_MPI_MAX,IssmComm::GetComm());
     741                                ISSM_MPI_Allreduce(&minscalar,&allminscalar,1,ISSM_MPI_PDOUBLE,ISSM_MPI_MIN,IssmComm::GetComm());
     742
     743                                /*Store broadcasted value for later computation of histograms:*/
     744                                *maxxs[counter]=allmaxscalar;
     745                                *minxs[counter]=allminscalar;
     746
     747                        }
     748                } /*}}}*/
     749                else{ /*deal with arrays:{{{*/
     750
     751                        int size=xsize[counter0];
     752                        for (int j=0;j<nsteps;j++){
     753                                int counter=f*nsteps+j;
     754
     755                                /*we are broadcasting double arrays:*/
     756                                IssmDouble* maxx=maxxs[counter];
     757                                IssmDouble* minx=minxs[counter];
     758
     759                                IssmDouble*  allmax=xNew<IssmDouble>(size);
     760                                IssmDouble*  allmin=xNew<IssmDouble>(size);
     761                               
     762                                ISSM_MPI_Allreduce(maxx,allmax,size,ISSM_MPI_PDOUBLE,ISSM_MPI_MAX,IssmComm::GetComm());
     763                                ISSM_MPI_Allreduce(minx,allmin,size,ISSM_MPI_PDOUBLE,ISSM_MPI_MIN,IssmComm::GetComm());
     764
     765                                /*Store broadcasted value for later computation of histograms:*/
     766                                maxxs[counter]=allmax;
     767                                minxs[counter]=allmin;
     768                        }
     769                } /*}}}*/
     770        }
     771       
     772        /*Now do the same for the time mean fields:*/
     773        for (int f=0;f<nfields;f++){
     774                if (meanxtype[f]==1){ /*deal with scalars {{{*/
     775
     776                        /*we are broadcasting doubles:*/
     777                        IssmDouble maxscalar=*maxmeans[f];
     778                        IssmDouble minscalar=*minmeans[f];
     779                        IssmDouble allmaxscalar;
     780                        IssmDouble allminscalar;
     781
     782                        ISSM_MPI_Allreduce(&maxscalar,&allmaxscalar,1,ISSM_MPI_PDOUBLE,ISSM_MPI_MAX,IssmComm::GetComm());
     783                        ISSM_MPI_Allreduce(&minscalar,&allminscalar,1,ISSM_MPI_PDOUBLE,ISSM_MPI_MIN,IssmComm::GetComm());
     784
     785                        /*Store for later use in histogram computation:*/
     786                        *maxmeans[f]=allmaxscalar;
     787                        *minmeans[f]=allminscalar;
     788
     789                } /*}}}*/
     790                else{ /*deal with arrays:{{{*/
     791
     792                        int size=meanxsize[f];
     793
     794                        /*we are broadcasting double arrays:*/
     795                        IssmDouble* maxx=maxmeans[f];
     796                        IssmDouble* minx=minmeans[f];
     797
     798                        IssmDouble*  allmax=xNew<IssmDouble>(size);
     799                        IssmDouble*  allmin=xNew<IssmDouble>(size);
     800
     801                        ISSM_MPI_Allreduce(maxx,allmax,size,ISSM_MPI_PDOUBLE,ISSM_MPI_MAX,IssmComm::GetComm());
     802                        ISSM_MPI_Allreduce(minx,allmin,size,ISSM_MPI_PDOUBLE,ISSM_MPI_MIN,IssmComm::GetComm());
     803
     804                       
     805                        /*Store for later use in histogram computation:*/
     806                        maxmeans[f]=allmax;
     807                        minmeans[f]=allmin;
     808
     809                } /*}}}*/
     810        }
     811
     812        /*Now that we have the min and max, we can start binning. First allocate
     813         * histograms, then start filling them:*/
     814        IssmDouble** histogram=xNew<IssmDouble*>(nfields*nsteps);
     815        IssmDouble** timehistogram=xNew<IssmDouble*>(nfields);
     816
     817        _printf0_("Start reading files again, this time binning values in the histogram:\n");
     818        /*Start opening files:*/
     819        for (int i=(lower_row+1);i<=upper_row;i++){
     820                _printf0_("reading file #: " << i << "\n");
     821                char file[1000];
     822                int  length;
     823                char* buffer=NULL;
     824
     825                /*string:*/
     826                sprintf(file,"%s/%i/%s.outbin.%i",directory,my_rank+1,model,i);
     827
     828                /*open file: */
     829                _printf0_("    opening file:\n");
     830                FILE* fid=fopen(file,"rb");
     831                if(fid==NULL)_error_("cound not open file: " << file << "\n");
     832
     833                /*figure out size of file, and read the whole thing:*/
     834                _printf0_("    reading file:\n");
     835                fseek (fid, 0, SEEK_END);
     836                length = ftell (fid);
     837                fseek (fid, 0, SEEK_SET);
     838                buffer = xNew<char>(length);
     839                fread (buffer, sizeof(char), length, fid);
     840
     841                /*close file:*/
     842                fclose (fid);
     843
     844                /*create a memory stream with this buffer:*/
     845                _printf0_("    processing file:\n");
     846                fid=fmemopen(buffer, length, "rb");
     847
     848                /*start reading data from the buffer directly:*/
     849                for (int f=0;f<nfields;f++){
     850                        char* field=fields[f];
     851                        fseek(fid,0,SEEK_SET);
     852                        for (int j=0;j<nsteps;j++){
     853                                int counter=f*nsteps+j;
     854                                xtype[counter]=readdata(&doublemat, &doublematsize, &scalar, fid,field,steps[j]);
     855                                if(i==(lower_row+1)){
     856                                        if(xtype[counter]==1){
     857                                                IssmDouble* localhistogram=xNewZeroInit<IssmDouble>(nbins);
     858                                                IssmDouble ma=*maxxs[counter];
     859                                                IssmDouble mi=*minxs[counter];
     860                                                int index=(scalar-mi)/(ma-mi)*nbins; if (index==nbins)index--;
     861                                                localhistogram[index]++;
     862                                                histogram[counter]=localhistogram;
     863                                        }
     864                                        else if (xtype[counter]==3){
     865                                                IssmDouble* localhistogram=xNewZeroInit<IssmDouble>(doublematsize*nbins);
     866                                                IssmDouble* ma=maxxs[counter];
     867                                                IssmDouble* mi=minxs[counter];
     868                                                for (int k=0;k<doublematsize;k++){
     869                                                        IssmDouble scalar=doublemat[k];
     870                                                        int index=(scalar-mi[k])/(ma[k]-mi[k])*nbins; if (index==nbins)index--;
     871                                                        _assert_(scalar<=ma[k]); _assert_(scalar>=mi[k]); _assert_(index<nbins);
     872                                                        localhistogram[k*nbins+index]++;
     873                                                }
     874                                                histogram[counter]=localhistogram;
     875                                        }
     876                                        else _error_("cannot carry out statistics on type " << xtype[counter]);
     877                                }
     878                                else{
     879                                        if(xtype[counter]==1){
     880                                                IssmDouble* localhistogram=histogram[counter];
     881                                                IssmDouble ma=*maxxs[counter];
     882                                                IssmDouble mi=*minxs[counter];
     883                                                int index=(scalar-mi)/(ma-mi)*nbins; if (index==nbins)index=nbins-1;
     884                                                localhistogram[index]++;
     885                                        }
     886                                        else if (xtype[counter]==3){
     887                                                IssmDouble* localhistogram=histogram[counter];
     888                                                IssmDouble* ma=maxxs[counter];
     889                                                IssmDouble* mi=minxs[counter];
     890                                                for (int k=0;k<doublematsize;k++){
     891                                                        IssmDouble scalar=doublemat[k];
     892                                                        int index=(scalar-mi[k])/(ma[k]-mi[k])*nbins; if (index==nbins)index=nbins-1;
     893                                                        localhistogram[k*nbins+index]++;
     894                                                }
    653895                                        }
    654896                                        else _error_("cannot carry out statistics on type " << xtype[counter]);
     
    674916                                /*Figure out max and min of time means: */
    675917                                if(i==(lower_row+1)){
    676                                         maxmeans[f]=xNewZeroInit<IssmDouble>(1);
    677                                         minmeans[f]=xNewZeroInit<IssmDouble>(1);
    678                                         *maxmeans[f]=timemean;
    679                                         *minmeans[f]=timemean;
    680                                 }
    681                                 else{
    682                                         *maxmeans[f]=max(*maxmeans[f],timemean);
    683                                         *minmeans[f]=min(*minmeans[f],timemean);
    684                                 }
    685                         }
    686                         else{
    687                                 fseek(fid,0,SEEK_SET);
    688                                 IssmDouble* timemean=xNewZeroInit<IssmDouble>(doublematsize);
    689                                 for (int j=0;j<nsteps;j++){
    690                                         readdata(&doublemat, &doublematsize, &scalar, fid,field,steps[j]);
    691                                         for (int k=0;i<doublematsize;k++){
    692                                                 timemean[k]+=doublemat[k]/nsteps;
    693                                         }
    694                                 }
    695 
    696                                 if(i==(lower_row+1)){
    697                                         maxmeans[f]=timemean;
    698                                         minmeans[f]=timemean;
    699                                 }
    700                                 else{
    701                                         IssmDouble* maxx=maxmeans[f];
    702                                         IssmDouble* minx=minmeans[f];
    703 
    704                                         for(int k=0;k<doublematsize;k++){
    705                                                 maxx[k]=max(maxx[k],timemean[k]);
    706                                                 minx[k]=min(minx[k],timemean[k]);
    707                                         }
    708                                         maxmeans[f]=maxx;
    709                                         minmeans[f]=minx;
    710                                 }
    711                         }
    712                 }
    713                 fclose(fid);
    714 
    715                 /*delete buffer:*/
    716                 xDelete<char>(buffer);
    717         }
    718         ISSM_MPI_Barrier(ISSM_MPI_COMM_WORLD);
    719         _printf0_("Done reading files, now computing min and max.\n");
    720 
    721         /*We have agregated minx and max across the cluster, now gather across the cluster onto
    722          *cpu0 and then compute statistics:*/
    723         for (int f=0;f<nfields;f++){
    724                 int counter0=f*nsteps+0;
    725                 if (xtype[counter0]==1){ /*deal with scalars {{{*/
    726                         for (int j=0;j<nsteps;j++){
    727                                 int counter=f*nsteps+j;
    728 
    729                                 /*we are broadcasting doubles:*/
    730                                 IssmDouble maxscalar=*maxxs[counter];
    731                                 IssmDouble minscalar=*minxs[counter];
    732                                 IssmDouble allmaxscalar;
    733                                 IssmDouble allminscalar;
    734                                 IssmDouble sumscalar_alltimes=0;
    735 
    736                                 ISSM_MPI_Allreduce(&maxscalar,&allmaxscalar,1,ISSM_MPI_PDOUBLE,ISSM_MPI_MAX,IssmComm::GetComm());
    737                                 ISSM_MPI_Allreduce(&minscalar,&allminscalar,1,ISSM_MPI_PDOUBLE,ISSM_MPI_MIN,IssmComm::GetComm());
    738 
    739                                 /*add to results:*/
    740                                 if(my_rank==0){
    741                                         char fieldname[1000];
    742 
    743                                         sprintf(fieldname,"%s%s",fields[f],"Max");
    744                                         results->AddResult(new GenericExternalResult<IssmDouble>(results->Size()+1,fieldname,allmaxscalar,j+1,0));
    745                                         sprintf(fieldname,"%s%s",fields[f],"Min");
    746                                         results->AddResult(new GenericExternalResult<IssmDouble>(results->Size()+1,fieldname,allminscalar,j+1,0));
    747                                 }
    748 
    749                                 /*Store broadcasted value for later computation of histograms:*/
    750                                 *maxxs[counter]=allmaxscalar;
    751                                 *minxs[counter]=allminscalar;
    752 
    753                         }
    754                 } /*}}}*/
    755                 else{ /*deal with arrays:{{{*/
    756 
    757                         int size=xsize[counter0];
    758                         for (int j=0;j<nsteps;j++){
    759                                 int counter=f*nsteps+j;
    760 
    761                                 /*we are broadcasting double arrays:*/
    762                                 IssmDouble* maxx=maxxs[counter];
    763                                 IssmDouble* minx=minxs[counter];
    764 
    765                                 IssmDouble*  allmax=xNew<IssmDouble>(size);
    766                                 IssmDouble*  allmin=xNew<IssmDouble>(size);
    767                                
    768                                 ISSM_MPI_Allreduce(maxx,allmax,size,ISSM_MPI_PDOUBLE,ISSM_MPI_MAX,IssmComm::GetComm());
    769                                 ISSM_MPI_Allreduce(minx,allmin,size,ISSM_MPI_PDOUBLE,ISSM_MPI_MIN,IssmComm::GetComm());
    770 
    771                                 /*add to results:*/
    772                                 if(my_rank==0){
    773                                         char fieldname[1000];
    774 
    775                                         sprintf(fieldname,"%s%s",fields[f],"Max");
    776                                         results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,allmax,size,1,j+1,0));
    777                                         sprintf(fieldname,"%s%s",fields[f],"Min");
    778                                         results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,allmin,size,1,j+1,0));
    779                                 }
    780                                 /*Store broadcasted value for later computation of histograms:*/
    781                                 maxxs[counter]=allmax;
    782                                 minxs[counter]=allmin;
    783                         }
    784                 } /*}}}*/
    785         }
    786        
    787         /*Now do the same for the time mean fields:*/
    788         for (int f=0;f<nfields;f++){
    789                 if (meanxtype[f]==1){ /*deal with scalars {{{*/
    790 
    791                         /*we are broadcasting doubles:*/
    792                         IssmDouble maxscalar=*maxmeans[f];
    793                         IssmDouble minscalar=*minmeans[f];
    794                         IssmDouble allmaxscalar;
    795                         IssmDouble allminscalar;
    796 
    797                         ISSM_MPI_Allreduce(&maxscalar,&allmaxscalar,1,ISSM_MPI_PDOUBLE,ISSM_MPI_MAX,IssmComm::GetComm());
    798                         ISSM_MPI_Allreduce(&minscalar,&allminscalar,1,ISSM_MPI_PDOUBLE,ISSM_MPI_MIN,IssmComm::GetComm());
    799 
    800                         /*add to results at time step 1:*/
    801                         if(my_rank==0){
    802                                 char fieldname[1000];
    803 
    804                                 sprintf(fieldname,"%s%s",fields[f],"TimeMeanMax");
    805                                 results->AddResult(new GenericExternalResult<IssmDouble>(results->Size()+1,fieldname,allmaxscalar,1,0));
    806                                 sprintf(fieldname,"%s%s",fields[f],"TimeMeaMin");
    807                                 results->AddResult(new GenericExternalResult<IssmDouble>(results->Size()+1,fieldname,allminscalar,1,0));
    808                         }
    809                         /*Store for later use in histogram computation:*/
    810                         *maxmeans[f]=allmaxscalar;
    811                         *minmeans[f]=allminscalar;
    812 
    813                 } /*}}}*/
    814                 else{ /*deal with arrays:{{{*/
    815 
    816                         int size=meanxsize[f];
    817 
    818                         /*we are broadcasting double arrays:*/
    819                         IssmDouble* maxx=maxmeans[f];
    820                         IssmDouble* minx=minmeans[f];
    821 
    822                         IssmDouble*  allmax=xNew<IssmDouble>(size);
    823                         IssmDouble*  allmin=xNew<IssmDouble>(size);
    824 
    825                         ISSM_MPI_Allreduce(maxx,allmax,size,ISSM_MPI_PDOUBLE,ISSM_MPI_MAX,IssmComm::GetComm());
    826                         ISSM_MPI_Allreduce(minx,allmin,size,ISSM_MPI_PDOUBLE,ISSM_MPI_MIN,IssmComm::GetComm());
    827 
    828                         /*add to results at step 1:*/
    829                         if(my_rank==0){
    830                                 char fieldname[1000];
    831 
    832                                 sprintf(fieldname,"%s%s",fields[f],"TimeMeanMax");
    833                                 results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,allmax,size,1,1,0));
    834                                 sprintf(fieldname,"%s%s",fields[f],"TimeMeanMin");
    835                                 results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,allmin,size,1,1,0));
    836                         }
    837                        
    838                         /*Store for later use in histogram computation:*/
    839                         maxmeans[f]=allmax;
    840                         minmeans[f]=allmin;
    841 
    842                 } /*}}}*/
    843         }
    844 
    845         /*Now that we have the min and max, we can start binning. First allocate
    846          * histograms, then start filling them:*/
    847         IssmDouble** histogram=xNew<IssmDouble*>(nfields*nsteps);
    848         IssmDouble** timehistogram=xNew<IssmDouble*>(nfields);
    849 
    850         _printf0_("Start reading files again, this time binning values in the histogram:\n");
    851         /*Start opening files:*/
    852         for (int i=(lower_row+1);i<=upper_row;i++){
    853                 _printf0_("reading file #: " << i << "\n");
    854                 char file[1000];
    855                 int  length;
    856                 char* buffer=NULL;
    857 
    858                 /*string:*/
    859                 sprintf(file,"%s/%i/%s.outbin.%i",directory,my_rank+1,model,i);
    860 
    861                 /*open file: */
    862                 _printf0_("    opening file:\n");
    863                 FILE* fid=fopen(file,"rb");
    864                 if(fid==NULL)_error_("cound not open file: " << file << "\n");
    865 
    866                 /*figure out size of file, and read the whole thing:*/
    867                 _printf0_("    reading file:\n");
    868                 fseek (fid, 0, SEEK_END);
    869                 length = ftell (fid);
    870                 fseek (fid, 0, SEEK_SET);
    871                 buffer = xNew<char>(length);
    872                 fread (buffer, sizeof(char), length, fid);
    873 
    874                 /*close file:*/
    875                 fclose (fid);
    876 
    877                 /*create a memory stream with this buffer:*/
    878                 _printf0_("    processing file:\n");
    879                 fid=fmemopen(buffer, length, "rb");
    880 
    881                 /*start reading data from the buffer directly:*/
    882                 for (int f=0;f<nfields;f++){
    883                         char* field=fields[f];
    884                         fseek(fid,0,SEEK_SET);
    885                         for (int j=0;j<nsteps;j++){
    886                                 int counter=f*nsteps+j;
    887                                 xtype[counter]=readdata(&doublemat, &doublematsize, &scalar, fid,field,steps[j]);
    888                                 if(i==(lower_row+1)){
    889                                         if(xtype[counter]==1){
    890                                                 IssmDouble* localhistogram=xNewZeroInit<IssmDouble>(nbins);
    891                                                 IssmDouble ma=*maxxs[counter];
    892                                                 IssmDouble mi=*minxs[counter];
    893                                                 int index=(scalar-mi)/(ma-mi)*nbins; if (index==nbins)index=nbins-1;
    894                                                 localhistogram[index]++;
    895                                                 histogram[counter]=localhistogram;
    896                                         }
    897                                         else if (xtype[counter]==3){
    898                                                 IssmDouble* localhistogram=xNewZeroInit<IssmDouble>(doublematsize*nbins);
    899                                                 IssmDouble* ma=maxxs[counter];
    900                                                 IssmDouble* mi=minxs[counter];
    901                                                 for (int k=0;k<doublematsize;k++){
    902                                                         IssmDouble scalar=doublemat[k];
    903                                                         int index=(scalar-mi[k])/(ma[k]-mi[k])*nbins; if (index==nbins)index=nbins-1;
    904                                                         localhistogram[k*nbins+index]++;
    905                                                 }
    906                                                 histogram[counter]=localhistogram;
    907                                         }
    908                                         else _error_("cannot carry out statistics on type " << xtype[counter]);
    909                                 }
    910                                 else{
    911                                         if(xtype[counter]==1){
    912                                                 IssmDouble* localhistogram=histogram[counter];
    913                                                 IssmDouble ma=*maxxs[counter];
    914                                                 IssmDouble mi=*minxs[counter];
    915                                                 int index=(scalar-mi)/(ma-mi)*nbins; if (index==nbins)index=nbins-1;
    916                                                 localhistogram[index]++;
    917                                         }
    918                                         else if (xtype[counter]==3){
    919                                                 IssmDouble* localhistogram=histogram[counter];
    920                                                 IssmDouble* ma=maxxs[counter];
    921                                                 IssmDouble* mi=minxs[counter];
    922                                                 for (int k=0;k<doublematsize;k++){
    923                                                         IssmDouble scalar=doublemat[k];
    924                                                         int index=(scalar-mi[k])/(ma[k]-mi[k])*nbins; if (index==nbins)index=nbins-1;
    925                                                         localhistogram[k*nbins+index]++;
    926                                                 }
    927                                         }
    928                                         else _error_("cannot carry out statistics on type " << xtype[counter]);
    929                                 }
    930                         }
    931                 }
    932                 _printf0_("    average in time:\n");
    933 
    934                 /*Deal with average in time: */
    935                 fseek(fid,0,SEEK_SET);
    936                 for (int f=0;f<nfields;f++){
    937                         char* field=fields[f];
    938                         meanxtype[f]=readdata(&doublemat, &doublematsize, &scalar, fid,field,steps[0]);
    939                        
    940                         if(meanxtype[f]==1){
    941                                 IssmDouble timemean=0;
    942                                 fseek(fid,0,SEEK_SET);
    943                                 for (int j=0;j<nsteps;j++){
    944                                         readdata(&doublemat, &doublematsize, &scalar, fid,field,steps[j]);
    945                                         timemean+=scalar/nsteps;
    946                                 }
    947                                        
    948                                 /*Figure out max and min of time means: */
    949                                 if(i==(lower_row+1)){
    950918                                        IssmDouble* localhistogram=xNewZeroInit<IssmDouble>(nbins);
    951919                                        IssmDouble ma=*maxmeans[f];
     
    968936                                for (int j=0;j<nsteps;j++){
    969937                                        readdata(&doublemat, &doublematsize, &scalar, fid,field,steps[j]);
    970                                         for (int k=0;i<doublematsize;k++){
     938                                        for (int k=0;k<doublematsize;k++){
    971939                                                timemean[k]+=doublemat[k]/nsteps;
    972940                                        }
     
    1025993                                        sprintf(fieldname,"%s%s",fields[f],"Histogram");
    1026994                                        results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,allhisto,1,nbins,j+1,0));
     995
     996                                        sprintf(fieldname,"%s%s",fields[f],"Max");
     997                                        results->AddResult(new GenericExternalResult<IssmDouble>(results->Size()+1,fieldname,*maxxs[counter],j+1,0));
     998                                        sprintf(fieldname,"%s%s",fields[f],"Min");
     999                                        results->AddResult(new GenericExternalResult<IssmDouble>(results->Size()+1,fieldname,*minxs[counter],j+1,0));
    10271000                                }
    10281001                        }
     
    10381011                                IssmDouble*  allhisto=xNew<IssmDouble>(size*nbins);
    10391012                               
    1040                                 ISSM_MPI_Allreduce(histo,allhisto,size*nbins,ISSM_MPI_PDOUBLE,ISSM_MPI_MAX,IssmComm::GetComm());
     1013                                ISSM_MPI_Allreduce(histo,allhisto,size*nbins,ISSM_MPI_PDOUBLE,ISSM_MPI_SUM,IssmComm::GetComm());
    10411014
    10421015                                /*add to results:*/
     
    10461019                                        sprintf(fieldname,"%s%s",fields[f],"Histogram");
    10471020                                        results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,allhisto,size,nbins,j+1,0));
     1021
     1022                                        sprintf(fieldname,"%s%s",fields[f],"Max");
     1023                                        results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,maxxs[counter],size,1,j+1,0));
     1024                                        sprintf(fieldname,"%s%s",fields[f],"Min");
     1025                                        results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,minxs[counter],size,1,j+1,0));
    10481026                                }
    10491027                        }
     
    10671045                                sprintf(fieldname,"%s%s",fields[f],"TimeMeanHistogram");
    10681046                                results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,allhisto,1,nbins,1,0));
     1047
     1048                                sprintf(fieldname,"%s%s",fields[f],"TimeMeanMax");
     1049                                results->AddResult(new GenericExternalResult<IssmDouble>(results->Size()+1,fieldname,*maxmeans[f],1,0));
     1050                                sprintf(fieldname,"%s%s",fields[f],"TimeMeaMin");
     1051                                results->AddResult(new GenericExternalResult<IssmDouble>(results->Size()+1,fieldname,*minmeans[f],1,0));
    10691052                        }
    10701053                } /*}}}*/
     
    10771060                        IssmDouble* allhisto=xNewZeroInit<IssmDouble>(size*nbins);
    10781061
    1079                         ISSM_MPI_Allreduce(histo,allhisto,size*nbins,ISSM_MPI_PDOUBLE,ISSM_MPI_MAX,IssmComm::GetComm());
     1062                        ISSM_MPI_Allreduce(histo,allhisto,size*nbins,ISSM_MPI_PDOUBLE,ISSM_MPI_SUM,IssmComm::GetComm());
    10801063                        /*add to results at step 1:*/
    10811064                        if(my_rank==0){
     
    10841067                                sprintf(fieldname,"%s%s",fields[f],"TimeMeanHistogram");
    10851068                                results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,allhisto,size,nbins,1,0));
     1069                                sprintf(fieldname,"%s%s",fields[f],"TimeMeanMax");
     1070                                results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,maxmeans[f],size,1,1,0));
     1071                                sprintf(fieldname,"%s%s",fields[f],"TimeMeanMin");
     1072                                results->AddResult(new GenericExternalResult<IssmPDouble*>(results->Size()+1,fieldname,minmeans[f],size,1,1,0));
    10861073                        }
    10871074                } /*}}}*/
Note: See TracChangeset for help on using the changeset viewer.