GCOSEventBin.cpp

Go to the documentation of this file.

/***************************************************************************
 *                 GCOSEventBin.cpp - COSI event bin class                 *
 * ----------------------------------------------------------------------- *
 *  copyright (C) 2026 by Juergen Knoedlseder                              *
 * ----------------------------------------------------------------------- *
 *                                                                         *
 *  This program 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.                                    *
 *                                                                         *
 *  This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.  *
 *                                                                         *
 ***************************************************************************/
/**
 * @file GCOSEventBin.hpp
 * @brief COSI event bin class implementation
 * @author Juergen Knoedlseder
 */
 
/* __ Includes ___________________________________________________________ */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <cmath>
#include <string>
#include "GTools.hpp"
#include "GCOSEventBin.hpp"
 
/* __ Method name definitions ____________________________________________ */
#define G_DIR_GET                                       "GCOSEventBin::dir()"
#define G_CHI_GET                                       "GCOSEventBin::chi()"
#define G_PSI_GET                                       "GCOSEventBin::psi()"
#define G_PHI_GET                                       "GCOSEventBin::phi()"
#define G_ENERGY_GET                                 "GCOSEventBin::energy()"
#define G_TIME_GET                                     "GCOSEventBin::time()"
#define G_COUNTS_GET                                 "GCOSEventBin::counts()"
#define G_SOLIDANGLE_GET                         "GCOSEventBin::solidangle()"
#define G_PHIWIDTH_GET                             "GCOSEventBin::phiwidth()"
#define G_EWIDTH_GET                                 "GCOSEventBin::ewidth()"
#define G_ONTIME_GET                                 "GCOSEventBin::ontime()"
#define G_DIR_SET1                          "GCOSEventBin::dir(GCOSInstDir&)"
#define G_DIR_SET2             "GCOSEventBin::dir(double&, double&, double&)"
#define G_ENERGY_SET                         "GCOSEventBin::energy(GEnergy&)"
#define G_TIME_SET                               "GCOSEventBin::time(GTime&)"
#define G_COUNTS_SET                          "GCOSEventBin::counts(double&)"
#define G_SOLIDANGLE_SET                  "GCOSEventBin::solidangle(double&)"
#define G_PHIWIDTH_SET                      "GCOSEventBin::phiwidth(double&)"
#define G_EWIDTH_SET                         "GCOSEventBin::ewidth(GEnergy&)"
#define G_ONTIME_SET                          "GCOSEventBin::ontime(double&)"
 
/* __ Macros _____________________________________________________________ */
 
/* __ Coding definitions _________________________________________________ */
 
/* __ Debug definitions __________________________________________________ */
 
 
/*==========================================================================
 =                                                                         =
 =                        Constructors/destructors                         =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Void constructor
 *
 * Creates an empty COSI event bin.
 ***************************************************************************/
