def join_gti_tables(gti_table_0, gti_table_1):
if not gti_table_0:
logging.warn("join_gti_tables: gti_table_0 is None, returned gti_table_1")
return gti_table_1
if not gti_table_1:
logging.warn("join_gti_tables: gti_table_1 is None, returned gti_table_0")
return gti_table_0
gti_0 = get_stingray_gti_from_gti_table (gti_table_0)
gti_1 = get_stingray_gti_from_gti_table (gti_table_1)
joined_gti = join_gtis(gti_0, gti_1)
return get_gti_table_from_stingray_gti(joined_gti)
def join_gti_tables(gti_table_0, gti_table_1):
if not gti_table_0:
logging.warn(
"join_gti_tables: gti_table_0 is None, returned gti_table_1")
return gti_table_1
if not gti_table_1:
logging.warn(
"join_gti_tables: gti_table_1 is None, returned gti_table_0")
return gti_table_0
gti_0 = get_stingray_gti_from_gti_table(gti_table_0)
gti_1 = get_stingray_gti_from_gti_table(gti_table_1)
joined_gti = join_gtis(gti_0, gti_1)
return get_gti_table_from_stingray_gti(joined_gti)
def join(self, other):
"""
Join two lightcurves into a single object.
The new Lightcurve object will contain time stamps from both the
objects. The count per bin in the resulting object will be the
individual count per bin, or the average in case of overlapping
time arrays of both lightcurve objects.
Good Time intervals are also joined.
Note : Time array of both lightcurves should not overlap each other.
Parameters
----------
other : Lightcurve object
The other Lightcurve object which is supposed to be joined with.
Returns
-------
lc_new : Lightcurve object
The resulting lightcurve object.
Example
-------
>>> time1 = [5, 10, 15]
>>> count1 = [300, 100, 400]
>>> time2 = [20, 25, 30]
>>> count2 = [600, 1200, 800]
>>> lc1 = Lightcurve(time1, count1)
>>> lc2 = Lightcurve(time2, count2)
>>> lc = lc1.join(lc2)
>>> lc.time
array([ 5, 10, 15, 20, 25, 30])
>>> lc.counts
array([ 300, 100, 400, 600, 1200, 800])
"""
if self.mjdref != other.mjdref:
raise ValueError("MJDref is different in the two light curves")
if self.dt != other.dt:
utils.simon("The two light curves have different bin widths.")
if( self.tstart < other.tstart ):
first_lc = self
second_lc = other
else:
first_lc = other
second_lc = self
if len(np.intersect1d(self.time, other.time) > 0):
utils.simon("The two light curves have overlapping time ranges. "
"In the common time range, the resulting count will "
"be the average of the counts in the two light "
"curves. If you wish to sum, use `lc_sum = lc1 + "
"lc2`.")
valid_err = False
if self.err_dist.lower() != other.err_dist.lower():
simon("Lightcurves have different statistics!"
"We are setting the errors to zero.")
elif self.err_dist.lower() in valid_statistics:
valid_err = True
# More conditions can be implemented for other statistics
else:
raise StingrayError("Statistics not recognized."
" Please use one of these: "
"{}".format(valid_statistics))
from collections import Counter
counts = Counter()
counts_err = Counter()
for i, time in enumerate(first_lc.time):
counts[time] = first_lc.counts[i]
counts_err[time] = first_lc.counts_err[i]
for i, time in enumerate(second_lc.time):
if (counts.get(time) != None): #Common time
counts[time] = (counts[time] + second_lc.counts[i]) / 2 #avg
counts_err[time] = np.sqrt(( ((counts_err[time]**2) + (second_lc.counts_err[i] **2)) / 2))
else:
counts[time] = second_lc.counts[i]
counts_err[time] = second_lc.counts_err[i]
new_time = list(counts.keys())
new_counts = list(counts.values())
if(valid_err):
new_counts_err = list(counts_err.values())
else:
new_counts_err = np.zeros_like(new_counts)
del[counts, counts_err]
else:
new_time = np.concatenate([first_lc.time, second_lc.time])
new_counts = np.concatenate([first_lc.counts, second_lc.counts])
new_counts_err = np.concatenate([first_lc.counts_err, second_lc.counts_err])
new_time = np.asarray(new_time)
new_counts = np.asarray(new_counts)
new_counts_err = np.asarray(new_counts_err)
gti = join_gtis(self.gti, other.gti)
lc_new = Lightcurve(new_time, new_counts, err=new_counts_err, gti=gti,
mjdref=self.mjdref, dt=self.dt)
return lc_new
def join(self, other):
"""
Join two lightcurves into a single object.
The new Lightcurve object will contain time stamps from both the
objects. The count per bin in the resulting object will be the
individual count per bin, or the average in case of overlapping
time arrays of both lightcurve objects.
Good Time intervals are also joined.
Note : Time array of both lightcurves should not overlap each other.
Parameters
----------
other : Lightcurve object
The other Lightcurve object which is supposed to be joined with.
Returns
-------
lc_new : Lightcurve object
The resulting lightcurve object.
Example
-------
>>> time1 = [5, 10, 15]
>>> count1 = [300, 100, 400]
>>> time2 = [20, 25, 30]
>>> count2 = [600, 1200, 800]
>>> lc1 = Lightcurve(time1, count1)
>>> lc2 = Lightcurve(time2, count2)
>>> lc = lc1.join(lc2)
>>> lc.time
array([ 5, 10, 15, 20, 25, 30])
>>> lc.counts
array([ 300, 100, 400, 600, 1200, 800])
"""
if self.dt != other.dt:
utils.simon("The two light curves have different bin widths.")
if self.tstart <= other.tstart:
new_time = np.unique(np.concatenate([self.time, other.time]))
else:
new_time = np.unique(np.concatenate([other.time, self.time]))
if len(new_time) != len(self.time) + len(other.time):
utils.simon("The two light curves have overlapping time ranges. "
"In the common time range, the resulting count will "
"be the average of the counts in the two light "
"curves. If you wish to sum, use `lc_sum = lc1 + "
"lc2`.")
new_counts = []
# For every time stamp, get the individual time counts and add them.
for time in new_time:
try:
count1 = self.counts[np.where(self.time == time)[0][0]]
except IndexError:
count1 = None
try:
count2 = other.counts[np.where(other.time == time)[0][0]]
except IndexError:
count2 = None
if count1 is not None:
if count2 is not None:
# Average the overlapping counts
new_counts.append((count1 + count2) / 2)
else:
new_counts.append(count1)
else:
new_counts.append(count2)
new_counts = np.asarray(new_counts)
gti = join_gtis(self.gti, other.gti)
lc_new = Lightcurve(new_time, new_counts, gti=gti)
return lc_new
def join(self, other):
"""
Join two lightcurves into a single object.
The new Lightcurve object will contain time stamps from both the
objects. The count per bin in the resulting object will be the
individual count per bin, or the average in case of overlapping
time arrays of both lightcurve objects.
Good Time intervals are also joined.
Note : Time array of both lightcurves should not overlap each other.
Parameters
----------
other : Lightcurve object
The other Lightcurve object which is supposed to be joined with.
Returns
-------
lc_new : Lightcurve object
The resulting lightcurve object.
Example
-------
>>> time1 = [5, 10, 15]
>>> count1 = [300, 100, 400]
>>> time2 = [20, 25, 30]
>>> count2 = [600, 1200, 800]
>>> lc1 = Lightcurve(time1, count1)
>>> lc2 = Lightcurve(time2, count2)
>>> lc = lc1.join(lc2)
>>> lc.time
array([ 5, 10, 15, 20, 25, 30])
>>> lc.counts
array([ 300, 100, 400, 600, 1200, 800])
"""
if self.dt != other.dt:
utils.simon("The two light curves have different bin widths.")
if self.tstart <= other.tstart:
new_time = np.unique(np.concatenate([self.time, other.time]))
else:
new_time = np.unique(np.concatenate([other.time, self.time]))
if len(new_time) != len(self.time) + len(other.time):
utils.simon("The two light curves have overlapping time ranges. "
"In the common time range, the resulting count will "
"be the average of the counts in the two light "
"curves. If you wish to sum, use `lc_sum = lc1 + "
"lc2`.")
new_counts = []
# For every time stamp, get the individual time counts and add them.
for time in new_time:
try:
count1 = self.counts[np.where(self.time == time)[0][0]]
except IndexError:
count1 = None
try:
count2 = other.counts[np.where(other.time == time)[0][0]]
except IndexError:
count2 = None
if count1 is not None:
if count2 is not None:
# Average the overlapping counts
new_counts.append((count1 + count2) / 2)
else:
new_counts.append(count1)
else:
new_counts.append(count2)
new_counts = np.asarray(new_counts)
gti = join_gtis(self.gti, other.gti)
lc_new = Lightcurve(new_time, new_counts, gti=gti)
return lc_new
def test_join_gtis_overlapping(self):
gti0 = [[0, 1], [2, 3], [4, 8]]
gti1 = [[7, 8], [10, 11], [12, 13]]
assert np.all(
join_gtis(gti0, gti1) == np.array([[0, 1], [2, 3], [4, 8],
[10, 11], [12, 13]]))
def join(self, other):
"""
Join two lightcurves into a single object.
The new Lightcurve object will contain time stamps from both the
objects. The count per bin in the resulting object will be the
individual count per bin, or the average in case of overlapping
time arrays of both lightcurve objects.
Good Time intervals are also joined.
Note : Time array of both lightcurves should not overlap each other.
Parameters
----------
other : Lightcurve object
The other Lightcurve object which is supposed to be joined with.
Returns
-------
lc_new : Lightcurve object
The resulting lightcurve object.
Example
-------
>>> time1 = [5, 10, 15]
>>> count1 = [300, 100, 400]
>>> time2 = [20, 25, 30]
>>> count2 = [600, 1200, 800]
>>> lc1 = Lightcurve(time1, count1)
>>> lc2 = Lightcurve(time2, count2)
>>> lc = lc1.join(lc2)
>>> lc.time
array([ 5, 10, 15, 20, 25, 30])
>>> lc.counts
array([ 300, 100, 400, 600, 1200, 800])
"""
if self.dt != other.dt:
utils.simon("The two light curves have different bin widths.")
if self.tstart <= other.tstart:
new_time = np.unique(np.concatenate([self.time, other.time]))
else:
new_time = np.unique(np.concatenate([other.time, self.time]))
if len(new_time) != len(self.time) + len(other.time):
utils.simon("The two light curves have overlapping time ranges. "
"In the common time range, the resulting count will "
"be the average of the counts in the two light "
"curves. If you wish to sum, use `lc_sum = lc1 + "
"lc2`.")
new_counts = []
new_counts_err = []
# For every time stamp, get the individual time counts and add them.
for time in new_time:
try:
count1 = self.counts[np.where(self.time == time)[0][0]]
count1_err = self.counts_err[np.where(self.time == time)[0][0]]
except IndexError:
count1 = None
count1_err = None
try:
count2 = other.counts[np.where(other.time == time)[0][0]]
count2_err = other.counts_err[np.where(other.time == time)[0][0]]
except IndexError:
count2 = None
count2_err = None
if count1 is not None:
if count2 is not None:
# Average the overlapping counts
new_counts.append((count1 + count2) / 2)
if self.err_dist.lower() != other.err_dist.lower():
simon("Lightcurves have different statistics!"
"We are setting the errors to zero.")
new_counts_err = np.zeros_like(new_counts)
elif self.err_dist.lower() in valid_statistics:
new_counts_err.append(np.sqrt(((count1_err**2) +
(count2_err**2)) / 2))
# More conditions can be implemented for other statistics
else:
raise StingrayError("Statistics not recognized."
" Please use one of these: "
"{}".format(valid_statistics))
else:
new_counts.append(count1)
new_counts_err.append(count1_err)
else:
new_counts.append(count2)
new_counts_err.append(count2_err)
new_counts = np.asarray(new_counts)
new_counts_err = np.asarray(new_counts_err)
gti = join_gtis(self.gti, other.gti)
lc_new = Lightcurve(new_time, new_counts, err=new_counts_err, gti=gti)
return lc_new