us_lamm_astfvm.h

Go to the documentation of this file.

#ifndef US_LAMMASTFVM_H
#define US_LAMMASTFVM_H

#include <QtCore>
#include "us_extern.h"
#include "us_model.h"
#include "us_simparms.h"
#include "us_buffer.h"
#include "us_dataIO.h"
#include "us_astfem_math.h"
#include "us_astfem_rsa.h"

#ifndef DbgLv
#define DbgLv(a) if(dbg_level>=a)qDebug() 
#endif

class US_UTIL_EXTERN US_LammAstfvm : public QObject
{
   Q_OBJECT

   public:

      class Mesh 
      {
         public: 
   
            Mesh( double, double, int, int );

            ~Mesh();

            void InitMesh( double, double, double );

            void RefineMesh( double*, double*, double );

            int     Nv;       
            int     Ne;       
            double* x;        

         private:
            int     dbg_level;       // debug level
            int     MaxRefLev;
            int     MonScale;
            double  MonCutoff;
            double  SmoothingWt;
            int     SmoothingCyl;

            int*    Eid;      // elem id
            int*    RefLev;   // refinement level of an elem
            double* MeshDen;  // desired mesh density
            int*    Mark;     // ref/unref marker

            // private functions
            void ComputeMeshDen_D3( double*, double* );
            void Smoothing( int, double*, double, int );
            void Unrefine(  double );
            void Refine(    double );
      };

      class SaltData
      {
         public:

            SaltData( US_Model, US_SimulationParameters,
                      US_DataIO::RawData* );

            ~SaltData();

            void initSalt();

            void InterpolateCSalt( int, double*, double, double* );

            US_DataIO::RawData      sa_data;   
         private:

            US_Model                model;     // salt data co-sed model
            US_SimulationParameters simparms;  // salt simulation parameters

            int     Nx;       // number of points in radial direction
            int     Nt;       // number of points in time direction
            int     scn;      // index to next available salt data scan
            double* xs;       // grids in radial direction
            double  t0;       // 1st time intervals in use.
            double  t1;       // 2nd time intervals in use.
            double* Cs0;      // salt concentration for the 1st time interval
            double* Cs1;      // salt concentration for the 2nd time interval
            int     dbg_level;          // debug level
            QVector< double > xsVec;    // Vector for xs
            QVector< double > Cs0Vec;   // Vector for Cs0
            QVector< double > Cs1Vec;   // Vector for Cs1
      };

      US_LammAstfvm( US_Model&, US_SimulationParameters&, QObject* = 0 );

      ~US_LammAstfvm();

      int  calculate( US_DataIO::RawData& );

      void set_buffer( US_Buffer );

      int  solve_component( int ); 

      void SetMeshSpeedFactor( double );

      void SetMeshRefineOpt( int );

      void setStopFlag ( bool );

      void setMovieFlag( bool );

   signals:
      void calc_start( int nsteps );

      void calc_progress( int istep );

      void calc_done( void );

      void comp_progress( int icomp );

      void new_scan     ( QVector< double >*, double* );

      void new_time     ( double );

   private:

      US_Model&                 model;       // input model
      US_SimulationParameters&  simparams;   // input simulation parameters
      US_DataIO::RawData*       auc_data;    // input/output AUC data

      US_AstfemMath::MfemData   af_data;     // internal data

      Mesh*   msh;             // radial grid

      int     NonIdealCaseNo;  // non-ideal case number
                               // = 0 : ideal, constant s, D
                               // = 1 : concentration dependent
                               // = 2 : co-sedimenting
                               // = 3 : compressibility

      double  sigma;           // constant for concentration dependence (s)
      double  delta;           // constant for concentration dependence (D)
                               // non-ideal case
                               // s = s_0/(1+sigma*C), D=D_0/(1+delta*C)

      double  density;         // buffer density
      double  compressib;      // factor for compressibility
      double  vbar_salt;       // vbar of the salt

      SaltData* saltdata;      // data handle for cosedimenting

      double  MeshSpeedFactor; // = 1: mesh following sedimentation
                               // = 0: fixed mesh in each time step

      int     MeshRefineOpt;   // = 1: perform mesh local refinement
                               // = 0: no mesh refinement

      int     comp_x;          // current component index
      int     dbg_level;       // debug level

      bool    stopFlag;        // flag to stop processing
      bool    movieFlag;       // flag to operate in show-movie mode

      double  param_m;         // m of cell (meniscus)
      double  param_b;         // b of cell (bottom)
      double  param_s;         // base s value (sedimentation coefficient)
      double  param_D;         // base D value (diffusion coefficient)
      double  param_w2;        // rpm-based omega-sq-t, w2=(rpm*pi/30)^2

      double  err_tol;         // error tolerance for mesh refinement

      double  d_coeff[ 6 ];    // SD Adjust buffer density coefficients
      double  v_coeff[ 6 ];    // SD Adjust buffer viscosity coefficients

      // private functions

      int  nonIdealCaseNo( void );

      void SetNonIdealCase_1( double, double );

      void SetNonIdealCase_2( void   );

      void SetNonIdealCase_3( int&, double& );

      // Lamm equation step for sedimentation difference - predict
      void LammStepSedDiff_P( double, double, int, double*, double*, double* );

      // Lamm equation step for sedimentation difference - calculate
      void LammStepSedDiff_C( double, double, int, double*, double*, 
                              int, double*, double*, double* );

      // Project piecewise quadratic solution onto mesh
      void   ProjectQ(   int, double*, double*, int, double*, double* );

      // Integrate piecewise quadratic function defined on mesh
      double IntQs(      double*, double*, int, double, int, double );

      // Perform quadratic interpolation to fill out radius,conc. vectors
      void   quadInterpolate( double*, double*, int,
                              QVector< double >&, QVector< double >& );

      void   LocateStar( int, double*, int, double*, int*, double* );

      // Adjust s and D arrays
      void   AdjustSD(   double, int, double*, double*, double*, double* );

      void   fun_phi(    double, double* );

      void   fun_dphi(   double, double* );

      void   fun_Iphi(   double, double* );

      double IntQ(       double*, double*, double, double );


      void LsSolver53(   int, double**, double*, double* );

      // load internal data from caller's raw data
      void load_mfem_data(  US_DataIO::RawData&, US_AstfemMath::MfemData&,
                            bool = true );

      // store internal data to caller's raw data
      void store_mfem_data( US_DataIO::RawData&, US_AstfemMath::MfemData& );
};
#endif