Nathan Kelley-Hoskins / ctools

Commit 2c3a446b8683039e4bd850c3df722a74d3c25345

Authored by Jürgen Knödlseder
1 parent 280c07a9

Relpace pointer to optimizer by optimizer member (avoids memory leak when reassi… 

…gning the old best optimizer result).
Inline Side-by-side
Showing 4 changed files with 45 additions and 41 deletions
src/cterror/cterror.cpp
  View file @2c3a446
... ... @@ -233,16 +233,16 @@ void cterror::run(void)
233 233 }
234 234  
235 235 // Optimize and save best log-likelihood
236   - m_obs.optimize(*m_opt);
237   - m_obs.errors(*m_opt);
  236 + m_obs.optimize(m_opt);
  237 + m_obs.errors(m_opt);
238 238 m_best_logL = m_obs.logL();
239 239  
240 240 // Store optimizer for later recovery
241   - GOptimizerLM best_opt = *m_opt;
  241 + GOptimizerLM best_opt = m_opt;
242 242  
243 243 // Write optimised model into logger
244 244 if (logTerse()) {
245   - log << *m_opt << std::endl;
  245 + log << m_opt << std::endl;
246 246 log << gammalib::parformat("Maximum log likelihood");
247 247 log << gammalib::str(m_best_logL,3) << std::endl;
248 248 log << m_obs.models() << std::endl;
... ... @@ -353,7 +353,7 @@ void cterror::run(void)
353 353 } // endif: source model exists
354 354  
355 355 // Recover optimizer
356   - *m_opt = best_opt;
  356 + m_opt = best_opt;
357 357  
358 358 // Return
359 359 return;
... ... @@ -406,20 +406,14 @@ void cterror::init_members(void)
406 406  
407 407 // Initialise protected members
408 408 m_obs.clear();
  409 + m_opt.clear();
409 410 m_dlogL = 0.0;
410 411 m_best_logL = 0.0;
411 412 m_model_par = NULL;
412   - m_opt = NULL;
413   -
414   - // Allocate LM optimizer
415   - GOptimizerLM* opt = new GOptimizerLM();
416 413  
417 414 // Set optimizer parameters
418   - opt->max_iter(m_max_iter);
419   - opt->max_stalls(10);
420   -
421   - // Set optimizer pointer
422   - m_opt = opt;
  415 + m_opt.max_iter(m_max_iter);
  416 + m_opt.max_stalls(10);
423 417  
424 418 // Return
425 419 return;
... ... @@ -443,7 +437,7 @@ void cterror::copy_members(const cterror&amp; app)
443 437 m_obs = app.m_obs;
444 438 m_dlogL = app.m_dlogL;
445 439 m_best_logL = app.m_best_logL;
446   - m_opt = app.m_opt->clone();
  440 + m_opt = app.m_opt;
447 441 m_model_par = NULL;
448 442  
449 443 // Return
... ... @@ -666,7 +660,7 @@ double cterror::evaluate(const double&amp; value)
666 660 m_model_par->fix();
667 661  
668 662 // Re-optimize
669   - m_obs.optimize(*m_opt);
  663 + m_obs.optimize(m_opt);
670 664  
671 665 // Retrieve likelihood
672 666 logL = m_obs.logL();
... ...
src/cterror/cterror.hpp
  View file @2c3a446
... ... @@ -84,7 +84,7 @@ protected:
84 84 double m_dlogL; //!< Likelihood difference for upper limit computation
85 85 GModelPar* m_model_par; //!< Pointer to model parameter
86 86 double m_best_logL; //!< Best fit log likelihood of given model
87   - GOptimizerLM* m_opt; //!< Optimizer
  87 + GOptimizerLM m_opt; //!< Optimizer
88 88  
89 89 };
90 90  
... ... @@ -92,7 +92,7 @@ protected:
92 92 /***********************************************************************//**
93 93 * @brief Return observation container
94 94 *
95   - * @return Reference to observation container
  95 + * @return Reference to observation container.
96 96 ***************************************************************************/
97 97 inline
98 98 const GObservations& cterror::obs(void) const
... ... @@ -100,15 +100,16 @@ const GObservations&amp; cterror::obs(void) const
100 100 return m_obs;
101 101 }
102 102  
  103 +
103 104 /***********************************************************************//**
104 105 * @brief Return optimizer
105 106 *
106   - * @return Pointer to optimizer
  107 + * @return Pointer to optimizer.
107 108 ***************************************************************************/
108 109 inline
109 110 const GOptimizer* cterror::opt(void) const
110 111 {
111   - return m_opt;
  112 + return &m_opt;
112 113 }
113 114  
114 115 #endif /* CTERROR_HPP */
... ...
src/ctulimit/ctulimit.cpp
  View file @2c3a446
... ... @@ -247,16 +247,16 @@ void ctulimit::run(void)
247 247 }
248 248  
249 249 // Optimize and save best log-likelihood
250   - m_obs.optimize(*m_opt);
251   - m_obs.errors(*m_opt);
  250 + m_obs.optimize(m_opt);
  251 + m_obs.errors(m_opt);
252 252 m_best_logL = m_obs.logL();
253 253  
254 254 // Store optimizer for later recovery
255   - best_opt = *m_opt;
  255 + best_opt = m_opt;
