source: issm/trunk-jpl/src/c/Container/Results.cpp@ 10989

/*
 * \file Results.c
 * \brief: implementation of the Results class, derived from DataSet class
 */

/*Headers: {{{1*/
#ifdef HAVE_CONFIG_H
        #include <config.h>
#else
#error "Cannot compile with HAVE_CONFIG_H symbol! run configure first!"
#endif

#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>

#include "./DataSet.h"
#include "../shared/shared.h"
#include "../include/include.h"
#include "../EnumDefinitions/EnumDefinitions.h"

using namespace std;
/*}}}*/

/*Object constructors and destructor*/
/*FUNCTION Results::Results(){{{1*/
Results::Results(){
        enum_type=ResultsEnum;
        return;
}
/*}}}*/
/*FUNCTION Results::~Results(){{{1*/
Results::~Results(){
        return;
}
/*}}}*/

/*Object management*/
/*FUNCTION Results::SpawnTriaResults{{{1*/
Results* Results::SpawnTriaResults(int* indices){

        /*Intermediary*/
        vector<Object*>::iterator object;
        ElementResult* resultin=NULL;
        ElementResult* resultout=NULL;

        /*Output*/
        Results* newresults=new Results();

        /*Go through results and call Spawn function*/
        for ( object=objects.begin() ; object < objects.end(); object++ ){

                /*Create new result*/
                resultin=(ElementResult*)(*object); 
                resultout=resultin->SpawnTriaElementResult(indices);

                /*Add result to new results*/
                newresults->AddObject((Object*)resultout);
        }

        /*Assign output pointer*/
        return newresults;
}
/*}}}*/
/*FUNCTION Results::Write{{{1*/
#ifdef _SERIAL_
void Results::Write(mxArray** pdataref){

        int i,j;
        int count;

        /*output: */
        mxArray* dataref=NULL;
        mxArray* processeddataref=NULL;
        mwSize nfields;
        mwSize maxfields;
        mwSize nsteps;
        mwSize step;
        const char **fnames      = NULL;
        int         *enums       = NULL;
        int          baseenum;
        mwSize       onebyone[2] = {1,1};
        mwSize       ndim        = 2;

        /*How many time steps do we have? : */
        nsteps=0;
        for(i=0;i<this->Size();i++){
                ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);
                step=result->GetStep();
                if(step>nsteps)nsteps=step;
        }
        onebyone[0]=nsteps;

        /*How many field names do we have. First, figure out how many result types we have: */
        maxfields=(mwSize)this->Size();
        enums=(int*)xmalloc(maxfields*sizeof(int));
        for(i=0;i<maxfields;i++){
                ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);
                enums[i]=result->InstanceEnum();
        }
        /*Now, make result types unique: */
        for(i=0;i<maxfields;i++){
                if(enums[i]>=0){//if <0, it means this enum was found to replicate another one previously
                        baseenum=enums[i];              
                        /*is the baseenum repeated later on?:*/
                        for(j=i+1;j<maxfields;j++){
                                if (enums[j]==baseenum)enums[j]=-1;
                        }
                }
                else continue;
        }

        /*Now, go through enums, and whatever is not null is a non repeated field name: */
        nfields=0;
        for(i=0;i<maxfields;i++)if(enums[i]>0)nfields++;

        /*Add 2 fields for time and step: */
        nfields=nfields+2;
        
        /*Fill the names of the structure field: */
        fnames=(const char**)xmalloc(nfields*sizeof(char*));
        count=0;
        for(i=0;i<maxfields;i++){
                if (enums[i]>0){
                        fnames[count]=EnumToStringx(enums[i]);
                        count++;
                }
        }
        /*don't forget the extra fields "time" and "step":*/
        fnames[nfields-2]="time";
        fnames[nfields-1]="step";

        /*Initialize structure: */
        dataref=mxCreateStructArray( ndim,onebyone,nfields,fnames);

        /*Fill each field: */
        for(i=0;i<this->Size();i++){ //do not include the last one used for time
                ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);
                result->SetMatlabField(dataref);
        }

        /*Now, process the patch in the dataref structure, by calling MatlabProcessPatch.m 
         *on the current dataref structure: */
        mexCallMATLAB(1,&processeddataref,1,&dataref, "MatlabProcessPatch");

        /*Assign output pointers:*/
        *pdataref=processeddataref;
}
#else 
void Results::Write(Parameters* parameters){
        
        int         i;
        FILE       *fid          = NULL;
        bool        io_gather=true;

        /*Recover file descriptor: */
        parameters->FindParam(&fid,OutputFilePointerEnum);
        parameters->FindParam(&io_gather,SettingsIoGatherEnum);

        for(i=0;i<this->Size();i++){
                ExternalResult* result=(ExternalResult*)this->GetObjectByOffset(i);

                /*write result to disk: */
                result->WriteData(fid,io_gather);
        }

}
#endif
/*}}}*/