GGEMSDosimetryCalculator.hh

Go to the documentation of this file.

#ifndef GUARD_GGEMS_NAVIGATORS_GGEMSDOSIMETRYCALCULATOR_HH
#define GUARD_GGEMS_NAVIGATORS_GGEMSDOSIMETRYCALCULATOR_HH
 
// ************************************************************************
// * This file is part of GGEMS.                                          *
// *                                                                      *
// * GGEMS is free software: you can redistribute it and/or modify        *
// * it under the terms of the GNU General Public License as published by *
// * the Free Software Foundation, either version 3 of the License, or    *
// * (at your option) any later version.                                  *
// *                                                                      *
// * GGEMS is distributed in the hope that it will be useful,             *
// * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
// * GNU General Public License for more details.                         *
// *                                                                      *
// * You should have received a copy of the GNU General Public License    *
// * along with GGEMS.  If not, see <https://www.gnu.org/licenses/>.      *
// *                                                                      *
// ************************************************************************
 
#ifdef _MSC_VER
#pragma warning(disable: 4251) // Deleting warning exporting STL members!!!
#endif
 
#include "GGEMS/global/GGEMSExport.hh"
#include "GGEMS/tools/GGEMSTypes.hh"
#include "GGEMS/navigators/GGEMSDoseRecording.hh"
 
class GGEMSNavigator;
 
class GGEMS_EXPORT GGEMSDosimetryCalculator
{
  public:
    GGEMSDosimetryCalculator(void);
 
    ~GGEMSDosimetryCalculator(void);
 
    GGEMSDosimetryCalculator(GGEMSDosimetryCalculator const& dose_calculator) = delete;
 
    GGEMSDosimetryCalculator& operator=(GGEMSDosimetryCalculator const& dose_calculator) = delete;
 
    GGEMSDosimetryCalculator(GGEMSDosimetryCalculator const&& dose_calculator) = delete;
 
    GGEMSDosimetryCalculator& operator=(GGEMSDosimetryCalculator const&& dose_calculator) = delete;
 
    void AttachToNavigator(std::string const& navigator_name);
 
    void Initialize(void);
 
    void SetDoselSizes(GGfloat const& dosel_x, GGfloat const& dosel_y, GGfloat const& dosel_z, std::string const& unit = "mm");
 
    void SetOutputDosimetryBasename(std::string const& output_filename);
 
    void SetScaleFactor(GGfloat const& scale_factor);
 
    void SetPhotonTracking(bool const& is_activated);
 
    void SetEdep(bool const& is_activated);
 
    void SetHitTracking(bool const& is_activated);
 
    void SetEdepSquared(bool const& is_activated);
 
    void SetUncertainty(bool const& is_activated);
 
    void SetWaterReference(bool const& is_activated);
 
    void SetMinimumDensity(GGfloat const& minimum_density, std::string const& unit = "g/cm3");
 
    inline cl::Buffer* GetPhotonTrackingBuffer(GGsize const& thread_index) const {return dose_recording_.photon_tracking_[thread_index];}
 
    inline cl::Buffer* GetHitTrackingBuffer(GGsize const& thread_index) const {return dose_recording_.hit_[thread_index];}
 
    inline cl::Buffer* GetEdepBuffer(GGsize const& thread_index) const {return dose_recording_.edep_[thread_index];}
 
    inline cl::Buffer* GetEdepSquaredBuffer(GGsize const& thread_index) const {return dose_recording_.edep_squared_[thread_index];}
 
    inline cl::Buffer* GetDoseParams(GGsize const& thread_index) const {return dose_params_[thread_index];}
 
    void ComputeDose(GGsize const& thread_index);
 
    void SaveResults(void) const;
 
  private:
    void CheckParameters(void) const;
 
    void InitializeKernel(void);
 
    void SavePhotonTracking(void) const;
 
    void SaveHit(void) const;
 
    void SaveEdep(void) const;
 
    void SaveDose(void) const;
 
    void SaveEdepSquared(void) const;
 
    void SaveUncertainty(void) const;
 
  private:
    GGfloat3 dosel_sizes_; 
    GGsize total_number_of_dosels_; 
    std::string dosimetry_output_filename_; 
    GGEMSNavigator* navigator_; 
    // Buffer storing dose data on OpenCL device and host
    cl::Buffer** dose_params_; 
    GGEMSDoseRecording dose_recording_; 
    bool is_photon_tracking_; 
    bool is_edep_; 
    bool is_hit_tracking_; 
    bool is_edep_squared_; 
    bool is_uncertainty_; 
    GGfloat scale_factor_; 
    GGchar is_water_reference_; 
    GGfloat minimum_density_; 
    cl::Kernel** kernel_compute_dose_; 
    GGsize number_activated_devices_; 
};
 
extern "C" GGEMS_EXPORT GGEMSDosimetryCalculator* create_ggems_dosimetry_calculator(void);
 
extern "C" GGEMS_EXPORT void delete_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator);
 
extern "C" GGEMS_EXPORT void scale_factor_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator, GGfloat const scale_factor);
 
extern "C" GGEMS_EXPORT void water_reference_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator, bool const is_activated);
 
extern "C" GGEMS_EXPORT void minimum_density_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator, GGfloat const minimum_density, char const* unit);
 
extern "C" GGEMS_EXPORT void set_dosel_size_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator, GGfloat const dose_x, GGfloat const dose_y, GGfloat const dose_z, char const* unit);
 
extern "C" GGEMS_EXPORT void set_dose_output_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator, char const* dose_output_filename);
 
extern "C" GGEMS_EXPORT void dose_photon_tracking_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator, bool const is_activated);
 
extern "C" GGEMS_EXPORT void dose_edep_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator, bool const is_activated);
 
extern "C" GGEMS_EXPORT void dose_hit_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator, bool const is_activated);
 
extern "C" GGEMS_EXPORT void dose_edep_squared_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator, bool const is_activated);
 
extern "C" GGEMS_EXPORT void dose_uncertainty_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator, bool const is_activated);
 
extern "C" GGEMS_EXPORT void attach_to_navigator_dosimetry_calculator(GGEMSDosimetryCalculator* dose_calculator, char const* navigator);
 
#endif // End of GUARD_GGEMS_NAVIGATORS_GGEMSDOSIMETRYCALCULATOR_HH