Changeset 21759 for issm/branches/trunk-larour-NatGeoScience2016/src/c/classes/ExternalResults/GenericExternalResult.h

Timestamp:

06/07/17 10:50:54 (8 years ago)

Author:

Eric.Larour

Message:

CHG: merged branch back to trunk-jpl 21754.

File:

• issm/branches/trunk-larour-NatGeoScience2016/src/c/classes/ExternalResults/GenericExternalResult.h (modified) (1 diff)

issm/branches/trunk-larour-NatGeoScience2016/src/c/classes/ExternalResults/GenericExternalResult.h

@@ -334 +334 @@
 }  /*}}}*/
 
+/*Specific instantiations for int*: */
+template <> inline GenericExternalResult<int*>::GenericExternalResult(int in_id, int in_enum_type,int* in_values, int in_M,int in_N,int in_step,IssmDouble in_time){/*{{{*/
+
+        id = in_id;
+        M  = in_M;
+        N  = in_N;
+
+        EnumToStringx(&this->result_name,in_enum_type);
+
+        step = in_step;
+        time = in_time;
+
+        /*Copy result in values*/
+        if(M*N){
+                value=xNew<int>(M*N);
+                xMemCpy<int>(value,in_values,M*N);
+        }
+        else value=NULL;
+}
+/*}}}*/
+template <> inline GenericExternalResult<int*>::GenericExternalResult(int in_id,const char* in_result_name,int* in_values, int in_M,int in_N,int in_step,IssmDouble in_time){/*{{{*/
+
+        id = in_id;
+        M  = in_M;
+        N  = in_N;
+
+        /*Copy name*/
+        this->result_name = xNew<char>(strlen(in_result_name)+1);
+        xMemCpy<char>(this->result_name,in_result_name,strlen(in_result_name)+1);
+
+        step = in_step;
+        time = in_time;
+
+        /*Copy result in values*/
+        if(M*N){
+                value=xNew<int>(M*N);
+                xMemCpy<int>(value,in_values,M*N);
+        }
+        else value=NULL;
+}
+/*}}}*/
+template <> inline GenericExternalResult<int*>::GenericExternalResult(int in_id, int in_enum_type,int* in_value,int in_step, IssmDouble in_time){ /*{{{*/
+        _error_("you cannot initialize a GenericExternalResult<int*> without providing the dimensions of the matrix! Please use a more appropriate constructor!");
+} /*}}}*/
+template <> inline GenericExternalResult<int*>::~GenericExternalResult(){ /*{{{*/
+        xDelete<char>(result_name);
+        xDelete<int>(value);
+} /*}}}*/
+template <> inline void GenericExternalResult<int*>::Echo(void){ /*{{{*/
+
+        _printf_("GenericExternalResult<int*>:\n");
+        this->GenericEcho();
+        _printf_("   matrix size: " << this->M << "-" << this->N << "\n");
+
+} /*}}}*/
+template <> inline void GenericExternalResult<int*>::DeepEcho(void){ /*{{{*/
+
+        int i,j;
+
+        _printf_("GenericExternalResult<int*>:\n");
+        this->GenericEcho();
+
+        _printf_("   matrix size: " << this->M << "-" << this->N << "\n");
+        for (i=0;i<this->M;i++){  
+                _printf_("   [ ");
+                for (j=0;j<this->N;j++){
+                        _printf_( " " << setw(11) << this->value[i*this->N+j]);
+                }  
+                _printf_(" ]\n");
+        }  
+
+} /*}}}*/
+template <> inline Object* GenericExternalResult<int*>::copy(void){ /*{{{*/
+        return new GenericExternalResult<int*>(this->id,StringToEnumx(this->result_name),this->value,this->M,this->N,this->step,this->time);
+} /*}}}*/
+template <> inline void GenericExternalResult<int*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
+
+        int     my_rank;
+        int     type;
+        int     rows,cols;
+        char   *name    = NULL;
+        IssmPDouble passiveDouble;
+
+        /*recover my_rank:*/
+        my_rank=IssmComm::GetRank();
+
+        if(io_gather){
+                /*we are gathering the data on cpu 0, don't write on other cpus: */
+                if(my_rank) return;
+        }
+
+        /*First write enum: */
+        int length=(strlen(this->result_name)+1)*sizeof(char);
+        fwrite(&length,sizeof(int),1,fid);
+        fwrite(this->result_name,length,1,fid);
+
+        /*Now write time and step: */
+        passiveDouble=reCast<IssmPDouble>(time);
+        fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
+        fwrite(&step,sizeof(int),1,fid);
+
+        /*writing an int array, type is 4 (see parseresultsfromdisk.m):*/
+        type=4;
+        fwrite(&type,sizeof(int),1,fid);
+        rows=this->M;
+        fwrite(&rows,sizeof(int),1,fid);
+        cols=this->N;
+        fwrite(&cols,sizeof(int),1,fid);
+        fwrite(value,cols*rows*sizeof(int),1,fid);
+
+}
+/*}}}*/
+template <> inline int GenericExternalResult<int*>::ObjectEnum(void){ /*{{{*/
+        return IntMatExternalResultEnum;
+} /*}}}*/
+template <> inline void GenericExternalResult<int*>::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
+
+        MARSHALLING_ENUM(this->ObjectEnum());
+
+        MARSHALLING(id);
+        MARSHALLING(result_name);
+        MARSHALLING(M);
+        MARSHALLING(N);
+        MARSHALLING_DYNAMIC(value,int,M*N);
+        MARSHALLING(step);
+        MARSHALLING(time);
+
+}  /*}}}*/
+/*Specific instantiations for int*: */
+#if defined(_HAVE_ADOLC_) && !defined(_WRAPPERS_)  //We hook off this specific specialization when not running ADOLC, otherwise we get a redeclaration with the next specialization. 
+template <> inline void GenericExternalResult<int*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
+
+        int     i;
+        int     my_rank;
+        int     type;
+        int     rows,cols;
+        char   *name    = NULL;
+        IssmPDouble passiveDouble;
+        int* passiveInts;
+
+        /*recover my_rank:*/
+        my_rank=IssmComm::GetRank();
+
+        if(io_gather){
+                /*we are gathering the data on cpu 0, don't write on other cpus: */
+                if(my_rank) return;
+        }
+
+        /*First write enum: */
+        int length=(strlen(this->result_name)+1)*sizeof(char);
+        fwrite(&length,sizeof(int),1,fid);
+        fwrite(this->result_name,length,1,fid);
+
+        /*Now write time and step: */
+        passiveDouble=reCast<IssmPDouble>(time);
+        fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
+        fwrite(&step,sizeof(int),1,fid);
+
+        /*writing a int array, type is 4 (see parseresultsfromdisk.m):*/
+        type=4;
+        fwrite(&type,sizeof(int),1,fid);
+        rows=this->M;
+        fwrite(&rows,sizeof(int),1,fid);
+        cols=this->N;
+        fwrite(&cols,sizeof(int),1,fid);
+
+        passiveInts=xNew<int>(this->M*this->N);
+        for (i=0;i<this->M*this->N;i++)passiveInts[i]=reCast<int>(value[i]);
+        fwrite(passiveInts,cols*rows*sizeof(int),1,fid);
+        xDelete<int>(int);
+
+}
+/*}}}*/
+#endif
+
 /*Specific instantiations for IssmPDouble*: */
 template <> inline GenericExternalResult<IssmPDouble*>::GenericExternalResult(int in_id, int in_enum_type,IssmPDouble* in_values, int in_M,int in_N,int in_step,IssmDouble in_time){/*{{{*/