---

metric.h

Go to the documentation of this file.

/*
 * Copyright (c) 2001 The AUTHORS 
 *   Romeu Andre' Pieritz, Ph.D.        - romeu_pieritz@hotmail.com
 *   Rafael Mendes, Eng.                – mendes_rafael@yahoo.com
 *   Rodrigo Ferraz de Andrade, Eng.    – rferraz@iname.com 
 * All rights reserved.
 *
 * Permission to use, copy and distribute this software and its
 * documentation for educational and personal use, without fee is hereby granted, 
 * provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 *
 * IN NO EVENT SHALL THE AUTHORS BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHORS
 * HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * THE AUTHORS SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HERE UNDER IS
 * ON AN "AS IS" BASIS, AND THE AUTHORS HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 *
 * SINMEC Lab. - CFD Sinflow Project - http://www.sinmec.ufsc.br/cfd
 */


// File Define
#ifndef __SFL_GEOM_METRIC_METRIC_H__
#define __SFL_GEOM_METRIC_METRIC_H__


// Include
#include <csfl/geom/grid/grid.h>
#include <csfl/field/value/scalar.h>
#include <csfl/field/value/scalar_face.h>


// Namespace
namespace csfl {


class IMetric : 
        virtual public ISFLObject


{

public:
        
        IMetric( IGrid *_grid = NULL );
    ~IMetric();
    
        static double control;
        
    inline TDomainRegion RegionID( const IPoint & _p );
    TDomainRegion RegionID( int _x, int _y );
    
    inline double Area( const IPoint & _p );
    inline double Area( int _x, int _y );
    
    inline double Jacobian( const IPoint & _p, TDirection _dir ); 
    inline double Jacobian( int _x, int _y, TDirection _dir ); 
    
    inline double XKsi( const IPoint & _p, TDirection _dir );
    inline double XKsi( int _x, int _y, TDirection _dir );

    inline double XEta( const IPoint & _p, TDirection _dir );
    inline double XEta( int _x, int _y, TDirection _dir );

    inline double YKsi( const IPoint & _p, TDirection _dir );
    inline double YKsi( int _x, int _y, TDirection _dir );

    inline double YEta( const IPoint & _p, TDirection _dir );
    inline double YEta( int _x, int _y, TDirection _dir );

    inline double Alpha( const IPoint & _p, TDirection _dir );
    inline double Alpha( int _x, int _y, TDirection _dir );

    inline double Beta( const IPoint & _p, TDirection _dir );
    inline double Beta( int _x, int _y, TDirection _dir );

    inline double Gamma( const IPoint & _p, TDirection _dir );
    inline double Gamma( int _x, int _y, TDirection _dir );
     
    inline double FaceLengthKsi( const IPoint & _p, TDirection _dir );
    inline double FaceLengthKsi( int _x, int _y, TDirection _dir );

    inline double FaceLengthEta( const IPoint & _p, TDirection _dir );
    inline double FaceLengthEta( int _x, int _y, TDirection _dir );
    
    IGrid * Grid() { return grid; }
    
    double PositionKsi( const IPoint & _p, TDirection _dir );
    double PositionKsi( int _x, int _y, TDirection);

    double PositionEta( const IPoint & _p, TDirection _dir );
    double PositionEta( int _x, int _y, TDirection _dir );

        inline IArray2D<TDomainRegion> * DomainRegion() { return domain; }
        inline TDomainRegion RelativeRegionID( int _i, int _j );
        inline TDomainRegion RelativeRegionID( const IPoint & _p);

        inline void SetDomainRegionID( int _i, int _j, TDomainRegion _tdr );

protected:
    IGrid       *grid;
        IFieldScalar            *cxksi, *cyksi,
                                                *cxeta, *cyeta;
        IFieldScalarFace *fxksi, *fyksi,
                                                *fxeta, *fyeta;

        IArray2D<TDomainRegion> *domain;

        void InitDomainRegionID();

        void CalculateXKsi();
        void CalculateYKsi();
        void CalculateXEta();
        void CalculateYEta();

    double EvalXKsi( int _x, int _y, TDirection _dir );
    double EvalXEta( int _x, int _y, TDirection _dir );
    double EvalYKsi( int _x, int _y, TDirection _dir );
    double EvalYEta( int _x, int _y, TDirection _dir );

};

// =============================================================================
// Inline functions
// =============================================================================

inline void IMetric::SetDomainRegionID( int _i, int _j, TDomainRegion _tdr )
{
        (*domain)( _i, _j ) = _tdr;
}

inline TDomainRegion IMetric::RelativeRegionID( int _i, int _j )
{
        return domain->Value( _i, _j );
}

inline TDomainRegion IMetric::RelativeRegionID( const IPoint &_p )
{
        return domain->Value( _p.x, _p.y );
}


inline double IMetric::XKsi( const IPoint &_p, TDirection _dir ) 
{ 
    return XKsi( _p.x, _p.y, _dir );
}
   

inline double IMetric::YKsi( const IPoint &_p, TDirection _dir ) 
{ 
    return YKsi( _p.x, _p.y, _dir );
}


inline double IMetric::XEta( const IPoint &_p, TDirection _dir )  
{ 
    return XEta( _p.x, _p.y, _dir );
}


inline double IMetric::XKsi( int _x, int _y, TDirection _dir ) 
{ 
        if (_dir==diNULL)
                return cxksi->Value( _x, _y );
        else
                return fxksi->Value( _x, _y, _dir);
}

inline double IMetric::YKsi( int _x, int _y, TDirection _dir ) 
{ 
        if (_dir==diNULL)
                return cyksi->Value( _x, _y );
        else
                return fyksi->Value( _x, _y, _dir);
}

inline double IMetric::XEta( int _x, int _y, TDirection _dir ) 
{ 
        if (_dir==diNULL)
                return cxeta->Value( _x, _y );
        else
                return fxeta->Value( _x, _y, _dir);
}

inline double IMetric::YEta( int _x, int _y, TDirection _dir ) 
{ 
        if (_dir==diNULL)
                return cyeta->Value( _x, _y );
        else
                return fyeta->Value( _x, _y, _dir);
}

inline TDomainRegion IMetric::RegionID( const IPoint &_p )
{
    return RegionID( _p.x, _p.y );
}

inline double IMetric::Area( int _x, int _y ) 
{ 
    return fabs(1.0 / Jacobian( _x, _y, diNULL ));
}

inline double IMetric::Area( const IPoint &_p ) 
{ 
    return Area( _p.x, _p.y );
}

inline double IMetric::Jacobian( int _x, int _y, TDirection _dir ) 
{       
        return 1.0 / fabs( ( XKsi( _x, _y, _dir )*YEta( _x, _y, _dir ) ) - 
                           ( XEta( _x, _y, _dir )*YKsi( _x, _y, _dir ) ) );                     
}

inline double IMetric::Jacobian( const IPoint &_p, TDirection _dir ) 
{ 
    return Jacobian( _p.x, _p.y, _dir );                    
}

inline double IMetric::YEta( const IPoint &_p, TDirection _dir )  
{ 
    return YEta( _p.x, _p.y, _dir );
}
 
inline double IMetric::Alpha( int _x, int _y, TDirection _dir )
{
        return ( XEta( _x, _y, _dir )*XEta( _x, _y, _dir ) + 
                     YEta( _x, _y, _dir )*YEta( _x, _y, _dir ) ); 
}
  
inline double IMetric::Alpha( const IPoint &_p, TDirection _dir )
{
        return Alpha( _p.x, _p.y, _dir ); 
}

inline double IMetric::Beta( const IPoint &_p, TDirection _dir ) 
{ 
    return ( XKsi( _p, _dir )*XEta( _p, _dir ) + 
                     YKsi( _p, _dir )*YEta( _p, _dir ) );
}

inline double IMetric::Beta( int _x, int _y, TDirection _dir ) 
{ 
    return ( XKsi( _x, _y, _dir )*XEta( _x, _y, _dir ) + 
                     YKsi( _x, _y, _dir )*YEta( _x, _y, _dir ) );
}

inline double IMetric::Gamma( const IPoint &_p, TDirection _dir )
{ 
    return ( XKsi( _p, _dir )*XKsi( _p, _dir ) + 
                     YKsi( _p, _dir )*YKsi( _p, _dir ) ); 
}

inline double IMetric::Gamma( int _x, int _y,   TDirection _dir )
{ 
    return ( XKsi( _x, _y, _dir )*XKsi( _x, _y, _dir ) + 
                     YKsi( _x, _y, _dir )*YKsi( _x, _y, _dir ) ); 
}

inline double IMetric::FaceLengthKsi( const IPoint &_p, TDirection _dir )
{
        return sqrt( Gamma( _p, _dir ) ); 
}

inline double IMetric::FaceLengthKsi( int _x, int _y, TDirection _dir )
{
        return sqrt( Gamma( _x, _y, _dir ) ); 
}

inline double IMetric::FaceLengthEta( const IPoint &_p, TDirection _dir ) 
{ 
        return sqrt( Alpha( _p, _dir ) ); 
}

inline double IMetric::FaceLengthEta( int _x, int _y, TDirection _dir ) 
{ 
        return sqrt( Alpha( _x, _y, _dir ) ); 
}
  

} // csfl namespace

#endif// __SFL_GEOM_METRIC_METRIC_H__

 

CFD Project | Documents | Downloads | Contact us | Use Terms
© SINMEC/EMC/UFSC, 2001.	All rights reserved.	Last Update: Jan. 18, 2002	Webmaster