VPAC - Computational Software Development

Main | SPModel | StGermain FrameWork |

SurfaceMeshSmoother.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 "SurfaceMesh.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <math.h>
#include "Catchment.h"
#include "SurfaceMesh.h"
#include "Context.h"
#include "SurfaceMeshSmoother.h"


/* Textual name of this class */
const Type SurfaceMeshSmoother_Type = "SurfaceMeshSmoother";
    
SurfaceMeshSmoother *SurfaceMeshSmoother_DefaultNew( Name name )
{
    return _SurfaceMeshSmoother_New( sizeof( SurfaceMeshSmoother ),
                                SurfaceMeshSmoother_Type,
                                _SurfaceMeshSmoother_Delete,
                                _SurfaceMeshSmoother_Print,
                                NULL,
                                (void*)SurfaceMeshSmoother_DefaultNew,
                                _SurfaceMeshSmoother_Construct,
                                _SurfaceMeshSmoother_Build,
                                _SurfaceMeshSmoother_Initialise,
                                _SurfaceMeshSmoother_Execute,
                                _SurfaceMeshSmoother_Destroy,
                                name,
                                False,
                                NULL );
    
}

SurfaceMeshSmoother *SurfaceMeshSmoother_New( Name name, Dictionary *dictionary )
{
    return _SurfaceMeshSmoother_New( sizeof( SurfaceMeshSmoother ),
                                SurfaceMeshSmoother_Type,
                                _SurfaceMeshSmoother_Delete,
                                _SurfaceMeshSmoother_Print,
                                NULL,
                                (void*)SurfaceMeshSmoother_DefaultNew,
                                _SurfaceMeshSmoother_Construct,
                                _SurfaceMeshSmoother_Build,
                                _SurfaceMeshSmoother_Initialise,
                                _SurfaceMeshSmoother_Execute,
                                _SurfaceMeshSmoother_Destroy,
                                name,
                                True,
                                dictionary );
    
}

SurfaceMeshSmoother                 *_SurfaceMeshSmoother_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 )
{
    SurfaceMeshSmoother* self;
    
    /* Allocate memory */
    assert( _sizeOfSelf >= sizeof(SurfaceMeshSmoother) );
    self = (SurfaceMeshSmoother*)_Stg_Component_New( _sizeOfSelf, type, _delete, _print, _copy, _defaultConstructor, _construct, _build, 
            _initialise, _execute, _destroy, name, NON_GLOBAL );

    self->dictionary = dictionary;
    
    if( initFlag ){
        _SurfaceMeshSmoother_Init( self );
    }

    return self;
    
}

void _SurfaceMeshSmoother_Init( SurfaceMeshSmoother *self )
{
    
}

void _SurfaceMeshSmoother_Print( void *surfaceMeshSmoother, Stream *stream )
{
    
    SurfaceMeshSmoother *self = (SurfaceMeshSmoother*) surfaceMeshSmoother;

    assert( self );
    assert( stream );

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

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

    /* Virtual Info */

    /* SurfaceMeshSmoother Info */
}

void _SurfaceMeshSmoother_Delete( void *surfaceMeshSmoother )
{
    SurfaceMeshSmoother *self = (SurfaceMeshSmoother*) surfaceMeshSmoother;

    assert( self );

    _Stg_Component_Delete( self );

}

void _SurfaceMeshSmoother_Construct( void *surfaceMeshSmoother, Stg_ComponentFactory *cf )
{
    
}

void _SurfaceMeshSmoother_Build( void *surfaceMeshSmoother, void *data )
{
    
}

void _SurfaceMeshSmoother_Initialise( void *surfaceMeshSmoother, void *data )
{
    
}

void _SurfaceMeshSmoother_Destroy( void *surfaceMeshSmoother, void *data )
{
    
}

/* public functions */
void _SurfaceMeshSmoother_Execute( void *meshSmoother, void *surfaceMesh )
{
    typedef struct vector_t{
        float x;
        float y;
    }
    vector;
    
    int i, j, iter;
    vector ab;
    int neighNode;
    SurfaceMeshSmoother *surfaceMeshSmoother = NULL;
    SurfaceMesh *mesh = NULL;

    surfaceMeshSmoother = (SurfaceMeshSmoother*)meshSmoother;
    mesh = (SurfaceMesh*)surfaceMesh;
    
    assert( surfaceMeshSmoother );
    assert( mesh );

    /* mesh smoothing is only performed on the master process, prior to mesh decomposition */
    if( mesh->rank != 0 ){
        return;
    }
    
    for( iter=0; iter<50; iter++ ){
        for( i=0; i<mesh->numNodes; i++ ){
            memset( &ab, 0, sizeof(vector) );
            if( mesh->boundaryConditions[i] ){
                for( j=0; j<mesh->numNeigh[i]; j++ ){
                    neighNode = mesh->id[mesh->nodeNeighbours[i][j]-1];
                    ab.x += mesh->x[neighNode-1] - mesh->x[i];
                    ab.y += mesh->y[neighNode-1] - mesh->y[i];
                }
            
                ab.x = ab.x * 0.05 / (j-1);
                ab.y = ab.y * 0.05 / (j-1);
            
                mesh->x[i] += ab.x;
                mesh->y[i] += ab.y;
            }
            else{
                /*printf( "\tnode fixed\n" );*/
            }
        }
    }
}

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