Changeset 22822 for issm/trunk/src/c/classes/ExternalResults/GenericExternalResult.h

Timestamp:

05/31/18 10:44:24 (7 years ago)

Author:

Mathieu Morlighem

Message:

merged trunk-jpl and trunk for revision 22820

Location:

issm/trunk

Files:

• . (modified) (1 prop)
• src (modified) (1 prop)
• src/c/classes/ExternalResults/GenericExternalResult.h (modified) (2 diffs)

issm/trunk/src/c/classes/ExternalResults/GenericExternalResult.h

@@ -179 +179 @@
 
 } /*}}}*/
+void  Transpose(void){ /*{{{*/
+        _error_("not implemented yet");
+} /*}}}*/
 char* GetResultName(void){ /*{{{*/
                 char* name = xNew<char>(strlen(this->result_name)+1);
@@ -594 +597 @@
 
 }  /*}}}*/
-
-/*Specific instantiations for IssmDouble*: */
+template <> inline void GenericExternalResult<IssmPDouble*>::Transpose(void){/*{{{*/
+
+
+        /*Perform transpose only if we have a matrix*/
+        if(M>1 && N>1){
+                IssmPDouble* temp=xNew<IssmPDouble>(M*N);
+                for(int i=0;i<M;i++){
+                        for(int j=0;j<N;j++){
+                                temp[j*M+i] = value[i*N+j];
+                        }
+                }
+                xDelete<IssmPDouble>(this->value);
+                this->value = temp;
+        }
+
+        /*Switch dimensions*/
+        int temp2 = this->N;
+        this->N = this->M;
+        this->M = temp2;
+
+
+
+} /*}}}*/
+
+        /*Specific instantiations for IssmDouble*: */
 #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<IssmDouble*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
-
-        int     i;
-        int     my_rank;
-        int     type;
-        int     rows,cols;
-        char   *name    = NULL;
-        IssmPDouble passiveDouble;
-        IssmPDouble* passiveDoubles;
-
-        /*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 IssmDouble array, type is 3:*/
-        type=3;
-        fwrite(&type,sizeof(int),1,fid);
-        rows=this->M;
-        fwrite(&rows,sizeof(int),1,fid);
-        cols=this->N;
-        fwrite(&cols,sizeof(int),1,fid);
-
-        passiveDoubles=xNew<IssmPDouble>(this->M*this->N);
-        for (i=0;i<this->M*this->N;i++)passiveDoubles[i]=reCast<IssmPDouble>(value[i]);
-        fwrite(passiveDoubles,cols*rows*sizeof(IssmPDouble),1,fid);
-        xDelete<IssmPDouble>(passiveDoubles);
-
-}
-/*}}}*/
-#endif
-
-/*Specifics instantiations for Vector*/
-template <> inline GenericExternalResult<Vector<IssmPDouble>*>::GenericExternalResult(int in_id, int in_enum_type,Vector<IssmPDouble>* in_values, int in_M,int in_N,int in_step,IssmDouble in_time){/*{{{*/
-        _error_("instanciation not correct");
-}
-/*}}}*/
-template <> inline GenericExternalResult<Vector<IssmPDouble>*>::GenericExternalResult(int in_id, int in_enum_type,Vector<IssmPDouble>* in_value,int in_step, IssmDouble in_time){ /*{{{*/
-        id = in_id;
-        M  = 0;
-        N  = 0;
-
-        /*Convert enum to name*/
-        EnumToStringx(&this->result_name,in_enum_type);
-
-        step = in_step;
-        time = in_time;
-
-        value = in_value;
-} /*}}}*/
-template <> inline GenericExternalResult<Vector<IssmPDouble>*>::~GenericExternalResult(){ /*{{{*/
-        xDelete<char>(this->result_name);
-        delete value;
-} /*}}}*/
-template <> inline void GenericExternalResult<Vector<IssmPDouble>*>::Echo(void){ /*{{{*/
-
-        _printf_("GenericExternalResult<Vector<IssmPDouble>*>:\n");
-        this->GenericEcho();
-        this->value->Echo();
-
-} /*}}}*/
-template <> inline void GenericExternalResult<Vector<IssmPDouble>*>::DeepEcho(void){ /*{{{*/
-
-        this->Echo();
-
-} /*}}}*/
-template <> inline Object* GenericExternalResult<Vector<IssmPDouble>*>::copy(void){ /*{{{*/
-        return new GenericExternalResult<Vector<IssmPDouble>*>(this->id,StringToEnumx(this->result_name),this->value,this->step,this->time);
-} /*}}}*/
-#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<Vector<IssmPDouble>*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
-
-        char *name   = NULL;
-        int   length,rows,cols=1;
-
-        if(!io_gather){
-                _error_("not supported yet");
-        }
-
-        /*Serialize vector*/
-        IssmPDouble* serialvalues = this->value->ToMPISerial();
-        this->value->GetSize(&rows);
-
-        if(IssmComm::GetRank()==0){
-                /*First write name: */
-                length=(strlen(this->result_name)+1)*sizeof(char);
+        template <> inline void GenericExternalResult<IssmDouble*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
+
+                int     i;
+                int     my_rank;
+                int     type;
+                int     rows,cols;
+                char   *name    = NULL;
+                IssmPDouble passiveDouble;
+                IssmPDouble* passiveDoubles;
+
+                /*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: */
-                IssmPDouble passiveDouble=reCast<IssmPDouble>(time);
+                passiveDouble=reCast<IssmPDouble>(time);
                 fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
                 fwrite(&step,sizeof(int),1,fid);
 
                 /*writing a IssmDouble array, type is 3:*/
-                int type=3;
+                type=3;
                 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(serialvalues,cols*rows*sizeof(IssmPDouble),1,fid);
-        }
-
-        /*Clean up*/
-        xDelete<IssmPDouble>(serialvalues);
-
-}
-/*}}}*/
+
+                passiveDoubles=xNew<IssmPDouble>(this->M*this->N);
+                for (i=0;i<this->M*this->N;i++)passiveDoubles[i]=reCast<IssmPDouble>(value[i]);
+                fwrite(passiveDoubles,cols*rows*sizeof(IssmPDouble),1,fid);
+                xDelete<IssmPDouble>(passiveDoubles);
+
+        }
+        /*}}}*/
 #endif
