diff --git a/src/include/stir/scatter/ScatterEstimation.h b/src/include/stir/scatter/ScatterEstimation.h
index 0c398d60e..c5001fb30 100644
--- a/src/include/stir/scatter/ScatterEstimation.h
+++ b/src/include/stir/scatter/ScatterEstimation.h
@@ -39,7 +39,7 @@
 
 #include "stir/stir_math.h"
 #include "stir/FilePath.h"
-#include <stir/recon_buildblock/ForwardProjectorByBin.h>
+#include "stir/recon_buildblock/ForwardProjectorByBin.h"
 
 START_NAMESPACE_STIR
 
@@ -172,9 +172,9 @@ class ScatterEstimation : public ParsingObject
   void set_recompute_mask_projdata(bool arg);
 
   //! Sets the forward projector for the scatter estimation
-  void set_forward_projector_sptr(const shared_ptr<ForwardProjectorByBin> projector_sptr);
-  //!Get the forward projector used for the scatter estimation
-  shared_ptr<ForwardProjectorByBin> get_forward_projector_sptr() const;
+  void set_forward_projector_for_mask_sptr(const shared_ptr<ForwardProjectorByBin> projector_sptr);
+  //! Get the forward projector used for the scatter estimation mask calculation
+  shared_ptr<ForwardProjectorByBin> get_forward_projector_for_mask_sptr() const;
 
   inline void set_scatter_simulation_method_sptr(const shared_ptr<ScatterSimulation>);
 
@@ -282,7 +282,7 @@ class ScatterEstimation : public ParsingObject
   //! If they are to be recalculated they will be stored here, if set.
   std::string atten_coeff_filename;
   //! ForwardProjector
-  shared_ptr<ForwardProjectorByBin> forward_projector_sptr;
+  shared_ptr<ForwardProjectorByBin> forward_projector_for_mask_sptr;
 
   //! \details the set of parameters to obtain a mask from the attenuation image
   /*! The attenuation image will be thresholded to find a plausible mask for where there
diff --git a/src/scatter_buildblock/ScatterEstimation.cxx b/src/scatter_buildblock/ScatterEstimation.cxx
index e555eef14..b2b80df56 100644
--- a/src/scatter_buildblock/ScatterEstimation.cxx
+++ b/src/scatter_buildblock/ScatterEstimation.cxx
@@ -114,7 +114,7 @@ ScatterEstimation::initialise_keymap()
   // END MASK
 
   // Forward projector for mask projection
-  this->parser.add_parsing_key("forward projector type", &this->forward_projector_sptr);
+  this->parser.add_parsing_key("forward projector for mask type", &this->forward_projector_for_mask_sptr);
 
   this->parser.add_key("background projdata filename", &this->back_projdata_filename);
   this->parser.add_parsing_key("Normalisation type", &this->norm_3d_sptr);
@@ -454,15 +454,15 @@ ScatterEstimation::set_recompute_mask_projdata(bool arg)
 }
 
 void
-ScatterEstimation::set_forward_projector_sptr(const shared_ptr<ForwardProjectorByBin> projector_sptr)
+ScatterEstimation::set_forward_projector_for_mask_sptr(const shared_ptr<ForwardProjectorByBin> projector_sptr)
 {
-  this->forward_projector_sptr = projector_sptr;
+  this->forward_projector_for_mask_sptr = projector_sptr;
 }
 
 shared_ptr<ForwardProjectorByBin>
-ScatterEstimation::get_forward_projector_sptr() const
+ScatterEstimation::get_forward_projector_for_mask_sptr() const
 {
-  return forward_projector_sptr;
+  return forward_projector_for_mask_sptr;
 }
 
 bool
@@ -1251,32 +1251,32 @@ ScatterEstimation::project_mask_image()
         }
     }
 
-  if (!this->forward_projector_sptr)
+  if (!this->forward_projector_for_mask_sptr)
     {
       shared_ptr<ProjMatrixByBin> PM(new ProjMatrixByBinUsingRayTracing());
-      forward_projector_sptr.reset(new ForwardProjectorByBinUsingProjMatrixByBin(PM));
+      forward_projector_for_mask_sptr.reset(new ForwardProjectorByBinUsingProjMatrixByBin(PM));
     }
   info(boost::format("ScatterEstimation: Forward projector used for the calculation of "
                      "the tail mask: %1%")
-       % forward_projector_sptr->parameter_info());
+       % forward_projector_for_mask_sptr->parameter_info());
 
   shared_ptr<ProjData> mask_projdata;
   if (run_in_2d_projdata)
     {
-      forward_projector_sptr->set_up(this->input_projdata_2d_sptr->get_proj_data_info_sptr(), this->mask_image_sptr);
+      forward_projector_for_mask_sptr->set_up(this->input_projdata_2d_sptr->get_proj_data_info_sptr(), this->mask_image_sptr);
 
       mask_projdata.reset(new ProjDataInMemory(this->input_projdata_2d_sptr->get_exam_info_sptr(),
                                                this->input_projdata_2d_sptr->get_proj_data_info_sptr()));
     }
   else
     {
-      forward_projector_sptr->set_up(this->input_projdata_sptr->get_proj_data_info_sptr(), this->mask_image_sptr);
+      forward_projector_for_mask_sptr->set_up(this->input_projdata_sptr->get_proj_data_info_sptr(), this->mask_image_sptr);
 
       mask_projdata.reset(new ProjDataInMemory(this->input_projdata_sptr->get_exam_info_sptr(),
                                                this->input_projdata_sptr->get_proj_data_info_sptr()));
     }
 
-  forward_projector_sptr->forward_project(*mask_projdata, *this->mask_image_sptr);
+  forward_projector_for_mask_sptr->forward_project(*mask_projdata, *this->mask_image_sptr);
 
   // add 1 to be able to use create_tail_mask_from_ACFs (which expects ACFs,
   // so complains if the threshold is too low)