Line data    Source code

       1             : /**
       2             :    Bojan Nikolic <bojan@bnikolic.co.uk> 
       3             :    Initial version 2003
       4             : 
       5             :    This file is part of BNMin1 and is licensed under GNU General
       6             :    Public License version 2
       7             : 
       8             :    \file minim.cxx
       9             :    Renamed to minim.cc 2023
      10             :    
      11             :  */
      12             : 
      13             : #include "minim.h"
      14             : 
      15             : #include <cmath>
      16             : 
      17             : #include "monitor.h"
      18             : #include "paramalgo.h"
      19             : 
      20             : #include <iostream>
      21             : 
      22             : 
      23             : namespace Minim {
      24             :   
      25          81 :   ModelDesc::ModelDesc( Model &mod ) :
      26          81 :     mod(mod)
      27             :   {
      28          81 :     mod.AddParams(pars);
      29          81 :   }
      30             : 
      31          81 :   ModelDesc::~ModelDesc(void)
      32             :   {
      33             : 
      34          81 :   }
      35             : 
      36             : 
      37          81 :   DParamCtr * ModelDesc::operator[] (const std::string &name) 
      38             :   {
      39          81 :     return findName(pars, name);
      40             :   }
      41             : 
      42           0 :   void ModelDesc::CopyParsFrom ( ModelDesc & mod2 )
      43             :   {
      44           0 :     for ( size_t i =0 ; i < mod2.NTotParam() ; ++ i )
      45             :       {
      46           0 :         DParamCtr * cpar = (*this)[ mod2[i]->getname() ] ;
      47           0 :         if ( cpar != NULL )
      48             :           {
      49           0 :             cpar->setp( mod2[i]->getp() );
      50           0 :             std::cerr<< mod2[i]->getp()  << std::endl;
      51             :           }
      52             :         
      53             :       }
      54           0 :   }
      55             : 
      56   158884163 :   unsigned ModelDesc::NParam(void) const 
      57             :   {
      58   158884163 :     unsigned count(0);
      59   953304978 :     for (std::vector<DParamCtr>::const_iterator i (pars.begin() ) ; i< pars.end() ; ++i ) 
      60   794420815 :       if (i->dofit) ++count;
      61   158884163 :     return count;
      62             :   }
      63             : 
      64   158113058 :   void ModelDesc::copytopars(const double *x) 
      65             :   { 
      66   158113058 :     unsigned count(0);
      67   158113058 :     for ( std::vector<DParamCtr>::iterator i ( pars.begin() ) ;
      68   948678348 :           i < pars.end();
      69   790565290 :           i++ )  
      70   790565290 :       if (i->dofit) {
      71   474339174 :             *(i-> p)  =  x[ count ]; 
      72   474339174 :             ++count;
      73             :           }
      74   158113058 :   }
      75             : 
      76     1542129 :   void ModelDesc::copyfrompars(double *x) 
      77             :   { 
      78     1542129 :     unsigned count(0);
      79     1542129 :     for ( std::vector<DParamCtr>::iterator i ( pars.begin() ) ;
      80     9252774 :           i < pars.end();
      81    12337032 :           i++ ) if(i->dofit) {
      82     4626387 :             x[ count ]  =  * (i-> p)  ; 
      83     4626387 :             ++count;
      84             :           }
      85     1542129 :   }
      86             : 
      87             : 
      88           0 :   Minimiser::Minimiser (Minim::Minimisable &pm) : 
      89             :     ModelDesc(pm),
      90             :     /* iter(0) ,*/
      91           0 :     m(pm) ,
      92           0 :     MonitorChi_stride(1) , 
      93           0 :     MonitorChi_cno(0)
      94             :   {
      95             :     
      96           0 :   }
      97           0 :   void Minimiser::AddMon (Monitor * mon)
      98             :   {
      99           0 :     mons.push_back(mon);
     100           0 :   }
     101             : 
     102             : 
     103           0 :   void Minim::Minimiser::ResEval       (void ) 
     104             :   { 
     105             :     
     106           0 :     m.residuals(res); 
     107             :     
     108           0 :     if ( MonitorChi_cno % MonitorChi_stride == 0 ) 
     109             :       {
     110           0 :         for ( unsigned i =0 ; i < mons.size() ; ++ i )
     111           0 :           mons[i]->Iter(this);
     112             :       }
     113             :     
     114           0 :     MonitorChi_cno++;
     115             :     
     116           0 :   }
     117             :   
     118           0 :   void Minimiser::InitRes (void) 
     119             :   {
     120           0 :     unsigned nresiduals ( m.nres() );
     121             :     
     122             :     
     123           0 :     res = std::vector<double> (  nresiduals);
     124           0 :   }
     125             :   
     126           0 :   void Minimiser::CollectParams ( Model & m ) 
     127             :   { 
     128           0 :     m.AddParams(pars) ; 
     129           0 :     MonitorChi_stride=NParam();
     130           0 :   };
     131             : 
     132             : 
     133           0 :   double Minimiser::ChiSquared(void) {
     134           0 :     double total(0.0);
     135           0 :     for (unsigned i (0) ; i < res.size() ; ++i) total += pow(res[i],2);
     136           0 :     return total;
     137             :   }
     138             : 
     139             : 
     140             : 
     141             : 
     142             : }
     143             : 
     144             :