SourceXtractorPlusPlus  0.11
Please provide a description of the project.
FlexibleModelFittingTask.cpp
Go to the documentation of this file.
1 
17 /*
18  * FlexibleModelFittingTask.cpp
19  *
20  * Created on: Sep 17, 2018
21  * Author: mschefer
22  */
23 
24 #include <mutex>
25 
35 
37 
39 
42 
49 
53 
55 
56 namespace SourceXtractor {
57 
58 using namespace ModelFitting;
59 
60 static auto logger = Elements::Logging::getLogger("FlexibleModelFitting");
61 
62 namespace {
63 
64 __attribute__((unused))
66  std::cerr << "\nMinimization info:\n";
67  std::cerr << " ||e||_2 at initial p: " << info[0] << '\n';
68  std::cerr << " ||e||_2: " << info[1] << '\n';
69  std::cerr << " ||J^T e||_inf: " << info[2] << '\n';
70  std::cerr << " ||Dp||_2: " << info[3] << '\n';
71  std::cerr << " mu/max[J^T J]_ii: " << info[4] << '\n';
72  std::cerr << " # iterations: " << info[5] << '\n';
73  switch ((int) info[6]) {
74  case 1:
75  std::cerr << " stopped by small gradient J^T e\n";
76  break;
77  case 2:
78  std::cerr << " stopped by small Dp\n";
79  break;
80  case 3:
81  std::cerr << " stopped by itmax\n";
82  break;
83  case 4:
84  std::cerr << " singular matrix. Restart from current p with increased mu\n";
85  break;
86  case 5:
87  std::cerr << " no further error reduction is possible. Restart with increased mu\n";
88  break;
89  case 6:
90  std::cerr << " stopped by small ||e||_2\n";
91  break;
92  case 7:
93  std::cerr << " stopped by invalid (i.e. NaN or Inf) func values; a user error\n";
94  break;
95  }
96  std::cerr << " # function evaluations: " << info[7] << '\n';
97  std::cerr << " # Jacobian evaluations: " << info[8] << '\n';
98  std::cerr << " # linear systems solved: " << info[9] << "\n\n";
99 }
100 
101 }
102 
104  unsigned int max_iterations, double modified_chi_squared_scale,
108  : m_least_squares_engine(least_squares_engine),
109  m_max_iterations(max_iterations), m_modified_chi_squared_scale(modified_chi_squared_scale),
110  m_parameters(parameters), m_frames(frames), m_priors(priors) {}
111 
113  auto stamp_rect = group.getProperty<MeasurementFrameGroupRectangle>(frame_index);
114  return stamp_rect.getWidth() > 0 && stamp_rect.getHeight() > 0;
115 }
116 
118  SourceGroupInterface& group, int frame_index) const {
120 
121  auto frame = group.begin()->getProperty<MeasurementFrame>(frame_index).getFrame();
122  auto frame_image = frame->getSubtractedImage();
123 
124  auto rect = group.getProperty<MeasurementFrameGroupRectangle>(frame_index);
125  auto image = VectorImage<SeFloat>::create(rect.getWidth(), rect.getHeight());
126  for (int y = 0; y < rect.getHeight(); y++) {
127  for (int x = 0; x < rect.getWidth(); x++) {
128  image->at(x, y) = frame_image->getValue(rect.getTopLeft().m_x + x, rect.getTopLeft().m_y + y);
129  }
130  }
131 
132  return image;
133 }
134 
136  SourceGroupInterface& group, int frame_index) const {
138 
139  auto frame = group.begin()->getProperty<MeasurementFrame>(frame_index).getFrame();
140  auto frame_image = frame->getSubtractedImage();
141  auto frame_image_thresholded = frame->getThresholdedImage();
142  auto variance_map = frame->getVarianceMap();
143 
144  auto rect = group.getProperty<MeasurementFrameGroupRectangle>(frame_index);
145  auto weight = VectorImage<SeFloat>::create(rect.getWidth(), rect.getHeight());
146  std::fill(weight->getData().begin(), weight->getData().end(), 1);
147 
148  auto measurement_frame = group.begin()->getProperty<MeasurementFrame>(frame_index).getFrame();
149  SeFloat gain = measurement_frame->getGain();
150  SeFloat saturation = measurement_frame->getSaturation();
151 
152  for (int y = 0; y < rect.getHeight(); y++) {
153  for (int x = 0; x < rect.getWidth(); x++) {
154  auto back_var = variance_map->getValue(rect.getTopLeft().m_x + x, rect.getTopLeft().m_y + y);
155  if (saturation > 0 && frame_image->getValue(rect.getTopLeft().m_x + x, rect.getTopLeft().m_y + y) > saturation) {
156  weight->at(x, y) = 0;
157  } else if (weight->at(x, y) > 0) {
158  if (gain > 0.0) {
159  weight->at(x, y) = sqrt(
160  1.0 / (back_var + frame_image->getValue(rect.getTopLeft().m_x + x, rect.getTopLeft().m_y + y) / gain));
161  } else {
162  weight->at(x, y) = sqrt(1.0 / back_var); // infinite gain
163  }
164  }
165  }
166  }
167 
168  return weight;
169 }
170 
172  SourceGroupInterface& group,
175 
176  int frame_index = frame->getFrameNb();
177 
178  auto frame_coordinates =
179  group.begin()->getProperty<MeasurementFrame>(frame_index).getFrame()->getCoordinateSystem();
180  auto ref_coordinates =
181  group.begin()->getProperty<DetectionFrame>().getFrame()->getCoordinateSystem();
182 
183  auto stamp_rect = group.getProperty<MeasurementFrameGroupRectangle>(frame_index);
184  auto psf_property = group.getProperty<PsfProperty>(frame_index);
185  auto jacobian = group.getProperty<JacobianGroup>(frame_index).asTuple();
186 
187  // The model fitting module expects to get a PSF with a pixel scale, but we have the pixel sampling step size
188  // It will be used to compute the rastering grid size, and after convolving with the PSF the result will be
189  // downscaled before copied into the frame image.
190  // We can multiply here then, as the unit is pixel/pixel, rather than "/pixel or similar
191  auto group_psf = ImagePsf(pixel_scale * psf_property.getPixelSampling(), psf_property.getPsf());
192 
193  std::vector<ConstantModel> constant_models;
194  std::vector<PointModel> point_models;
196 
197  for (auto& source : group) {
198  for (auto model : frame->getModels()) {
199  model->addForSource(manager, source, constant_models, point_models, extended_models, jacobian, ref_coordinates, frame_coordinates,
200  stamp_rect.getTopLeft());
201  }
202  }
203 
204  // Full frame model with all sources
206  pixel_scale, (size_t) stamp_rect.getWidth(), (size_t) stamp_rect.getHeight(),
207  std::move(constant_models), std::move(point_models), std::move(extended_models), group_psf);
208 
209  return frame_model;
210 }
211 
212 
214  double pixel_scale = 1;
215  FlexibleModelFittingParameterManager parameter_manager;
216  ModelFitting::EngineParameterManager engine_parameter_manager{};
217  int n_free_parameters = 0;
218 
219  {
221 
222  // Prepare parameters
223  for (auto& source : group) {
224  for (auto parameter : m_parameters) {
225  if (std::dynamic_pointer_cast<FlexibleModelFittingFreeParameter>(parameter)) {
226  ++n_free_parameters;
227  }
228  parameter_manager.addParameter(source, parameter,
229  parameter->create(parameter_manager, engine_parameter_manager, source));
230  }
231  }
232  }
233 
234  try {
235  // Reset access checks, as a dependent parameter could have triggered it
236  parameter_manager.clearAccessCheck();
237 
238  // Add models for all frames
239  ResidualEstimator res_estimator{};
240 
241  int valid_frames = 0;
242  int n_good_pixels = 0;
243  for (auto frame : m_frames) {
244  int frame_index = frame->getFrameNb();
245  // Validate that each frame covers the model fitting region
246  if (isFrameValid(group, frame_index)) {
247  valid_frames++;
248 
249  auto frame_model = createFrameModel(group, pixel_scale, parameter_manager, frame);
250 
251  auto image = createImageCopy(group, frame_index);
252  auto weight = createWeightImage(group, frame_index);
253 
254  for (int y = 0; y < weight->getHeight(); ++y) {
255  for (int x = 0; x < weight->getWidth(); ++x) {
256  n_good_pixels += (weight->at(x, y) != 0.);
257  }
258  }
259 
260  // Setup residuals
261  auto data_vs_model =
262  createDataVsModelResiduals(image, std::move(frame_model), weight,
263  //LogChiSquareComparator(m_modified_chi_squared_scale));
265  res_estimator.registerBlockProvider(std::move(data_vs_model));
266  }
267  }
268 
269  // Check that we had enough data for the fit
270  Flags group_flags = Flags::NONE;
271  if (valid_frames == 0) {
272  group_flags = Flags::OUTSIDE;
273  }
274  else if (n_good_pixels < n_free_parameters) {
275  group_flags = Flags::INSUFFICIENT_DATA;
276  }
277 
278  if (group_flags != Flags::NONE) {
279  setDummyProperty(group, parameter_manager, group_flags);
280  return;
281  }
282 
283  // Add priors
284  for (auto& source : group) {
285  for (auto prior : m_priors) {
286  prior->setupPrior(parameter_manager, source, res_estimator);
287  }
288  }
289 
290  // Model fitting
291 
292  // FIXME we can no longer specify different settings with LeastSquareEngineManager!!
293  // LevmarEngine engine{m_max_iterations, 1E-3, 1E-6, 1E-6, 1E-6, 1E-4};
295  auto solution = engine->solveProblem(engine_parameter_manager, res_estimator);
296  size_t iterations = (size_t) boost::any_cast<std::array<double, 10>>(solution.underlying_framework_info)[5];
297 
298  int total_data_points = 0;
299  SeFloat avg_reduced_chi_squared = computeChiSquared(group, pixel_scale, parameter_manager, total_data_points);
300 
301  int nb_of_free_parameters = 0;
302  for (auto& source : group) {
303  for (auto parameter : m_parameters) {
304  bool is_free_parameter = std::dynamic_pointer_cast<FlexibleModelFittingFreeParameter>(parameter).get();
305  bool accessed_by_modelfitting = parameter_manager.isParamAccessed(source, parameter);
306  if (is_free_parameter && accessed_by_modelfitting) {
307  nb_of_free_parameters++;
308  }
309  }
310  }
311  avg_reduced_chi_squared /= (total_data_points - nb_of_free_parameters);
312 
313  // Collect parameters for output
314  for (auto& source : group) {
315  std::unordered_map<int, double> parameter_values, parameter_sigmas;
316  auto source_flags = Flags::NONE;
317 
318  for (auto parameter : m_parameters) {
319  bool is_dependent_parameter = std::dynamic_pointer_cast<FlexibleModelFittingDependentParameter>(parameter).get();
320  bool accessed_by_modelfitting = parameter_manager.isParamAccessed(source, parameter);
321  auto modelfitting_parameter = parameter_manager.getParameter(source, parameter);
322 
323  if (is_dependent_parameter || accessed_by_modelfitting) {
324  parameter_values[parameter->getId()] = modelfitting_parameter->getValue();
325  parameter_sigmas[parameter->getId()] = parameter->getSigma(parameter_manager, source, solution.parameter_sigmas);
326  }
327  else {
328  // Need to cascade the NaN to any potential dependent parameter
329  auto engine_parameter = std::dynamic_pointer_cast<EngineParameter>(modelfitting_parameter);
330  if (engine_parameter) {
331  engine_parameter->setEngineValue(std::numeric_limits<double>::quiet_NaN());
332  }
333  parameter_values[parameter->getId()] = std::numeric_limits<double>::quiet_NaN();
334  parameter_sigmas[parameter->getId()] = std::numeric_limits<double>::quiet_NaN();
336  }
337  }
338  source.setProperty<FlexibleModelFitting>(iterations, avg_reduced_chi_squared, source_flags, parameter_values,
339  parameter_sigmas);
340  }
341  updateCheckImages(group, pixel_scale, parameter_manager);
342 
343  }
344  catch (const Elements::Exception& e) {
345  logger.error() << "An exception occured during model fitting: " << e.what();
346  setDummyProperty(group, parameter_manager, Flags::ERROR);
347  }
348 }
349 
350 // Used to set a dummy property in case of error that contains no result but just an error flag
352  for (auto& source : group) {
353  std::unordered_map<int, double> dummy_values;
354  for (auto parameter : m_parameters) {
355  auto modelfitting_parameter = parameter_manager.getParameter(source, parameter);
356  auto manual_parameter = std::dynamic_pointer_cast<ManualParameter>(modelfitting_parameter);
357  if (manual_parameter) {
358  manual_parameter->setValue(std::numeric_limits<double>::quiet_NaN());
359  }
360  dummy_values[parameter->getId()] = std::numeric_limits<double>::quiet_NaN();
361  }
362  source.setProperty<FlexibleModelFitting>(0, std::numeric_limits<double>::quiet_NaN(), flags,
363  dummy_values, dummy_values);
364  }
365 }
366 
368  double pixel_scale, FlexibleModelFittingParameterManager& manager) const {
369 
370  int frame_id = 0;
371  for (auto frame : m_frames) {
372  int frame_index = frame->getFrameNb();
373  // Validate that each frame covers the model fitting region
374  if (isFrameValid(group, frame_index)) {
375  auto frame_model = createFrameModel(group, pixel_scale, manager, frame);
376  auto final_stamp = frame_model.getImage();
377 
378  auto stamp_rect = group.getProperty<MeasurementFrameGroupRectangle>(frame_index);
379  auto frame = group.begin()->getProperty<MeasurementFrame>(frame_index).getFrame();
380 
381  auto debug_image = CheckImages::getInstance().getModelFittingImage(frame);
382  if (debug_image) {
384  for (int x = 0; x < final_stamp->getWidth(); x++) {
385  for (int y = 0; y < final_stamp->getHeight(); y++) {
386  auto x_coord = stamp_rect.getTopLeft().m_x + x;
387  auto y_coord = stamp_rect.getTopLeft().m_y + y;
388  debug_image->setValue(x_coord, y_coord,
389  debug_image->getValue(x_coord, y_coord) + final_stamp->getValue(x, y));
390  }
391  }
392  }
393  }
394  frame_id++;
395  }
396 }
397 
399  std::shared_ptr<const Image<SeFloat>> model, std::shared_ptr<const Image<SeFloat>> weights, int& data_points) const {
400  double reduced_chi_squared = 0.0;
401  data_points = 0;
402  for (int y=0; y < image->getHeight(); y++) {
403  for (int x=0; x < image->getWidth(); x++) {
404  double tmp = image->getValue(x, y) - model->getValue(x, y);
405  reduced_chi_squared += tmp * tmp * weights->getValue(x, y) * weights->getValue(x, y);
406  if (weights->getValue(x, y) > 0) {
407  data_points++;
408  }
409  }
410  }
411  return reduced_chi_squared;
412 }
413 
415  double pixel_scale, FlexibleModelFittingParameterManager& manager, int& total_data_points) const {
416 
417  SeFloat total_chi_squared = 0;
418  total_data_points = 0;
419  int valid_frames = 0;
420  for (auto frame : m_frames) {
421  int frame_index = frame->getFrameNb();
422  // Validate that each frame covers the model fitting region
423  if (isFrameValid(group, frame_index)) {
424  valid_frames++;
425  auto frame_model = createFrameModel(group, pixel_scale, manager, frame);
426  auto final_stamp = frame_model.getImage();
427 
428  auto stamp_rect = group.getProperty<MeasurementFrameGroupRectangle>(frame_index);
429  auto image = createImageCopy(group, frame_index);
430  auto weight = createWeightImage(group, frame_index);
431 
432  int data_points = 0;
433  SeFloat chi_squared = computeChiSquaredForFrame(
434  image, final_stamp, weight, data_points);
435 
436  total_data_points += data_points;
437  total_chi_squared += chi_squared;
438  }
439  }
440 
441  return total_chi_squared;
442 }
443 
445 }
446 
447 }
ModelFitting::ResidualEstimator
Provides to the LeastSquareEngine the residual values.
Definition: ResidualEstimator.h:50
SourceXtractor::FlexibleModelFittingParameterManager::clearAccessCheck
void clearAccessCheck()
Definition: FlexibleModelFittingParameterManager.h:72
MeasurementFrame.h
std::lock
T lock(T... args)
Jacobian.h
AsinhChiSquareComparator.h
ModelFitting::LeastSquareEngineManager::create
static std::shared_ptr< LeastSquareEngine > create(const std::string &name, unsigned max_iterations=1000)
Definition: LeastSquareEngineManager.cpp:65
std::string
STL class.
std::shared_ptr
STL class.
CheckImages.h
SourceXtractor::FlexibleModelFittingTask::~FlexibleModelFittingTask
virtual ~FlexibleModelFittingTask()
Definition: FlexibleModelFittingTask.cpp:444
VectorImageDataVsModelInputTraits.h
std::move
T move(T... args)
SourceXtractor::ImagePsf
Definition: ImagePsf.h:37
__attribute__
#define __attribute__(x)
MeasurementFramePixelCentroid.h
std::numeric_limits::quiet_NaN
T quiet_NaN(T... args)
ResidualEstimator.h
SourceXtractor::SeFloat
SeFloat32 SeFloat
Definition: Types.h:32
std::vector
STL class.
SourceXtractor::FlexibleModelFittingTask::computeProperties
virtual void computeProperties(SourceGroupInterface &group) const override
Computes one or more properties for the SourceGroup and/or the Sources it contains.
Definition: FlexibleModelFittingTask.cpp:213
FlexibleModelFittingTask.h
SourceXtractor::Flags::ERROR
@ ERROR
Error flag: something bad happened during the measurement, model fitting, etc.
SourceXtractor::JacobianGroup
Definition: Jacobian.h:56
DetectionFrame.h
std::lock_guard
STL class.
SourceXtractor::FlexibleModelFittingTask::setDummyProperty
void setDummyProperty(SourceGroupInterface &group, FlexibleModelFittingParameterManager &parameter_manager, Flags flags) const
Definition: FlexibleModelFittingTask.cpp:351
SourceXtractor::Flags
Flags
Flagging of bad sources.
Definition: SourceFlags.h:34
SourceXtractor::FlexibleModelFittingTask::computeChiSquared
SeFloat computeChiSquared(SourceGroupInterface &group, double pixel_scale, FlexibleModelFittingParameterManager &manager, int &total_data_points) const
Definition: FlexibleModelFittingTask.cpp:414
SourceXtractor::CheckImages::getModelFittingImage
std::shared_ptr< WriteableImage< MeasurementImage::PixelType > > getModelFittingImage(std::shared_ptr< const MeasurementImageFrame > frame)
Definition: CheckImages.cpp:171
SourceXtractor::MultithreadedMeasurement::g_global_mutex
static std::recursive_mutex g_global_mutex
Definition: MultithreadedMeasurement.h:54
ModelFitting::AsinhChiSquareComparator
Data vs model comparator which computes a modified residual, using asinh.
Definition: AsinhChiSquareComparator.h:40
SourceXtractor::Image< SeFloat >
FrameModel.h
SourceXtractor::Flags::PARTIAL_FIT
@ PARTIAL_FIT
Some/all of the model parameters could not be fitted.
std::sqrt
T sqrt(T... args)
SourceXtractor::SourceGroupInterface::getProperty
const PropertyType & getProperty(unsigned int index=0) const
Convenience template method to call getProperty() with a more user-friendly syntax.
Definition: SourceInterface.h:57
std::fill
T fill(T... args)
SourceXtractor::FlexibleModelFittingTask::isFrameValid
bool isFrameValid(SourceGroupInterface &group, int frame_index) const
Definition: FlexibleModelFittingTask.cpp:112
SourceXtractor::FlexibleModelFittingParameterManager
Definition: FlexibleModelFittingParameterManager.h:43
MeasurementFrameGroupRectangle.h
SourceXtractor::MeasurementFrameGroupRectangle::getWidth
int getWidth() const
Definition: MeasurementFrameGroupRectangle.h:55
SourceXtractor::CheckImages::getInstance
static CheckImages & getInstance()
Definition: CheckImages.h:114
SourceXtractor::source_flags
static StaticPlugin< SourceFlagsPlugin > source_flags
Definition: SourceFlagsPlugin.cpp:43
SourceXtractor
Definition: Aperture.h:30
SourceXtractor::FlexibleModelFittingTask::createWeightImage
std::shared_ptr< VectorImage< SeFloat > > createWeightImage(SourceGroupInterface &group, int frame_index) const
Definition: FlexibleModelFittingTask.cpp:135
SourceXtractor::FlexibleModelFittingTask::m_frames
std::vector< std::shared_ptr< FlexibleModelFittingFrame > > m_frames
Definition: FlexibleModelFittingTask.h:82
pixel_scale
const double pixel_scale
Definition: TestImage.cpp:75
SourceXtractor::FlexibleModelFittingParameterManager::getParameter
std::shared_ptr< ModelFitting::BasicParameter > getParameter(const SourceInterface &source, std::shared_ptr< const FlexibleModelFittingParameter > parameter) const
Definition: FlexibleModelFittingParameterManager.h:51
SourceXtractor::PsfProperty
Definition: PsfProperty.h:32
SourceXtractor::MeasurementFrameGroupRectangle
Definition: MeasurementFrameGroupRectangle.h:33
SourceXtractor::FlexibleModelFittingTask::updateCheckImages
void updateCheckImages(SourceGroupInterface &group, double pixel_scale, FlexibleModelFittingParameterManager &manager) const
Definition: FlexibleModelFittingTask.cpp:367
std::cerr
SourceXtractor::FlexibleModelFittingParameterManager::isParamAccessed
bool isParamAccessed(const SourceInterface &source, std::shared_ptr< const FlexibleModelFittingParameter > parameter) const
Definition: FlexibleModelFittingParameterManager.h:76
ManualParameter.h
LeastSquareEngineManager.h
SourceXtractor::FlexibleModelFittingTask::m_parameters
std::vector< std::shared_ptr< FlexibleModelFittingParameter > > m_parameters
Definition: FlexibleModelFittingTask.h:81
std::array
STL class.
PointModel.h
ModelFitting::EngineParameterManager
Class responsible for managing the parameters the least square engine minimizes.
Definition: EngineParameterManager.h:61
SourceXtractor::DetectionFrame
Definition: DetectionFrame.h:33
SourceXtractor::VectorImage::create
static std::shared_ptr< VectorImage< T > > create(Args &&... args)
Definition: VectorImage.h:89
Elements::Exception
SourceXtractor::FlexibleModelFittingTask::m_priors
std::vector< std::shared_ptr< FlexibleModelFittingPrior > > m_priors
Definition: FlexibleModelFittingTask.h:83
SourceXtractor::MeasurementFrame
Definition: MeasurementFrame.h:36
PsfProperty.h
SourceXtractor::SourceGroupInterface::begin
virtual iterator begin()=0
SourceXtractor::Flags::INSUFFICIENT_DATA
@ INSUFFICIENT_DATA
There are not enough good pixels to fit the parameters.
FlexibleModelFitting.h
SourceXtractor::logger
static Elements::Logging logger
Definition: PluginManager.cpp:45
e
constexpr double e
Elements::Logging::getLogger
static Logging getLogger(const std::string &name="")
SourceXtractor::Flags::NONE
@ NONE
No flag is set.
SourceXtractor::Flags::OUTSIDE
@ OUTSIDE
The object is completely outside of the measurement frame.
SourceXtractor::FlexibleModelFitting
Definition: FlexibleModelFitting.h:40
SourceXtractor::FlexibleModelFittingTask::m_least_squares_engine
std::string m_least_squares_engine
Definition: FlexibleModelFittingTask.h:77
ExtendedModel.h
SourceXtractor::SourceGroupInterface
Defines the interface used to group sources.
Definition: SourceGroupInterface.h:37
x
std::shared_ptr< DependentParameter< std::shared_ptr< EngineParameter > > > x
Definition: MoffatModelFittingTask.cpp:93
SourceXtractor::FlexibleModelFittingTask::createFrameModel
ModelFitting::FrameModel< ImagePsf, std::shared_ptr< VectorImage< SourceXtractor::SeFloat > > > createFrameModel(SourceGroupInterface &group, double pixel_scale, FlexibleModelFittingParameterManager &manager, std::shared_ptr< FlexibleModelFittingFrame > frame) const
Definition: FlexibleModelFittingTask.cpp:171
MultithreadedMeasurement.h
printLevmarInfo
void printLevmarInfo(std::array< double, 10 > info)
Definition: utils.h:118
SourceXtractor::FlexibleModelFittingTask::FlexibleModelFittingTask
FlexibleModelFittingTask(const std::string &least_squares_engine, unsigned int max_iterations, double modified_chi_squared_scale, std::vector< std::shared_ptr< FlexibleModelFittingParameter >> parameters, std::vector< std::shared_ptr< FlexibleModelFittingFrame >> frames, std::vector< std::shared_ptr< FlexibleModelFittingPrior >> priors)
Definition: FlexibleModelFittingTask.cpp:103
ModelFitting::FrameModel
Definition: FrameModel.h:125
SourceXtractor::FlexibleModelFittingTask::m_max_iterations
unsigned int m_max_iterations
Definition: FlexibleModelFittingTask.h:78
Elements::Logging::error
void error(const std::string &logMessage)
std::size_t
TransformedModel.h
SourceXtractor::FlexibleModelFittingParameterManager::addParameter
void addParameter(const SourceInterface &source, std::shared_ptr< const FlexibleModelFittingParameter > parameter, std::shared_ptr< ModelFitting::BasicParameter > engine_parameter)
Definition: FlexibleModelFittingParameterManager.h:59
y
std::shared_ptr< DependentParameter< std::shared_ptr< EngineParameter > > > y
Definition: MoffatModelFittingTask.cpp:93
SourceXtractor::FlexibleModelFittingTask::computeChiSquaredForFrame
SeFloat computeChiSquaredForFrame(std::shared_ptr< const Image< SeFloat >> image, std::shared_ptr< const Image< SeFloat >> model, std::shared_ptr< const Image< SeFloat >> weights, int &data_points) const
Definition: FlexibleModelFittingTask.cpp:398
SourceXtractor::FlexibleModelFittingTask::createImageCopy
std::shared_ptr< VectorImage< SeFloat > > createImageCopy(SourceGroupInterface &group, int frame_index) const
Definition: FlexibleModelFittingTask.cpp:117
ModelFitting::createDataVsModelResiduals
std::unique_ptr< DataVsModelResiduals< typename std::remove_reference< DataType >::type, typename std::remove_reference< ModelType >::type, typename std::remove_reference< WeightType >::type, typename std::remove_reference< Comparator >::type > > createDataVsModelResiduals(DataType &&data, ModelType &&model, WeightType &&weight, Comparator &&comparator)
ModelFitting
Definition: AsinhChiSquareComparator.h:30
std::unordered_map< int, double >
std::numeric_limits
SourceXtractor::FlexibleModelFittingTask::m_modified_chi_squared_scale
double m_modified_chi_squared_scale
Definition: FlexibleModelFittingTask.h:79
DataVsModelResiduals.h
LogChiSquareComparator.h
ImagePsf.h
FlexibleModelFittingParameterManager.h