/***********************************************************************//** * @brief Insert Good Time Interval * * @param[in] index Index after which interval is inserted. * @param[in] tstart Start time of interval. * @param[in] tstop Stop time of interval. * * @exception GException::invalid_argument * Start time later than stop time * * Inserts a Good Time Interval after the specified @p index in the Good * Time Intervals. The method does not reorder the intervals by time, * instead the client needs to determine the approriate @p index. * * Invalid parameters do not produce any exception, but are handled * transparently. If the interval is invalid (i.e. @p tstart > @p tstop) * an exception is thrown. If the @p index is out of the valid range, the * index will be adjusted to either the first or the last element. ***************************************************************************/ void GGti::insert_gti(const int& index, const GTime& tstart, const GTime& tstop) { // Throw an exception if time interval is invalid if (tstart > tstop) { std::string msg = "Invalid time interval specified. Start time "+ tstart.print(NORMAL)+" can not be later than " "stop time "+tstop.print(NORMAL)+"."; throw GException::invalid_argument(G_INSERT_GTI, msg); } // Set index int inx = index; // If inx is out of range then adjust it if (inx < 0) inx = 0; if (inx > m_num) inx = m_num; // Allocate new intervals int num = m_num+1; GTime* start = new GTime[num]; GTime* stop = new GTime[num]; // Copy intervals before GTI to be inserted for (int i = 0; i < inx; ++i) { start[i] = m_start[i]; stop[i] = m_stop[i]; } // Insert GTI start[inx] = tstart; stop[inx] = tstop; // Copy intervals after GTI to be inserted for (int i = inx+1; i < num; ++i) { start[i] = m_start[i-1]; stop[i] = m_stop[i-1]; } // Free memory if (m_start != NULL) delete [] m_start; if (m_stop != NULL) delete [] m_stop; // Set new memory m_start = start; m_stop = stop; // Set number of elements m_num = num; // Set attributes set_attributes(); // Return return; }
/***********************************************************************//** * @brief Invalid Good Time Interval found * * @param[in] origin Method that throws the error. * @param[in] tstart Good Time Interval start time. * @param[in] tstop Good Time Interval stop time. * @param[in] message Optional error message. ***************************************************************************/ GException::gti_invalid::gti_invalid(std::string origin, GTime tstart, GTime tstop, std::string message) { // Set method name m_origin = origin; // Set error message m_message = "Invalid Good Time Interval (" + tstart.print() + "-" + tstop.print() + ") specified."; if (message.length() > 0) { m_message += " " + message; } // Return return; }
/***********************************************************************//** * @brief Reduce Good Time Intervals to specified interval * * @param[in] tstart Start time of interval. * @param[in] tstop Stop time of interval. * * @exception GException::invalid_argument * Start time is later than stop time * * Reduces the Good Time Intervals to the specified interval. Reducing means * that all Good Time Intervals are dropped that fall outside the specified * interval [@p tstart, @p tstop], and Good Time Intervals will be limited * to >@p tstart and <=@p tstop in case that their boundaries are outside * [@p tstart, @p tstop]. ***************************************************************************/ void GGti::reduce(const GTime& tstart, const GTime& tstop) { // Throw an exception if time interval is invalid if (tstart > tstop) { std::string msg = "Invalid time interval specified. Start time "+ tstart.print(NORMAL)+" can not be later than " "stop time "+tstop.print(NORMAL)+"."; throw GException::invalid_argument(G_REDUCE, msg); } // Adjust existing GTIs. This will limit all GTIs to [tstart,tstop]. // All GTIs outside [tstart,tstop] will have start > stop. The number // of valid GTIs will also be determined. int num = 0; for (int i = 0; i < m_num; ++i) { if (m_start[i] < tstart) { m_start[i] = tstart; } if (m_stop[i] > tstop) { m_stop[i] = tstop; } if (m_start[i] <= m_stop[i]) { num++; } } // If we still have valid GTIs then allocate memory for them, copy // over the start and stop times, and update the attributes if (num > 0) { // Allocate new intervals GTime* start = new GTime[num]; GTime* stop = new GTime[num]; // Copy valid intervals for (int i = 0; i < m_num; ++i) { if (m_start[i] <= m_stop[i]) { start[i] = m_start[i]; stop[i] = m_stop[i]; } } // Free old memory if (m_start != NULL) delete [] m_start; if (m_stop != NULL) delete [] m_stop; // Set new memory m_start = start; m_stop = stop; // Set attributes m_num = num; set_attributes(); } // endif: there were still valid GTIs // ... otherwise we remove all GTIs else { clear(); } // Return return; }