VPAC - Computational Software Development

Main | SPModel | StGermain FrameWork |

LinearInterpolator.c

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**
** Copyright (C), 2004, Victorian Partnership for Advanced Computing (VPAC) Ltd, 110 Victoria Street, Melbourne, 3053, Australia.
**
** Authors:
**  Ogar R. Widjaja, Computational Scientist, VPAC.
**  Raquibul Hassan, Software Engineer, VPAC. (raq@vpac.org)
**  Keith Hsuan, Computational Scientist, VPAC (keith@vpac.org)
**  William F. Appelbe, Director, VPAC. (bill@vpac.org)
**  Stevan M. Quenette, Senior Software Engineer, VPAC. (steve@vpac.org)
**  Patrick D. Sunter, Software Engineer, VPAC. (patrick@vpac.org)
**
** This file may be distributed under the terms of the VPAC Public License
** as defined by VPAC of Australia and appearing in the file
** LICENSE.VPL included in the packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
*/
#include <mpi.h>
#include <StGermain/StGermain.h>
#include <Cascade/cascade.h>

#include "types.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include "Catchment.h"
#include "SurfaceMesh.h"
#include "SurfaceRegularMesh.h"
#include "Context.h"
#include "_Interpolator.h"
#include "LinearInterpolator.h"

/* Textual name of this class */
const Type LinearInterpolator_Type = "LinearInterpolator";

LinearInterpolator *LinearInterpolator_DefaultNew( Name name )
{
    return _LinearInterpolator_New( sizeof( LinearInterpolator ),
                                LinearInterpolator_Type,
                                _LinearInterpolator_Delete,
                                _LinearInterpolator_Print,
                                NULL,
                                (void*)LinearInterpolator_DefaultNew,
                                _LinearInterpolator_Construct,
                                _LinearInterpolator_Build,
                                _LinearInterpolator_Initialise,
                                _LinearInterpolator_Execute,
                                _LinearInterpolator_Destroy,
                                name,
                                False,
                                NULL,
                                NULL,
                                NULL );
    
}

LinearInterpolator *LinearInterpolator_New( Name name, Dictionary *dictionary, SurfaceMesh *mesh, SurfaceRegularMesh *regularMesh )
{
    return _LinearInterpolator_New( sizeof( LinearInterpolator ),
                                LinearInterpolator_Type,
                                _LinearInterpolator_Delete,
                                _LinearInterpolator_Print,
                                NULL,
                                (void*)LinearInterpolator_DefaultNew,
                                _LinearInterpolator_Construct,
                                _LinearInterpolator_Build,
                                _LinearInterpolator_Initialise,
                                _LinearInterpolator_Execute,
                                _LinearInterpolator_Destroy,
                                name,
                                True,
                                dictionary,
                                mesh,
                                regularMesh );
    
}

LinearInterpolator          *_LinearInterpolator_New( SizeT                         _sizeOfSelf,
                                    Type                            type,
                                    Stg_Class_DeleteFunction*               _delete,
                                    Stg_Class_PrintFunction*                _print,
                                    Stg_Class_CopyFunction*             _copy, 
                                    Stg_Component_DefaultConstructorFunction*   _defaultConstructor,
                                    Stg_Component_ConstructFunction*            _construct,
                                    Stg_Component_BuildFunction*        _build,
                                    Stg_Component_InitialiseFunction*       _initialise,
                                    Stg_Component_ExecuteFunction*      _execute,
                                    Stg_Component_DestroyFunction*      _destroy,
                                    Name                            name,
                                    Bool                            initFlag,
                                    Dictionary                      *dictionary,
                                    SurfaceMesh                     *mesh,
                                    SurfaceRegularMesh              *regularMesh )
{
    LinearInterpolator* self;
    
    /* Allocate memory */
    assert( _sizeOfSelf >= sizeof(LinearInterpolator) );
    self = (LinearInterpolator*)_Interpolator_New( _sizeOfSelf, type, _delete, _print, _copy, _defaultConstructor, _construct, _build, 
            _initialise, _execute, _destroy, name, NON_GLOBAL, dictionary, mesh, regularMesh, LinearInterpolator_InterpolateFromGridToMesh );

    if( initFlag ){
        _LinearInterpolator_Init( self );
    }

    return self;
}

void _LinearInterpolator_Init( LinearInterpolator *self )
{
    _Interpolator_Init( (_Interpolator*)self );
}

void _LinearInterpolator_Print( void *linearInterpolator, Stream *stream )
{
    int numNodes;
    
    LinearInterpolator *self = (LinearInterpolator*) linearInterpolator;

    assert( self );
    assert( stream );
    
    if( self->mesh->rank == MASTER_PROC ){
        numNodes = self->mesh->numNodes;
    }
    else{
        numNodes = self->mesh->myLoad;
    }

    /* print parent */
    _Stg_Component_Print( (void*) self, stream );
    
    _Interpolator_Print( (_Interpolator*) self, stream );

    /* general info */
    Journal_Printf( stream, "LinearInterpolator (ptr): (%p)\n", self );

    /* Virtual Info */

    /* LinearInterpolator Info */
}

