[In work! You might use it as a reference in the meantime, but some things are not yet covered. Also let me know if things are not clear! -- VG]

== Foucalc ==

The basic tool for X-ray timing analysis with the Remeis scripts is ''foucalc'' <ref>The original version of the Remeis timing scripts were written by Katja Pottschmidt. When using the tools, please cite [http://adsabs.harvard.edu/abs/2003A%26A...407.1039P Pottschmidt et al. 2003, A&A 407, 1039] and [http://adsabs.harvard.edu/abs/2000A%26A...357L..17P Pottschmidt et al. 2000, A&A 357, L17]; see also [http://adsabs.harvard.edu/abs/1999ApJ...510..874N Nowak et al., 1999, ApJ 510, 874]</ref>, which calculates power-, cross power-, coherence- and timelag-spectra <ref>What these are is wonderfully explained in Katja Pottschmidt's [http://astro.uni-tuebingen.de/publications/pottschmidt-diss.shtml PhD Thesis]</ref>. It requires '''equally spaced, gapless''' lightcurves as well as the length of the lightcurve segment on which the Fourier transformation is to be performed, given in number of bins. Note that because the underlying algorithm is FFT, the segment length should be a power of two to increase the performance.

When only one lightcurve is given, <tt>foucalc</tt> calculates the power density and related quantities only. When more than one lightcurve is given, the cross power-, coherence- and timelag-spectra are calculated for all pairs of lightcurves. The lightcurves have to be in the format:

<pre>
lc = struct { time=[t_1, t_2, ...], rate1=[r1_1, r1_2, ...], rate2=..., rate3= };
</pre>

The time has to be given in seconds (so be cautious when using <tt>fits_read_lc</tt>, which usually returns the time in MJD).

If you use RXTE/PCA lightcurves, don't forget to set the <tt>numinst</tt> keyword, which defines the number of instruments (=PCUs) on, since otherwise your noise correction will be wrong. If you are not using RXTE/PCA set the <tt>deadtime</tt> keyword to whatever is appropriate for the instrument you are using (e.g. 0).

Given a single PSD value before any further calculations, its uncertainty will be of the same order of magnitude as the PSD itself. Averaging therefore crucial. This is build in into <tt>foucalc</tt>: given a lightcurve of say 1288192 bins and a segment length of 16384, foucalc will calculate a PSDs on every segment and average every value over all 1288192/15385 = 78 segments.

== PSDs ==

=== Calculating the PSD ===

Given two PCA lightcurves, <pre>50110-01-45-00_437_AND_good_14off_excl_0-10.lc</pre> and <pre>50110-01-45-00_437_AND_good_14off_excl_11-13.lc</pre> (which have been checked for gaps and found to be gapless <ref>A useful function for this is <tt>split_lc_at_gaps</tt></ref> ) we want to calculate and bin the PSD, lags and coherence.

<pre>
%% read in lightcurves
variable lc1 = fits_read_table("50110-01-45-00_438_AND_good_14off_excl_0-10.lc");
variable lc2 = fits_read_table("50110-01-45-00_438_AND_good_14off_excl_11-13.lc");

%%define variables to store average rate of lightcurve & rms
variable rms,avg;

%%calculate timing quantities
variable result = foucalc(struct{time=lc1.time,rate1=lc1.rate,rate2=lc2.rate},16384;
numinst=3,RMS=&rms,avgrate=&avg,verbose);
</pre>

This produces the following output - thank to the <tt>verbose</tt> keyword:

<pre>
light curves: 2516 s with 1288192 bins of 0.00195312 s (0 s gaps)
segmentation: 78 segments of 16384 bins
=> frequencies: 0.03125-256 Hz.
Power spectra will be calculated in Miyamoto-normalization.
Calculating power spectrum for rate1. RMS(0.03125-256 Hz) = 27.1%
Calculating power spectrum for rate2. RMS(0.03125-256 Hz) = 25.7%
Calculating cross power spectrum (=> coherence and timelags) for rate1 and rate2.
</pre>

This is right now the only place at which <tt>foucalc</tt> will complain if the lightcurve contains gap. It will calculate the quantities even if the lightcurve contains gaps - only you can't trust your results. Therefore: use verbose, check that you've done everything right, at least while building up your scripts.

Plot the PSD for the first lightcurve with:

<pre>
xlog;ylog;plot_with_err(result.freq,result.signormpsd1,result.errnormpsd1);
</pre>

=== Rebinning the PSD ===

The uncertainties on the individual PSDs values are still large, especially at high frequencies. To further improve the SNR, the PSD is rebinned to a new frequency grid and the final PSDs is then the average over the individual PSDs at the frequencies corresponding to the frequencies included into the new frequency bin. Mostly, a logarithmic rebinning with df/f = const. is used, a typical value would be df/f = 0.15 .

Quantities calculated with <tt>foucalc</tt> are rebinned with the <tt>rebin_fouquan</tt> tool - the quantity and it's error have to be rebinned in two individual steps:

<pre>
variable reb_psd = rebin_fouquan(result.freq,result.signormpsd1,
result.numavgall;logfreq=0.15);
variable reb_err = rebin_fouquan(result.freq,result.errnormpsd1,
result.numavgall;logfreq=0.15);
</pre>

<tt>reb_err</tt> does not yet contain the real errors of the psds, but needs to be weighted with the square root of the number of values the averaging was performed over. The final PSD is therefore:

<pre>
variable psd1 = struct{freq_lo = reb_psd.freq_lo,freq_hi=reb_psd.freq_hi,
value = reb_psd.value, error= reb_err.value/sqrt(reb_err.n)};
</pre>

Once again plot you PSD - either as PSD vs. frequency or PSD x frequency vs. frequency:

<pre>
%%PSD vs. frequency
xlog;ylog;plot_with_err((psd1.freq_lo+psd1.freq_hi)/2,psd1.value,psd1.error);

%%PSDxfreuency vs. frequency
xlog;ylog;plot_with_err((psd1.freq_lo+psd1.freq_hi)/2, psd1.value*(psd1.freq_lo+psd1.freq_hi)/2,
psd1.error*(psd1.freq_lo+psd1.freq_hi)/2);
</pre>

== Lag-energy spectrum for archival XMM-Newton data ==

--- under construction ---

The following is an example how to compute PSDs, a lag-frequency spectrum, and a lag-energy spectrum on archival XMM-Newton data of GX 339-4 (written by OK, please ask if something is unclear) <ref>The corresponding publication is [https://ui.adsabs.harvard.edu/abs/2011MNRAS.414L..60U/abstract Uttley, P. e al, MNRAS, Vol. 414, I. 1, pp. L60-L64 (2011)]</ref>.

We start by extracting the XMM-Newton PN lightcurve in two energy bands (500-900eV and 2000-3000eV)

<pre>
#!/bin/tcsh
source $SOFTDIR/sas_init.csh # initialize the SAS software
set xmmscripts=${XMMTOOLS} # make sure the proper xmmscripts are loaded
set obsid='0204730201'
set datadir=/userdata/data/koenig/GX339-4/XMM-2004-03-16/odf
set dt=0.1

${xmmscripts}/xmmprepare --datadir=$datadir --prepdir=$obsid --pn --noapplyflaregti --timing --notimelog # prepare the data

${xmmscripts}/xmmextract --prepdir=$obsid --pn --timing --full --energyband="500,900" --noflarescreen --defaultpattern --dt=$dt --clobber
</pre>

Now we can start the analysis. Let's load the data and correct them for the telemetry drop-outs (encoded in the Good Time Intervals):

<pre>
%% Load the lightcurve and GTI file
a=fits_read_table("full_sd_0.1s_0500-0900.lc");
b=fits_read_table("full_sd_0.1s_2000-3000.lc");
gtia=fits_read_table("full_sd_0.1s_0500-0900.lc[GTI0006]");
gtib=fits_read_table("full_sd_0.1s_2000-3000.lc[GTI0006]");

%% Get the start time such that LC starts at 0s
tstart=fits_read_key("full_sd_0.1s_0500-0900.lc[1]", "TSTART");

%% Subtract TSTART and do GTI correction
(filta,filtb) = filter_gti(a.time, gtia), filter_gti(b.time,gtib);
(timea,timeb) = a.time[filta]-tstart,b.time[filtb]-tstart;
(countsa,countsb) = a.counts[filta],b.counts[filtb];
</pre>

If we plot the (re-binned) lightcurve, there is not much to see.

[[File:gx399m4_xmm_lc.jpg]]

[[File:gx399m4_xmm_lc.pdf]]

But, we can do a Fourier analysis in order to reveal the variability and correlations of these lightcurves (and ignore the warnings of <code>foucalc</code> if verbose is set that there are gaps in the lightcurve).

<pre>
%% Choose segment length
dimseg=8192; %% (bins), should be a power of 2 for FFT

%% Compute PSDs, CPD, and time lags with foucalc
r=foucalc( struct{time=timea, rate1=countsa/dt, rate2=countsb/dt}, dimseg ; normtype="Miyamoto");
xlog;ylog;plot_with_err(r.freq,r.signormpsd1*r.freq,r.errnormpsd1*r.freq);
</pre>

[[File:Gx339m4 xmm psd unbinned.png]]

[[File:Gx399m4 xmm psd unbinned.pdf]]

This really needs some re-binning to increase the S/N-ratio, which can be done with the <code>rebin_fouquan</code> routine.

<pre>
%% Choose Delta f/f, the logarithmic frequency resolution
dff=0.15
reb_psd1 = rebin_fouquan(r.freq, r.signormpsd1, r.numavgall ; logfreq=dff);
reb_err1 = rebin_fouquan(r.freq, r.errnormpsd1, r.numavgall ; logfreq=dff);
reb_psd2 = rebin_fouquan(r.freq, r.signormpsd2, r.numavgall ; logfreq=dff);
reb_err2 = rebin_fouquan(r.freq, r.errnormpsd2, r.numavgall ; logfreq=dff);

%% Need to weight the PSD error with the square root of the number of values the averaging was performed over
hplot_with_err( reb_psd1.freq_lo, reb_psd1.freq_hi, reb_psd1.value*reb_psd1.freq_lo, reb_err1.value/sqrt(reb_err1.n)*reb_psd1.freq_lo );
</pre>

[[File:Gx339m4 xmm psd binned.png]]

[[File:Gx339m4 xmm psd binned.pdf]]

<code>foucalc</code> also computes the time lag between the two lightcurves. Let's first rebin and then plot them together with the coherence:

<pre>
%% Rebin time lag results
variable reb_lag12 = rebin_fouquan(r.freq, r.lag12, r.numavgall ; logfreq=dff);
variable reb_errlag12 = rebin_fouquan(r.freq, r.errlag12, r.numavgall ; logfreq=dff);
hplot_with_err(reb_lag12.freq_lo, reb_lag12.freq_hi, reb_lag12.value, reb_errlag12.value/sqrt(reb_errlag12.n) );

%% Rebin coherence function
variable reb_cof12 = rebin_fouquan(r.freq, r.cof12, r.numavgall ; logfreq=dff);
variable reb_errcof12 = rebin_fouquan(r.freq, r.errcof12, r.numavgall ; logfreq=dff);
hplot_with_err( reb_cof12.freq_lo, reb_cof12.freq_hi, reb_cof12.value, reb_errcof12.value/sqrt(reb_errcof12.n) );
</pre>

[[File:Gx339m4_xmm_tlag.png]] [[File:Gx339m4_xmm_coherence.png]]

[[File:Gx339m4_xmm_tlag.pdf]] [[File:Gx339m4_xmm_coherence.pdf]]

Explain large error bars, explain decay, explain coherence>1

---

<references/>

[[Category:Isis / Slang]]

Timing tools

2020-02-12T15:30:45Z

Koenig:

[In work! You might use it as a reference in the meantime, but some things are not yet covered. Also let me know if things are not clear! -- VG]

== Foucalc ==

The basic tool for X-ray timing analysis with the Remeis scripts is ''foucalc'' <ref>The original version of the Remeis timing scripts were written by Katja Pottschmidt. When using the tools, please cite [http://adsabs.harvard.edu/abs/2003A%26A...407.1039P Pottschmidt et al. 2003, A&A 407, 1039] and [http://adsabs.harvard.edu/abs/2000A%26A...357L..17P Pottschmidt et al. 2000, A&A 357, L17]; see also [http://adsabs.harvard.edu/abs/1999ApJ...510..874N Nowak et al., 1999, ApJ 510, 874]</ref>, which calculates power-, cross power-, coherence- and timelag-spectra <ref>What these are is wonderfully explained in Katja Pottschmidt's [http://astro.uni-tuebingen.de/publications/pottschmidt-diss.shtml PhD Thesis]</ref>. It requires '''equally spaced, gapless''' lightcurves as well as the length of the lightcurve segment on which the Fourier transformation is to be performed, given in number of bins. Note that because the underlying algorithm is FFT, the segment length should be a power of two to increase the performance.

When only one lightcurve is given, <tt>foucalc</tt> calculates the power density and related quantities only. When more than one lightcurve is given, the cross power-, coherence- and timelag-spectra are calculated for all pairs of lightcurves. The lightcurves have to be in the format:

<pre>
lc = struct { time=[t_1, t_2, ...], rate1=[r1_1, r1_2, ...], rate2=..., rate3= };
</pre>

The time has to be given in seconds (so be cautious when using <tt>fits_read_lc</tt>, which usually returns the time in MJD).

If you use RXTE/PCA lightcurves, don't forget to set the <tt>numinst</tt> keyword, which defines the number of instruments (=PCUs) on, since otherwise your noise correction will be wrong. If you are not using RXTE/PCA set the <tt>deadtime</tt> keyword to whatever is appropriate for the instrument you are using (e.g. 0).

Given a single PSD value before any further calculations, its uncertainty will be of the same order of magnitude as the PSD itself. Averaging therefore crucial. This is build in into <tt>foucalc</tt>: given a lightcurve of say 1288192 bins and a segment length of 16384, foucalc will calculate a PSDs on every segment and average every value over all 1288192/15385 = 78 segments.

== PSDs ==

=== Calculating the PSD ===

Given two PCA lightcurves, <pre>50110-01-45-00_437_AND_good_14off_excl_0-10.lc</pre> and <pre>50110-01-45-00_437_AND_good_14off_excl_11-13.lc</pre> (which have been checked for gaps and found to be gapless <ref>A useful function for this is <tt>split_lc_at_gaps</tt></ref> ) we want to calculate and bin the PSD, lags and coherence.

<pre>
%% read in lightcurves
variable lc1 = fits_read_table("50110-01-45-00_438_AND_good_14off_excl_0-10.lc");
variable lc2 = fits_read_table("50110-01-45-00_438_AND_good_14off_excl_11-13.lc");

%%define variables to store average rate of lightcurve & rms
variable rms,avg;

%%calculate timing quantities
variable result = foucalc(struct{time=lc1.time,rate1=lc1.rate,rate2=lc2.rate},16384;
numinst=3,RMS=&rms,avgrate=&avg,verbose);
</pre>

This produces the following output - thank to the <tt>verbose</tt> keyword:

<pre>
light curves: 2516 s with 1288192 bins of 0.00195312 s (0 s gaps)
segmentation: 78 segments of 16384 bins
=> frequencies: 0.03125-256 Hz.
Power spectra will be calculated in Miyamoto-normalization.
Calculating power spectrum for rate1. RMS(0.03125-256 Hz) = 27.1%
Calculating power spectrum for rate2. RMS(0.03125-256 Hz) = 25.7%
Calculating cross power spectrum (=> coherence and timelags) for rate1 and rate2.
</pre>

This is right now the only place at which <tt>foucalc</tt> will complain if the lightcurve contains gap. It will calculate the quantities even if the lightcurve contains gaps - only you can't trust your results. Therefore: use verbose, check that you've done everything right, at least while building up your scripts.

Plot the PSD for the first lightcurve with:

<pre>
xlog;ylog;plot_with_err(result.freq,result.signormpsd1,result.errnormpsd1);
</pre>

=== Rebinning the PSD ===

The uncertainties on the individual PSDs values are still large, especially at high frequencies. To further improve the SNR, the PSD is rebinned to a new frequency grid and the final PSDs is then the average over the individual PSDs at the frequencies corresponding to the frequencies included into the new frequency bin. Mostly, a logarithmic rebinning with df/f = const. is used, a typical value would be df/f = 0.15 .

Quantities calculated with <tt>foucalc</tt> are rebinned with the <tt>rebin_fouquan</tt> tool - the quantity and it's error have to be rebinned in two individual steps:

<pre>
variable reb_psd = rebin_fouquan(result.freq,result.signormpsd1,
result.numavgall;logfreq=0.15);
variable reb_err = rebin_fouquan(result.freq,result.errnormpsd1,
result.numavgall;logfreq=0.15);
</pre>

<tt>reb_err</tt> does not yet contain the real errors of the psds, but needs to be weighted with the square root of the number of values the averaging was performed over. The final PSD is therefore:

<pre>
variable psd1 = struct{freq_lo = reb_psd.freq_lo,freq_hi=reb_psd.freq_hi,
value = reb_psd.value, error= reb_err.value/sqrt(reb_err.n)};
</pre>

Once again plot you PSD - either as PSD vs. frequency or PSD x frequency vs. frequency:

<pre>
%%PSD vs. frequency
xlog;ylog;plot_with_err((psd1.freq_lo+psd1.freq_hi)/2,psd1.value,psd1.error);

%%PSDxfreuency vs. frequency
xlog;ylog;plot_with_err((psd1.freq_lo+psd1.freq_hi)/2, psd1.value*(psd1.freq_lo+psd1.freq_hi)/2,
psd1.error*(psd1.freq_lo+psd1.freq_hi)/2);
</pre>

== Lag-energy spectrum for archival XMM-Newton data ==

--- under construction ---

The following is an example how to compute PSDs, a lag-frequency spectrum, and a lag-energy spectrum on archival XMM-Newton data of GX 339-4 (written by OK, please ask if something is unclear) <ref>The corresponding publication is [https://ui.adsabs.harvard.edu/abs/2011MNRAS.414L..60U/abstract Uttley, P. e al, MNRAS, Vol. 414, I. 1, pp. L60-L64 (2011)]</ref>.

We start with extracting the lightcurve in two energy bands (500-900eV and 2000-3000eV) with

<pre>
#!/bin/tcsh
source $SOFTDIR/sas_init.csh # initialize the SAS software
set xmmscripts=${XMMTOOLS} # make sure the proper xmmscripts are loaded
set obsid='0204730201'
set datadir=/userdata/data/koenig/GX339-4/XMM-2004-03-16/odf
set dt=0.1

${xmmscripts}/xmmprepare --datadir=$datadir --prepdir=$obsid --pn --noapplyflaregti --timing --notimelog # prepare the data

${xmmscripts}/xmmextract --prepdir=$obsid --pn --timing --full --energyband="500,900" --noflarescreen --defaultpattern --dt=$dt --clobber
</pre>

Now we load the data and correct them for the telemetry drop-outs
(encoded in the Good Time Intervals):

<pre>
%% Load the lightcurve and GTI file
a=fits_read_table("full_sd_0.1s_0500-0900.lc");
b=fits_read_table("full_sd_0.1s_2000-3000.lc");
gtia=fits_read_table("full_sd_0.1s_0500-0900.lc[GTI0006]");
gtib=fits_read_table("full_sd_0.1s_2000-3000.lc[GTI0006]");

%% Get the start time such that LC starts at 0s
tstart=fits_read_key("full_sd_0.1s_0500-0900.lc[1]", "TSTART");

%% Subtract TSTART and do GTI correction
(filta,filtb) = filter_gti(a.time, gtia), filter_gti(b.time,gtib);
(timea,timeb) = a.time[filta]-tstart,b.time[filtb]-tstart;
(countsa,countsb) = a.counts[filta],b.counts[filtb];
</pre>

If we plot the (re-binned) lightcurve, there is not much to see.

[[File:gx399m4_xmm_lc.jpg]]

[[File:gx399m4_xmm_lc.pdf]]

But, we can do a Fourier analysis in order to reveal the variability and correlations of these lightcurves (and ignore the warnings of foucalc if verbose is set that there are gaps in the lightcurve).

<pre>
%% Choose segment length
dimseg=8192; %% (bins), should be a power of 2 for FFT

%% Compute PSDs, CPD, and time lags with foucalc
r=foucalc( struct{time=timea, rate1=countsa/dt, rate2=countsb/dt}, dimseg ; normtype="Miyamoto");
xlog;ylog;plot_with_err(r.freq,r.signormpsd1*r.freq,r.errnormpsd1*r.freq);
</pre>

[[File:Gx339m4 xmm psd unbinned.png]]

[[File:Gx399m4 xmm psd unbinned.pdf]]

This really needs some re-binning to increase the S/N-ratio, which can be done with the <code>rebin_fouquan</code> routine.

<pre>
%% Choose Delta f/f, the logarithmic frequency resolution
dff=0.15
reb_psd1 = rebin_fouquan(r.freq, r.signormpsd1, r.numavgall ; logfreq=dff);
reb_err1 = rebin_fouquan(r.freq, r.errnormpsd1, r.numavgall ; logfreq=dff);
reb_psd2 = rebin_fouquan(r.freq, r.signormpsd2, r.numavgall ; logfreq=dff);
reb_err2 = rebin_fouquan(r.freq, r.errnormpsd2, r.numavgall ; logfreq=dff);

%% Need to weight the PSD error with the square root of the number of values the averaging was performed over
hplot_with_err( reb_psd1.freq_lo, reb_psd1.freq_hi, reb_psd1.value*reb_psd1.freq_lo, reb_err1.value/sqrt(reb_err1.n)*reb_psd1.freq_lo );
</pre>

[[File:Gx339m4 xmm psd binned.png]]

[[File:Gx339m4 xmm psd binned.pdf]]

<code>foucalc</code> also computes the time lag between the two lightcurves. Let's first rebin and then plot them together with the coherence:

<pre>
%% Rebin time lag results
variable reb_lag12 = rebin_fouquan(r.freq, r.lag12, r.numavgall ; logfreq=dff);
variable reb_errlag12 = rebin_fouquan(r.freq, r.errlag12, r.numavgall ; logfreq=dff);
hplot_with_err(reb_lag12.freq_lo, reb_lag12.freq_hi, reb_lag12.value, reb_errlag12.value/sqrt(reb_errlag12.n) );

%% Rebin coherence function
variable reb_cof12 = rebin_fouquan(r.freq, r.cof12, r.numavgall ; logfreq=dff);
variable reb_errcof12 = rebin_fouquan(r.freq, r.errcof12, r.numavgall ; logfreq=dff);
hplot_with_err( reb_cof12.freq_lo, reb_cof12.freq_hi, reb_cof12.value, reb_errcof12.value/sqrt(reb_errcof12.n) );
</pre>

[[File:Gx339m4_xmm_tlag.png]] [[File:Gx339m4_xmm_coherence.png]]

[[File:Gx339m4_xmm_tlag.pdf]] [[File:Gx339m4_xmm_coherence.pdf]]

<references/>

[[Category:Isis / Slang]]

File:Gx339m4 xmm tlag.png

2020-02-12T15:30:34Z

Koenig: Koenig uploaded a new version of File:Gx339m4 xmm tlag.png

File:Gx339m4 xmm tlag.pdf

2020-02-12T15:29:59Z

Koenig: Koenig uploaded a new version of File:Gx339m4 xmm tlag.pdf

File:Gx339m4 xmm coherence.pdf

2020-02-12T15:27:29Z

Koenig: Koenig uploaded a new version of File:Gx339m4 xmm coherence.pdf

File:Gx339m4 xmm coherence.png

2020-02-12T15:27:02Z

Koenig: Koenig uploaded a new version of File:Gx339m4 xmm coherence.png

Timing tools

2020-02-12T15:06:59Z

Koenig:

[In work! You might use it as a reference in the meantime, but some things are not yet covered. Also let me know if things are not clear! -- VG]

== Foucalc ==

The basic tool for X-ray timing analysis with the Remeis scripts is ''foucalc'' <ref>The original version of the Remeis timing scripts were written by Katja Pottschmidt. When using the tools, please cite [http://adsabs.harvard.edu/abs/2003A%26A...407.1039P Pottschmidt et al. 2003, A&A 407, 1039] and [http://adsabs.harvard.edu/abs/2000A%26A...357L..17P Pottschmidt et al. 2000, A&A 357, L17]; see also [http://adsabs.harvard.edu/abs/1999ApJ...510..874N Nowak et al., 1999, ApJ 510, 874]</ref>, which calculates power-, cross power-, coherence- and timelag-spectra <ref>What these are is wonderfully explained in Katja Pottschmidt's [http://astro.uni-tuebingen.de/publications/pottschmidt-diss.shtml PhD Thesis]</ref>. It requires '''equally spaced, gapless''' lightcurves as well as the length of the lightcurve segment on which the Fourier transformation is to be performed, given in number of bins. Note that because the underlying algorithm is FFT, the segment length should be a power of two to increase the performance.

When only one lightcurve is given, <tt>foucalc</tt> calculates the power density and related quantities only. When more than one lightcurve is given, the cross power-, coherence- and timelag-spectra are calculated for all pairs of lightcurves. The lightcurves have to be in the format:

<pre>
lc = struct { time=[t_1, t_2, ...], rate1=[r1_1, r1_2, ...], rate2=..., rate3= };
</pre>

The time has to be given in seconds (so be cautious when using <tt>fits_read_lc</tt>, which usually returns the time in MJD).

If you use RXTE/PCA lightcurves, don't forget to set the <tt>numinst</tt> keyword, which defines the number of instruments (=PCUs) on, since otherwise your noise correction will be wrong. If you are not using RXTE/PCA set the <tt>deadtime</tt> keyword to whatever is appropriate for the instrument you are using (e.g. 0).

Given a single PSD value before any further calculations, its uncertainty will be of the same order of magnitude as the PSD itself. Averaging therefore crucial. This is build in into <tt>foucalc</tt>: given a lightcurve of say 1288192 bins and a segment length of 16384, foucalc will calculate a PSDs on every segment and average every value over all 1288192/15385 = 78 segments.

== PSDs ==

=== Calculating the PSD ===

Given two PCA lightcurves, <pre>50110-01-45-00_437_AND_good_14off_excl_0-10.lc</pre> and <pre>50110-01-45-00_437_AND_good_14off_excl_11-13.lc</pre> (which have been checked for gaps and found to be gapless <ref>A useful function for this is <tt>split_lc_at_gaps</tt></ref> ) we want to calculate and bin the PSD, lags and coherence.

<pre>
%% read in lightcurves
variable lc1 = fits_read_table("50110-01-45-00_438_AND_good_14off_excl_0-10.lc");
variable lc2 = fits_read_table("50110-01-45-00_438_AND_good_14off_excl_11-13.lc");

%%define variables to store average rate of lightcurve & rms
variable rms,avg;

%%calculate timing quantities
variable result = foucalc(struct{time=lc1.time,rate1=lc1.rate,rate2=lc2.rate},16384;
numinst=3,RMS=&rms,avgrate=&avg,verbose);
</pre>

This produces the following output - thank to the <tt>verbose</tt> keyword:

<pre>
light curves: 2516 s with 1288192 bins of 0.00195312 s (0 s gaps)
segmentation: 78 segments of 16384 bins
=> frequencies: 0.03125-256 Hz.
Power spectra will be calculated in Miyamoto-normalization.
Calculating power spectrum for rate1. RMS(0.03125-256 Hz) = 27.1%
Calculating power spectrum for rate2. RMS(0.03125-256 Hz) = 25.7%
Calculating cross power spectrum (=> coherence and timelags) for rate1 and rate2.
</pre>

This is right now the only place at which <tt>foucalc</tt> will complain if the lightcurve contains gap. It will calculate the quantities even if the lightcurve contains gaps - only you can't trust your results. Therefore: use verbose, check that you've done everything right, at least while building up your scripts.

Plot the PSD for the first lightcurve with:

<pre>
xlog;ylog;plot_with_err(result.freq,result.signormpsd1,result.errnormpsd1);
</pre>

=== Rebinning the PSD ===

The uncertainties on the individual PSDs values are still large, especially at high frequencies. To further improve the SNR, the PSD is rebinned to a new frequency grid and the final PSDs is then the average over the individual PSDs at the frequencies corresponding to the frequencies included into the new frequency bin. Mostly, a logarithmic rebinning with df/f = const. is used, a typical value would be df/f = 0.15 .

Quantities calculated with <tt>foucalc</tt> are rebinned with the <tt>rebin_fouquan</tt> tool - the quantity and it's error have to be rebinned in two individual steps:

<pre>
variable reb_psd = rebin_fouquan(result.freq,result.signormpsd1,
result.numavgall;logfreq=0.15);
variable reb_err = rebin_fouquan(result.freq,result.errnormpsd1,
result.numavgall;logfreq=0.15);
</pre>

<tt>reb_err</tt> does not yet contain the real errors of the psds, but needs to be weighted with the square root of the number of values the averaging was performed over. The final PSD is therefore:

<pre>
variable psd1 = struct{freq_lo = reb_psd.freq_lo,freq_hi=reb_psd.freq_hi,
value = reb_psd.value, error= reb_err.value/sqrt(reb_err.n)};
</pre>

Once again plot you PSD - either as PSD vs. frequency or PSD x frequency vs. frequency:

<pre>
%%PSD vs. frequency
xlog;ylog;plot_with_err((psd1.freq_lo+psd1.freq_hi)/2,psd1.value,psd1.error);

%%PSDxfreuency vs. frequency
xlog;ylog;plot_with_err((psd1.freq_lo+psd1.freq_hi)/2, psd1.value*(psd1.freq_lo+psd1.freq_hi)/2,
psd1.error*(psd1.freq_lo+psd1.freq_hi)/2);
</pre>

== Lag-energy spectrum for archival XMM-Newton data ==

--- under construction ---

The following is an example how to compute PSDs, a lag-frequency spectrum, and a lag-energy spectrum on archival XMM-Newton data of GX 339-4 (written by OK, please ask if something is unclear) <ref>The corresponding publication is [https://ui.adsabs.harvard.edu/abs/2011MNRAS.414L..60U/abstract Uttley, P. e al, MNRAS, Vol. 414, I. 1, pp. L60-L64 (2011)]</ref>.

We start with extracting the lightcurve in two energy bands (500-900eV and 2000-3000eV) with

<pre>
#!/bin/tcsh
source $SOFTDIR/sas_init.csh # initialize the SAS software
set xmmscripts=${XMMTOOLS} # make sure the proper xmmscripts are loaded
set obsid='0204730201'
set datadir=/userdata/data/koenig/GX339-4/XMM-2004-03-16/odf
set dt=0.1

${xmmscripts}/xmmprepare --datadir=$datadir --prepdir=$obsid --pn --noapplyflaregti --timing --notimelog # prepare the data

${xmmscripts}/xmmextract --prepdir=$obsid --pn --timing --full --energyband="500,900" --noflarescreen --defaultpattern --dt=$dt --clobber
</pre>

Now we load the data and correct them for the telemetry drop-outs
(encoded in the Good Time Intervals):

<pre>
%% Load the lightcurve and GTI file
a=fits_read_table("full_sd_0.1s_0500-0900.lc");
b=fits_read_table("full_sd_0.1s_2000-3000.lc");
gtia=fits_read_table("full_sd_0.1s_0500-0900.lc[GTI0006]");
gtib=fits_read_table("full_sd_0.1s_2000-3000.lc[GTI0006]");

%% Get the start time such that LC starts at 0s
tstart=fits_read_key("full_sd_0.1s_0500-0900.lc[1]", "TSTART");

%% Subtract TSTART and do GTI correction
(filta,filtb) = filter_gti(a.time, gtia), filter_gti(b.time,gtib);
(timea,timeb) = a.time[filta]-tstart,b.time[filtb]-tstart;
(countsa,countsb) = a.counts[filta],b.counts[filtb];
</pre>

If we plot the (re-binned) lightcurve, there is not much to see.

[[File:gx399m4_xmm_lc.jpg]]

[[File:gx399m4_xmm_lc.pdf]]

But, we can do a Fourier analysis in order to reveal the variability and correlations of these lightcurves (and ignore the warnings of foucalc if verbose is set that there are gaps in the lightcurve).

<pre>
%% Choose segment length
dimseg=8192; %% (bins), should be a power of 2 for FFT

%% Compute PSDs, CPD, and time lags with foucalc
r=foucalc( struct{time=timea, rate1=countsa/dt, rate2=countsb/dt}, dimseg ; normtype="Miyamoto");
xlog;ylog;plot_with_err(r.freq,r.signormpsd1*r.freq,r.errnormpsd1*r.freq);
</pre>

[[File:Gx339m4 xmm psd unbinned.png]]

[[File:Gx399m4 xmm psd unbinned.pdf]]

This really needs some re-binning to increase the S/N-ratio, which can be done with the <code>rebin_fouquan</code> routine.

<pre>
%% Choose Delta f/f, the logarithmic frequency resolution
dff=0.15
reb_psd1 = rebin_fouquan(r.freq, r.signormpsd1, r.numavgall ; logfreq=dff);
reb_err1 = rebin_fouquan(r.freq, r.errnormpsd1, r.numavgall ; logfreq=dff);
reb_psd2 = rebin_fouquan(r.freq, r.signormpsd2, r.numavgall ; logfreq=dff);
reb_err2 = rebin_fouquan(r.freq, r.errnormpsd2, r.numavgall ; logfreq=dff);

%% Need to weight the PSD error with the square root of the number of values the averaging was performed over
psd1 = struct{
freq_lo = reb_psd1.freq_lo,
freq_hi = reb_psd1.freq_hi,
value = reb_psd1.value,
error = reb_err1.value/sqrt(reb_err1.n)
};
psd2 = struct{
freq_lo = reb_psd2.freq_lo,
freq_hi = reb_psd2.freq_hi,
value = reb_psd2.value,
error = reb_err2.value/sqrt(reb_err2.n)
};

plot_with_err((psd1.freq_lo+psd1.freq_hi)/2, psd1.value*(psd1.freq_lo+psd1.freq_hi)/2, psd1.error*(psd1.freq_lo+psd1.freq_hi)/2);
</pre>

[[File:Gx339m4 xmm psd binned.png]]

[[File:Gx339m4 xmm psd binned.pdf]]

<code>foucalc</code> also computes the time lag between the two lightcurves. Let's first rebin and then plot them together with the coherence:

<pre>
variable reb_lag12 = rebin_fouquan(r.freq, r.lag12, r.numavgall ; logfreq=dff);
variable reb_errlag12 = rebin_fouquan(r.freq, r.errlag12, r.numavgall ; logfreq=dff);
ylin; plot_with_err((reb_lag12.freq_lo+reb_lag12.freq_hi)/2., reb_lag12.value, reb_errlag12.value);

variable reb_cof12 = rebin_fouquan(r.freq, r.cof12, r.numavgall ; logfreq=dff);
variable reb_errcof12 = rebin_fouquan(r.freq, r.errcof12, r.numavgall ; logfreq=dff);

</pre>

<references/>

[[Category:Isis / Slang]]

File:Gx339m4 xmm tlag.pdf

2020-02-12T15:00:41Z

Koenig:

File:Gx339m4 xmm tlag.png

2020-02-12T15:00:27Z

Koenig:

File:Gx339m4 xmm coherence.png

2020-02-12T15:00:19Z

Koenig:

File:Gx339m4 xmm coherence.pdf

2020-02-12T15:00:11Z

Koenig:

Timing tools

2020-02-12T14:32:19Z

Koenig:

[In work! You might use it as a reference in the meantime, but some things are not yet covered. Also let me know if things are not clear! -- VG]

== Foucalc ==

The basic tool for X-ray timing analysis with the Remeis scripts is ''foucalc'' <ref>The original version of the Remeis timing scripts were written by Katja Pottschmidt. When using the tools, please cite [http://adsabs.harvard.edu/abs/2003A%26A...407.1039P Pottschmidt et al. 2003, A&A 407, 1039] and [http://adsabs.harvard.edu/abs/2000A%26A...357L..17P Pottschmidt et al. 2000, A&A 357, L17]; see also [http://adsabs.harvard.edu/abs/1999ApJ...510..874N Nowak et al., 1999, ApJ 510, 874]</ref>, which calculates power-, cross power-, coherence- and timelag-spectra <ref>What these are is wonderfully explained in Katja Pottschmidt's [http://astro.uni-tuebingen.de/publications/pottschmidt-diss.shtml PhD Thesis]</ref>. It requires '''equally spaced, gapless''' lightcurves as well as the length of the lightcurve segment on which the Fourier transformation is to be performed, given in number of bins. Note that because the underlying algorithm is FFT, the segment length should be a power of two to increase the performance.

When only one lightcurve is given, <tt>foucalc</tt> calculates the power density and related quantities only. When more than one lightcurve is given, the cross power-, coherence- and timelag-spectra are calculated for all pairs of lightcurves. The lightcurves have to be in the format:

<pre>
lc = struct { time=[t_1, t_2, ...], rate1=[r1_1, r1_2, ...], rate2=..., rate3= };
</pre>

The time has to be given in seconds (so be cautious when using <tt>fits_read_lc</tt>, which usually returns the time in MJD).

If you use RXTE/PCA lightcurves, don't forget to set the <tt>numinst</tt> keyword, which defines the number of instruments (=PCUs) on, since otherwise your noise correction will be wrong. If you are not using RXTE/PCA set the <tt>deadtime</tt> keyword to whatever is appropriate for the instrument you are using (e.g. 0).

Given a single PSD value before any further calculations, its uncertainty will be of the same order of magnitude as the PSD itself. Averaging therefore crucial. This is build in into <tt>foucalc</tt>: given a lightcurve of say 1288192 bins and a segment length of 16384, foucalc will calculate a PSDs on every segment and average every value over all 1288192/15385 = 78 segments.

== PSDs ==

=== Calculating the PSD ===

Given two PCA lightcurves, <pre>50110-01-45-00_437_AND_good_14off_excl_0-10.lc</pre> and <pre>50110-01-45-00_437_AND_good_14off_excl_11-13.lc</pre> (which have been checked for gaps and found to be gapless <ref>A useful function for this is <tt>split_lc_at_gaps</tt></ref> ) we want to calculate and bin the PSD, lags and coherence.

<pre>
%% read in lightcurves
variable lc1 = fits_read_table("50110-01-45-00_438_AND_good_14off_excl_0-10.lc");
variable lc2 = fits_read_table("50110-01-45-00_438_AND_good_14off_excl_11-13.lc");

%%define variables to store average rate of lightcurve & rms
variable rms,avg;

%%calculate timing quantities
variable result = foucalc(struct{time=lc1.time,rate1=lc1.rate,rate2=lc2.rate},16384;
numinst=3,RMS=&rms,avgrate=&avg,verbose);
</pre>

This produces the following output - thank to the <tt>verbose</tt> keyword:

<pre>
light curves: 2516 s with 1288192 bins of 0.00195312 s (0 s gaps)
segmentation: 78 segments of 16384 bins
=> frequencies: 0.03125-256 Hz.
Power spectra will be calculated in Miyamoto-normalization.
Calculating power spectrum for rate1. RMS(0.03125-256 Hz) = 27.1%
Calculating power spectrum for rate2. RMS(0.03125-256 Hz) = 25.7%
Calculating cross power spectrum (=> coherence and timelags) for rate1 and rate2.
</pre>

This is right now the only place at which <tt>foucalc</tt> will complain if the lightcurve contains gap. It will calculate the quantities even if the lightcurve contains gaps - only you can't trust your results. Therefore: use verbose, check that you've done everything right, at least while building up your scripts.

Plot the PSD for the first lightcurve with:

<pre>
xlog;ylog;plot_with_err(result.freq,result.signormpsd1,result.errnormpsd1);
</pre>

=== Rebinning the PSD ===

The uncertainties on the individual PSDs values are still large, especially at high frequencies. To further improve the SNR, the PSD is rebinned to a new frequency grid and the final PSDs is then the average over the individual PSDs at the frequencies corresponding to the frequencies included into the new frequency bin. Mostly, a logarithmic rebinning with df/f = const. is used, a typical value would be df/f = 0.15 .

Quantities calculated with <tt>foucalc</tt> are rebinned with the <tt>rebin_fouquan</tt> tool - the quantity and it's error have to be rebinned in two individual steps:

<pre>
variable reb_psd = rebin_fouquan(result.freq,result.signormpsd1,
result.numavgall;logfreq=0.15);
variable reb_err = rebin_fouquan(result.freq,result.errnormpsd1,
result.numavgall;logfreq=0.15);
</pre>

<tt>reb_err</tt> does not yet contain the real errors of the psds, but needs to be weighted with the square root of the number of values the averaging was performed over. The final PSD is therefore:

<pre>
variable psd1 = struct{freq_lo = reb_psd.freq_lo,freq_hi=reb_psd.freq_hi,
value = reb_psd.value, error= reb_err.value/sqrt(reb_err.n)};
</pre>

Once again plot you PSD - either as PSD vs. frequency or PSD x frequency vs. frequency:

<pre>
%%PSD vs. frequency
xlog;ylog;plot_with_err((psd1.freq_lo+psd1.freq_hi)/2,psd1.value,psd1.error);

%%PSDxfreuency vs. frequency
xlog;ylog;plot_with_err((psd1.freq_lo+psd1.freq_hi)/2, psd1.value*(psd1.freq_lo+psd1.freq_hi)/2,
psd1.error*(psd1.freq_lo+psd1.freq_hi)/2);
</pre>

== Lag-energy spectrum for archival XMM-Newton data ==
The following is an example how to compute PSDs, a lag-frequency spectrum, and a lag-energy spectrum on archival XMM-Newton data of GX 339-4 (written by OK, please ask if something is unclear) <ref>The corresponding publication is [https://ui.adsabs.harvard.edu/abs/2011MNRAS.414L..60U/abstract Uttley, P. e al, MNRAS, Vol. 414, I. 1, pp. L60-L64 (2011)]</ref>.

We start with extracting the lightcurve in two energy bands (500-900eV and 2000-3000eV) with

<pre>
#!/bin/tcsh
source $SOFTDIR/sas_init.csh # initialize the SAS software
set xmmscripts=${XMMTOOLS} # make sure the proper xmmscripts are loaded
set obsid='0204730201'
set datadir=/userdata/data/koenig/GX339-4/XMM-2004-03-16/odf
set dt=0.1

${xmmscripts}/xmmprepare --datadir=$datadir --prepdir=$obsid --pn --noapplyflaregti --timing --notimelog # prepare the data

${xmmscripts}/xmmextract --prepdir=$obsid --pn --timing --full --energyband="500,900" --noflarescreen --defaultpattern --dt=$dt --clobber
</pre>

Now we load the data and correct them for the telemetry drop-outs
(encoded in the Good Time Intervals):

<pre>
%% Load the lightcurve and GTI file
a=fits_read_table("full_sd_0.1s_0500-0900.lc");
b=fits_read_table("full_sd_0.1s_2000-3000.lc");
gtia=fits_read_table("full_sd_0.1s_0500-0900.lc[GTI0006]");
gtib=fits_read_table("full_sd_0.1s_2000-3000.lc[GTI0006]");

%% Get the start time such that LC starts at 0s
tstart=fits_read_key("full_sd_0.1s_0500-0900.lc[1]", "TSTART");

%% Subtract TSTART and do GTI correction
(filta,filtb) = filter_gti(a.time, gtia), filter_gti(b.time,gtib);
(timea,timeb) = a.time[filta]-tstart,b.time[filtb]-tstart;
(countsa,countsb) = a.counts[filta],b.counts[filtb];
</pre>

If we plot the (re-binned) lightcurve, there is not much to see.

[[File:gx399m4_xmm_lc.jpg]]

[[File:gx399m4_xmm_lc.pdf]]

But, we can do a Fourier analysis in order to reveal the variability and correlations of these lightcurves (and ignore the warnings of foucalc if verbose is set that there are gaps in the lightcurve).

<pre>
%% Choose segment length
dimseg=8192; %% (bins), should be a power of 2 for FFT

%% Compute PSDs, CPD, and time lags with foucalc
r=foucalc( struct{time=timea, rate1=countsa/dt, rate2=countsb/dt}, dimseg ; normtype="Miyamoto");
xlog;ylog;plot_with_err(r.freq,r.signormpsd1*r.freq,r.errnormpsd1*r.freq);
</pre>

[[File:Gx339m4 xmm psd unbinned.png]]

[[File:Gx399m4 xmm psd unbinned.pdf]]

This really needs some re-binning to increase the S/N-ratio, which can be done with the <code>rebin_fouquan</code> routine.

<pre>
%% Choose Delta f/f, the logarithmic frequency resolution
dff=0.15
reb_psd1 = rebin_fouquan(r.freq, r.signormpsd1, r.numavgall ; logfreq=dff);
reb_err1 = rebin_fouquan(r.freq, r.errnormpsd1, r.numavgall ; logfreq=dff);
reb_psd2 = rebin_fouquan(r.freq, r.signormpsd2, r.numavgall ; logfreq=dff);
reb_err2 = rebin_fouquan(r.freq, r.errnormpsd2, r.numavgall ; logfreq=dff);

%% Need to weight the PSD error with the square root of the number of values the averaging was performed over
psd1 = struct{
freq_lo = reb_psd1.freq_lo,
freq_hi = reb_psd1.freq_hi,
value = reb_psd1.value,
error = reb_err1.value/sqrt(reb_err1.n)
};
psd2 = struct{
freq_lo = reb_psd2.freq_lo,
freq_hi = reb_psd2.freq_hi,
value = reb_psd2.value,
error = reb_err2.value/sqrt(reb_err2.n)
};

plot_with_err((psd1.freq_lo+psd1.freq_hi)/2, psd1.value*(psd1.freq_lo+psd1.freq_hi)/2, psd1.error*(psd1.freq_lo+psd1.freq_hi)/2);
</pre>

[[File:Gx339m4 xmm psd binned.png]]

[[File:Gx339m4 xmm psd binned.pdf]]

<references/>

[[Category:Isis / Slang]]

File:Gx339m4 xmm psd binned.png

2020-02-12T14:31:35Z

Koenig:

File:Gx339m4 xmm psd binned.pdf

2020-02-12T14:31:07Z

Koenig: Koenig uploaded a new version of File:Gx339m4 xmm psd binned.pdf

GX 339-4 binned PSD

File:Gx339m4 xmm psd binned.pdf

2020-02-12T14:30:08Z

Koenig: GX 339-4 binned PSD

GX 339-4 binned PSD

File:Gx339m4 xmm psd unbinned.png

2020-02-12T14:16:33Z

Koenig: Unbinned power-spectrum of GX 339-4

Unbinned power-spectrum of GX 339-4

File:Gx399m4 xmm psd unbinned.pdf

2020-02-12T14:15:24Z

Koenig: Unbinned power spectrum of GX 399-4

Unbinned power spectrum of GX 399-4

2019-09-26T12:33:39Z

Koenig:

[[Category:Accreting X-ray Pulsars]]

'''Other names''' : 2EG J1746-2852 ([http://simbad.u-strasbg.fr/simbad/sim-basic?Ident=GRO+J1744-28&submit=SIMBAD+search])

'''Available data''': NuSTAR ObsID 80202027002

'''Monitoring data''':
[https://swift.gsfc.nasa.gov/results/transients/weak/GROJ1744-28/ Swift/BAT]

= Type =
Transient Low-mass X-ray Binary exhibiting Type I and II X-ray bursts and pulsations. Next to the Rapid Burster this is one of a few sources where Type II bursts are observed.
Discovered on 1995 December 2 with the Burst And Transient Source Experiment (BATSE) on-board the Compton Gamma Ray Observatory (<ref name="Kouveliotou96A"/>)

= Coordinates =

RA 17h 44‘ 33.09“ DEC -28° 44‘ 27.0“

= Binary system =

* Distance: 7.5-8.5 kpc (<ref name="Augusteijn97"/>, <ref name="Nishiuchi99"/>)
* Optical companion: G4 III star (<ref name="Gosling07A"/>, <ref name="Masetti14Atel"/>) with M<0.4M_sun and inclination i>15° (<ref name="Gosling07A"/>)

== Orbit ==

The orbital parameters were approximated to Porb = 11.836 days, T π/2 = 2456696.19880 (JED), ax sin(i) = 2.637 light-sec on the basis of the 2014 outburst with no constrains on the longitude of periastron or eccentricity (<ref name="Pintore14Atel"/>).
See [https://gammaray.msfc.nasa.gov/gbm/science/pulsars/lightcurves/groj1744.html NSSTC Gamma Ray Astrophysics].

== Pulsations & Magnetic field ==

GRO J1744-28 is special because it exhibits X-ray bursts and pulsations at the same time. Sources which show X-ray bursts are generally believed to have surface conditions (low B-fields) which do not allow pulsations.
Pulse period: 2.14Hz <ref name="Finger96A"/>

The magnetic field strength deduced from disk reflection models lies in the 2–6×10^10 G range (Degenaar et al. 2014), mismatching the values deduced from the CRSF measurements (5.27±0.06 × 10^11 G <ref name="DAi15A"/>) by one order of magnitude.

== Outbursts ==

* 1995 December: Discovery and first report of Type II X-ray bursts (<ref name="Finger96A"/>)
* 1996 December: Similar burst characteristics (<ref name="Woods99"/>), CRSF report at 5keV in BeppoSAX data (not yet proven) (<ref name="Doroshenko15A"/>)
* 2014 February: Outburst after 18 years of quiescence (<ref name="Younes15"/>, no CRSF), CRSF report at 5keV, 10keV and 15keV in XMM-Newton/INTEGRAL data, still under debate (<ref name="DAi15A"/>)
* 2017 February: Fourth outburst with ~two orders of magnitude lower luminosity (Koenig et al. in prep.)

== X-ray Spectrum ==

* Spectrum shows typical cut-off powerlaw like expected from accreting X-ray binary
* Broad iron line at 6-7 keV

=== Cyclotron Features ===

Cyclotron line in this source is under debate

* Fundamental CRSF at 4.68±0.05 keV (gabs, XMM-Newton/INTEGRAL, 2014 outburst <ref name="DAi15A"/>) / ∼4.5 keV (gabs, BeppoSAX, 1997 outburst <ref name="Doroshenko15A"/>)
* Indication of second and third harmonic at 10.4±0.1 keV and 15.8+1.3−0.7 keV in XMM-Newton/INTEGRAL data (using gabs) (<ref name="DAi15A"/>)
* GRO J1744−28 one of the few LMXBs where a CRSF has been reported below 10 keV (Other candidates are X1822−371 with a claimed cyclotron line energy of 0.7 keV (<ref name="Iaria15A"/>) and SWIFT J0051.8−7320 at 5 keV (<ref name="Maitra18A"/>)
* No cyclotron line in low-flux 2017 February outburst (König et al. in prep.)

'''References'''