-template <> inline int GenericExternalResult<Vector<IssmPDouble>*>::ObjectEnum(void){ /*{{{*/
-        return NoneEnum;
-        /*???? FIXME*/
-} /*}}}*/
-
-/*Specifics instantiations for Vector<IssmDouble>*/
-template <> inline void GenericExternalResult<Vector<IssmDouble>*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
-
-        int i;
-        char *name   = NULL;
-        int   length,rows,cols=1;
-        IssmDouble*  serialvalues = NULL;
-        IssmPDouble* pserialvalues = NULL;
-
-        if(!io_gather){
-                _error_("not supported yet");
-        }
-
-        /*Serialize vector*/
-        serialvalues = this->value->ToMPISerial();
-        this->value->GetSize(&rows);
-        
-        pserialvalues=xNew<IssmPDouble>(rows);
-        for(i=0;i<rows;i++)pserialvalues[i]=reCast<IssmPDouble>(serialvalues[i]);
-
-        if(IssmComm::GetRank()==0){
-                /*First write name: */
-                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: */
-                IssmPDouble passiveDouble=reCast<IssmPDouble>(time);
-                fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
-                fwrite(&step,sizeof(int),1,fid);
-
-                /*writing a IssmDouble array, type is 3:*/
-                int type=3;
-                fwrite(&type,sizeof(int),1,fid);
-                fwrite(&rows,sizeof(int),1,fid);
-                fwrite(&cols,sizeof(int),1,fid);
-                fwrite(pserialvalues,cols*rows*sizeof(IssmPDouble),1,fid);
-        }
-
-        /*Clean up*/
-        xDelete<IssmPDouble>(pserialvalues);
-        xDelete<IssmDouble>(serialvalues);
-
-}
-/*}}}*/
-template <> inline void GenericExternalResult<Vector<IssmDouble>*>::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
-
-        _error_("GenericExternalResult instantiated for type Vector<IssmDouble>* called " << result_name << " not implemented yet");
-
-}  /*}}}*/
+
+        /*Specifics instantiations for Vector*/
+        template <> inline GenericExternalResult<Vector<IssmPDouble>*>::GenericExternalResult(int in_id, int in_enum_type,Vector<IssmPDouble>* in_values, int in_M,int in_N,int in_step,IssmDouble in_time){/*{{{*/
+                _error_("instanciation not correct");
+        }
+        /*}}}*/
+        template <> inline GenericExternalResult<Vector<IssmPDouble>*>::GenericExternalResult(int in_id, int in_enum_type,Vector<IssmPDouble>* in_value,int in_step, IssmDouble in_time){ /*{{{*/
+                id = in_id;
+                M  = 0;
+                N  = 0;
+
+                /*Convert enum to name*/
+                EnumToStringx(&this->result_name,in_enum_type);
+
+                step = in_step;
+                time = in_time;
+
+                value = in_value;
+        } /*}}}*/
+        template <> inline GenericExternalResult<Vector<IssmPDouble>*>::~GenericExternalResult(){ /*{{{*/
+                xDelete<char>(this->result_name);
+                delete value;
+        } /*}}}*/
+        template <> inline void GenericExternalResult<Vector<IssmPDouble>*>::Echo(void){ /*{{{*/
+
+                _printf_("GenericExternalResult<Vector<IssmPDouble>*>:\n");
+                this->GenericEcho();
+                this->value->Echo();
+
+        } /*}}}*/
+        template <> inline void GenericExternalResult<Vector<IssmPDouble>*>::DeepEcho(void){ /*{{{*/
+
+                this->Echo();
+
+        } /*}}}*/
+        template <> inline Object* GenericExternalResult<Vector<IssmPDouble>*>::copy(void){ /*{{{*/
+                return new GenericExternalResult<Vector<IssmPDouble>*>(this->id,StringToEnumx(this->result_name),this->value,this->step,this->time);
+        } /*}}}*/
+#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<Vector<IssmPDouble>*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
+
+                char *name   = NULL;
+                int   length,rows,cols=1;
+
+                if(!io_gather){
+                        _error_("not supported yet");
+                }
+
+                /*Serialize vector*/
+                IssmPDouble* serialvalues = this->value->ToMPISerial();
+                this->value->GetSize(&rows);
+
+                if(IssmComm::GetRank()==0){
+                        /*First write name: */
+                        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: */
+                        IssmPDouble passiveDouble=reCast<IssmPDouble>(time);
+                        fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
+                        fwrite(&step,sizeof(int),1,fid);
+
+                        /*writing a IssmDouble array, type is 3:*/
+                        int type=3;
+                        fwrite(&type,sizeof(int),1,fid);
+                        fwrite(&rows,sizeof(int),1,fid);
+                        fwrite(&cols,sizeof(int),1,fid);
+                        fwrite(serialvalues,cols*rows*sizeof(IssmPDouble),1,fid);
+                }
+
+                /*Clean up*/
+                xDelete<IssmPDouble>(serialvalues);
+
+        }
+        /*}}}*/
+#endif
+        template <> inline int GenericExternalResult<Vector<IssmPDouble>*>::ObjectEnum(void){ /*{{{*/
+                return NoneEnum;
+                /*???? FIXME*/
+        } /*}}}*/
+
+        /*Specifics instantiations for Vector<IssmDouble>*/
+        template <> inline void GenericExternalResult<Vector<IssmDouble>*>::WriteData(FILE* fid,bool io_gather){ /*{{{*/
+
+                int i;
+                char *name   = NULL;
+                int   length,rows,cols=1;
+                IssmDouble*  serialvalues = NULL;
+                IssmPDouble* pserialvalues = NULL;
+
+                if(!io_gather){
+                        _error_("not supported yet");
+                }
+
+                /*Serialize vector*/
+                serialvalues = this->value->ToMPISerial();
+                this->value->GetSize(&rows);
+
+                pserialvalues=xNew<IssmPDouble>(rows);
+                for(i=0;i<rows;i++)pserialvalues[i]=reCast<IssmPDouble>(serialvalues[i]);
+
+                if(IssmComm::GetRank()==0){
+                        /*First write name: */
+                        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: */
+                        IssmPDouble passiveDouble=reCast<IssmPDouble>(time);
+                        fwrite(&passiveDouble,sizeof(IssmPDouble),1,fid);
+                        fwrite(&step,sizeof(int),1,fid);
+
+                        /*writing a IssmDouble array, type is 3:*/
+                        int type=3;
+                        fwrite(&type,sizeof(int),1,fid);
+                        fwrite(&rows,sizeof(int),1,fid);
+                        fwrite(&cols,sizeof(int),1,fid);
+                        fwrite(pserialvalues,cols*rows*sizeof(IssmPDouble),1,fid);
+                }
+
+                /*Clean up*/
+                xDelete<IssmPDouble>(pserialvalues);
+                xDelete<IssmDouble>(serialvalues);
+
+        }
+        /*}}}*/
+        template <> inline void GenericExternalResult<Vector<IssmDouble>*>::Marshall(char** pmarshalled_data,int* pmarshalled_data_size, int marshall_direction){/*{{{*/
+
+                _error_("GenericExternalResult instantiated for type Vector<IssmDouble>* called " << result_name << " not implemented yet");
+
+        }  /*}}}*/
 
 #endif  /* _EXTERNAL_RESULTOBJECT_H */