---

pv.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 __CSFL_NUM_SEQUENCER_PV_H__
#define __CSFL_NUM_SEQUENCER_PV_H__

// Include =====================================================================
#include <csfl/num/sequencer/sequencer.h>
#include <csfl/sys/container/equation.h>
#include <csfl/math/equation/momentum_u.h>
#include <csfl/math/equation/momentum_v.h>
#include <csfl/field/value/scalar_face.h>


// Namespace
namespace csfl {

//==============================================================================
//              Class ISequencerPV
//              Description: Class for the Pressure-Velocity sequence objects
//==============================================================================

class ISequencerPV : 
        virtual public ISequencer


{

public:
        
        ISequencerPV(
        const IString &_id ,
                IContainerEquation *_contEquation,
                ISolver *_solver,
                double _starttime = 0.0, 
                double _finaltime = 1.0, 
                double _steptime = 0.5 );
        ISequencerPV( ISequencerPV *_s );
        ~ISequencerPV();

    IEquationMomentumU * EquationMomU()   { return eqU; }

    IEquationMomentumV * EquationMomV()   { return eqV; }
 
        IFieldVector* VelocityMesh( bool _reCalculate );

    IFieldVector * Velocity() { return V; }
        
        IFieldScalar* PressureMesh( bool _reCalculate );
        
    IFieldScalar * Pressure() { return P; }

        IFieldVectorFace * FaceVelocity() { return fuv; }

        IFieldScalar *StreamLines( bool _reCalculate = true );
        
        IFieldScalar *StreamLinesMesh( bool _reCalculate = true );

        
        void CheckSteadyStateMerror( bool _b ){ checkSSMerror = _b; }
        
        void CheckSteadyStatePerror( bool _b ){ checkSSPerror = _b; }
        
        void CheckSteadyStateVerror( bool _b ){ checkSSVerror = _b; }
        
        void CheckPVMerror( bool _b ){ checkPVMerror = _b; }
        
        void CheckPVPerror( bool _b ){ checkPVPerror = _b; }
        
        void CheckPVVerror( bool _b ){ checkPVVerror = _b; }    
        
        void SetSteadyStateMassError( double _v ) 
                { toleranceM = _v; checkSSMerror = true; }
    
        void SetSteadyStatePressureError( double _v ) 
                { toleranceP = _v; checkSSPerror = true; }
        
        void SetSteadyStateVelocityError( double _v )
                { toleranceV = _v; checkSSVerror = true; }
        
        void SetSteadyStateError( double _v )
        { 
                toleranceV = _v; checkSSVerror = true; 
                toleranceP = _v; checkSSPerror = true;
                toleranceM = _v; checkSSMerror = true; 
        }
        
        
        double SteadyStateMassError() { return toleranceM; }
        
        double SteadyStatePressureError() { return toleranceP; }
        
        double SteadyStateVelocityError() { return toleranceV; }

    void SetPressureError( double _v )
                { pError = _v; checkPVPerror = true;}
    
        void SetVelocityError( double _v )
                { vError = _v; checkPVVerror = true; }
    
        void SetMassError( double _v ) 
                { mError = _v; checkPVMerror = true;}
        
        double MassError() { return mError; }

        double PressureError() { return pError; }

        double VelocityError() { return vError; }
        
        void SetPressureRelaxation( double _v ) { relaxationP = _v; }
        
        double PressureRelaxation() { return relaxationP; }
                
        void SetVelocityRelaxation( double _v ) { relaxationV = _v; }
        
        double VelocityRelaxation() { return relaxationV; }

        int IteratorPV() { return itPV; }
        
        void SetMaximumIteratorPV( int _v ) { itPVMax = _v; }

        double RunTimeErrorMass() { return mdif; }
        
        double RunTimeErrorPressure() { return pdif; }
        
        double RunTimeErrorVelocity() { return vdif; }


        double SteadyStateErrorMass() { return smdif; }

        double SteadyStateErrorPressure() { return spdif; }
        
        double SteadyStateErrorVelocity() { return svdif; }


        void SetReferecePressure( bool _v ) { fixPressure = _v; }
        
        void SetFixedPressure( double _v ) { fixedPressure = _v; }
        
        void SetVolumeWithFixedPressure( IPoint _v ) { volumeFixedPressure = _v; }

        bool IsReferencePressure() { return fixPressure; }
        
        double GetFixedPressure() { return fixedPressure; }
        
        IPoint GetVolumeWithFixedPressure() { return volumeFixedPressure; }


public:

        virtual void Write( ostream &_os );

        virtual void Read ( istream &_is );
        
        virtual void WritePV( ostream &_is );
        
        virtual void ReadPV( istream &_os );


public: 
 
    IAction ActionRequestSolutionPV, ActionSolutionPV, 
                        ActionRequestIteractPV;
        IAction ActionCalculateUVelocity,
                        ActionCalculateVVelocity, ActionCalculateFaceVelocity,
                        ActionCalculatePLine;   
 
        IAction ActionIteractPV, ActionPVError, ActionSolutionPVError;
        IAction ActionUpDateVelocity, ActionUpDatePressure, ActionUpDateFaceVelocity;

protected:
        IEquationMomentumU  *eqU;
        IEquationMomentumV  *eqV;
    IFieldVector                *V, *VAnt, *Ver, *Vnode;
    IFieldScalar                *P, *PAnt, *Per, *Pl, *Pnode;   
    IFieldVectorFace    *fuv, *fuvAnt;                     // Interface velocities fvel(u and v)
    IFieldScalarFace    *db;
    IFieldScalar                *dbu, *dbv;
        IFieldScalar            *streamLines, *ppSLines;


    int ni, nj; 
        int itPV, itPVMax;

        int nitprob;

        double  toleranceM, toleranceP, toleranceV;

        double mError, vError, pError;                                  // mass, u, v, pressure
        double vdif, pdif, mdif;
        double spdif, svdif, smdif;
        double relaxationP, relaxationV;
        
        bool checkSSMerror, checkSSPerror, checkSSVerror;
        bool checkPVMerror, checkPVPerror, checkPVVerror;

        bool fixPressure;
        IPoint volumeFixedPressure;
        double fixedPressure;


        virtual void Begin();
    virtual void Solution( double );
        virtual void End();
        
        virtual bool IteractError();

        virtual bool SolutionError();
        virtual void ActualizeVariables();

        virtual void PVCoupling();
    virtual void SetPressureCoefficients();
        inline virtual void SetDbCoeficients(){}

        virtual void Find(); 


        void CalcVMesh();
        void CalcPMesh();
        void CalcStrLines();
        void CalcStrLinesMesh();

    void CalcVelEst();
    void CalcPLine();
    void CorrectionVel();
    void CorrectionPres();              
     
        bool PVError();
        double VariableErrorMass( IFieldVectorFace * );
        double VariableErrorMassEdges( IFieldVectorFace * );
        
 
    void SetPLine( Vector * );

    virtual void InitVariables();
  

        void SetPVCouplingVariables();
  
    void CalculateVelFace_uv();

    double SumNeighbors_u( int, int );
    double SumNeighbors_v( int, int );

    double PressGrad_u_Ksi( int, int );
    double PressGrad_u_Eta( int, int );
    double PressGrad_v_Ksi( int, int );
    double PressGrad_v_Eta( int, int );

        friend class ISequencerIO;

};
} // csfl namespace

#endif // __CSFL_NUM_SEQUENCER_PV_H__

 

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