EQuUs_MATLAB.cpp

Go to the documentation of this file.

#include "mex.h"
#include <unistd.h>
#include <string.h>
#include "EQuUs_MATLAB.h"

void convert2FortranString( char* cstring, int strlength ) {

   int strlength_in, idx;

   strlength_in = strlen( cstring );

   for( idx=strlength_in; idx<strlength; idx++ ) {
     cstring[idx] = ' ';
   }
}



char** getFieldnames( EQstruct* eq_struct ) {

    char **fieldnames;

    fieldnames = (char**)mxMalloc(eq_struct->numfields * sizeof(char**) );

#ifdef DEBUG
      mexPrintf( "\nRetriving the fieldnames\n" );
#endif

    int idx;
    for( idx=0; idx<eq_struct->numfields; idx++ ) {
#ifdef DEBUG
      mexPrintf( "field #%d: %s\n", idx+1, eq_struct->fields[idx].elementname );
#endif
      fieldnames[idx] = eq_struct->fields[idx].elementname;
    }


    return fieldnames;

}



void regularizeEQstruct( EQstruct* eq_struct ) {

    int idx_orig, idx_new;
    EQelement* eq_element;
    int numfields;

    if (!eq_struct->numfields) {
      mexWarnMsgTxt("siesta_EQuUs:EQuUs_MATLAB:regularizeEQstruct:EQuInvalid EQstructure: numfields was not set in EQstructure");
      return;
    }

    if (!eq_struct->fields) {
      mexWarnMsgTxt("siesta_EQuUs:EQuUs_MATLAB:regularizeEQstruct:EQuInvalid EQstructure: fields was not set in EQstructure");
      return;
    }

    numfields = 0;
    idx_new = 0;
    for ( idx_orig=0; idx_orig<eq_struct->numfields; idx_orig++ ) {
      eq_element = &eq_struct->fields[idx_orig];
      if (strlen( eq_element->elementname ) != 0) {
        eq_struct->fields[idx_new] = eq_struct->fields[idx_orig];
        idx_new++;
        numfields++;
      } 
    }

    if ( numfields == eq_struct->numfields ) {
      return;
    }

    mexPrintf( "%d fields were invalid in the scanned structure\n", eq_struct->numfields - numfields );

    eq_struct->numfields = numfields;

    for ( idx_orig=numfields; idx_orig<eq_struct->numfields; idx_orig++ ) {
#ifdef __INTEL_COMPILER
      equus_c_mp_deallocateelement_( &eq_struct->fields[idx_orig] );
#else
      __equus_c_MOD_deallocateelement( &eq_struct->fields[idx_orig] );
#endif        
    }

}