void _LinearInterpolator_Delete( void *linearInterpolator )
{
    LinearInterpolator *self = (LinearInterpolator*)linearInterpolator;

    assert( self );

    free( self->meshWeights[0] );
    free( self->meshWeights );
    
    _Interpolator_Delete( self );
}

void _LinearInterpolator_Construct( void *linearInterpolator, Stg_ComponentFactory *cf )
{
    
}

void _LinearInterpolator_Build( void *linearInterpolator, void *data )
{
    float dx, dy;
    int i, id;
    float gridNodeX, gridNodeY, s, t;
    SurfaceMesh *mesh = NULL;
    SurfaceMesh *globalMesh = NULL;
    SurfaceRegularMesh *regularMesh = NULL;

    LinearInterpolator *self = (LinearInterpolator*)linearInterpolator;
    
    assert( self );

    mesh = self->mesh;
    regularMesh = self->regularMesh;
    globalMesh = ( SurfaceMesh* )data;
    assert( globalMesh );

    Journal_Firewall( (self->regularMesh->nx > 0), Journal_Register( Error_Type, "errorStream" ), "0 nodes in x direction..!\n" );
    Journal_Firewall( (self->regularMesh->ny > 0), Journal_Register( Error_Type, "errorStream" ), "0 nodes in y direction..!\n" );

    _Interpolator_Build( linearInterpolator, data );
    
    self->meshWeights = (float**)malloc( sizeof(float*) * self->mesh->numNodes );
    self->meshWeights[0] = (float*)malloc( sizeof(float) * 4 * self->mesh->numNodes );
    for( i=0; i<self->mesh->numNodes; i++ ){
        self->meshWeights[i] = (self->meshWeights[0] + i * 4 );
    }
    
    dx = self->mesh->sideX / (self->regularMesh->nx-1);
    dy = self->mesh->sideY / (self->regularMesh->ny-1);

    for( i=0; i<self->mesh->myLoad; i++ ){
        id = self->mesh->id[i];

            
            gridNodeX = self->regularMesh->regularNodes[self->gridPointsForNode[id-1][0].i-1][self->gridPointsForNode[id-1][0].j-1].x;
            gridNodeY = self->regularMesh->regularNodes[self->gridPointsForNode[id-1][0].i-1][self->gridPointsForNode[id-1][0].j-1].y;

            s = 2.0*(self->mesh->x[i] - gridNodeX)/dx - 1.0;
            t = 2.0*(self->mesh->y[i] - gridNodeY)/dy - 1.0;
     
            self->meshWeights[id-1][0] = 0.25*(1.0 - s)*(1.0 - t);
            self->meshWeights[id-1][1] = 0.25*(1.0 + s)*(1.0 - t);
            self->meshWeights[id-1][2] = 0.25*(1.0 + s)*(1.0 + t);
            self->meshWeights[id-1][3] = 0.25*(1.0 - s)*(1.0 + t);
        
            /*for( j=0; j<4; j++ )
                printf( "\ts %lf, t %lf, meshWeights[%d][%d] = %lf\n", s, t, i, j, self->meshWeights[i][j] );*/
    }
}

void _LinearInterpolator_Initialise( void *linearInterpolator, void *data )
{

}

void _LinearInterpolator_Execute( void *linearInterpolator, void *data )
{
    
}

void _LinearInterpolator_Destroy( void *linearInterpolator, void *data )
{
    
}

void LinearInterpolator_InterpolateFromGridToMesh( _Interpolator *interpolator,
        float **gridDeflectionArray,
        float *meshDeflectionArray )
{
    int i = 0, j = 0;
    LinearInterpolator *self = NULL;

    assert( interpolator );
    
    assert( gridDeflectionArray );
    assert( meshDeflectionArray );
    
    self = (LinearInterpolator*)interpolator;
    
    memset( meshDeflectionArray, 0, sizeof( float ) * interpolator->mesh->numNodes );
    for( i=0; i<interpolator->mesh->numNodes; i++ ){
        meshDeflectionArray[i] = 0.0f;
        for( j=0; j<4; j++ ){
            
            
            if( (interpolator->gridPointsForNode[i][j].i > 0) && (interpolator->gridPointsForNode[i][j].j > 0) ){
                
                meshDeflectionArray[i] += self->meshWeights[i][j] *
                    gridDeflectionArray[interpolator->gridPointsForNode[i][j].i-1]
                                        [interpolator->gridPointsForNode[i][j].j-1];
            }
        }
    }
}

SPModel documentation generated by doxygen at Fri Mar 24 01:41:45 2006