Changeset 9373

Timestamp:

08/23/11 07:22:50 (14 years ago)

Author:

Mathieu Morlighem

Message:

reduced number of files for marshall and parseresults by merging files

Location:

issm/trunk/src/m/model

Files:

• ReadData.m (deleted)
• ReadDataDimensions.m (deleted)
• WriteData.m (deleted)
• marshall.m (modified) (1 diff)
• parseresultsfromdisk.m (modified) (1 diff)
• parseresultsfromdiskioserial.m (deleted)
• parseresultsfromdiskiosplit.m (deleted)

issm/trunk/src/m/model/marshall.m

@@ -32 +32 @@
         error(['marshall error message: could not close file ' [md.name '.bin']]);
 end
+
+function WriteData(md,fid,template,field) % {{{
+%WRITEDATA - write model field in binary file
+%
+%   Usage:
+%      WriteData(md,fid,template,field)
+%
+%   Example:
+%     WriteData(md,fid,template,'thickness')
+
+%first recover data, enum of the data and type of data
+data=md.(field);
+enum=BuildEnum(field);
+data_type=template.(field){3};
+
+if issparse(data),
+        data=full(data);
+end
+
+%Ok! write the enum (name) to identify this record uniquely
+fwrite(fid,enum,'int'); 
+
+%Now, write the data itself.
+if     strcmpi(data_type,'Boolean'),% {{{
+        if(numel(data)~=1), error(['field ' field ' cannot be marshalled as it has more than one element!']); end
+
+        %first write length of record
+        fwrite(fid,4+4,'int');  %1 bool (disguised as an int)+code
+
+        %write data code: 
+        fwrite(fid,TypeToCode(data_type),'int'); 
+
+        %now write integer
+        fwrite(fid,data,'int');  %send an int, not easy to send a bool
+        % }}}
+elseif strcmpi(data_type,'Integer'), % {{{
+        if(numel(data)~=1), error(['field ' field ' cannot be marshalled as it has more than one element!']); end
+
+        %first write length of record
+        fwrite(fid,4+4,'int');  %1 integer + code
+
+        %write data code: 
+        fwrite(fid,TypeToCode(data_type),'int'); 
+
+        %now write integer
+        fwrite(fid,data,'int'); 
+        % }}}
+elseif strcmpi(data_type,'Double'), % {{{
+        if(numel(data)~=1), error(['field ' field ' cannot be marshalled as it has more than one element!']); end
+
+        %first write length of record
+        fwrite(fid,8+4,'int');  %1 double+code
+
+        %write data code: 
+        fwrite(fid,TypeToCode(data_type),'int'); 
+
+        %now write double
+        fwrite(fid,data,'double'); 
+        % }}}
+elseif strcmpi(data_type,'String'), % {{{
+        %first write length of record
+        fwrite(fid,length(data)+4+4,'int');  %string + string size + code
+
+        %write data code: 
+        fwrite(fid,TypeToCode(data_type),'int'); 
+
+        %now write string
+        fwrite(fid,length(data),'int'); 
+        fwrite(fid,data,'char'); 
+        % }}}
+elseif strcmpi(data_type,'BooleanMat'), % {{{
+
+        %matrix type:
+        mattype=template.(field){4};
+
+        %Get size
+        s=size(data);
+        %if matrix = NaN, then do not write anything
+        if (s(1)==1 & s(2)==1 & isnan(data)),
+                s(1)=0; s(2)=0;
+        end
+        
+        %first write length of record
+        fwrite(fid,4+4+8*s(1)*s(2)+4+4,'int');  %2 integers (32 bits) + the double matrix + code + matrix type
+
+        %write data code and matrix type: 
+        fwrite(fid,TypeToCode(data_type),'int'); 
+        fwrite(fid,mattype,'int');
+
+        %now write matrix
+        fwrite(fid,s(1),'int'); 
+        fwrite(fid,s(2),'int'); 
+        if s(1)*s(2),
+                fwrite(fid,data','double'); %get to the "c" convention, hence the transpose
+        end
+        % }}}
+elseif strcmpi(data_type,'IntMat'), % {{{
+
+        %matrix type:
+        mattype=template.(field){4};
+
+        %Get size
+        s=size(data);
+        %if matrix = NaN, then do not write anything
+        if (s(1)==1 & s(2)==1 & isnan(data)),
+                s(1)=0; s(2)=0;
+        end
+        
+        %first write length of record
+        fwrite(fid,4+4+8*s(1)*s(2)+4+4,'int');  %2 integers (32 bits) + the double matrix + code + matrix type
+
+        %write data code and matrix type: 
+        fwrite(fid,TypeToCode(data_type),'int'); 
+        fwrite(fid,mattype,'int');
+
+        %now write matrix
+        fwrite(fid,s(1),'int'); 
+        fwrite(fid,s(2),'int'); 
+        if s(1)*s(2),
+                fwrite(fid,data','double'); %get to the "c" convention, hence the transpose
+        end
+        % }}}
+elseif strcmpi(data_type,'DoubleMat'), % {{{
+
+        %matrix type:
+        mattype=template.(field){4};
+
+        %Get size
+        s=size(data);
+        %if matrix = NaN, then do not write anything
+        if (s(1)==1 & s(2)==1 & isnan(data)),
+                s(1)=0; s(2)=0;
+        end
+        
+        %first write length of record
+        fwrite(fid,4+4+8*s(1)*s(2)+4+4,'int');  %2 integers (32 bits) + the double matrix + code + matrix type
+
+        %write data code and matrix type: 
+        fwrite(fid,TypeToCode(data_type),'int'); 
+        fwrite(fid,mattype,'int');
+
+        %now write matrix
+        fwrite(fid,s(1),'int'); 
+        fwrite(fid,s(2),'int'); 
+        if s(1)*s(2),
+                fwrite(fid,data','double'); %get to the "c" convention, hence the transpose
+        end
+        % }}}
+elseif strcmpi(data_type,'MatArray'), % {{{
+
+        numrecords=numel(data);
+        
+        %first get length of record
+        recordlength=4+4; %number of records + code
+        for i=1:numrecords,
+                matrix=data{i};
+                s=size(matrix);
+                recordlength=recordlength+4*2+... %row and col of matrix
+                                         s(1)*s(2)*8; %matrix of doubles
+        end
+
+        %write length of record
+        fwrite(fid,recordlength,'int'); 
+
+        %write data code: 
+        fwrite(fid,TypeToCode(data_type),'int'); 
+
+        %write data, first number of records
+        fwrite(fid,numrecords,'int'); 
+        
+        %write each matrix: 
+        for i=1:numrecords,
+                matrix=data{i};
+                s=size(matrix);
+                fwrite(fid,s(1),'int'); 
+                fwrite(fid,s(2),'int'); 
+                fwrite(fid,matrix','double');
+        end
+        % }}}
+elseif strcmpi(data_type,'StringArray'), % {{{
+
+        %first get length of string array: 
+        num=numel(data);
+        %now get length of record: 
+        recordlength=4+4; %for length of array + code
+        for i=1:num,
+                string=data{i};
+                recordlength=recordlength+4+length(string); %for each string
+        end
+
+        %write length of record
+        fwrite(fid,recordlength,'int'); 
+
+        %write data code: 
+        fwrite(fid,TypeToCode(data_type),'int'); 
+
+        %now write length of string array
+        fwrite(fid,num,'int'); 
+        
+        %now write the strings
+        for i=1:num,
+                string=data{i};
+                fwrite(fid,length(string),'int'); 
+                fwrite(fid,string,'char'); 
+        end
+        % }}}
+else 
+        error(['WriteData error message: data type: ' num2str(data_type) ' not supported yet! (' EnumToString(enum) ')']);
+end
+% }}}
+function code=TypeToCode(data_type) % {{{1
+%This routine takes the data_type string, and hardcodes it into an integer, which 
+%is passed along the record, in order to identify the nature of the dataset being 
+%sent.
+if     strcmpi(data_type,'Boolean'),
+        code=1;
+elseif strcmpi(data_type,'Integer'), 
+        code=2;
+elseif strcmpi(data_type,'Double'), 
+        code=3;
+elseif strcmpi(data_type,'String'), 
+        code=4;
+elseif strcmpi(data_type,'BooleanMat'),
+        code=5;
+elseif strcmpi(data_type,'IntMat'),
+        code=6;
+elseif strcmpi(data_type,'DoubleMat'),
+        code=7;
+elseif strcmpi(data_type,'MatArray'), 
+        code=8;
+elseif strcmpi(data_type,'StringArray'),
+        code=9;
+else 
+        error('TypeToCode error message: data type not supported yet!');
+end% }}}

issm/trunk/src/m/model/parseresultsfromdisk.m

@@ -13 +13 @@
 %process patch if necessary
 results=MatlabProcessPatch(results);
+
+function results=parseresultsfromdiskioserial(filename) % {{{
+%PARSERESULTSFROMDISK - ...
+%
+%   Usage:
+%      results=parseresultsfromdiskioserial(filename)
+
+
+%Open file
+fid=fopen(filename,'rb');
+if(fid==-1),
+        error(['loadresultsfromdisk error message: could not open ',filename,' for binary reading']);
+end
+results=struct();
+
+%Read fields until the end of the file.
+result=ReadData(fid);
+while ~isempty(result), 
+        %Get time and step
+        results(result.step).step=result.step;
+        results(result.step).time=result.time; 
+
+        %Add result
+        if (length(results)>=result.step & isfield(results,result.fieldname) & ~strcmp(result.fieldname,'SolutionType')),
+                        results(result.step).(result.fieldname)=[ results(result.step).(result.fieldname); result.field];
+        else
+                results(result.step).(result.fieldname)=result.field;
+        end
+
+        %read next result
+        result=ReadData(fid);
+
+end
+
+fclose(fid);
+% }}}
+function results=parseresultsfromdisk(filename) % {{{
+%PARSERESULTSFROMDISKIOSPLIT - ...
+%
+%   Usage:
+%      results=parseresultsfromdiskiosplit(filename)
+
+
+%Open file
+fid=fopen(filename,'rb');
+if(fid==-1),
+        error(['loadresultsfromdisk error message: could not open ',filename,' for binary reading']);
+end
+results=struct();
+
+%if we have done split I/O, ie, we have results that are fragmented across patches, 
+%do a first pass, and figure out the structure of results
+result=ReadDataDimensions(fid);
+while ~isempty(result),
+
+        %Get time and step
+        results(result.step).step=result.step;
+        results(result.step).time=result.time; 
+
+        %Add result
+        if strcmpi(result.fieldname,'Patch'),
+                results(result.step).(result.fieldname)=[0 result.N];
+        else
+                results(result.step).(result.fieldname)=NaN;
+        end
+
+        %read next result
+        result=ReadDataDimensions(fid);
+end
+
+%do a second pass, and figure out the size of the patches
+fseek(fid,0,-1); %rewind
+result=ReadDataDimensions(fid);
+while ~isempty(result),
+
+        %Add result
+        if strcmpi(result.fieldname,'Patch'),
+                patchdimensions=results(result.step).(result.fieldname);
+                results(result.step).(result.fieldname)=[patchdimensions(1)+result.M result.N];
+        end
+
+        %read next result
+        result=ReadDataDimensions(fid);
+end
+
+%allocate patches
+for i=1:length(results),
+        results(i).Patch=zeros(results(i).Patch(1),results(i).Patch(2));
+        results(i).counter=1; %use to index into the patch
+end
+
+%third pass, this time to read the real information
+fseek(fid,0,-1); %rewind
+result=ReadData(fid);
+while ~isempty(result),
+
+        %Get time and step
+        results(result.step).step=result.step;
+        results(result.step).time=result.time; 
+
+        %Add result
+        if strcmpi(result.fieldname,'Patch'),
+                counter=results(result.step).counter;
+                counter2=counter+size(result.field,1)-1;
+                results(result.step).(result.fieldname)(counter:counter2,:)=result.field;
+
+                %increment counter: 
+                results(result.step).counter=counter2+1;
+        else
+                results(result.step).(result.fieldname)=result.field;
+        end
+
+        %read next result
+        result=ReadData(fid);
+
+end
+
+%close file
+fclose(fid);
+        % }}}
+function result=ReadData(fid) % {{{
+%READDATA - ...
+%
+%   Usage:
+%      field=ReadData(fid)
+
+
+%read field
+[length,count]=fread(fid,1,'int');
+
+if count==0,
+        result=struct([]);
+else
+        fieldname=fread(fid,length,'char');
+        fieldname=fieldname(1:end-1)';
+        fieldname=char(fieldname);
+        time=fread(fid,1,'double');
+        step=fread(fid,1,'int');
+
+        type=fread(fid,1,'int');
+        M=fread(fid,1,'int');
+        if type==1,
+                field=fread(fid,M,'double');
+        elseif type==2,
+                field=fread(fid,M,'char');
+                field=char(field(1:end-1)');
+        elseif type==3,
+                N=fread(fid,1,'int');
+                field=transpose(fread(fid,[N M],'double'));
+        else
+                error(['cannot read data of type ' num2str(type) ]);
+        end
+
+        result.fieldname=fieldname;
+        result.time=time;
+        result.step=step;
+        result.field=field;
+end
+% }}}
+function result=ReadDataDimensions(fid) % {{{
+%READDATA - read data dimensions, step and time, but not the data itself.
+%
+%   Usage:
+%      field=ReadDataDimensions(fid)
+
+
+%read field
+[length,count]=fread(fid,1,'int');
+
+if count==0,
+        result=struct([]);
+else
+        fieldname=fread(fid,length,'char');
+        fieldname=fieldname(1:end-1)';
+        fieldname=char(fieldname);
+        time=fread(fid,1,'double');
+        step=fread(fid,1,'int');
+
+        type=fread(fid,1,'int');
+        M=fread(fid,1,'int');
+        N=1; %default
+        if type==1,
+                fseek(fid,M*8,0);
+        elseif type==2,
+                fseek(fid,M,0);
+        elseif type==3,
+                N=fread(fid,1,'int');
+                fseek(fid,N*M*8,0);
+        else
+                error(['cannot read data of type ' num2str(type) ]);
+        end
+
+        result.fieldname=fieldname;
+        result.time=time;
+        result.step=step;
+        result.M=M;
+        result.N=N;
+end
+% }}}