void setField( EQelement* eq_element, mxArray* Mstruct )
{
      if (mxIsStruct( Mstruct ) == 0) {
        mexErrMsgIdAndTxt ("siesta_EQuUs:setField:NotStructure", "The given mxArray is not a structure.");
      }

      mwSize *dims;
      mxArray *value;
      int numElements = 1;

      dims = (mwSize*)malloc( (*eq_element->dim)*sizeof(mwSize));
      int idx;
      for ( idx=1; idx<=*eq_element->dim; idx++) {
        dims[idx-1] = eq_element->dims[idx-1];
        numElements = numElements*eq_element->dims[idx-1];
      }

#ifdef DEBUG
      mexPrintf( "elementname: %s\n", eq_element->elementname );
      mexPrintf( "Number of elements: %d\n", numElements );
      mexPrintf( "Type of elements: %d\n", *eq_element->classID );
      mexPrintf( "number of dimensions: %d\n", *eq_element->dim );
      if ( *eq_element->dim == 2) {
        mexPrintf( "dimensions: %d x %d\n\n", dims[0], dims[1] );
      } else {
        mexPrintf( "dimensions: %d x 1\n\n", dims[0] );
      }
#endif
    
      
      if ( *eq_element->classID == mxLOGICAL_CLASS ) {
        // setting logical value
        value = mxCreateLogicalArray( *eq_element->dim, dims );
        mxLogical *start_of_pr = mxGetLogicals(value);
        int bytes_to_copy = numElements * mxGetElementSize(value);
        memcpy(start_of_pr,eq_element->value,bytes_to_copy);
      } 
      else if (*eq_element->classID == mxCHAR_CLASS ) {
        // setting string value
        value = mxCreateCharMatrixFromStrings(numElements, (const char **)(eq_element->value));
      }
      else if (*eq_element->classID == mxSTRUCT_CLASS ) {
        // setting structure value
        EQstruct* eq_struct = (EQstruct*)eq_element->value;
        regularizeEQstruct( eq_struct );
        char** fieldnames = getFieldnames( eq_struct );
        value = mxCreateStructMatrix(1, 1, eq_struct->numfields, (const char**)fieldnames);
        for ( idx=0; idx<eq_struct->numfields; idx++) {
          setField( &eq_struct->fields[idx], value );
        }
      }
      else if ( *eq_element->classID == mxDOUBLE_CLASS || 
                *eq_element->classID == mxSINGLE_CLASS ||
                *eq_element->classID == mxINT8_CLASS ||
                *eq_element->classID == mxUINT8_CLASS ||
                *eq_element->classID == mxINT16_CLASS ||
                *eq_element->classID == mxUINT16_CLASS ||
                *eq_element->classID == mxINT32_CLASS ||
                *eq_element->classID == mxUINT32_CLASS ||
                *eq_element->classID == mxINT64_CLASS ||
                *eq_element->classID == mxUINT64_CLASS ) {
        // setting numeric values
        value = mxCreateNumericArray( *eq_element->dim, dims, *eq_element->classID, mxREAL );
        void *start_of_pr = mxGetData(value);
        int bytes_to_copy = numElements * mxGetElementSize(value);
        memcpy(start_of_pr,eq_element->value,bytes_to_copy);     
      }
      else {
        value = mxCreateDoubleMatrix( 0, 0, mxREAL );
      }

      if( ~mxIsEmpty( (const mxArray *)value) )  {
        setField(value, eq_element->elementname, Mstruct);
      }

#ifdef __INTEL_COMPILER
      equus_c_mp_deallocateelement_( eq_element );
#else
      __equus_c_MOD_deallocateelement( eq_element );
#endif        
}



void setField( mxArray* field, const char* fieldname, mxArray* Mstruct )
{
      if (mxIsStruct( Mstruct ) == 0) {
        mexErrMsgIdAndTxt ("siesta_EQuUs:setField:NotStructure", "The given mxArray is not a structure.");
      }

      int stat;
      int field_idx;
      field_idx = mxGetFieldNumber(Mstruct, fieldname);

      // if the field does not exist, creates the field and append the given value to the end of the structure fields. 
      if (field_idx == - 1) {
        mxAddField(Mstruct, fieldname);
        if( ~mxIsEmpty( (const mxArray *)field) )  {
         mxSetField(Mstruct, 0, fieldname, field);
        }
        return;
      }


      mxArray *field_tmp;
      field_tmp = mxGetFieldByNumber(Mstruct, 0, field_idx);

      // if the field already exists and it is empty, replace the empty element with the given value
      if(  field_tmp == NULL )  {
        mxSetFieldByNumber(Mstruct, 0, field_idx, field);
        return;
      }

      // if the field already exists and it is NOT empty, turns the field into a cell array and add the current value at the end
      mxArray *cellarray;
      mxArray *cell;
      mwSize ndim = 1;
      mwSize *dims;
      dims = (mwSize*)mxMalloc(ndim * sizeof(mwSize) );



      if (mxIsCell(field_tmp)) {
#ifdef DEBUG
        mexPrintf("Adding another element to the cell array\n");
#endif
        const size_t * dims_tmp = (const size_t *) mxGetDimensions( field_tmp );
        dims[0] = dims_tmp[0]+1;
        cellarray = mxCreateCellArray(ndim, dims);

        int idx;
        for ( idx=0; idx<dims[0]-1; idx++) {
          mxSetCell(cellarray, idx, mxGetCell(field_tmp, idx) );
        }

        mxSetCell(cellarray, dims[0]-1, field);        
        mxSetFieldByNumber(Mstruct, 0, field_idx, cellarray);

      }
      else {
#ifdef DEBUG
        mexPrintf("Converting field to cell array\n");
#endif

        dims[0] = 2;
        cellarray = mxCreateCellArray(ndim, dims);
        mxSetCell(cellarray, 0, field_tmp);
        mxSetCell(cellarray, 1, field);        

        mxSetFieldByNumber(Mstruct, 0, field_idx, cellarray);
      }


      mxFree( dims );
   
}