Landau.cxx

Go to the documentation of this file.

/*
 * HippoPlot Landau class implementation
 *
 * Copyright (C) 2000-2003   The Board of Trustees of The Leland
 * Stanford Junior University.  All Rights Reserved.
 *
 * $Id: Landau.cxx,v 1.7 2003/07/09 15:29:13 pfkeb Exp $
 *
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#else
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif
#endif

#include "Landau.h"

#include "FunctionHelper.h"

#include <cmath>
#include <cassert>

using std::distance;

#ifdef ITERATOR_MEMBER_DEFECT
using namespace std;
#else
using std::exp;
using std::vector;
#endif

Landau::Landau ( )
{
  initialize ();
}

Landau::Landau ( double p, double c, double s )
{
  initialize ();
  
  m_parms[peak] = p;
  m_parms[norm] = c;
  m_parms[sigma] = s;
}

void Landau::initialize ()
{
  m_name = "Landau";

  m_parm_names.push_back ( "Peak" );
  m_parm_names.push_back ( "Normalization" );
  m_parm_names.push_back ( "Sigma" );

  resize ();
}

FunctionBase * Landau::clone () const
{
  return new Landau ( *this );
}

//                            REAL FUNCTION FITLAND(X)

//                             DOUBLE PRECISION FITEMP

//                             COMMON/PAWPAR/ PAR(3)


//                             PI=3.1415926

//                            Y=(X-PAR(1))/PAR(3)

//            FITEMP=DBLE(PAR(2)*EXP(-0.5*(Y+EXP(-1.*Y)))/SQRT(2.*PI))

//                               FITLAND=REAL(FITEMP)

//                            END
double Landau::operator () ( double x ) const
{  
  double y = calcY ( x );
  double t = exp ( -0.5 * ( y + exp ( -1.0 * y ) ) ) 
    / sqrt ( 2.0 * M_PI );

  return m_parms[norm] * t;
}

/* virtual */
void 
Landau::
initialParameters ( const FunctionHelper * helper )
{
  m_parms[norm] = helper->maxValue () * sqrt ( 2.0 * M_PI * M_E );
  m_parms[peak] = helper->meanCoord ();
  m_parms[sigma] = helper->stdCoord ();
}

double Landau::derivByParm ( int i, double x ) const
{
  switch ( i ) {
  case peak :
    return derivByPeak ( x );
    break;

  case norm :
    return derivByNorm ( x );
    break;

  case sigma :
    return derivBySigma ( x );
    break;

  default :
    assert ( false );
    break;
  }
  return 0.0;
}

double Landau::derivByNorm ( double x ) const
{
  double norm_aux = 0.0001;
  if(m_parms[norm] != 0) norm_aux = m_parms[norm];
  return operator () (x) / norm_aux;
}

double Landau::derivByPeak ( double x ) const
{
  return operator () ( x ) * calcZ ( x ) * ( ( -1.0 ) / m_parms[sigma] );
}

double Landau::derivBySigma ( double x ) const
{
  return operator () ( x ) * calcZ ( x ) 
    * ( - ( x - m_parms[peak] ) / ( m_parms[sigma] * m_parms[sigma] ) );
}

---