propagate renormalization configuration from MeasurementImage

Author: marcschefer

SEImplementation/SEImplementation/Configuration/MeasurementImageConfig.h

@@ -65,6 +65,8 @@ class MeasurementImageConfig : public Euclid::Configuration::Configuration {
     bool m_is_data_cube;
     int m_image_layer;
     int m_weight_layer;
+
+    bool m_psf_renormalize;
   };
 
   explicit MeasurementImageConfig(long manager_id);

SEImplementation/SEImplementation/Plugin/Psf/PsfPluginConfig.h

@@ -45,13 +45,8 @@ class PsfPluginConfig: public Euclid::Configuration::Configuration {
   static std::shared_ptr<Psf> readPsf(const std::string &filename, int hdu_number = 1);
   static std::shared_ptr<Psf> generateGaussianPsf(SeFloat fwhm, SeFloat pixel_sampling);
 
-  bool shouldNormalizePsf() const {
-    return m_psf_normalization;
-  }
-
 private:
   std::shared_ptr<Psf> m_vpsf;
-  bool m_psf_normalization { true };
 };
 
 } // end SourceXtractor

SEImplementation/SEImplementation/Plugin/SourcePsf/SourcePsfTask.h

@@ -27,7 +27,9 @@ class SourcePsfTask: public SourceTask {
 public:
   virtual ~SourcePsfTask() = default;
 
-  SourcePsfTask(unsigned instance, const std::shared_ptr<Psf> &vpsf);
+  SourcePsfTask(unsigned instance, const std::shared_ptr<Psf>& vpsf, bool normalize_psf = true)
+      : m_instance(instance), m_vpsf(vpsf), m_normalize_psf(normalize_psf) {
+  }
 
   void computeProperties(SourceInterface& source) const override;
 

SEImplementation/SEImplementation/Plugin/SourcePsf/SourcePsfTaskFactory.h

@@ -37,7 +37,13 @@ class SourcePsfTaskFactory: public TaskFactory {
   std::shared_ptr<Task> createTask(const PropertyId& property_id) const override;
 
 private:
-  std::map<int, std::shared_ptr<Psf>> m_vpsf;
+
+  struct PsfInfo {
+    std::shared_ptr<Psf> m_psf;
+    bool m_normalize_psf;
+  };
+
+  std::map<int, PsfInfo> m_psf_infos;
 };
 
 } // end SourceXtractor

SEImplementation/SEImplementation/PythonConfig/PyMeasurementImage.h

@@ -54,6 +54,8 @@ class PyMeasurementImage : public PyId {
   bool is_data_cube;
   int image_layer;
   int weight_layer;
+
+  bool psf_renormalize;
 };
 
 }

SEImplementation/python/sourcextractor/config/measurement_images.py

@@ -107,6 +107,8 @@ class MeasurementImage(cpp.MeasurementImage):
         For multi-extension FITS file specifies the HDU number for the psf. Defaults to the same value as image_hdu
     weight_hdu : int
         For multi-extension FITS file specifies the HDU number for the weight. Defaults to the same value as image_hdu
+    psf_renormalize : bool
+        If True, the PSF will be renormalized to have a total flux of 1.0. Default True
     """
 
     def _set_checked(self, attr_name, value):
@@ -122,7 +124,7 @@ def __init__(self, fits_file, psf_file=None, weight_file=None, gain=None,
                  flux_scale=None, flux_scale_keyword='FLXSCALE',
                  weight_type='none', weight_absolute=False, weight_scaling=1.,
                  weight_threshold=None, constant_background=None,
-                 image_hdu=0, psf_hdu=None, weight_hdu=None
+                 image_hdu=0, psf_hdu=None, weight_hdu=None, psf_renormalize=True
                  ):
         """
         Constructor.