GCOSEventBin::GCOSEventBin(void) : GEventBin()
{
    // Initialise class members for clean destruction
    init_members();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Copy constructor
 *
 * @param[in] bin COSI event bin.
 ***************************************************************************/
GCOSEventBin::GCOSEventBin(const GCOSEventBin& bin) : GEventBin(bin)
{
    // Initialise class members for clean destruction
    init_members();
 
    // Copy members
    copy_members(bin);
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Destructor
 ***************************************************************************/
GCOSEventBin::~GCOSEventBin(void)
{
    // Free members
    free_members();
 
    // Return
    return;
}
 
 
/*==========================================================================
 =                                                                         =
 =                               Operators                                 =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Assignment operator
 *
 * @param[in] bin COSI event bin.
 * @return COSI event bin.
 ***************************************************************************/
GCOSEventBin& GCOSEventBin::operator=(const GCOSEventBin& bin)
{
    // Execute only if object is not identical
    if (this != &bin) {
 
        // Copy base class members
        this->GEventBin::operator=(bin);
 
        // Free members
        free_members();
 
        // Initialise private members for clean destruction
        init_members();
 
        // Copy members
        copy_members(bin);
 
    } // endif: object was not identical
 
    // Return this object
    return *this;
}
 
 
/*==========================================================================
 =                                                                         =
 =                             Public methods                              =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Clear COSI event bin
 *
 * Clears COSI event bin by resetting all class members to an initial state.
 * Any information that was present before will be lost.
 ***************************************************************************/
void GCOSEventBin::clear(void)
{
    // Free class members (base and derived classes, derived class first)
    free_members();
    this->GEventBin::free_members();
    this->GEvent::free_members();
 
    // Initialise members
    this->GEvent::init_members();
    this->GEventBin::init_members();
    init_members();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Clone event bin
 *
 * @return Pointer to deep copy of COSI event bin.
 ***************************************************************************/
GCOSEventBin* GCOSEventBin::clone(void) const
{
    return new GCOSEventBin(*this);
}
 
 
/***********************************************************************//**
 * @brief Return size of event bin
 *
 * @return Size of event bin (sr MeV s)
 *
 * The size of the event bin (units: sr MeV s) is given by
 * \f[size = \Omega \times \Delta E \times \Delta T\f]
 * where
 * \f$\Omega\f$ is the size of the spatial bin in sr,
 * \f$\Delta E\f$ is the size of the energy bin in MeV, and
 * \f$\Delta T\f$ is the ontime of the observation in seconds. 
 ***************************************************************************/
double GCOSEventBin::size(void) const
{
    // Compute bin size
    double size = solidangle() * ewidth().MeV() * ontime();
 
    // Return bin size
    return size;
}
 
 
/***********************************************************************//**
 * @brief Return instrument direction of event bin
 *
 * @return Instrument direction of event bin.
 *
 * @exception GException::invalid_value
 *            Invalid instrument direction pointer.
 *
 * Returns reference to the instrument direction of the event bin.
 ***************************************************************************/
const GCOSInstDir& GCOSEventBin::dir(void) const
{
    // Throw an exception if instrument direction pointer is not valid
    if (m_dir == NULL) {
        std::string msg = "No memory has been allocated from which the "
                          "instrument direction could be retrieved.";
        throw GException::invalid_value(G_DIR_GET, msg);
    }
 
    // Return instrument direction
    return *m_dir;
}
 
 
/***********************************************************************//**
 * @brief Return Galactic longitude of event bin scatter direction Chi
 *
 * @return Galactic longitude of event bin scatter direction Chi (deg).
 *
 * @exception GException::invalid_value
 *            Invalid instrument direction pointer.
 *
 * Returns Galactic longitude of event bin scatter direction Chi in degrees.
 ***************************************************************************/
double GCOSEventBin::chi(void) const
{
    // Throw an exception if instrument direction pointer is not valid
    if (m_dir == NULL) {
        std::string msg = "No memory has been allocated from which the "
                          "scatter direction Chi could be retrieved.";
        throw GException::invalid_value(G_CHI_GET, msg);
    }
 
    // Return scatter direction Chi
    return (m_dir->dir().l_deg());
}
 
 
/***********************************************************************//**
 * @brief Return Galactic longitude of event bin scatter direction Psi
 *
 * @return Galactic longitude of event bin scatter direction Psi (deg).
 *
 * @exception GException::invalid_value
 *            Invalid instrument direction pointer.
 *
 * Returns Galactic longitude of event bin scatter direction Psi in degrees.
 ***************************************************************************/
double GCOSEventBin::psi(void) const
{
    // Throw an exception if instrument direction pointer is not valid
    if (m_dir == NULL) {
        std::string msg = "No memory has been allocated from which the "
                          "scatter direction Psi could be retrieved.";
        throw GException::invalid_value(G_PSI_GET, msg);
    }
 
    // Return scatter direction Psi
    return (m_dir->dir().b_deg());
}
 
 
/***********************************************************************//**
 * @brief Return event bin scatter angle Phi
 *
 * @return Galactic longitude of event bin scatter angle Phi (deg).
 *
 * @exception GException::invalid_value
 *            Invalid instrument direction pointer.
 *
 * Returns Galactic longitude of event bin scatter angle Phi in degrees.
 ***************************************************************************/
const double& GCOSEventBin::phi(void) const
{
    // Throw an exception if instrument direction pointer is not valid
    if (m_dir == NULL) {
        std::string msg = "No memory has been allocated from which the "
                          "scatter angle Phi could be retrieved.";
        throw GException::invalid_value(G_PHI_GET, msg);
    }
 
    // Return scatter angle Phi
    return (m_dir->phi());
}
 
 
/***********************************************************************//**
 * @brief Return energy of event bin
 *
 * @return Energy of event bin.
 *
 * @exception GException::invalid_value
 *            Invalid energy pointer.
 *
 * Returns reference to the energy of the event bin.
 ***************************************************************************/
const GEnergy& GCOSEventBin::energy(void) const
{
    // Throw an exception if energy pointer is not valid
    if (m_energy == NULL) {
        std::string msg = "No memory has been allocated from which the energy "
                          "could be retrieved.";
        throw GException::invalid_value(G_ENERGY_GET, msg);
    }
 
    // Return energy
    return *m_energy;
}
 
 
/***********************************************************************//**
 * @brief Return time of event bin
 *
 * @return Time of event bin.
 *
 * @exception GException::invalid_value
 *            Invalid time pointer.
 *
 * Returns reference to the time of the event bin.
 ***************************************************************************/
const GTime& GCOSEventBin::time(void) const
{
    // Throw an exception if time pointer is not valid
    if (m_energy == NULL) {
        std::string msg = "No memory has been allocated from which the time "
                          "could be retrieved.";
        throw GException::invalid_value(G_TIME_GET, msg);
    }
 
    // Return time
    return *m_time;
}
 
 
/***********************************************************************//**
 * @brief Return number of counts in event bin
 *
 * @return Number of counts in event bin.
 *
 * @exception GCTAException::invalid_value
 *            Invalid counts pointer.
 *
 * Returns the number of counts in the event bin.
 ***************************************************************************/
double GCOSEventBin::counts(void) const
{
    // Throw an exception if counts pointer is not valid
    if (m_counts == NULL) {
        std::string msg = "No memory has been allocated from which the counts "
                          "could be retrieved.";
        throw GException::invalid_value(G_COUNTS_GET, msg);
    }
 
    // Return counts
    return *m_counts;
}
 
 
/***********************************************************************//**
 * @brief Return error in number of counts
 *
 * @return Error in number of counts in event bin.
 *
 * Returns \f$\sqrt(counts+delta)\f$ as the uncertainty in the number of
 * counts in the bin. Adding delta avoids uncertainties of 0 which will
 * lead in the optimisation step to the exlusion of the corresponding bin.
 * In the actual implementation delta=1e-50.
 *
 * @todo The choice of delta has been made somewhat arbitrary, mainly
 * because the optimizer routines filter error^2 below 1e-100.
 ***************************************************************************/
double GCOSEventBin::error(void) const
{
    // Compute uncertainty
    double error = std::sqrt(counts()+1.0e-50);
 
    // Return error
    return error;
}
 
 
/***********************************************************************//**
 * @brief Return solid angle of event bin
 *
 * @return Solid angle of event bin (sr).
 *
 * @exception GException::invalid_value
 *            Invalid solid angle pointer.
 *
 * Returns reference to the solid angle of the event bin.
 ***************************************************************************/
const double& GCOSEventBin::solidangle(void) const
{
    // Throw an exception if counts pointer is not valid
    if (m_solidangle == NULL) {
        std::string msg = "No memory has been allocated from which the solid "
                          "angle could be retrieved.";
        throw GException::invalid_value(G_SOLIDANGLE_GET, msg);
    }
 
    // Return solid angle
    return *m_solidangle;
}
 
 
/***********************************************************************//**
 * @brief Return Phi width of event bin
 *
 * @return Phi width of event bin (deg).
 *
 * @exception GException::invalid_value
 *            Invalid Phi width pointer.
 *
 * Returns reference to the Phi width of the event bin.
 ***************************************************************************/
const double& GCOSEventBin::phiwidth(void) const
{
    // Throw an exception if counts pointer is not valid
    if (m_phiwidth == NULL) {
        std::string msg = "No memory has been allocated from which the Phi "
                          "width could be retrieved.";
        throw GException::invalid_value(G_PHIWIDTH_GET, msg);
    }
 
    // Return Phi width
    return *m_phiwidth;
}
 
 
/***********************************************************************//**
 * @brief Return energy width of event bin
 *
 * @return Energy width of event bin.
 *
 * @exception GException::invalid_value
 *            Invalid energy width pointer.
 *
 * Returns reference to the energy width of the event bin.
 ***************************************************************************/
const GEnergy& GCOSEventBin::ewidth(void) const
{
    // Throw an exception if energy width pointer is not valid
    if (m_ewidth == NULL) {
        std::string msg = "No memory has been allocated from which the energy "
                          "width could be retrieved.";
        throw GException::invalid_value(G_EWIDTH_GET, msg);
    }
 
    // Return energy width
    return *m_ewidth;
}
 
 
/***********************************************************************//**
 * @brief Return ontime of event bin
 *
 * @return Ontime of event bin (sec).
 *
 * @exception GException::invalid_value
 *            Invalid ontime pointer.
 *
 * Returns reference to the ontime of the event bin.
 ***************************************************************************/
const double& GCOSEventBin::ontime(void) const
{
    // Throw an exception if energy width pointer is not valid
    if (m_ontime == NULL) {
        std::string msg = "No memory has been allocated from which the "
                          "ontime could be retrieved.";
        throw GException::invalid_value(G_ONTIME_GET, msg);
    }
 
    // Return ontime
    return *m_ontime;
}
 
 
/***********************************************************************//**
 * @brief Set instrument direction of event bin
 *
 * @param[in] dir Instrument direction of event bin.
 *
 * @exception GException::invalid_value
 *            No memory allocated to hold instrument direction.
 *
 * Sets the instrument direction of the event bin.
 ***************************************************************************/
void GCOSEventBin::dir(const GCOSInstDir& dir)
{
    // Throw an exception if no memory has been allocated
    if (m_dir == NULL) {
        std::string msg = "No memory has been allocated to store the "
                          "instrument direction.";
        throw GException::invalid_value(G_DIR_SET1, msg);
    }
 
    // Set instrument direction
    *m_dir = dir;
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Set Chi, Psi and Phi of event bin
 *
 * @param[in] chi Galactic longitude of scatter direction Chi (deg).
 * @param[in] psi Galactic longitude of scatter direction Psi (deg).
 * @param[in] phi Scatter angle Phi (deg).
 *
 * @exception GException::invalid_value
 *            No memory allocated to hold Chi, Psi and Phi values.
 *
 * Sets the scatter direction and scatter angle of the event bin.
 *
 * Note that this method does not set the scatter direction in local
 * coordinates. Use the dir(GCOSInstDir&) method to also set the scatter
 * direction in local coordinates.
 ***************************************************************************/
void GCOSEventBin::dir(const double& chi, const double& psi, const double& phi)
{
    // Throw an exception if no memory has been allocated
    if (m_dir == NULL) {
        std::string msg = "No memory has been allocated to store the "
                          "Chi, Psi and Phi values.";
        throw GException::invalid_value(G_DIR_SET2, msg);
    }
 
    // Set scatter direction
    GSkyDir dir;
    dir.lb_deg(chi,psi);
 
    // Set instrument direction
    m_dir->dir(dir);
    m_dir->phi(phi);
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Set energy of event bin
 *
 * @param[in] energy Energy of event bin.
 *
 * @exception GException::invalid_value
 *            No memory allocated to store the energy.
 *
 * Sets the energy of the event bin.
 ***************************************************************************/
void GCOSEventBin::energy(const GEnergy& energy)
{
    // Throw an exception if no memory has been allocated
    if (m_energy == NULL) {
        std::string msg = "No memory has been allocated to store the energy.";
        throw GException::invalid_value(G_ENERGY_SET, msg);
    }
 
    // Set energy
    *m_energy = energy;
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Set time of event bin
 *
 * @param[in] time Time of event bin.
 *
 * @exception GException::invalid_value
 *            No memory allocated to store the time.
 *
 * Sets the time of the event bin.
 ***************************************************************************/
void GCOSEventBin::time(const GTime& time)
{
    // Throw an exception if no memory has been allocated
    if (m_time == NULL) {
        std::string msg = "No memory has been allocated to store the time.";
        throw GException::invalid_value(G_TIME_SET, msg);
    }
 
    // Set time
    *m_time = time;
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Set number of counts in event bin
 *
 * @param[in] counts Number of counts.
 *
 * @exception GException::invalid_value
 *            No memory allocated to store counts.
 *
 * Set the number of counts in the event bin.
 ***************************************************************************/
void GCOSEventBin::counts(const double& counts)
{
    // Throw an exception if counts pointer is not valid
    if (m_counts == NULL) {
        std::string msg = "No memory has been allocated to store the counts.";
        throw GException::invalid_value(G_COUNTS_SET, msg);
    }
 
    // Set number of counts in event bin
    *m_counts = counts;
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Set solid angle of event bin
 *
 * @param[in] solidangle Solid angle of event bin (sr).
 *
 * @exception GException::invalid_value
 *            No memory allocated to store solid angle.
 *
 * Sets the solid angle of the event bin.
 ***************************************************************************/
void GCOSEventBin::solidangle(const double& solidangle)
{
    // Throw an exception if no memory has been allocated
    if (m_solidangle == NULL) {
        std::string msg = "No memory has been allocated to store the solid "
                          "angle.";
        throw GException::invalid_value(G_SOLIDANGLE_SET, msg);
    }
 
    // Set solid angle
    *m_solidangle = solidangle;
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Set Phi width of event bin
 *
 * @param[in] phiwidth Energy width of event bin (deg).
 *
 * @exception GException::invalid_value
 *            No memory allocated to store Phi width.
 *
 * Sets the Phi width of the event bin.
 ***************************************************************************/
void GCOSEventBin::phiwidth(const double& phiwidth)
{
    // Throw an exception if no memory has been allocated
    if (m_phiwidth == NULL) {
        std::string msg = "No memory has been allocated to store the Phi "
                          "width.";
        throw GException::invalid_value(G_PHIWIDTH_SET, msg);
    }
 
    // Set Phi width
    *m_phiwidth = phiwidth;
 
    // Return
    return;
}
 
/***********************************************************************//**
 * @brief Set energy width of event bin
 *
 * @param[in] ewidth Energy width of event bin.
 *
 * @exception GException::invalid_value
 *            No memory allocated to store energy width.
 *
 * Sets the energy width of the event bin.
 ***************************************************************************/
void GCOSEventBin::ewidth(const GEnergy& ewidth)
{
    // Throw an exception if no memory has been allocated
    if (m_ewidth == NULL) {
        std::string msg = "No memory has been allocated to store the energy "
                          "width.";
        throw GException::invalid_value(G_EWIDTH_SET, msg);
    }
 
    // Set energy width
    *m_ewidth = ewidth;
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Set ontime of event bin
 *
 * @param[in] ontime Ontime of event bin (sec).
 *
 * @exception GException::invalid_value
 *            No memory allocated to store ontime.
 *
 * Sets the ontime of the event bin.
 ***************************************************************************/
void GCOSEventBin::ontime(const double& ontime)
{
    // Throw an exception if no memory has been allocated
    if (m_ontime == NULL) {
        std::string msg = "No memory has been allocated to store the ontime.";
        throw GException::invalid_value(G_ONTIME_SET, msg);
    }
 
    // Set solid angle
    *m_ontime = ontime;
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Print event information
 *
 * @param[in] chatter Chattiness.
 * @return String containing event information.
 ***************************************************************************/
std::string GCOSEventBin::print(const GChatter& chatter) const
{
    // Initialise result string
    std::string result;
 
    // Continue only if chatter is not silent
    if (chatter != SILENT) {
 
        // Append number of counts
        result.append(gammalib::str(counts()));
 
    } // endif: chatter was not silent
 
    // Return result
    return result;
}
 
 
/*==========================================================================
 =                                                                         =
 =                            Private methods                              =
 =                                                                         =
 ==========================================================================*/
 
/***********************************************************************//**
 * @brief Initialise class members
 *
 * This method allocates memory for all event bin attributes and intialises
 * the attributes to well defined initial values.
 * 
 * The method assumes that on entry no memory is hold by the member pointers.
 ***************************************************************************/
void GCOSEventBin::init_members(void)
{
    // Allocate members
    m_alloc      = true;
    m_index      = -1;   // Signals that event bin does not correspond to cube
    m_counts     = new double;
    m_dir        = new GCOSInstDir;
    m_solidangle = new double;
    m_time       = new GTime;
    m_ontime     = new double;
    m_phiwidth   = new double;
    m_energy     = new GEnergy;
    m_ewidth     = new GEnergy;
 
    // Initialise members
    *m_counts = 0.0;
    m_dir->clear();
    *m_solidangle = 0.0,
    m_time->clear();
    *m_ontime   = 0.0;
    *m_phiwidth = 0.0;
    m_energy->clear();
    m_ewidth->clear();
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Copy class members
 *
 * @param[in] bin COSI event bin.
 ***************************************************************************/
void GCOSEventBin::copy_members(const GCOSEventBin& bin)
{
    // First de-allocate existing memory if needed
    free_members();
 
    // Copy members by cloning
    m_counts     = new double(*bin.m_counts);
    m_dir        = new GCOSInstDir(*bin.m_dir);
    m_solidangle = new double(*bin.m_solidangle);
    m_time       = new GTime(*bin.m_time);
    m_ontime     = new double(*bin.m_ontime);
    m_phiwidth   = new double(*bin.m_phiwidth);
    m_energy     = new GEnergy(*bin.m_energy);
    m_ewidth     = new GEnergy(*bin.m_ewidth);
 
    // Copy non-pointer members
    m_index = bin.m_index;
 
    // Signal memory allocation
    m_alloc = true;
 
    // Return
    return;
}
 
 
/***********************************************************************//**
 * @brief Delete class members
 *
 * This method frees all memory of the class attributes and sets the member
 * pointers to NULL. This method should only be called if new memory is
 * allocated immediately afterwards (for example by cloning another event
 * bin), or upon destruction of the object.
 *
 * Note that some logic has been implemented that frees only memory that also
 * has indeed been allocated by the class. Thus if the class only serves as
 * container to hold memory pointer allocated by someone else (for example
 * the GCOSEventCube class), no memory is freed.
 ***************************************************************************/
void GCOSEventBin::free_members(void)
{
    // If memory was allocated then free members now
    if (m_alloc) {
        if (m_counts     != NULL) delete m_counts;
        if (m_dir        != NULL) delete m_dir;
        if (m_solidangle != NULL) delete m_solidangle;
        if (m_time       != NULL) delete m_time;
        if (m_ontime     != NULL) delete m_ontime;
        if (m_phiwidth   != NULL) delete m_phiwidth;
        if (m_energy     != NULL) delete m_energy;
        if (m_ewidth     != NULL) delete m_ewidth;
    }
 
    // Signal member pointers as free
    m_counts     = NULL;
    m_dir        = NULL;
    m_solidangle = NULL;
    m_time       = NULL;
    m_ontime     = NULL;
    m_phiwidth   = NULL;
    m_energy     = NULL;
    m_ewidth     = NULL;
 
    // Signal memory de-allocation
    m_alloc = false;
 
    // Return
    return;
}