propagate config for and fix DownsampledPsf

Author: marcschefer

SEImplementation/SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingIterativeTask.h

@@ -27,12 +27,12 @@
 #include "SEFramework/Image/VectorImage.h"
 #include "SEFramework/Task/GroupTask.h"
 
-//#include "SEImplementation/Configuration/SamplingConfig.h"
-
 #include "SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingParameter.h"
 #include "SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingFrame.h"
 #include "SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingPrior.h"
 
+#include "SEImplementation/Image/DownSampledImagePsf.h"
+
 namespace SourceXtractor {
 
 class FlexibleModelFittingIterativeTask : public GroupTask {
@@ -43,6 +43,7 @@ class FlexibleModelFittingIterativeTask : public GroupTask {
       std::vector<std::shared_ptr<FlexibleModelFittingParameter>> parameters,
       std::vector<std::shared_ptr<FlexibleModelFittingFrame>> frames,
       std::vector<std::shared_ptr<FlexibleModelFittingPrior>> priors,
+      std::vector<bool> should_renormalize,
       double scale_factor=1.0,
       int meta_iterations=3,
       double deblend_factor=1.0,
@@ -98,6 +99,11 @@ class FlexibleModelFittingIterativeTask : public GroupTask {
       ModelFitting::LeastSquareSummary solution,
       int index, FittingState& state) const;
 
+  ModelFitting::FrameModel<DownSampledImagePsf, std::shared_ptr<VectorImage<SourceXtractor::SeFloat>>> createFrameModel(
+      SourceInterface& source, double pixel_scale, FlexibleModelFittingParameterManager& manager,
+      std::shared_ptr<FlexibleModelFittingFrame> frame, PixelRectangle stamp_rect, double down_scaling=1.0) const;
+
+
   // Task configuration
   std::string m_least_squares_engine;
   unsigned int m_max_iterations;
@@ -111,6 +117,8 @@ class FlexibleModelFittingIterativeTask : public GroupTask {
   std::vector<std::shared_ptr<FlexibleModelFittingParameter>> m_parameters;
   std::vector<std::shared_ptr<FlexibleModelFittingFrame>> m_frames;
   std::vector<std::shared_ptr<FlexibleModelFittingPrior>> m_priors;
+
+  std::vector<bool> m_should_renormalize;
 };
 
 }

SEImplementation/SEImplementation/Plugin/FlexibleModelFitting/FlexibleModelFittingTaskFactory.h

@@ -60,6 +60,9 @@ class FlexibleModelFittingTaskFactory : public TaskFactory {
 
   double m_scale_factor {1.0};
   double m_max_fit_size {100};
+
+  // should we renormalize the PSF for each frame?
+  std::vector<bool> m_should_renormalize;
 };
 
 }

SEImplementation/python/sourcextractor/config/measurement_images.py

@@ -205,7 +205,6 @@ def __init__(self, fits_file, psf_file=None, weight_file=None, gain=None,
             self._set_checked('weight_hdu', weight_hdu)
 
         self.psf_renormalize = psf_renormalize
-        print(self.psf_renormalize)
 
     def __str__(self):
         """

SEImplementation/src/lib/Image/DownSampledImagePsf.cpp

@@ -58,9 +58,11 @@ DownSampledImagePsf::DownSampledImagePsf(
           pixel /= psf_sum;
         }
       } else {
-        double area_factor = 1.0 / (down_scaling * down_scaling);
+        auto original_psf_sum = std::accumulate(image->getData().begin(), image->getData().end(), 0.);
+        auto new_psf_sum = std::accumulate(new_image->getData().begin(), new_image->getData().end(), 0.);
+
         for (auto& pixel : new_image->getData()) {
-          pixel *= area_factor;
+          pixel *= original_psf_sum / new_psf_sum;
         }
       }
 

SEImplementation/src/lib/Plugin/FlexibleModelFitting/FlexibleModelFittingIterativeTask.cpp

@@ -21,7 +21,6 @@
 #include "ModelFitting/Engine/LeastSquareEngineManager.h"
 
 #include "SEImplementation/Image/ImagePsf.h"
-#include "SEImplementation/Image/DownSampledImagePsf.h"
 #include "SEImplementation/Image/VectorImageDataVsModelInputTraits.h"
 
 #include "SEImplementation/CheckImages/CheckImages.h"
@@ -51,6 +50,7 @@ FlexibleModelFittingIterativeTask::FlexibleModelFittingIterativeTask(const std::
     std::vector<std::shared_ptr<FlexibleModelFittingParameter>> parameters,
     std::vector<std::shared_ptr<FlexibleModelFittingFrame>> frames,
     std::vector<std::shared_ptr<FlexibleModelFittingPrior>> priors,
+    std::vector<bool> should_renormalize,
     double scale_factor,
     int meta_iterations,
     double deblend_factor,
@@ -59,8 +59,8 @@ FlexibleModelFittingIterativeTask::FlexibleModelFittingIterativeTask(const std::
     : m_least_squares_engine(least_squares_engine), m_max_iterations(max_iterations),
       m_modified_chi_squared_scale(modified_chi_squared_scale), m_scale_factor(scale_factor),
       m_meta_iterations(meta_iterations), m_deblend_factor(deblend_factor), m_meta_iteration_stop(meta_iteration_stop),
-      m_max_fit_size(max_fit_size * max_fit_size), m_parameters(parameters), m_frames(frames), m_priors(priors) {
-}
+      m_max_fit_size(max_fit_size * max_fit_size), m_parameters(parameters), m_frames(frames), m_priors(priors),
+      m_should_renormalize(should_renormalize) {}
 
 FlexibleModelFittingIterativeTask::~FlexibleModelFittingIterativeTask() {
 }
@@ -142,9 +142,12 @@ std::shared_ptr<VectorImage<SeFloat>> createWeightImage(SourceInterface& source,
   return weight;
 }
 
-FrameModel<DownSampledImagePsf, std::shared_ptr<VectorImage<SourceXtractor::SeFloat>>> createFrameModel(
+} // anonymous namespace
+
+FrameModel<DownSampledImagePsf, std::shared_ptr<VectorImage<SourceXtractor::SeFloat>>>
+FlexibleModelFittingIterativeTask::createFrameModel(
     SourceInterface& source, double pixel_scale, FlexibleModelFittingParameterManager& manager,
-    std::shared_ptr<FlexibleModelFittingFrame> frame, PixelRectangle stamp_rect, double down_scaling=1.0) {
+    std::shared_ptr<FlexibleModelFittingFrame> frame, PixelRectangle stamp_rect, double down_scaling) const {
 
   int frame_index = frame->getFrameNb();
 
@@ -158,7 +161,8 @@ FrameModel<DownSampledImagePsf, std::shared_ptr<VectorImage<SourceXtractor::SeFl
   // It will be used to compute the rastering grid size, and after convolving with the PSF the result will be
   // downscaled before copied into the frame image.
   // We can multiply here then, as the unit is pixel/pixel, rather than "/pixel or similar
-  auto source_psf = DownSampledImagePsf(psf_property.getPixelSampling(), psf_property.getPsf(), down_scaling);
+  auto source_psf = DownSampledImagePsf(psf_property.getPixelSampling(), psf_property.getPsf(),
+      down_scaling, m_should_renormalize[frame_index]);
 
   std::vector<ConstantModel> constant_models;
   std::vector<PointModel> point_models;
@@ -178,9 +182,6 @@ FrameModel<DownSampledImagePsf, std::shared_ptr<VectorImage<SourceXtractor::SeFl
   return frame_model;
 }
 
-}
-
-
 void FlexibleModelFittingIterativeTask::computeProperties(SourceGroupInterface& group) const {
   FittingState fitting_state;
 

SEImplementation/src/lib/Plugin/FlexibleModelFitting/FlexibleModelFittingTaskFactory.cpp

@@ -29,6 +29,7 @@
 
 #include "SEImplementation/Configuration/ModelFittingConfig.h"
 #include "SEImplementation/Configuration/SamplingConfig.h"
+#include "SEImplementation/Configuration/MeasurementImageConfig.h"
 
 namespace SourceXtractor {
 
@@ -38,7 +39,7 @@ std::shared_ptr<Task> FlexibleModelFittingTaskFactory::createTask(const Property
   if (property_id == PropertyId::create<FlexibleModelFitting>()) {
     if (m_use_iterative_fitting) {
       return std::make_shared<FlexibleModelFittingIterativeTask>(m_least_squares_engine, m_max_iterations,
-          m_modified_chi_squared_scale, m_parameters, m_frames, m_priors, m_scale_factor,
+          m_modified_chi_squared_scale, m_parameters, m_frames, m_priors, m_should_renormalize, m_scale_factor,
           m_meta_iterations, m_deblend_factor, m_meta_iteration_stop, m_max_fit_size);
     } else {
       return std::make_shared<FlexibleModelFittingTask>(m_least_squares_engine, m_max_iterations,
@@ -51,6 +52,8 @@ std::shared_ptr<Task> FlexibleModelFittingTaskFactory::createTask(const Property
 
 void FlexibleModelFittingTaskFactory::reportConfigDependencies(Euclid::Configuration::ConfigManager& manager) const {
   manager.registerConfiguration<ModelFittingConfig>();
+  manager.registerConfiguration<SamplingConfig>();
+  manager.registerConfiguration<MeasurementImageConfig>();
 }
 
 void FlexibleModelFittingTaskFactory::configure(Euclid::Configuration::ConfigManager& manager) {
@@ -90,6 +93,11 @@ void FlexibleModelFittingTaskFactory::configure(Euclid::Configuration::ConfigMan
 
   m_scale_factor = sampling_config.getScaleFactor();
   m_max_fit_size = sampling_config.getMaxFitSize();
+
+  const auto& image_infos = manager.getConfiguration<MeasurementImageConfig>().getImageInfos();
+  for (const auto& info : image_infos) {
+    m_should_renormalize.push_back(info.m_psf_renormalize);
+  }
 }
 
 void FlexibleModelFittingTaskFactory::registerPropertyInstances(OutputRegistry& registry) {