@@ -201,6 +203,9 @@ def __init__(self, fits_file, psf_file=None, weight_file=None, gain=None,
             self._set_checked('weight_hdu', image_hdu)
         else:
             self._set_checked('weight_hdu', weight_hdu)
+            
+        self.psf_renormalize = psf_renormalize
+        print(self.psf_renormalize)
 
     def __str__(self):
         """

SEImplementation/src/lib/Configuration/MeasurementImageConfig.cpp

@@ -220,6 +220,8 @@ void MeasurementImageConfig::initialize(const UserValues&) {
       info.m_psf_hdu = py_image.psf_hdu + 1;
       info.m_weight_hdu = py_image.weight_hdu + 1;
 
+      info.m_psf_renormalize = py_image.psf_renormalize;
+
       m_image_infos.emplace_back(std::move(info));
     }
   } else {
@@ -252,10 +254,14 @@ void MeasurementImageConfig::initialize(const UserValues&) {
 
       0, // id
 
-      1,1,1 // HDUs
-    });
+      1,1,1, // HDUs
 
+      false, // is_data_cube
+      0, // image_layer
+      0, // weight_layer
 
+      true // psf_renormalize
+    });
   }
 }
 

SEImplementation/src/lib/Plugin/Psf/PsfPluginConfig.cpp

@@ -42,7 +42,6 @@ namespace SourceXtractor {
 static const std::string PSF_FILE{"psf-filename"};
 static const std::string PSF_FWHM {"psf-fwhm" };
 static const std::string PSF_PIXEL_SAMPLING {"psf-pixel-sampling" };
-static const std::string PSF_NORMALIZATION {"psf-normalization" };
 
 /*
  * Reading in a stacked PSF as it is being developed for co-added images in Euclid
@@ -232,9 +231,7 @@ std::map<std::string, Configuration::OptionDescriptionList> PsfPluginConfig::get
     {PSF_FWHM.c_str(), po::value<double>(),
        "Generate a gaussian PSF with the given full-width half-maximum (in pixels)"},
     {PSF_PIXEL_SAMPLING.c_str(), po::value<double>(),
-        "Generate a gaussian PSF with the given pixel sampling step size"},
-    {PSF_NORMALIZATION.c_str(), po::value<bool>()->default_value(true),
-        "Whether PSFs should be normalized"}
+        "Generate a gaussian PSF with the given pixel sampling step size"}
   }}};
 }
 
@@ -259,7 +256,6 @@ void PsfPluginConfig::initialize(const UserValues &args) {
     m_vpsf = generateGaussianPsf(args.find(PSF_FWHM)->second.as<double>(),
                                 args.find(PSF_PIXEL_SAMPLING)->second.as<double>());
   }
-  m_psf_normalization = args.find(PSF_NORMALIZATION)->second.as<bool>();
 }
 
 const std::shared_ptr<Psf>& PsfPluginConfig::getPsf() const {

SEImplementation/src/lib/Plugin/SourcePsf/SourcePsfTask.cpp

@@ -45,10 +45,6 @@ std::map<std::string, SourcePsfTask::ValueGetter> SourcePsfTask::component_value
   {"YMODEL_IMAGE", getCoordY}
 };
 
-SourcePsfTask::SourcePsfTask(unsigned instance, const std::shared_ptr<Psf> &vpsf)
-    : m_instance(instance), m_vpsf(vpsf) {
-}
-
 void SourcePsfTask::computeProperties(SourceXtractor::SourceInterface &source) const {
   if (m_vpsf != nullptr) {
     std::vector<double> component_values;
@@ -57,15 +53,14 @@ void SourcePsfTask::computeProperties(SourceXtractor::SourceInterface &source) c
       component_values.push_back(component_value_getters[component](source, m_instance));
     }
 
-    auto psf = m_vpsf->getPsf(component_values);
-    std::shared_ptr<VectorImage<SeFloat>> psf_normalized = psf;
+    std::shared_ptr<VectorImage<SeFloat>> psf = m_vpsf->getPsf(component_values);
 
     if (m_normalize_psf) {
       // The result may not be normalized!
       auto psf_sum = std::accumulate(psf->getData().begin(), psf->getData().end(), 0.);
-      psf_normalized = VectorImage<SeFloat>::create(*MultiplyImage<SeFloat>::create(psf, 1. / psf_sum));
+      psf = VectorImage<SeFloat>::create(*MultiplyImage<SeFloat>::create(psf, 1. / psf_sum));
     }
-    source.setIndexedProperty<SourcePsfProperty>(m_instance, m_vpsf->getPixelSampling(), psf_normalized);
+    source.setIndexedProperty<SourcePsfProperty>(m_instance, m_vpsf->getPixelSampling(), psf);
 
     // Check image
     auto check_image = CheckImages::getInstance().getPsfImage(m_instance);
@@ -74,7 +69,7 @@ void SourcePsfTask::computeProperties(SourceXtractor::SourceInterface &source) c
       auto y = component_value_getters["Y_IMAGE"](source, m_instance);
 
       ModelFitting::ImageTraits<ModelFitting::WriteableInterfaceTypePtr>::addImageToImage(
-        check_image, psf_normalized, m_vpsf->getPixelSampling(), x, y);
+        check_image, psf, m_vpsf->getPixelSampling(), x, y);
     }
   } else {
     source.setIndexedProperty<SourcePsfProperty>(m_instance, 1.0, nullptr);

SEImplementation/src/lib/Plugin/SourcePsf/SourcePsfTaskFactory.cpp

@@ -34,23 +34,27 @@ void SourcePsfTaskFactory::configure(Euclid::Configuration::ConfigManager& manag
 
   for (unsigned int i = 0; i < image_infos.size(); i++) {
     if (!image_infos[i].m_psf_path.empty()) {
-      m_vpsf[image_infos[i].m_id] = PsfPluginConfig::readPsf(image_infos[i].m_psf_path, image_infos[i].m_psf_hdu);
+      m_psf_infos[image_infos[i].m_id] = {
+          PsfPluginConfig::readPsf(image_infos[i].m_psf_path, image_infos[i].m_psf_hdu),
+          image_infos[i].m_psf_renormalize
+      };
     }
     else if (default_psf) {
-      m_vpsf[image_infos[i].m_id] = default_psf;
+      m_psf_infos[image_infos[i].m_id] = { default_psf, true };
     }
   }
 }
 
 std::shared_ptr<Task> SourcePsfTaskFactory::createTask(const SourceXtractor::PropertyId& property_id) const {
   auto instance = property_id.getIndex();
 
-  if (m_vpsf.find(instance) == m_vpsf.end()) {
+  if (m_psf_infos.find(instance) == m_psf_infos.end()) {
     throw Elements::Exception() << "Missing PSF. Make sure every frame has a PSF";
   }
 
   try {
-    return std::make_shared<SourcePsfTask>(instance, m_vpsf.at(instance));
+    return std::make_shared<SourcePsfTask>(
+        instance, m_psf_infos.at(instance).m_psf, m_psf_infos.at(instance).m_normalize_psf);
   } catch (const std::out_of_range&) {
     return nullptr;
   }