us_2dsa_process.h

Go to the documentation of this file.

#ifndef US_2DSA_PROCESS_H
#define US_2DSA_PROCESS_H

#include <QtCore>

#include "us_extern.h"
#include "us_widgets.h"
#include "us_dataIO.h"
#include "us_simparms.h"
#include "us_model.h"
#include "us_noise.h"
#include "us_db2.h"
#include "us_solute.h"
#include "us_worker_2d.h"

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

#ifndef SS_DATASET
#define SS_DATASET US_SolveSim::DataSet
#endif


class US_2dsaProcess : public QObject
{
   Q_OBJECT

   public:

      enum RefineType { UGRID, LUGRID, RLGRID, SOLCO, CLIPLO };

      enum TaskState  { READY, WORKING, ABORTED };

      US_2dsaProcess( QList< SS_DATASET* >&, QObject* = 0 );

      void start_fit( double, double, int, double, double, int,
                      int, int, int );

      void set_iters( int, int, int, double, double, double, int );

      bool get_results( US_DataIO::RawData*, US_DataIO::RawData*,
                        US_Model*, US_Noise*, US_Noise* );

      void stop_fit(       void );

      void clear_data(     void );

      int  estimate_steps( int  );

      QString lastError( void ) { return errMsg; }

      // Number of doubles in a solute object
      static const int solute_doubles = sizeof( US_Solute ) / sizeof( double );

private:

      signals:
      void progress_update(  int  );
      void process_complete( int  );
      void stage_complete(   int,     int  );
      void message_update(   QString, bool );

private:
      QList< SS_DATASET* >&      dsets;      // List of dataset pointers

      long int maxrss;

      long int max_rss( void );

      QList< WorkerThread2D* >   wthreads;   // worker threads
      QList< WorkPacket2D >      job_queue;  // job queue

      QVector< int >             wkstates;   // worker thread states
      QVector< int >             wkdepths;   // worker thread depths
      QVector< int >             tkdepths;   // task packet depths

      QVector< double >          sigmas;     // monte carlo sigma variations

      QList< double >            itvaris;    // iteration variances

      QList< QVector< US_Solute > > c_solutes;  // calculated solutes
      QList< QVector< US_Solute > > orig_sols;  // original solutes
      QList< QVector< US_Solute > > ical_sols;  // iteration calculated solutes

      US_DataIO::EditedData*     edata;      // experimental data (mc_iter)
      US_DataIO::EditedData*     bdata;      // base experimental data
      US_DataIO::EditedData      wdata;      // work experimental data

      US_DataIO::RawData         sdata;      // simulation data
      US_DataIO::RawData         sdata1;     // simulation data (mc iter 1)

      US_DataIO::RawData         rdata;      // residuals data

      US_Model                   model;      // constructed model

      US_Noise                   ti_noise;   // time-invariant noise
      US_Noise                   ri_noise;   // radially-invariant noise

      US_SimulationParameters*   simparms;   // simulation parameters

      QObject*   parentw;      // parent object

      QString    errMsg;       // message from last error

      int        dbg_level;    // debug level
      int        nthreads;     // number of worker threads
      int        nssteps;      // number of s steps
      int        nksteps;      // number of k steps
      int        ngrefine;     // number of grid refinements
      int        jgrefine;     // grid refinement type flag (+ve., -1, -2)
      int        nctotal;      // number of total compute-progress steps
      int        kcsteps;      // count of completed progress steps
      int        noisflag;     // noise out flag: 0(none), 1(ti), 2(ri), 3(both)
      int        nscans;       // number of experiment scans
      int        npoints;      // number of reading points per experiment scan
      int        nsubgrid;     // number of subgrids (tasks)
      int        kctask;       // count of completed subgrid tasks
      int        kstask;       // count of started subgrid tasks;
      int        mmiters;      // number of meniscus or monte carlo iterations
      int        mmtype;       // mm type: 0,1,2 for NONE|MENISCUS|MONTECARLO
      int        maxtsols;     // maximum number of task solutes
      int        mintsols;     // minimum number of depth 1ff task solutes
      int        maxdepth;     // maximum depth of iteration jobs
      int        maxiters;     // maximum number of refinement iterations
      int        r_iter;       // refinement iteration index
      int        mm_iter;      // meniscus/MC iteration index
      int        ntisols;      // number total task input solutes
      int        ntcsols;      // number total task computed solutes

      bool       abort;        // flag used with stop_fit clicked
      bool       fnoionly;     // flag to use noise flag on final call only

      double     slolim;       // s lower limit
      double     suplim;       // s upper limit
      double     klolim;       // k lower limit
      double     kuplim;       // k upper limit
      double     gdelta_s;     // grid delta in s
      double     gdelta_k;     // grid delta in k
      double     sdelta_s;     // subgrid delta in s
      double     sdelta_k;     // subgrid delta in k
      double     varitol;      // variance difference tolerance
      double     menrange;     // meniscus range
      double     cnstff0;      // constant f/f0 (or 0.0)

      QTime      timer;        // timer for elapsed time measure

   private slots:
      void queue_task( WorkPacket2D&, double, double,
                       int, int, int, QVector< US_Solute > );
      void process_job(      WorkerThread2D* );
      void process_final(    WorkerThread2D* );
      void step_progress(    int );
      void final_computes(   void );
      void iterate(          void );
      void set_meniscus(     void );
      void set_monteCarlo(   void );
      void set_gaussians(    void );
      void requeue_tasks(    void );
      void submit_job(       WorkPacket2D&, int );
      void free_worker(      int  );
      int  running_at_depth( int );
      int  queued_at_depth(  int );
      int  jobs_at_depth(    int );
      QString pmessage_head( void );
      WorkPacket2D next_job( void );
      bool memory_check    ( void );
};
#endif