256 256  
257 257 // Write optimised model into logger
258 258 if (logTerse()) {
259   - log << *m_opt << std::endl;
  259 + log << m_opt << std::endl;
260 260 log << gammalib::parformat("Maximum log likelihood");
261 261 log << gammalib::str(m_best_logL,3) << std::endl;
262 262 log << m_obs.models() << std::endl;
... ... @@ -341,7 +341,7 @@ void ctulimit::run(void)
341 341 m_obs.models(models_orig);
342 342  
343 343 // Recover optimizer
344   - *m_opt = best_opt;
  344 + m_opt = best_opt;
345 345  
346 346 // Return
347 347 return;
... ... @@ -408,6 +408,7 @@ void ctulimit::init_members(void)
408 408  
409 409 // Initialise protected members
410 410 m_obs.clear();
  411 + m_opt.clear();
411 412 m_dlogL = 0.0;
412 413 m_skymodel = NULL;
413 414 m_model_par = NULL;
... ... @@ -415,17 +416,10 @@ void ctulimit::init_members(void)
415 416 m_flux_ulimit = 0.0;
416 417 m_diff_ulimit = 0.0;
417 418 m_eflux_ulimit = 0.0;
418   - m_opt = NULL;
419   -
420   - // Allocate LM optimizer
421   - GOptimizerLM* opt = new GOptimizerLM();
422 419  
423 420 // Set optimizer parameters
424   - opt->max_iter(m_max_iter);
425   - opt->max_stalls(10);
426   -
427   - // Set optimizer pointer
428   - m_opt = opt;
  421 + m_opt.max_iter(m_max_iter);
  422 + m_opt.max_stalls(10);
429 423  
430 424 // Return
431 425 return;
... ... @@ -458,7 +452,7 @@ void ctulimit::copy_members(const ctulimit&amp; app)
458 452 m_diff_ulimit = app.m_diff_ulimit;
459 453 m_flux_ulimit = app.m_flux_ulimit;
460 454 m_eflux_ulimit = app.m_eflux_ulimit;
461   - m_opt = app.m_opt->clone();
  455 + m_opt = app.m_opt;
462 456  
463 457 // Extract model parameter
464 458 get_model_parameter();
... ... @@ -697,7 +691,7 @@ double ctulimit::evaluate(const double&amp; value)
697 691 m_model_par->fix();
698 692  
699 693 // Re-optimize
700   - m_obs.optimize(*m_opt);
  694 + m_obs.optimize(m_opt);
701 695  
702 696 // Retrieve likelihood
703 697 logL = m_obs.logL();
... ...
src/ctulimit/ctulimit.hpp
  View file @2c3a446
... ... @@ -103,14 +103,14 @@ protected:
103 103 double m_diff_ulimit; //!< Differential upper limit value
104 104 double m_flux_ulimit; //!< Flux upper limit value
105 105 double m_eflux_ulimit; //!< Energy flux upper limits
106   - GOptimizerLM* m_opt; //!< Optimizer
  106 + GOptimizerLM m_opt; //!< Optimizer
107 107 };
108 108  
109 109  
110 110 /***********************************************************************//**
111 111 * @brief Return observation container
112 112 *
113   - * @return Reference to observation container
  113 + * @return Reference to observation container.
114 114 ***************************************************************************/
115 115 inline
116 116 const GObservations& ctulimit::obs(void) const
... ... @@ -118,10 +118,23 @@ const GObservations&amp; ctulimit::obs(void) const
118 118 return m_obs;
119 119 }
120 120  
  121 +
  122 +/***********************************************************************//**
  123 + * @brief Return optimizer
  124 + *
  125 + * @return Pointer to optimizer.
  126 + ***************************************************************************/
  127 +inline
  128 +const GOptimizer* ctulimit::opt(void) const
  129 +{
  130 + return &m_opt;
  131 +}
  132 +
  133 +
121 134 /***********************************************************************//**
122 135 * @brief Return differential upper limit
123 136 *
124   - * @return differential upper limit
  137 + * @return Differential upper flux limit.
125 138 ***************************************************************************/
126 139 inline
127 140 const double& ctulimit::diff_ulimit(void) const
... ... @@ -129,10 +142,11 @@ const double&amp; ctulimit::diff_ulimit(void) const
129 142 return m_diff_ulimit;
130 143 }
131 144  
  145 +
132 146 /***********************************************************************//**
133 147 * @brief Return flux upper limit
134 148 *
135   - * @return flux upper limit
  149 + * @return Upper flux limit.
136 150 ***************************************************************************/
137 151 inline
138 152 const double& ctulimit::flux_ulimit(void) const
... ... @@ -140,10 +154,11 @@ const double&amp; ctulimit::flux_ulimit(void) const
140 154 return m_flux_ulimit;
141 155 }
142 156  
  157 +
143 158 /***********************************************************************//**
144 159 * @brief return energy flux upper limit
145 160 *
146   - * @return energy flux upper limits
  161 + * @return Upper energy flux limit.
147 162 ***************************************************************************/
148 163 inline
149 164 const double& ctulimit::eflux_ulimit(void) const
... ...