PTheory.h

Go to the documentation of this file.

/***************************************************************************
 
  PTheory.h
 
  Author: Andreas Suter
  e-mail: andreas.suter@psi.ch
 
***************************************************************************/
 
/***************************************************************************
 *   Copyright (C) 2007-2026 by Andreas Suter                              *
 *   andreas.suter@psi.ch                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef _PTHEORY_H_
#define _PTHEORY_H_
 
#include <TSystem.h>
#include <TString.h>
 
#include "PMusr.h"
#include "PMsrHandler.h"
#include "PUserFcnBase.h"
 
//-------------------------------------------------------------

#define THEORY_UNDEFINED                    -1
#define THEORY_CONST                         0
#define THEORY_ASYMMETRY                     1
#define THEORY_SIMPLE_EXP                    2
#define THEORY_GENERAL_EXP                   3
#define THEORY_SIMPLE_GAUSS                  4
#define THEORY_STATIC_GAUSS_KT               5
#define THEORY_STATIC_GAUSS_KT_LF            6
#define THEORY_DYNAMIC_GAUSS_KT_LF           7
#define THEORY_STATIC_LORENTZ_KT             8
#define THEORY_STATIC_LORENTZ_KT_LF          9
#define THEORY_DYNAMIC_LORENTZ_KT_LF        10
#define THEORY_DYNAMIC_GAULOR_FAST_KT_ZF    11
#define THEORY_DYNAMIC_GAULOR_FAST_KT_LF    12
#define THEORY_DYNAMIC_GAULOR_KT_LF         13
#define THEORY_COMBI_LGKT                   14
#define THEORY_STR_KT                       15
#define THEORY_SPIN_GLASS                   16
#define THEORY_RANDOM_ANISOTROPIC_HYPERFINE 17
#define THEORY_ABRAGAM                      18
#define THEORY_TF_COS                       19
#define THEORY_INTERNAL_FIELD               20
#define THEORY_INTERNAL_FIELD_KORNILOV      21
#define THEORY_INTERNAL_FIELD_LARKIN        22
#define THEORY_BESSEL                       23
#define THEORY_INTERNAL_BESSEL              24
#define THEORY_SKEWED_GAUSS                 25
#define THEORY_STATIC_ZF_NK                 26
#define THEORY_STATIC_TF_NK                 27
#define THEORY_DYNAMIC_ZF_NK                28
#define THEORY_DYNAMIC_TF_NK                29
#define THEORY_F_MU_F                       30
#define THEORY_MU_MINUS_EXP                 31
#define THEORY_POLYNOM                      32
#define THEORY_USER_FCN                     33
 
//-------------------------------------------------------------
#define THEORY_PARAM_CONST                        1 // const
#define THEORY_PARAM_ASYMMETRY                    1 // asymmetry
#define THEORY_PARAM_SIMPLE_EXP                   1 // damping (tshift)
#define THEORY_PARAM_GENERAL_EXP                  2 // damping, exponents  (tshift)
#define THEORY_PARAM_SIMPLE_GAUSS                 1 // damping (tshift)
#define THEORY_PARAM_STATIC_GAUSS_KT              1 // damping (tshift)
#define THEORY_PARAM_STATIC_GAUSS_KT_LF           2 // frequency, damping (tshift)
#define THEORY_PARAM_DYNAMIC_GAUSS_KT_LF          3 // frequency, damping, hop-rate (tshift)
#define THEORY_PARAM_STATIC_LORENTZ_KT            1 // damping (tshift)
#define THEORY_PARAM_STATIC_LORENTZ_KT_LF         2 // frequency, damping (tshift)
#define THEORY_PARAM_DYNAMIC_LORENTZ_KT_LF        3 // frequency, damping, hop-rate (tshift)
#define THEORY_PARAM_DYNAMIC_GAULOR_FAST_KT_ZF    2 // damping, hop-rate (tshift)
#define THEORY_PARAM_DYNAMIC_GAULOR_FAST_KT_LF    3 // frequency, damping, hop-rate (tshift)
#define THEORY_PARAM_DYNAMIC_GAULOR_KT_LF         3 // frequency, damping, hop-rate (tshift)
#define THEORY_PARAM_COMBI_LGKT                   2 // Lorentz rate, Gauss rate (tshift)
#define THEORY_PARAM_STR_KT                       2 // rate, exponent (tshift)
#define THEORY_PARAM_SPIN_GLASS                   3 // rate, hop-rate, order parameter (tshift)
#define THEORY_PARAM_RANDOM_ANISOTROPIC_HYPERFINE 2 // frequency, rate (tshift)
#define THEORY_PARAM_ABRAGAM                      2 // rate, hop-rate (tshift)
#define THEORY_PARAM_TF_COS                       2 // phase, frequency (tshift)
#define THEORY_PARAM_INTERNAL_FIELD               5 // fraction, phase, frequency, TF damping, damping (tshift)
#define THEORY_PARAM_INTERNAL_FIELD_KORNILOV      5 // fraction, frequency, TF damping, damping, beta (tshift)
#define THEORY_PARAM_INTERNAL_FIELD_LARKIN        4 // fraction, frequency, TF damping, damping (tshift)
#define THEORY_PARAM_BESSEL                       2 // phase, frequency (tshift)
#define THEORY_PARAM_INTERNAL_BESSEL              5 // fraction, phase, frequency, TF damping, LF damping (tshift)
#define THEORY_PARAM_SKEWED_GAUSS                 4 // phase, frequency, rate minus, rate plus (tshift)
#define THEORY_PARAM_STATIC_ZF_NK                 2 // damping D0, R_b=DGbG/D0 (tshift)
#define THEORY_PARAM_STATIC_TF_NK                 4 // phase, frequency, damping D0, R_b=DGbG/D0 (tshift)
#define THEORY_PARAM_DYNAMIC_ZF_NK                3 // damping D0, R_b=DGbG/D0, nu_c (tshift)
#define THEORY_PARAM_DYNAMIC_TF_NK                5 // phase, frequency, damping D0, R_b=DGbG/D0, nu_c (tshift)
#define THEORY_PARAM_F_MU_F                       1 // frequency (tshift)
#define THEORY_PARAM_MU_MINUS_EXP                 6 // N0, tau, A, damping, phase, frequency (tshift)
 
//-------------------------------------------------------------
#define THEORY_MAX 34
 
//-------------------------------------------------------------
#define THEORY_MAX_PARAM 10
 
//-------------------------------------------------------------
#define DEG_TO_RAD 0.0174532925199432955

#define TWO_PI 6.28318530717958623
 
class PTheory;
 
//--------------------------------------------------------------------------------------
typedef struct theo_data_base {
  UInt_t fType;      
  UInt_t fNoOfParam; 
  Bool_t fTable;     
  TString fName;     
  TString fAbbrev;   
  TString fComment;  
  TString fCommentTimeShift; 
} PTheoDataBase;
 
//--------------------------------------------------------------------------------------
static PTheoDataBase fgTheoDataBase[THEORY_MAX] = {
 
  {THEORY_CONST, THEORY_PARAM_CONST, false,
   "const", "c", "", ""},
 
  {THEORY_ASYMMETRY, THEORY_PARAM_ASYMMETRY, false,
   "asymmetry", "a", "", ""},
 
  {THEORY_SIMPLE_EXP, THEORY_PARAM_SIMPLE_EXP, false,
   "simplExpo", "se", "(rate)", "(rate tshift)"},
 
  {THEORY_GENERAL_EXP, THEORY_PARAM_GENERAL_EXP, false,
   "generExpo", "ge", "(rate exponent)", "(rate exponent tshift)"},
 
  {THEORY_SIMPLE_GAUSS, THEORY_PARAM_SIMPLE_GAUSS, false,
   "simpleGss", "sg", "(rate)", "(rate tshift)"},
 
  {THEORY_STATIC_GAUSS_KT, THEORY_PARAM_STATIC_GAUSS_KT, false,
   "statGssKt", "stg", "(rate)", "(rate tshift)"},
 
  {THEORY_STATIC_GAUSS_KT_LF, THEORY_PARAM_STATIC_GAUSS_KT_LF, true,
   "statGssKTLF", "sgktlf", "(frequency damping)", "(frequency damping tshift)"},
 
  {THEORY_DYNAMIC_GAUSS_KT_LF, THEORY_PARAM_DYNAMIC_GAUSS_KT_LF, true,
   "dynGssKTLF", "dgktlf", "(frequency damping hopping-rate)", "(frequency damping hopping-rate tshift)"},
 
  {THEORY_STATIC_LORENTZ_KT, THEORY_PARAM_STATIC_LORENTZ_KT, true,
   "statExpKT", "sekt", "(rate)", "(rate tshift)"},
 
  {THEORY_STATIC_LORENTZ_KT_LF, THEORY_PARAM_STATIC_LORENTZ_KT_LF, true,
   "statExpKTLF", "sektlf", "(frequency damping)", "(frequency damping tshift)"},
 
  {THEORY_DYNAMIC_LORENTZ_KT_LF, THEORY_PARAM_DYNAMIC_LORENTZ_KT_LF, true,
   "dynExpKTLF", "dektlf", "(frequency damping hopping-rate)", "(frequency damping hopping-rate tshift)"},
 
  {THEORY_DYNAMIC_GAULOR_FAST_KT_ZF, THEORY_PARAM_DYNAMIC_GAULOR_FAST_KT_ZF, true,
   "dynGLKT_F_ZF", "dglktfzf", "(damping hopping-rate)", "(damping hopping-rate tshift)"},
 
  {THEORY_DYNAMIC_GAULOR_FAST_KT_LF, THEORY_PARAM_DYNAMIC_GAULOR_FAST_KT_LF, true,
   "dynGLKT_F_LF", "dglktflf", "(frequency damping hopping-rate)", "(frequency damping hopping-rate tshift)"},
 
  {THEORY_DYNAMIC_GAULOR_KT_LF, THEORY_PARAM_DYNAMIC_GAULOR_KT_LF, true,
   "dynGLKT_LF", "dglktlf", "(frequency damping hopping-rate)", "(frequency damping hopping-rate tshift)"},
 
  {THEORY_COMBI_LGKT, THEORY_PARAM_COMBI_LGKT, false,
   "combiLGKT", "lgkt", "(lorentzRate gaussRate)", "(lorentzRate gaussRate tshift)"},
 
  {THEORY_STR_KT, THEORY_PARAM_STR_KT, false,
   "strKT", "skt", "(rate beta)", "(rate beta tshift)"},
 
  {THEORY_SPIN_GLASS, THEORY_PARAM_SPIN_GLASS, false,
   "spinGlass",  "spg", "(rate hopprate order)", "(rate hopprate order tshift)"},
 
  {THEORY_RANDOM_ANISOTROPIC_HYPERFINE, THEORY_PARAM_RANDOM_ANISOTROPIC_HYPERFINE, false,
   "rdAnisoHf", "rahf", "(frequency rate)", "(frequency rate tshift)"},
 
  {THEORY_ABRAGAM, THEORY_PARAM_ABRAGAM, false,
   "abragam", "ab", "(rate hopprate)", "(rate hopprate tshift)"},
 
  {THEORY_TF_COS, THEORY_PARAM_TF_COS, false,
   "TFieldCos", "tf", "(phase frequency)", "(phase frequency tshift)"},
 
  {THEORY_INTERNAL_FIELD, THEORY_PARAM_INTERNAL_FIELD, false,
   "internFld", "ifld", "(fraction phase frequency Trate Lrate)", "(fraction phase frequency Trate Lrate tshift)"},
 
  {THEORY_INTERNAL_FIELD_KORNILOV, THEORY_PARAM_INTERNAL_FIELD_KORNILOV, false,
   "internFldGK", "ifgk", "(fraction frequency sigma lambda beta)", "(fraction frequency sigma lambda beta tshift)"},
 
  {THEORY_INTERNAL_FIELD_LARKIN, THEORY_PARAM_INTERNAL_FIELD_LARKIN, false,
   "internFldLL", "ifll", "(fraction frequency sigma lambda beta)", "(fraction frequency sigma lambda beta tshift)"},
 
  {THEORY_BESSEL, THEORY_PARAM_BESSEL, false,
   "bessel", "b", "(phase frequency)", "(phase frequency tshift)"},
 
  {THEORY_INTERNAL_BESSEL, THEORY_PARAM_INTERNAL_BESSEL, false,
   "internBsl", "ib", "(fraction phase frequency Trate Lrate)", "(fraction phase frequency Trate Lrate tshift)"},
 
  {THEORY_SKEWED_GAUSS, THEORY_PARAM_SKEWED_GAUSS, false,
   "skewedGss", "skg", "(phase frequency rate_m rate_p)", "(phase frequency rate_m rate_p tshift)"},
 
  {THEORY_STATIC_ZF_NK, THEORY_PARAM_STATIC_ZF_NK, false,
   "staticNKZF", "snkzf", "(damping_D0 R_b)", "(damping_D0 R_b tshift)"},
 
  {THEORY_STATIC_TF_NK, THEORY_PARAM_STATIC_TF_NK, false,
   "staticNKTF", "snktf", "(phase frequency damping_D0 R_b)", "(phase frequency damping_D0 R_b tshift)"},
 
  {THEORY_DYNAMIC_ZF_NK, THEORY_PARAM_DYNAMIC_ZF_NK, false,
   "dynamicNKZF", "dnkzf", "(damping_D0 R_b nu_c)", "(damping_D0 R_b nu_c tshift)"},
 
  {THEORY_DYNAMIC_TF_NK, THEORY_PARAM_DYNAMIC_TF_NK, false,
   "dynamicNKTF", "dnktf", "(phase frequency damping_D0 R_b nu_c)", "(phase frequency damping_D0 R_b nu_c tshift)"},
 
  {THEORY_F_MU_F, THEORY_PARAM_F_MU_F, false,
   "F_mu_F", "fmuf", "(frequency)", "(frequency tshift)"},
 
  {THEORY_MU_MINUS_EXP, THEORY_PARAM_MU_MINUS_EXP, false,
   "muMinusExpTF", "mmsetf", "(N0 tau A lambda phase nu)", "(N0 tau A lambda phase nu tshift)"},
 
  {THEORY_POLYNOM, 0, false,
   "polynom", "p", "(tshift p0 p1 ... pn)", "(tshift p0 p1 ... pn)"},
 
  {THEORY_USER_FCN, 0, false,
   "userFcn", "u", "", ""}
};
 
//--------------------------------------------------------------------------------------
class PTheory
{
  public:
    PTheory(PMsrHandler *msrInfo, UInt_t runNo, const Bool_t hasParent = false);

    virtual ~PTheory();

    virtual Bool_t IsValid();

    virtual Double_t Func(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
 
  private:
    virtual void CleanUp(PTheory *theo);

    virtual Int_t SearchDataBase(TString name);

    virtual Int_t GetUserFcnIdx(UInt_t lineNo) const;

    virtual void MakeCleanAndTidyTheoryBlock(PMsrLines* fullTheoryBlock);

    virtual void MakeCleanAndTidyPolynom(UInt_t i, PMsrLines* fullTheoryBlock);

    virtual void MakeCleanAndTidyUserFcn(UInt_t i, PMsrLines* fullTheoryBlock);
 
    // -------------------- Theory Function Implementations --------------------
    // Each function evaluates its specific physical model at time t.
    // Parameters are resolved from fParamNo using paramValues and funcValues.

    virtual Double_t Constant(const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t Asymmetry(const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t SimpleExp(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t GeneralExp(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t SimpleGauss(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t StaticGaussKT(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t StaticGaussKTLF(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t DynamicGaussKTLF(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t StaticLorentzKT(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t StaticLorentzKTLF(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t DynamicLorentzKTLF(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t DynamicGauLorKTZFFast(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t DynamicGauLorKTLFFast(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t DynamicGauLorKTLF(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t CombiLGKT(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t StrKT(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t SpinGlass(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t RandomAnisotropicHyperfine(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t Abragam(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t TFCos(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t InternalField(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t InternalFieldGK(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t InternalFieldLL(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t Bessel(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t InternalBessel(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t SkewedGauss(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t StaticNKZF(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t StaticNKTF(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t DynamicNKZF(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t DynamicNKTF(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t FmuF(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t MuMinusExpTF(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t Polynom(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
    virtual Double_t UserFcn(Double_t t, const PDoubleVector& paramValues, const PDoubleVector& funcValues) const;
 
    // -------------------- LF Calculation Helpers --------------------
    virtual void CalculateGaussLFIntegral(const Double_t *val) const;
    virtual void CalculateLorentzLFIntegral(const Double_t *val) const;
    virtual Double_t GetLFIntegralValue(const Double_t t) const;
    virtual void CalculateDynKTLF(const Double_t *val, Int_t tag) const;
    virtual Double_t GetDynKTLFValue(const Double_t t) const;
    virtual Double_t GetDyn_GL_KTLFValue(const Double_t t) const;
 
    // -------------------- Member Variables --------------------
    Bool_t fValid;               
    UInt_t fType;                
    std::vector<UInt_t> fParamNo; 
    UInt_t fNoOfParam;           
    PTheory *fAdd;               
    PTheory *fMul;               
 
    // User function members
    Int_t fUserFcnIdx;              
    TString fUserFcnClassName;      
    TString fUserFcnSharedLibName;  
    PUserFcnBase *fUserFcn;         
    mutable PDoubleVector fUserParam; 
 
    PMsrHandler *fMsrInfo;          
 
    // LF calculation caching (mutable for const Func() calls)
    mutable Double_t fSamplingTime;                
    mutable Double_t fPrevParam[THEORY_MAX_PARAM]; 
    mutable PDoubleVector fLFIntegral;             
    mutable Double_t fDynLFdt;                     
    mutable PDoubleVector fDynLFFuncValue;         
    mutable PDoubleVector fDyn_GL_LFFuncValue;     
};
 
#endif //  _PTHEORY_H_