appatt.h

/* ======== IGeoS ===== Distribition full ===== IGeoS =========
**                                                                         
** appatt.h     : Created by 'AMSS-developer' on Wed Sep 30 19:29:02 2015
**                                                                         
** Product      : IGeoS - Integrated Geoscience Software
**                                                                         
** Description  : System for seismic, well log, and potential-field data analysis
**                                                                         
** =================== Limited License: ===================================
** 
** This software is provided free under the following terms and conditions:
** 
** 1. Permission to use, copy, and modify this software 
** for non-commercial purposes without fee is hereby granted, provided  
** that this copyright notice, the warranty disclaimer, and this
** permission notice appear in all copies.
** 
** 2. Distribution of this software or any part of it "bundled" in with
** any product is considered to be a 'commercial purpose'.
** 
** 3. Any new or adapted code developed to operate as a part of this
** software shall be contributed to the authors and distributed under
** the same license.
** 
** ================== Warranty Disclaimer: ================================
** 
** This software is provided "as is", with no support and without
** obligation on the part of the author to assist in its use, correction,
** modification, or enhancement. No guarantees or warranties,
** either express or implied, and regarding the accuracy, safety, or
** fitness for any particular purpose are provided by any contributor
** to this software package.
** 
** ======== IGeoS ===== Distribition full ===== IGeoS ========= */


#ifndef MOD_APPATT_H
#define MOD_APPATT_H

#include "sia_module.C.h"
#include "../_lib/if/if.h"
#include "../_lib/dbase/dbase_sia.h"

class APPATT;

#define EPS             0.0001  /* margin by which the ranges are expanded */
#define EPS_DOWN        0.9999
#define EPS_UP          1.0001  

#define X_TOLERANCE     1.0e-3
#define T_STAR_FACTOR   366.4678        /* factor to scale t* 
                                        (1000 included to express it in ms):
                                                1000 / TWO_PI / lg(e) */

typedef float   MATRIX_FORMAT;

struct FP                       /* frequency-power pairs */
{
  DATA_SAMPLE   f, p;
};

struct IN_SOURCE                        /* input source table structure */
{
  USER_DBTAB    *table;
  HEADER        *number,                /* trial number */
                *freq,                  /* frequency */
                *power, *variance;      /* source spectral power and its
                                                variance */
  int           num_f;
  double        *spectrum;              /* array for the storage of the
                                                input source spectrum */
};

struct OUT_TT                   /* output table structure */
{
  USER_DBTAB    *table;
  HEADER        *number,                /* trial number */
                *arg,                   /* X or frequency */
                *value, *variance;      /* parameter found by inversion and its
                                                variance */

  int entry_length() const { return table ? table->entry.length() : 0; }
};

struct OUT_RES_VAR                      /* output resolution and covariance table */
{
  USER_DBTAB    *table;
  HEADER        *row, *column,                  /* rows and columns */
                *resolution,  *covariance;
};

struct APPATT_RANGES
{
  APPATT_RANGES(APPATT &a) : A(a) {}
  
  virtual double basis_fun ( const POINT &p, int k ) const = 0;

  virtual int prepare() = 0;
        
  virtual boolean check( const char *title ) { return OK; }
  
  virtual int num_points() const { return 0; }  
  
  virtual void prepare( const POINT &p ) {}     
  
  virtual void output_gamma() {}                
  virtual void output_kappa() {}                
  
  APPATT &A;    
};

class X_RANGES;

struct X_RANGE                  /* subranges in the parameterization in X */
{
  X_RANGE() : num(0), used(FALSE) {}
  X_RANGE(const X_RANGE &from) { _copy(from);}
  X_RANGE &operator=(const X_RANGE &from) { _copy(from); return *this; }

  int   num,            
        used;           
        
  float min,            
        max,            
        inc;            
                                
  boolean read( const X_RANGES &current );      

  int num_points() const { return num; }        

protected:
    void _copy(const X_RANGE &r) 
          { num = r.num; used = r.used; min = r.min; max = r.max; inc = r.inc; }
};

struct X_RANGES : public APPATT_RANGES, ARRAY<X_RANGE> 
{
  X_RANGES( APPATT &a ) : APPATT_RANGES(a), ARRAY<X_RANGE>() {}
  
  double basis_fun ( const POINT &p, int k ) const { return basis_fun0(p.x,k); }

  int prepare();        

  void prepare( const POINT &p );       
  boolean check( const char *title );   


        
  void output_gamma();          
  void output_kappa();          

  int num_points() const;        

private:
      double basis_fun0 ( double x, int k ) const;
};

struct APPATT : public SIA_MODULE, DBMODULE
{
  APPATT();

  SELECT        *select;                

  /*---- parameters -------------------------------------*/

  int   num_freq,       /* number of values of parameterization in frequency */
        num_iter;       /* number of iterations of spectral balancing */

  HEADER_PARAM  xg,             /* trace position for G parameterization--
                                        channel number, or X, or offset, etc. */
                xt,             /* trace position for t* parameterization--
                                        channel number, or X, or offset, etc. */
                freq_min, freq_max, freq_inc,   /* frequency range */
                weight,                         /* trace weight */
                power_weight_min,               /* power-dependent weight */
                power_weight_max,
                power_range_width;

  int   trial_number;           
  float shift_t_star,           
        shift_g;                
  
  /*----- parameterization ranges in X, different for G and t* terms -----*/

  int           num_xg;         /* total number of basis functions in G */
  APPATT_RANGES *xg_range;      /* array of G-ranges in X */

  int           num_xt;         /* total number of basis functions in t* */
  APPATT_RANGES *xt_range;      /* array of t*-ranges in X */

  /*---- output tables -------------------------------------*/

  OUT_TT        t_star,         /* apparent attenuation terms */
                amplitude,      /* amplitude terms */
                source;         /* source terms */

  OUT_RES_VAR   quality;        /* output quality control table */

  /*---- input source table -------------------------------------*/

  IN_SOURCE     in_source;

  /*---- randomization -------------------------------------*/

  int   num_trials;

  float min_freq_min, max_freq_min,
        min_freq_max, max_freq_max;

  /*----- work areas ---------------------------------------*/

  float min_freq, max_freq, inc_freq;

  int           num_u;                  /* number of unknowns */
  MATRIX_FORMAT *u, *result;            /* row of Hessian and output */

  ARRAY<FP>     work;                   

  double *old_t_star, *old_source;      /* t* and source spectrum
                                                from the previous iteration */
                                                
  void proc ( boolean random_trial=TRUE );

  void compute_quality();

  void converge();

  void fill_source();
        
  CHARSTR module_name( boolean active );        
  int edit();                                   
  boolean process();                            

  int branch ( int range ) const;

  boolean trace_power ( TRACE *t, double freq, double &power ) const;

protected:

  boolean pass_traces();        

  virtual double freq_basis ( double freq, int k );
};

#endif

---