/***********************************************************************//**
* @brief Evaluate function
*
* @param[in] event Observed event.
* @param[in] obs Observation.
* @return Function value.
*
* @exception GException::invalid_argument
* Specified observation is not of the expected type.
*
* @todo Make sure that DETX and DETY are always set in GCTAInstDir.
***************************************************************************/
double GCTAModelIrfBackground::eval(const GEvent& event,
const GObservation& obs) const
{
// Get pointer on CTA observation
const GCTAObservation* cta = dynamic_cast<const GCTAObservation*>(&obs);
if (cta == NULL) {
std::string msg = "Specified observation is not a CTA observation.\n" +
obs.print();
throw GException::invalid_argument(G_EVAL, msg);
}
// Get pointer on CTA IRF response
const GCTAResponseIrf* rsp = dynamic_cast<const GCTAResponseIrf*>(cta->response());
if (rsp == NULL) {
std::string msg = "Specified observation does not contain an IRF response.\n" +
obs.print();
throw GException::invalid_argument(G_EVAL, msg);
}
// Retrieve pointer to CTA background
const GCTABackground* bgd = rsp->background();
if (bgd == NULL) {
std::string msg = "Specified observation contains no background"
" information.\n" + obs.print();
throw GException::invalid_argument(G_EVAL, msg);
}
// Extract CTA instrument direction from event
const GCTAInstDir* dir = dynamic_cast<const GCTAInstDir*>(&(event.dir()));
if (dir == NULL) {
std::string msg = "No CTA instrument direction found in event.";
throw GException::invalid_argument(G_EVAL, msg);
}
// Set DETX and DETY in instrument direction
GCTAInstDir inst_dir = cta->pointing().instdir(dir->dir());
// Evaluate function
double logE = event.energy().log10TeV();
double spat = (*bgd)(logE, inst_dir.detx(), inst_dir.dety());
double spec = (spectral() != NULL)
? spectral()->eval(event.energy(), event.time()) : 1.0;
double temp = (temporal() != NULL)
? temporal()->eval(event.time()) : 1.0;
// Compute value
double value = spat * spec * temp;
// Apply deadtime correction
value *= obs.deadc(event.time());
// Return value
return value;
}
/***********************************************************************//**
* @brief Evaluate function
*
* @param[in] event Observed event.
* @param[in] obs Observation.
* @return Function value.
*
* @exception GException::invalid_argument
* Specified observation is not of the expected type.
***************************************************************************/
double GCTAModelCubeBackground::eval(const GEvent& event,
const GObservation& obs) const
{
// Get pointer on CTA observation
const GCTAObservation* cta = dynamic_cast<const GCTAObservation*>(&obs);
if (cta == NULL) {
std::string msg = "Specified observation is not a CTA observation.";
throw GException::invalid_argument(G_EVAL, msg);
}
// Get pointer on CTA IRF response
const GCTAResponseCube* rsp = dynamic_cast<const GCTAResponseCube*>(cta->response());
if (rsp == NULL) {
std::string msg = "Specified observation does not contain a cube response.";
throw GException::invalid_argument(G_EVAL, msg);
}
// Extract CTA instrument direction from event
const GCTAInstDir* dir = dynamic_cast<const GCTAInstDir*>(&(event.dir()));
if (dir == NULL) {
std::string msg = "No CTA instrument direction found in event.";
throw GException::invalid_argument(G_EVAL, msg);
}
// Retrieve reference to CTA cube background
const GCTACubeBackground& bgd = rsp->background();
// Evaluate function
//double logE = event.energy().log10TeV();
double spat = bgd((*dir), event.energy());
double spec = (spectral() != NULL)
? spectral()->eval(event.energy(), event.time()) : 1.0;
double temp = (temporal() != NULL)
? temporal()->eval(event.time()) : 1.0;
// Compute value. Note that background rates are already per
// livetime, hence no deadtime correction is needed here.
double value = spat * spec * temp;
// Return value
return value;
}
/***********************************************************************//**
* @brief Evaluate function
*
* @param[in] event Observed event.
* @param[in] obs Observation.
* @return Function value.
*
* @exception GException::invalid_argument
* No CTA instrument direction found in event.
*
* Evaluates tha CTA background model which is a factorization of a
* spatial, spectral and temporal model component. This method also applies
* a deadtime correction factor, so that the normalization of the model is
* a real rate (counts/exposure time).
*
* @todo Add bookkeeping of last value and evaluate only if argument
* changed
***************************************************************************/
double GCTAModelBackground::eval(const GEvent& event,
const GObservation& obs) const
{
// Get pointer on CTA observation
const GCTAObservation* ctaobs = dynamic_cast<const GCTAObservation*>(&obs);
if (ctaobs == NULL) {
std::string msg = "Specified observation is not a CTA observation.\n" +
obs.print();
throw GException::invalid_argument(G_EVAL, msg);
}
// Extract CTA instrument direction
const GCTAInstDir* dir = dynamic_cast<const GCTAInstDir*>(&(event.dir()));
if (dir == NULL) {
std::string msg = "No CTA instrument direction found in event.";
throw GException::invalid_argument(G_EVAL, msg);
}
// Create a Photon from the event.
// We need the GPhoton to evaluate the spatial model.
// For the background, GEvent and GPhoton are identical
// since the IRFs are not folded in
GPhoton photon(dir->dir(), event.energy(), event.time());
// Evaluate function and gradients
double spat = (spatial() != NULL)
? spatial()->eval(photon) : 1.0;
double spec = (spectral() != NULL)
? spectral()->eval(event.energy(), event.time()) : 1.0;
double temp = (temporal() != NULL)
? temporal()->eval(event.time()) : 1.0;
// Compute value
double value = spat * spec * temp;
// Apply deadtime correction
value *= obs.deadc(event.time());
// Return
return value;
}
/***********************************************************************//**
* @brief Evaluate function and gradients
*
* @param[in] event Observed event.
* @param[in] obs Observation.
* @return Function value.
*
* @exception GException::invalid_argument
* No CTA instrument direction found in event.
*
* Evaluates tha CTA background model and parameter gradients. The CTA
* background model is a factorization of a spatial, spectral and
* temporal model component. This method also applies a deadtime correction
* factor, so that the normalization of the model is a real rate
* (counts/exposure time).
*
* @todo Add bookkeeping of last value and evaluate only if argument
* changed
***************************************************************************/
double GCTAModelBackground::eval_gradients(const GEvent& event,
const GObservation& obs) const
{
// Get pointer on CTA observation
const GCTAObservation* ctaobs = dynamic_cast<const GCTAObservation*>(&obs);
if (ctaobs == NULL) {
std::string msg = "Specified observation is not a CTA observation.\n" +
obs.print();
throw GException::invalid_argument(G_EVAL_GRADIENTS, msg);
}
// Extract CTA instrument direction
const GCTAInstDir* dir = dynamic_cast<const GCTAInstDir*>(&(event.dir()));
if (dir == NULL) {
std::string msg = "No CTA instrument direction found in event.";
throw GException::invalid_argument(G_EVAL_GRADIENTS, msg);
}
// Create a Photon from the event
// We need the photon to evaluate the spatial model
// For the background, GEvent and GPhoton are identical
// since the IRFs are not folded in
GPhoton photon = GPhoton(dir->dir(), event.energy(),event.time());
// Evaluate function and gradients
double spat = (spatial() != NULL)
? spatial()->eval_gradients(photon) : 1.0;
double spec = (spectral() != NULL)
? spectral()->eval_gradients(event.energy(), event.time()) : 1.0;
double temp = (temporal() != NULL)
? temporal()->eval_gradients(event.time()) : 1.0;
// Compute value
double value = spat * spec * temp;
// Apply deadtime correction
double deadc = obs.deadc(event.time());
value *= deadc;
// Multiply factors to spatial gradients
if (spatial() != NULL) {
double fact = spec * temp * deadc;
if (fact != 1.0) {
for (int i = 0; i < spatial()->size(); ++i)
(*spatial())[i].factor_gradient( (*spatial())[i].factor_gradient() * fact );
}
}
// Multiply factors to spectral gradients
if (spectral() != NULL) {
double fact = spat * temp * deadc;
if (fact != 1.0) {
for (int i = 0; i < spectral()->size(); ++i)
(*spectral())[i].factor_gradient( (*spectral())[i].factor_gradient() * fact );
}
}
// Multiply factors to temporal gradients
if (temporal() != NULL) {
double fact = spat * spec * deadc;
if (fact != 1.0) {
for (int i = 0; i < temporal()->size(); ++i)
(*temporal())[i].factor_gradient( (*temporal())[i].factor_gradient() * fact );
}
}
// Return value
return value;
}
/***********************************************************************//**
* @brief Evaluate function
*
* @param[in] event Observed event.
* @param[in] obs Observation.
* @param[in] gradients Compute gradients?
* @return Function value.
*
* @exception GException::invalid_argument
* Specified observation is not of the expected type.
*
* If the @p gradients flag is true the method will also set the parameter
* gradients of the model parameters.
*
* @todo Make sure that DETX and DETY are always set in GCTAInstDir.
***************************************************************************/
double GCTAModelAeffBackground::eval(const GEvent& event,
const GObservation& obs,
const bool& gradients) const
{
// Get pointer on CTA observation
const GCTAObservation* cta = dynamic_cast<const GCTAObservation*>(&obs);
if (cta == NULL) {
std::string msg = "Specified observation is not a CTA observation.\n" +
obs.print();
throw GException::invalid_argument(G_EVAL, msg);
}
// Get pointer on CTA IRF response
const GCTAResponseIrf* rsp = dynamic_cast<const GCTAResponseIrf*>(cta->response());
if (rsp == NULL) {
std::string msg = "Specified observation does not contain an IRF response.\n" +
obs.print();
throw GException::invalid_argument(G_EVAL, msg);
}
// Retrieve pointer to CTA Effective Area
const GCTAAeff* aeff = rsp->aeff();
if (aeff == NULL) {
std::string msg = "Specified observation contains no effective area"
" information.\n" + obs.print();
throw GException::invalid_argument(G_EVAL, msg);
}
// Extract CTA instrument direction from event
const GCTAInstDir* dir = dynamic_cast<const GCTAInstDir*>(&(event.dir()));
if (dir == NULL) {
std::string msg = "No CTA instrument direction found in event.";
throw GException::invalid_argument(G_EVAL, msg);
}
// Set DETX and DETY in instrument direction
GCTAInstDir inst_dir = cta->pointing().instdir(dir->dir());
// Set theta and phi from instrument coordinates
double theta = std::sqrt(inst_dir.detx() * inst_dir.detx() +
inst_dir.dety() * inst_dir.dety());
double phi = gammalib::atan2d(inst_dir.dety(), inst_dir.detx()) *
gammalib::deg2rad;
// Evaluate function
double logE = event.energy().log10TeV();
double spat = (*aeff)(logE, theta, phi,
cta->pointing().zenith(),
cta->pointing().azimuth(), false);
double spec = (spectral() != NULL)
? spectral()->eval(event.energy(), event.time(), gradients)
: 1.0;
double temp = (temporal() != NULL)
? temporal()->eval(event.time(), gradients) : 1.0;
// Compute value
double value = spat * spec * temp;
// Apply deadtime correction
double deadc = obs.deadc(event.time());
value *= deadc;
// Optionally compute partial derivatives
if (gradients) {
// Multiply factors to spectral gradients
if (spectral() != NULL) {
double fact = spat * temp * deadc;
if (fact != 1.0) {
for (int i = 0; i < spectral()->size(); ++i)
(*spectral())[i].factor_gradient((*spectral())[i].factor_gradient() * fact );
}
}
// Multiply factors to temporal gradients
if (temporal() != NULL) {
double fact = spat * spec * deadc;
if (fact != 1.0) {
for (int i = 0; i < temporal()->size(); ++i)
(*temporal())[i].factor_gradient((*temporal())[i].factor_gradient() * fact );
}
}
} // endif: computed partial derivatives
// Return value
return value;
}