def psd(self,xstr,nfft=256,noverlap=0,coarsable=False):
"""Return the PSD(power spectral density) of the time-series
Positional parameter:
xstr -- string naming the observable, either 'A', 'E', or 'T'
Keyword parameters:
nfft -- length of the fast fourier transform (fft) (default 256)
noverlap -- number of data points overlapping between segments (default 0)
coarsable -- return the PSD as a Coarsable object (default False)
OUTPUT:
f -- frequencies
P -- PSD
Note:
The PSD is calculated using pl.psd() with an additional factor of dt in the normalisation.
This gives the correct dimension.
"""
x = getattr(self,xstr)
fs = 1. / x.Cadence1
P , f = pl.psd( x.data , nfft , fs , noverlap=noverlap , scale_by_freq=False )
P = P / fs
if coarsable:
scale = {'Offset1' : f[0] ,
'Cadence1': f[1] - f[0] }
f = AS.Coarsable( f , **scale )
P = AS.Coarsable( P , **scale )
return f , P
def G1Michelson_to_G1Sagnac( FT ) :
L = 16.6782
f = FT.s1.Offset1 + FT.s1.Cadence1 * np.arange( FT.s1.data.shape[0] )
fdict = { 'Offset1' : FT.s1.Offset1 , 'Cadence1' : FT.s1.Cadence1 }
Xdata , Ydata , Zdata = FT.s1.data , FT.s2.data , FT.s3.data
e1 = np.exp( - 1j * 2 * np.pi * L * f )
e2 = np.exp( - 1j * 4 * np.pi * L * f )
e3 = np.exp( - 1j * 6 * np.pi * L * f )
A = 1 - e1 + e2
B = 1 - e1 - e2 + e3
alphadata = ( A*Xdata + e1 * ( Ydata + Zdata ) ) / B
betadata = ( A*Ydata + e1 * ( Zdata + Xdata ) ) / B
gammadata = ( A*Zdata + e1 * ( Xdata + Ydata ) ) / B
alpha = AS.Coarsable( alphadata , **fdict )
beta = AS.Coarsable( betadata , **fdict )
gamma = AS.Coarsable( gammadata , **fdict )
SagnacFT = AS.ShortTermFT( alpha , beta , gamma )
return SagnacFT
def csd(self,xstr,ystr,nfft=256,noverlap=0,coarsable=False):
"""Return CSD(cross spectral density) of the time-series.
Positional parameters:
xstr -- string naming one observable, either 'A', 'E' or 'T'
ystr -- string naming one observable, either 'A', 'E' or 'T'
Keyword parameters:
nfft -- length of fast fourier transform(fft) (default 256)
noverlap -- number of data points overlapping between segments (default 0)
coarsable -- return the CSD as a Coarsable object (default False)
OUTPUT:
f -- frequencies
P -- CSD
Note:
The CPSD is calculated using pl.csd() with an additional factor of dt in the normalisation.
If xstr='A' and ystr='E', then the CSD between A and E is returned.
"""
x = getattr(self,xstr)
y = getattr(self,ystr)
fs = 1. / x.Cadence1
P , f = pl.csd( x.data , y.data , nfft , fs , noverlap=noverlap )
P = P / fs
if coarsable:
scale = {'Offset1' : f[0] ,
'Cadence1': f[1] - f[0] }
f = AS.Coarsable( f , **scale )
P = AS.Coarsable( P , **scale )
return f , P
def make_arbitrary_tdiORF_SpHs( orfpath , f , IJ='AA' , lmax=0 ) :
"""
This lets you set multipole moments of overlap-reduction function arbitrarily, and save them in the form\n
{'OrfMultipleMoments':\n
{ 'ntrunc': lmax , 'f': f , 'Antenna': IJ , 'real': SpHreal , 'imag': SpHimag } }\n
which is loadable by AnisotropySearch.OrfMultipleMoments()\n
INPUT:
orfpath --- file path to save the orfs\n
f --- frequency/frequencies at which ORF will be computed
IJ --- IJ of ORF
lmax --- Maximum degree l for the SpHs
OUTPUT:
None
"""
""" ###### This is where you define SpHs of real and imaginary parts of ORF. Note that the value returned is for the SpH defined in pyspharm."""
indxp = AS.getMLvec( lmax , m='p' )
SpHimag = np.zeros( ( len(indxp) , f.shape[0] ) , dtype=complex )
if IJ in [ 'AA' , 'EE' , 'TT' ] :
SpHreal = np.ones( ( len(indxp) , f.shape[0] ) , dtype=complex ) * 288. / np.sqrt( 2*np.pi )
elif IJ in [ 'AT','ET','TA','TE', 'AE' , 'EA' ] :
SpHreal = np.ones( ( len(indxp) , f.shape[0] ) , dtype=complex ) * 288. / np.sqrt( 2*np.pi )
""" ###### """
orfdict = {'OrfMultipleMoments':{ 'ntrunc':lmax , 'f':f , 'Antenna':IJ , 'real': SpHreal , 'imag': SpHimag } }
orfdir = os.path.dirname( orfpath )
if orfdir == '' :
pass
elif orfdir not in glob.glob( orfdir ) :
os.system( 'mkdir -p %s' % orfdir )
file = open( orfpath , 'wb' ) ; cpkl.dump( orfdict , file , -1 ) ; file.close()
print " Orf multipole moments saved in %s " % orfpath
return
def FracPhase_to_FracFreq( FT ) :
f = FT.s1.Offset1 + FT.s1.Cadence1 * np.arange( FT.s1.data.shape[0] )
fdict = { 'Offset1' : FT.s1.Offset1 , 'Cadence1' : FT.s1.Cadence1 }
phase1data , phase2data , phase3data = FT.s1.data , FT.s2.data , FT.s3.data
a = 1 / ( 1j * 2 * np.pi * f )
freq1data = phase1data * a
freq2data = phase2data * a
freq3data = phase3data * a
freq1 = AS.Coarsable( freq1data , **fdict )
freq2 = AS.Coarsable( freq2data , **fdict )
freq3 = AS.Coarsable( freq3data , **fdict )
freqFT = AS.ShortTermFT( freq1 , freq2 , freq3 )
return freqFT
def G1Sagnac_to_GmSagnac( FT ) :
L = 16.6782
f = FT.s1.Offset1 + FT.s1.Cadence1 * np.arange( FT.s1.data.shape[0] )
fdict = { 'Offset1' : FT.s1.Offset1 , 'Cadence1' : FT.s1.Cadence1 }
G1adata , G1bdata , G1cdata = FT.s1.data , FT.s2.data , FT.s3.data
e3 = np.exp( - 1j * 6 * np.pi * L * f )
Gmadata = ( e3 - 1 ) * G1adata
Gmbdata = ( e3 - 1 ) * G1bdata
Gmcdata = ( e3 - 1 ) * G1cdata
Gma = AS.Coarsable( Gmadata , **fdict )
Gmb = AS.Coarsable( Gmbdata , **fdict )
Gmc = AS.Coarsable( Gmcdata , **fdict )
GmSagnac = AS.ShortTermFT( Gma , Gmb , Gmc )
return GmSagnac
def GpretdiMichelson_to_G1Michelson( FT ) :
L = 16.6782
f = FT.s1.Offset1 + FT.s1.Cadence1 * np.arange( FT.s1.data.shape[0] )
fdict = { 'Offset1' : FT.s1.Offset1 , 'Cadence1' : FT.s1.Cadence1 }
Xdata , Ydata , Zdata = FT.s1.data , FT.s2.data , FT.s3.data
e2 = np.exp( - 1j * 4 * np.pi * L * f )
G1Xdata = ( e2 - 1 ) * Xdata
G1Ydata = ( e2 - 1 ) * Ydata
G1Zdata = ( e2 - 1 ) * Zdata
G1X = AS.Coarsable( G1Xdata , **fdict )
G1Y = AS.Coarsable( G1Ydata , **fdict )
G1Z = AS.Coarsable( G1Zdata , **fdict )
G1Michelson = AS.ShortTermFT( G1X , G1Y , G1Z )
return G1Michelson
def make_arbitrary_tdiORF_SpHs(orfpath, f, IJ='AA', lmax=0):
"""
This lets you set multipole moments of overlap-reduction function arbitrarily, and save them in the form\n
{'OrfMultipleMoments':\n
{ 'ntrunc': lmax , 'f': f , 'Antenna': IJ , 'real': SpHreal , 'imag': SpHimag } }\n
which is loadable by AnisotropySearch.OrfMultipleMoments()\n
INPUT:
orfpath --- file path to save the orfs\n
f --- frequency/frequencies at which ORF will be computed
IJ --- IJ of ORF
lmax --- Maximum degree l for the SpHs
OUTPUT:
None
"""
""" ###### This is where you define SpHs of real and imaginary parts of ORF. Note that the value returned is for the SpH defined in pyspharm."""
indxp = AS.getMLvec(lmax, m='p')
SpHimag = np.zeros((len(indxp), f.shape[0]), dtype=complex)
if IJ in ['AA', 'EE', 'TT']:
SpHreal = np.ones((len(indxp), f.shape[0]),
dtype=complex) * 288. / np.sqrt(2 * np.pi)
elif IJ in ['AT', 'ET', 'TA', 'TE', 'AE', 'EA']:
SpHreal = np.ones((len(indxp), f.shape[0]),
dtype=complex) * 288. / np.sqrt(2 * np.pi)
""" ###### """
orfdict = {
'OrfMultipleMoments': {
'ntrunc': lmax,
'f': f,
'Antenna': IJ,
'real': SpHreal,
'imag': SpHimag
}
}
orfdir = os.path.dirname(orfpath)
if orfdir == '':
pass
elif orfdir not in glob.glob(orfdir):
os.system('mkdir -p %s' % orfdir)
file = open(orfpath, 'wb')
cpkl.dump(orfdict, file, -1)
file.close()
print " Orf multipole moments saved in %s " % orfpath
return
def TransformMultipoles_Rot323( xlm , rphi , rthe , rpsi ) :
xlm = np.copy( xlm )
ntrunc = np.sqrt( xlm.shape[0] ) - 1
if ( ntrunc % 1 ) != 0 :
print "The length of the entered numpy array does not correspond to an integer ntrunc."
raise ValueError
indxpn = AS.getMLvec( ntrunc )
ylm_rphi = np.array( [ np.exp( - 1j * ml[0] * rphi ) for ml in indxpn ] ) * xlm
ylm_rthe = np.zeros( ylm_rphi.shape , dtype=ylm_rphi.dtype )
for i , ml in enumerate( indxpn ) :
m , l = ml
nls = [ ( n , l ) for n in range( -l , l + 1 , 1 ) ]
ylns = [ ylm_rphi[ indxpn.index( nl ) ] for nl in nls ]
dlnms = [ WignerD( rthe , l , nl[0] , m ) for nl in nls ]
ylm_rthe[ i ] = np.dot( np.array( dlnms ) , np.array( ylns ) )
ylm_rpsi = np.array( [ np.exp( - 1j * ml[0] * rpsi ) for ml in indxpn ] ) * ylm_rthe
return ylm_rpsi
else :
c12 = 2 * np.conj( Y1[ : (N+1)/2 ] ) * Y2[ : (N+1)/2 ] / (N*stime) ; f_c12 = df_c12 * np.arange( (N+1)/2 )
Qc12 = AS.Coarsable( c12 , Offset1=f_c12[0] , Cadence1=df_c12 )
Qf_c12 = AS.Coarsable( f_c12 , Offset1=f_c12[0] , Cadence1=df_c12 )
p11l , f_p11l = pl.psd( y1l , nfft , fs , noverlap=noverlap )
p11r , f_p11r = pl.psd( y1r , nfft , fs , noverlap=noverlap )
p11 = ( p11l + p11r ) / 2 ; f_p11 = np.copy( f_p11l ) ; df_p11 = f_p11[1] - f_p11[0]
Qp11 = AS.Coarsable( p11 , Offset1=f_p11[0] , Cadence1=df_p11 )
Qf_p11 = AS.Coarsable( f_p11 , Offset1=f_p11[0] , Cadence1=df_p11 )
p22l , f_p22l = pl.psd( y2l , nfft , fs , noverlap=noverlap )
p22r , f_p22r = pl.psd( y2r , nfft , fs , noverlap=noverlap )
p22 = ( p22l + p22r ) / 2 ; f_p22 = np.copy( f_p22l ) ; df_p22 = f_p22[1] - f_p22[0]
Qp22 = AS.Coarsable( p22 , Offset1=f_p22[0] , Cadence1=df_p22 )
Qff = AS.coarsefrequency( Qf_c12 , Qf_p11 ) ; Nf = Qff.data.shape[0]
Qcc12 = Qc12.coarsegrain( Offset1=Qff.Offset1 , Cadence1=Qff.Cadence1 , N1=Qff.data.shape[0] )
Qpp11 = Qp11.coarsegrain( Offset1=Qff.Offset1 , Cadence1=Qff.Cadence1 , N1=Qff.data.shape[0] )
Qpp22 = Qp22.coarsegrain( Offset1=Qff.Offset1 , Cadence1=Qff.Cadence1 , N1=Qff.data.shape[0] )
GG = (N*stime*Qff.Cadence1) * 4 * stime**2 * np.sum( 2. / (Qpp11.data * Qpp22.data) )
XX = (N*stime*Qff.Cadence1) * 2 * stime * np.sum( 2*np.real( Qcc12.data ) / (Qpp11.data * Qpp22.data) )
Ometer1 = XX / GG
var_Ometer1 = 1. / GG * ( 1 +
(N*stime*Qff.Cadence1) * (2*stime)**4 * Omega**2 * np.sum( 2. / (Qpp11.data**2 * Qpp22.data**2) ) / GG )
var_Ometer1_weak = 1. / GG
Ometers += [ Ometer ] ; Ometer1s += [ Ometer1 ] ; var_Ometer1s += [ var_Ometer1 ] ; var_Ometer1s_weak += [ var_Ometer1_weak ]
Ometers = np.array( Ometers ) ; Ometer1s = np.array( Ometer1s ) ; var_Ometer1s = np.array( var_Ometer1s )
type='string',
nargs=1,
default='default',
help='Path to the strong signal bias matrix')
(options, args) = parser.parse_args()
if len(args) < 2:
parser.error(
'You must specify GPATH and STDPPATH! See Help: ./x_stdP.py -h')
Gpath, stdPpath = args[:2]
stdPdir = os.path.dirname(stdPpath)
fish = AS.FisherMatrix(Gpath, lmax=options.lmax)
if options.regMethod == 0:
print 'Calculating unregularised inverse of Fisher matrix...'
fishinv = fish.invert()
else:
print "Calculating regularised inverse of Fisher matrix..."
fish.regularise(regMethod=options.regMethod,
regCutoff=float(options.regCutoff))
fishinv = fish.reginvert()
covarm = np.dot(fishinv, np.dot(fish.fish, fishinv))
if options.strong_signal:
if options.Spath == 'default':
Spath = os.path.dirname(stdPdir) + '/S/S.pkl'
else:
csdpath = csddir + '/d%03d.pkl' % day
orfpath = orfdir + '/d%03d.pkl' % day
psdpath = psddir + '/d%03d.pkl' % day
if csdpath not in glob.glob(csdpath):
print 'CSD not found at %s' % csdpath
continue
if orfpath not in glob.glob(orfpath):
print 'Orf not found at %s' % orfpath
continue
if psdpath not in glob.glob(psdpath):
print 'PSD not found at %s' % psdpath
continue
orf = AS.OrfMultipleMoments(orfpath)
file = open(csdpath, 'rb')
csddict = cpkl.load(file)
file.close()
file = open(psdpath, 'rb')
psddict = cpkl.load(file)
file.close()
SSdata = AS.get_covariance_bias_matrix_for_the_day(
orf, psddict, csddict, options.H0, options.GWslope, day, options.flow,
options.fhigh, options.lmax)
if firstavailable:
Sdata = np.zeros(SSdata.shape, dtype=SSdata.dtype)
print 'Calculating normalisation factor due to coarsegraining and windowing'
tspath = tsdir + '/d%03d.pkl' % day
"You must specify CSDDIR! Type './x_simulate_expected_signal_CSD.py -h' for help "
)
else:
csddir = args[0]
if options.whichtdi == 'ordinary':
IJs = ['12', '13', '23']
elif options.whichtdi == 'optimal':
IJs = ['AE', 'AT', 'ET']
if csddir not in glob.glob(csddir):
os.system('mkdir %s' % csddir)
fdata = options.f0 + options.df * np.arange(options.Nf)
fscale = {'Offset1': options.f0, 'Cadence1': options.df}
f = AS.Coarsable(fdata, **fscale)
print "Calculating expected cross NSD..."
PIJdatas = [
mlisar.get_tdiNSD(options.tditype, options.tdigen, IJ[0], IJ[1], fdata)
for IJ in IJs
]
PIJs = [AS.Coarsable(PIJdata, **fscale) for PIJdata in PIJdatas]
P12, P13, P23 = PIJs
print 'done'
psddict = {'f': f, 'AE': P12, 'AT': P13, 'ET': P23}
file = open(csddir + 'd001.pkl', 'wb')
cpkl.dump(psddict, file, -1)
file.close()
import sys
import glob
import cPickle as cpkl
import numpy as np
import AnisotropySearch as AS
import PostProcess as PP
GWslopes = [ 0 ]
IJs = [ 'AE' , 'AT' , 'ET' , 'AE_AT' , 'AE_ET' , 'AT_ET' , 'AE_AT_ET' ]
lmax , nlon , nlat = 15 , 180 , 91
Ppath = '/gpfs1/JC0311443/workhere/stochasGW/Mapp/skymaps/library/sphericalharmonics/Y_l0_m0_x1e-34/Y_l0_m0.pkl'
GPnorm = 1e-40
file = open( Ppath , 'rb' ) ; P0 = cpkl.load( file ) ; file.close()
P0lm = AS.get_lmax_subset_from( np.copy( P0.xlm ) , lmax )
workdir = os.getcwd() + '/'
for slope in GWslopes :
for IJ in IJs :
print 'GWslope = %d , IJ = %s' % ( slope , IJ )
Gpath = workdir + 'GW_slope_%d/%s/G/G.pkl' % ( slope , IJ )
fish = AS.FisherMatrix( Gpath , lmax = lmax )
Xlm = np.dot( fish.fish , P0lm )
X0path = workdir + 'GW_slope_%d/%s/X/X.pkl' % ( slope , IJ )
file = open( X0path ) ; X0 = cpkl.load( file ) ; file.close()
X0lm = AS.get_lmax_subset_from( np.copy( X0.xlm ) , lmax )
print 'The obtained X is the same as the product of the obtained Fisher mastrix and the injected P.' , np.allclose( Xlm , X0lm )
print 'X0lm.shape , Xlm.shape = ' , X0lm.shape , ',' , Xlm.shape
print 'X0lm[ :10 ]'
for v in range(Nvar):
print 'v = ', v
if s == 1:
print 'tails[v]', tails[v]
else:
print 'tails[v][:3]', tails[v][:3]
ts, tail = mufls.window_and_join(tsl[v], tsr[v], tails[v])
TSs[v] += list(ts)
tails[v] = np.copy(tail)
print 'tails[v][:3]', tails[v][:3]
s += 2
TSs = np.array(TSs)[:, :N]
tscale = {'Cadence1': options.stime, 'Offset1': t0}
tsdict = {
't': AS.Coarsable(t, **tscale),
'1': AS.Coarsable(TSs[0], **tscale),
'2': AS.Coarsable(TSs[1], **tscale),
'3': AS.Coarsable(TSs[2], **tscale)
}
if tsdir == '':
pass
elif tsdir not in glob.glob(tsdir):
os.system('mkdir -p %s' % tsdir)
print 'saving time-series to disk...'
file = open(tsdir + '/d%03d.pkl' % day, 'wb')
cpkl.dump(tsdict, file, -1)
file.close()
orf = AS.OrfMultipleMoments( orfpath )
xxx = AS.XXX_test( orf , psddict , csddict , options.GWslope , day , cIJdir=cIJdir )
XX = xxx.getsummand( flow=options.flow , fhigh=options.fhigh , lmax=options.lmax )
if firstavailable :
X = np.zeros( np.shape(XX.data) , complex )
firstavailable = False
X += XX.data
file = open( tspath , 'rb' ) ; tsdict = cpkl.load( file ) ; file.close()
'normalise for coarsegraining and windowing with a Hanning window for both time-series'
ts = AS.TimeSeries( tsdict )
N = ts.t.data.shape[0] ; T = ts.t.Cadence1 * N ; df = xxx.fcoarse.Cadence1
window = np.hanning( N )
norm = ( np.sum( window**2 ) / N ) / ( np.sum( window**4 ) / N ) * T*df
map_X = AS.xlmSkyMap( xlm = norm * X )
if Xdir not in glob.glob( Xdir ) :
os.system( 'mkdir -p %s' % Xdir )
file = open( Xpath , 'wb') ; cpkl.dump( map_X , file , -1 ) ; file.close()
days_skippedpath = Xdir + '/days_skipped.pkl'
file = open( days_skippedpath , 'wb' ) ; cpkl.dump( days_skipped , file , -1 ) ; file.close()
parser.add_option( '--nlat' , action='store' , dest='nlat' , type='int' , default=91 ,
help='Number of latitudes to plot in the sky.' )
parser.add_option( '--plot_imag' , action='store_true' ,
help='Plot the imaginary part as well and save in the same directory as the real part.' )
( options , args ) = parser.parse_args()
if len( args ) < 2 :
parser.error( 'You must specify SNRMAPPATH and FIGPATH! ' )
SNRmappath , figpath = args[ :2 ]
file = open( SNRmappath , 'rb' ) ; SNRmap = cpkl.load( file ) ; file.close()
SNRlm = AS.get_lmax_subset_from( SNRmap.xlm , options.lmax )
Smap = AS.xlmSkyMap( xlm = float( options.mapnorm ) * SNRlm )
Smap.xlm_to_plm() ; Smap.xlm_to_qlm()
Smap.create_sky( nlon=options.nlon , nlat=options.nlat )
Smap.plm_to_P() ; Smap.qlm_to_Q() ; Smap.PQ_to_X()
figdir = os.path.dirname( figpath )
if figdir not in glob.glob( figdir ) :
os.system( 'mkdir -p %s' % figdir )
if options.plot_imag :
Qpath = figdir + '/SNR_imag.png'
else :
Qpath = None
PP.project_SkyMap( Smap , Ppath = figpath , Qpath = Qpath )
covarm = np.dot( fishinv , np.dot( fish.fish , fishinv ) )
if options.strong_signal :
if options.Spath == 'default' :
Spath = os.path.dirname( stdPdir ) + '/S/S.pkl'
else :
Spath = options.Spath
if Spath not in glob.glob( Spath ) :
print 'Cannot locate the bias matrix, skipping...'
pass
else :
print 'Including the strong signal bias...'
file = open( Spath , 'rb' ) ; Sdict = cpkl.load( file ) ; file.close()
Sdata = AS.get_lmax_subset_from( Sdict['S'].data , options.lmax )
covarm = np.dot( fishinv , np.dot( ( fish.fish + Sdata ) , fishinv ) )
variance = np.diag( covarm )
indxpn = AS.getMLvec( options.lmax )
for i , ml in enumerate( indxpn ) :
if variance[i] < 0 :
print "Warning: negative variance for (m,l)=(%d,%d)" % ml
print "Taking the absolute value"
variance[i] = np.abs( variance[i] )
stdP = np.sqrt( variance )
if stdPdir not in glob.glob( stdPdir ) :
os.system( 'mkdir %s' % stdPdir )
file = open( stdPpath , 'wb' ) ; cpkl.dump( stdP , file , -1 ) ; file.close()
import PostProcess as PP
mapdir = './'
l = 0 #of Ylm
m = 0 #of Ylm
Amplitude = 1e-38 #Real number only please!
nlon = 360
nlat = 181
ntrunc = 20
skymap = AS.xlmSkyMap( ntrunc=ntrunc )
if m % 2 == 0 :
if m == 0:
skymap.alter_ml( False , (m,l,Amplitude) )
else:
skymap.alter_ml( False , (m,l,Amplitude/2.) , (-m,l,Amplitude/2.) )
else:
skymap.alter_ml( False , (m,l,Amplitude/2.) , (-m,l,-Amplitude/2.) )
skymap.xlm_to_plm()
skymap.xlm_to_qlm()
skymap.create_sky( nlon=nlon , nlat=nlat )
skymap.plm_to_P()
skymap.qlm_to_Q()
skymap.PQ_to_X()
parser.add_option( '--nlat' , action='store' , dest='nlat' , type='int' , default=91 ,
help='Number of latitudes to plot in the sky.' )
parser.add_option( '--plot_imag' , action='store_true' ,
help='Plot the imaginary part as well and save in the same directory as the real part.' )
( options , args ) = parser.parse_args()
if len( args ) < 2 :
parser.error( 'You must specify SIGMAPPATH and FIGPATH! ' )
sigmappath , figpath = args[ :2 ]
file = open( sigmappath , 'rb' ) ; sigmamap = cpkl.load( file ) ; file.close()
Smapdata = AS.get_lmax_subset_from( sigmamap.xlm , options.lmax )
Smap = AS.xlmSkyMap( xlm = options.mapnorm * Smapdata )
Smap.xlm_to_plm() ; Smap.xlm_to_qlm()
Smap.create_sky( nlon=options.nlon , nlat=options.nlat ) ; Smap.plm_to_P() ; Smap.qlm_to_Q()
figdir = os.path.dirname( figpath )
if figdir not in glob.glob( figdir ) :
os.system( 'mkdir -p %s' % figdir )
if options.plot_imag :
Qpath = figdir + '/S_imag.png'
else :
Qpath = None
PP.project_SkyMap( Smap , Ppath = figpath , Qpath = Qpath )
y2r = n2r + hr
""" Straight cross-correlation """
Ometer = np.mean(y1 * y2)
Ometer_ana, var_Ometer_ana = Omega, (var_n1 + Omega) * (
var_n2 + Omega) / N + Omega**2 / N
""" Cross-correlation with filtering """
Y1 = stime * np.fft.fft(y1)
Y2 = stime * np.fft.fft(y2)
df_c12 = 1. / (N * stime)
if N % 2 == 0:
c12 = 2 * np.conj(Y1[:N / 2 + 1]) * Y2[:N / 2 + 1] / (N * stime)
f_c12 = df_c12 * np.arange(N / 2 + 1)
else:
c12 = 2 * np.conj(Y1[:(N + 1) / 2]) * Y2[:(N + 1) / 2] / (N * stime)
f_c12 = df_c12 * np.arange((N + 1) / 2)
Qc12 = AS.Coarsable(c12, Offset1=f_c12[0], Cadence1=df_c12)
Qf_c12 = AS.Coarsable(f_c12, Offset1=f_c12[0], Cadence1=df_c12)
p11l, f_p11l = pl.psd(y1l, nfft, fs, noverlap=noverlap)
p11r, f_p11r = pl.psd(y1r, nfft, fs, noverlap=noverlap)
p11 = (p11l + p11r) / 2
f_p11 = np.copy(f_p11l)
df_p11 = f_p11[1] - f_p11[0]
Qp11 = AS.Coarsable(p11, Offset1=f_p11[0], Cadence1=df_p11)
Qf_p11 = AS.Coarsable(f_p11, Offset1=f_p11[0], Cadence1=df_p11)
p22l, f_p22l = pl.psd(y2l, nfft, fs, noverlap=noverlap)
p22r, f_p22r = pl.psd(y2r, nfft, fs, noverlap=noverlap)
p22 = (p22l + p22r) / 2
f_p22 = np.copy(f_p22l)
df_p22 = f_p22[1] - f_p22[0]
Qp22 = AS.Coarsable(p22, Offset1=f_p22[0], Cadence1=df_p22)
( options , args ) = parser.parse_args()
if len( args ) < 2 :
parser.error( "You must specify PSDDIR, directory containing PSDs, and AVGPSDDIR, directory to save average PSDs in!" )
psddir , avgpsddir = args
if avgpsddir not in glob.glob( avgpsddir ) :
os.system( 'mkdir %s' % avgpsddir )
for day in options.days :
print "++++ DAY %d ++++" % day
dayl , dayr = day - 1 , day + 1
psdpathl , psdpathr = ( psddir + 'd%03d.pkl' % dayl ) , ( psddir + 'd%03d.pkl' % dayr )
if psdpathl not in glob.glob( psdpathl ) :
print 'Left PSD not available on day %d. Nothing to do.' % day
continue
if psdpathr not in glob.glob( psdpathr ) :
print 'Right PSD not available on day %d. Nothing to do.' % day
continue
print "PSDs of adjacent days available, taking the average...",
AS.avg_psdPKL_avg( day , psdpathl , psdpathr , avgpsddir )
print "done"
(options, args) = parser.parse_args()
if len(args) < 2:
parser.error(
'You must specify GDIR and AVGSIGDIR! See Help: ./x_sigma_avg.py -h')
Gdir, avgsigdir = args[:2]
avgsigpath = avgsigdir + 'sigma_avg.pkl'
sigma_avgs = []
for lmax in range(options.lmax + 1):
print 'Calculating average sigma from Fisher matrix truncated at lmax = %d' % lmax
fish = AS.FisherMatrix(Gdir + 'G.pkl', lmax=lmax)
if options.regMethod == 0:
print 'Calculating unregularised inverse of Fisher matrix...'
fishinv = fish.invert()
print 'done'
else:
print "Calculating regularised inverse of Fisher matrix..."
fish.regularise(regMethod=options.regMethod,
regCutoff=float(options.regCutoff))
fishinv = fish.reginvert()
covarm = np.dot(fishinv, np.dot(fish.fish, fishinv))
map_sigma, lats, lons = AS.getSigmaMap(covarm, options.nlat, options.nlon)
dlon = lons[1] - lons[0]
dlat = lats[0] - lats[options.nlon]
psdpath = psddir + '/d%03d.pkl' % day
orfpath = orfdir + '/d%03d.pkl' % day
if tspath not in glob.glob( tspath ) :
print 'Time-series not available on day %03d' % day ; days_skipped += [ day ] ; continue
if psdpath not in glob.glob( psdpath ) :
print 'PSD not available on day %03d' % day ; days_skipped += [ day ] ; continue
if orfpath not in glob.glob( orfpath ) :
print 'ORF not found at %s' % orfpath ; days_skipped += [ day ] ; continue
# print 'ORF not availalbe on day %03d' % day ; days_skipped += [ day ] ; continue
print "Time-series, psd and orf all available on day %03d. " % day
print "First available day?" , firstavailable
file = open( tspath , 'rb' ) ; tsdict = cpkl.load( file ) ; file.close()
ts = AS.TimeSeries( tsdict )
if options.scale_ts :
ts.scale_by( options.scale_ts )
file = open( psdpath , 'rb' ) ; psddict = cpkl.load( file ) ; file.close()
orf = AS.OrfMultipleMoments( orfpath )
xxx = AS.XXX( orf , psddict , ts , options.H0, options.GWslope , day , cIJdir=cIJdir )
XX = xxx.getsummand( flow=options.flow , fhigh=options.fhigh , lmax=options.lmax , window=options.window )
if firstavailable :
X = np.zeros( np.shape(XX.data) , complex )
print 'Calculating normalisation factor due to coarsegraining and windowing'
N = xxx.ts.t.data.shape[0] ; T = xxx.ts.t.Cadence1 * N ; df = xxx.fcoarse.Cadence1
if options.window == 'None' :
action='store_true',
help=
'Plot the imaginary part as well and save in the same directory as the real part.'
)
(options, args) = parser.parse_args()
if len(args) < 2:
parser.error('You must specify SIGMAPPATH and FIGPATH! ')
sigmappath, figpath = args[:2]
file = open(sigmappath, 'rb')
sigmamap = cpkl.load(file)
file.close()
Smapdata = AS.get_lmax_subset_from(sigmamap.xlm, options.lmax)
Smap = AS.xlmSkyMap(xlm=options.mapnorm * Smapdata)
Smap.xlm_to_plm()
Smap.xlm_to_qlm()
Smap.create_sky(nlon=options.nlon, nlat=options.nlat)
Smap.plm_to_P()
Smap.qlm_to_Q()
figdir = os.path.dirname(figpath)
if figdir not in glob.glob(figdir):
os.system('mkdir -p %s' % figdir)
if options.plot_imag:
Qpath = figdir + '/S_imag.png'
else:
Qpath = None
PP.project_SkyMap(Smap, Ppath=figpath, Qpath=Qpath)
( options , args ) = parser.parse_args()
if len( args ) < 1 :
parser.error( "You must specify a TSPATH! Type './x_simulate_defined_stationary_noise.py' " )
else :
tspath = args[ 0 ] ; tsdir = os.path.dirname( tspath )
stime , duration , inittime , N_previous_draws = float(options.stime) , float(options.duration) , float(options.inittime) , int( options.N_previous_draws )
N = np.round( duration / stime )
if N % 2 == 0 :
Nf = int( N/2 - 1 ) ; parityN = 'Even'
else :
Nf = int( ( N-1 ) / 2 ) ; parityN = 'Odd'
df = 1 / (N*stime)
f = df * np.arange( 1 , Nf + 1 )
comatrix = get_comatrix( f )
t , n = mufls.get_noise_freq_domain_CovarMatrix( comatrix , df , inittime , parityN , options.seed , N_previous_draws )
tscale = { 'Cadence1':stime , 'Offset1':inittime }
tsdict = { 't':AS.Coarsable( t , **tscale ) ,
'1':AS.Coarsable( n[0] , **tscale ) , '2':AS.Coarsable( n[1] , **tscale ) , '3':AS.Coarsable( n[2] , **tscale ) }
if tsdir not in glob.glob( tsdir ) :
os.system( 'mkdir %s' % tsdir )
print 'saving time-series to disk...'
file = open( tspath , 'wb' ) ; cpkl.dump( tsdict , file , -1 ) ; file.close()
print "---- DAY %d ----" % day
tspath = tsdir + '/d%03d.pkl' % day
if tspath not in glob.glob( tspath ) :
print 'Time-series NOT found at %s' % tspath
continue
psdpath = psddir + 'd%03d.pkl' % day
if psdpath in glob.glob( psdpath ) :
print 'psd/%s exists. Nothing to do.' % psdpath
continue
print "Time-series available on day %03d, calculating its PSDs... " % day ,
file = open( tspath , 'rb' ) ; tsdict = cpkl.load( file ) ; file.close()
ts = AS.TimeSeries( tsdict )
if options.scale_ts :
ts.scale_by( options.scale_ts )
t , n1 , n2 , n3 = ts.t.data , ts.A.data , ts.E.data , ts.T.data
stime = ts.t.Cadence1 ; inittime = ts.t.Offset1 ; N = t.shape[0]
nfft = int( options.segduration / stime ) ; noverlap = nfft / 2 ; fs = 1. / stime
P11data , fdata = mymlab.psd( n1 , nfft , fs , noverlap = noverlap )
P22data , fdata = mymlab.psd( n2 , nfft , fs , noverlap = noverlap )
P33data , fdata = mymlab.psd( n3 , nfft , fs , noverlap = noverlap )
f0 = fdata[0] ; df = fdata[1] - fdata[0] ; fscale = { 'Offset1':f0 , 'Cadence1':df }
f = AS.Coarsable( fdata , **fscale )
P11 = AS.Coarsable( P11data , **fscale )
fish = AS.FisherMatrix( Gpath , lmax=options.lmax )
if options.regMethod == 0 :
print 'Calculating unregularised inverse of Fisher matrix...'
fishinv = fish.invert()
else :
print "Calculating regularised inverse of Fisher matrix..."
fish.regularise( regMethod=options.regMethod , regCutoff=float( options.regCutoff ) )
fishinv = fish.reginvert()
if options.N_keptSV :
print 'Number of eigenvalues kept = ' , fish.N_keptSV
file = open( Xpath , 'rb' ) ; map_X = cpkl.load( file ) ; file.close()
Xlm = AS.get_lmax_subset_from( map_X.xlm , options.lmax )
Pdata = np.dot( fishinv , Xlm )
Pmap = AS.xlmSkyMap( xlm = options.mapnorm * Pdata )
Pmap.xlm_to_plm() ; Pmap.xlm_to_qlm()
Pmap.create_sky( nlon = options.nlon , nlat = options.nlat )
Pmap.plm_to_P() ; Pmap.qlm_to_Q() ; Pmap.PQ_to_X()
Pdir = os.path.dirname( Ppath )
if Pdir not in glob.glob( Pdir ) :
os.system( 'mkdir -p %s' % Pdir )
file = open( Ppath , 'wb' ) ; cpkl.dump( Pmap , file , -1 ) ; file.close()
#!/usr/bin/env python
import os
import sys
import glob
import cPickle as cpkl
import numpy as np
import AnisotropySearch as AS
IJs = ["AE", "AT", "ET", "AE_AT", "AE_ET", "AT_ET", "AE_AT_ET"]
injPpath = "/gpfs1/JC0311443/workhere/stochasGW/Mapp/skymaps/library/sphericalharmonics/Y_l0_m0_x1e-34/Y_l0_m0.pkl"
anadir = "GW_slope_0_test1/"
m, l, lmax = 0, 0, 15
scale_Plm = 1.0
indxpn = AS.getMLvec(lmax)
""" Load injected Plm """
file = open(injPpath)
P0 = cpkl.load(file)
file.close()
""" Load clean map of Plm """
Plms = []
for IJ in IJs:
Ppath = "%s/%s/P/P_lmax_%d.pkl" % (anadir, IJ, lmax)
file = open(Ppath, "rb")
P = cpkl.load(file)
file.close()
Plms += [P.plm[indxpn.index((m, l))] * scale_Plm]
if True not in [ proj_X ,
proj_P , save_P ,
proj_sigmamap , save_sigmamap ,
proj_SNRmap , save_SNRmap ,
proj_stdP ] :
print "Nothing to do."
if proj_X :
print "Plotting X"
mapnorm = 1.
Xpath = Xdir + 'X.pkl'
file = open( Xpath , 'rb' ) ; map_X = cpkl.load( file ) ; file.close()
Xlm = AS.get_lmax_subset_from( map_X.xlm , lmax )
Xmap = AS.xlmSkyMap( xlm = mapnorm * Xlm )
Xmap.xlm_to_plm() ; Xmap.xlm_to_qlm()
Xmap.create_sky( nlon=nlon , nlat=nlat )
Xmap.plm_to_P() ; Xmap.qlm_to_Q()
projdir = 'post_process/figures/X/'
if projdir not in glob.glob( projdir ) :
os.system( 'mkdir -p %s' % projdir )
PP.project_SkyMap( Xmap , Ppath = projdir + 'Xreal.png' )
if True in [ proj_P , save_P ,
proj_sigmamap , save_sigmamap ,
proj_SNRmap , save_SNRmap ,
proj_stdP ] :
parser.add_option( '--lmax' , action='store' , dest='lmax' , type='int' , default=15 ,
help='l up to which to truncate the X and G.' )
parser.add_option( '--mapnorm' , action='store' , dest='mapnorm' , type='string' , default='1.' ,
help='Scalar factor to scale all multipole moments before plotting.' )
( options , args ) = parser.parse_args()
if len( args ) < 2 :
parser.error( 'You must specify GPATH and SIGMAPPATH! See Help: ./x_sigmamap.py -h' )
Gpath , sigmappath = args[ :2 ]
fish = AS.FisherMatrix( Gpath , lmax = options.lmax )
fish.regularise( regMethod = options.regMethod , regCutoff = float( options.regCutoff ) )
regfishinv = fish.reginvert()
covarm = np.dot( regfishinv , np.dot( fish.fish , regfishinv ) )
map_sigma , lats , lons = AS.getSigmaMap( covarm , options.nlat , options.nlon )
mapdata = np.reshape( map_sigma , ( options.nlat , options.nlon ) )
sigmamap = AS.XSkyMap( X = float( options.mapnorm ) * mapdata ) ; sigmamap.X_to_P() ; sigmamap.X_to_Q()
sigmamap.ntrunc_equals( options.lmax ) ; sigmamap.P_to_plm() ; sigmamap.Q_to_qlm() ; sigmamap.plmqlm_to_xlm()
sigmapdir = os.path.dirname( sigmappath )
if sigmapdir not in glob.glob( sigmapdir ) :
os.system( 'mkdir %s' % sigmapdir )
file = open( sigmappath , 'wb' ) ; cpkl.dump( sigmamap , file , -1 ) ; file.close()
print "Initial times:" , t0l , ',' , t0r
print ""
if options.seed == 'None' :
shortftl = AS.CSpectra_to_ShortTermFT( cspec_dict , seed=None ) ; shortftr = AS.CSpectra_to_ShortTermFT( cspec_dict , seed=None )
else :
seedl = int( options.seed ) + ( day - 1 )*Nseg + seg ; seedr = int( options.seed ) + ( day - 1 )*Nseg + ( seg + 1 )
print 'seeds: left, right' , seedl , seedr
shortftl = AS.CSpectra_to_ShortTermFT( cspec_dict , seed=seedl ) ; shortftr = AS.CSpectra_to_ShortTermFT( cspec_dict , seed=seedr )
stsl = AS.InverseFT( shortftl , Neven=True , tOffset=t0l ) ; stsr = AS.InverseFT( shortftr , Neven=True , tOffset=t0r )
if i == 0 :
Offset = stsl.s1.Offset1 ; Cadence = stsl.s1.Cadence1
joinrems = [ AS.WindowAndJoin( getattr( stsl , s ) , getattr( stsr , s ) , leftover = getattr( leftover , s , None ) ) for s in slist ]
joins = [ joinrem[0] for joinrem in joinrems ]
rems = [ joinrem[1] for joinrem in joinrems ]
rem_dict = dict( zip( slist , rems ) )
leftover = AS.sTimeSeries( **rem_dict )
oldandnews = zip( [ Ajoins , Ejoins , Tjoins ] , joins )
[ oldandnew[0].append( oldandnew[1].data ) for oldandnew in oldandnews ]
tsdatas = [ np.concatenate( tuple( Ijoins ) ) for Ijoins in [ Ajoins , Ejoins , Tjoins ] ]
numberofsamplesinaday = int( duration / Cadence )
onedaytsdatas = [ tsdata[ : numberofsamplesinaday ] for tsdata in tsdatas ]
tscoarsables = [ AS.Coarsable( onedaytsdata , Offset1=Offset , Cadence1=Cadence ) for onedaytsdata in onedaytsdatas ]
tsdict = dict( zip( [ '1' , '2' , '3' ] , tscoarsables ) )
tsdict['t'] = AS.Coarsable( Offset + Cadence * np.arange( numberofsamplesinaday ) , Offset1=Offset , Cadence1=Cadence )
if tsdir not in glob.glob( tsdir ) :
import numpy as np
import matplotlib.pyplot as plt
import myLISAmodule as mlisar
import AnisotropySearch as AS
t0s = [ 100 ]
m , l = 3 , 5
tdiORF_SpH_dir = 'data_nlon_220_nlat_111/'
fig_dir = 'figures_f_vs_tdiORF_SpHs_nlon_220_nlat_111/'
indxpn = AS.getMLvec( l , 'pn' ) ; k = indxpn.index( (m,l) )
for t0 in t0s :
orf = AS.OrfMultipleMoments( tdiORF_SpH_dir + 'orf_t0_%.1f.pkl' % t0 )
glm = orf.getMultipleMoments( 'pn' , l )
f = glm.Offset1 + glm.Cadence1 * np.arange( glm.data.shape[1] )
glmdata = glm.data[ k , : ]
fig_dir = fig_dir + 't0_%.1f/' % t0
if fig_dir not in glob.glob( fig_dir ) :
os.system( 'mkdir -p %s' % fig_dir )
fig = plt.figure()
fig.suptitle( 'tdiORF SpH: l = %d , m = %d , t0 = %.1f' % ( l , m , t0 ) )
ax = fig.add_subplot( 311 )
parser.error( 'You must specify at least GPATH, XPATH and SNRMAPPATH! Type ./x_SNRmap.py -h' )
Gpath , Xpath , SNRmappath = args[ :3 ]
fish = AS.FisherMatrix( Gpath , lmax=options.lmax )
if options.regMethod == 0 :
print 'Calculating unregularised inverse of Fisher matrix...'
fishinv = fish.invert()
print 'done'
else :
print "Calculating regularised inverse of Fisher matrix..."
fish.regularise( regMethod=options.regMethod , regCutoff=float( options.regCutoff ) )
fishinv = fish.reginvert()
file = open( Xpath , 'rb' ) ; map_X = cpkl.load( file ) ; file.close()
Xlm = AS.get_lmax_subset_from( map_X.xlm , options.lmax )
Pdata = np.dot( fishinv , Xlm )
Pmap = AS.xlmSkyMap( xlm = Pdata )
Pmap.xlm_to_plm() ; Pmap.xlm_to_qlm()
Pmap.create_sky( nlon = options.nlon , nlat = options.nlat )
Pmap.plm_to_P() ; Pmap.qlm_to_Q() ; Pmap.PQ_to_X()
covarm = np.dot( fishinv , np.dot( fish.fish , fishinv ) )
map_sigma , lats , lons = AS.getSigmaMap( covarm , options.nlat , options.nlon )
mapdata = np.reshape( map_sigma , ( options.nlat , options.nlon ) )
sigmamap = AS.XSkyMap( X = mapdata ) ; sigmamap.X_to_P() ; sigmamap.X_to_Q()
sigmamap.ntrunc_equals( options.lmax ) ; sigmamap.P_to_plm() ; sigmamap.Q_to_qlm() ; sigmamap.plmqlm_to_xlm()
SNRdata = Pmap.P / sigmamap.P
SNRmap = AS.XSkyMap( X = float( options.mapnorm ) * SNRdata ) ; SNRmap.X_to_P() ; SNRmap.X_to_Q()
(options, args) = parser.parse_args()
if len(args) < 2:
parser.error(
'You must specify at least an XPATH and a NETWORKXPATH! ( See help: x_network_X.py -h )'
)
else:
Xpaths = args[:-1]
netXpath = args[-1]
for i, Xpath in enumerate(Xpaths):
file = open(Xpath, 'rb')
X = cpkl.load(file)
file.close()
if i == 0:
netXdata = np.copy(X.xlm)
lmax = X.ntrunc
else:
netXdata += np.copy(X.xlm)
netX = AS.xlmSkyMap(xlm=netXdata)
netXdir = os.path.dirname(netXpath)
if netXdir not in glob.glob(netXdir):
os.system('mkdir -p %s' % netXdir)
file = open(netXpath, 'wb')
cpkl.dump(netX, file, -1)
file.close()
parser.add_option( '--Nf' , action='store' , dest='Nf' , type='string' , nargs=1 , default='5' , help='Number of frequencies' )
parser.add_option( '--IJ' , action='store' , dest='IJ' , type='string' , nargs=1 , default='AA' , help='IJ of ORF' )
parser.add_option( '--lmax' , action='store' , dest='lmax' , type='string' , nargs=1 , default='0' , help='Maximum degree l for the SpHs' )
( options , args ) = parser.parse_args()
if len( args ) < 1 :
parser.error( 'You must specify ORFPATH, the file path to save the tdiORF_SpHs!' )
else :
orfpath = args[ 0 ]
f = options.f0 + options.df * np.arange( options.Nf )
indxp = AS.getMLvec( options.lmax , 'p' )
SpHreal = np.ones( ( len( indxp ) , options.Nf ) ) * arbitrary_SpHreal_ML( f )
SpHimag = np.ones( ( len( indxp ) , options.Nf ) ) * arbitrary_SpHimag_ML( f )
orfdict = {'OrfMultipleMoments': { 'ntrunc': options.lmax , 'f': f , 'Antenna': options.IJ , 'real': SpHreal , 'imag': SpHimag } }
orfdir = os.path.dirname( orfpath )
if orfdir not in glob.glob( orfdir ) :
os.system( 'mkdir -p %s' % orfdir )
file = open( orfpath , 'wb' ) ; cpkl.dump( orfdict , file , -1 ) ; file.close()
print " Orf multipole moments saved in %s " % orfpath
nlat, nlon = setup['postproc']['nlat'], setup['postproc']['nlon']
if True not in [
proj_X, proj_P, save_P, proj_sigmamap, save_sigmamap, proj_SNRmap,
save_SNRmap, proj_stdP
]:
print "Nothing to do."
if proj_X:
print "Plotting X"
mapnorm = 1.
Xpath = Xdir + 'X.pkl'
file = open(Xpath, 'rb')
map_X = cpkl.load(file)
file.close()
Xlm = AS.get_lmax_subset_from(map_X.xlm, lmax)
Xmap = AS.xlmSkyMap(xlm=mapnorm * Xlm)
Xmap.xlm_to_plm()
Xmap.xlm_to_qlm()
Xmap.create_sky(nlon=nlon, nlat=nlat)
Xmap.plm_to_P()
Xmap.qlm_to_Q()
projdir = 'post_process/figures/X/'
if projdir not in glob.glob(projdir):
os.system('mkdir -p %s' % projdir)
PP.project_SkyMap(Xmap, Ppath=projdir + 'Xreal.png')
if True in [
proj_P, save_P, proj_sigmamap, save_sigmamap, proj_SNRmap, save_SNRmap,
proj_stdP
]:
action='store',
dest='mapnorm',
type='string',
default='1.',
help='Scalar factor to scale the map plotting.')
(options, args) = parser.parse_args()
if len(args) < 3:
parser.error(
'You must specify at least GPATH, XPATH and SNRMAPPATH! Type ./x_SNRmap.py -h'
)
Gpath, Xpath, SNRmappath = args[:3]
fish = AS.FisherMatrix(Gpath, lmax=options.lmax)
if options.regMethod == 0:
print 'Calculating unregularised inverse of Fisher matrix...'
fishinv = fish.invert()
print 'done'
else:
print "Calculating regularised inverse of Fisher matrix..."
fish.regularise(regMethod=options.regMethod,
regCutoff=float(options.regCutoff))
fishinv = fish.reginvert()
file = open(Xpath, 'rb')
map_X = cpkl.load(file)
file.close()
Xlm = AS.get_lmax_subset_from(map_X.xlm, options.lmax)
usage = """
$prog [ XPATH,... ] NETWORKXPATH\n
XPATH --- path to file of Xs to be summed(can have more than one)
NETWORKXPATH --- path to file in which to save network X
"""
parser = optparse.OptionParser( usage = usage )
( options , args ) = parser.parse_args()
if len( args ) < 2 :
parser.error( 'You must specify at least an XPATH and a NETWORKXPATH! ( See help: x_network_X.py -h )' )
else :
Xpaths = args[ : -1 ] ; netXpath = args[ -1 ]
for i , Xpath in enumerate( Xpaths ) :
file = open( Xpath , 'rb' ) ; X = cpkl.load( file ) ; file.close()
if i == 0 :
netXdata = np.copy( X.xlm )
lmax = X.ntrunc
else :
netXdata += np.copy( X.xlm )
netX = AS.xlmSkyMap( xlm = netXdata )
netXdir = os.path.dirname( netXpath )
if netXdir not in glob.glob( netXdir ) :
os.system( 'mkdir -p %s' % netXdir )
file = open( netXpath , 'wb') ; cpkl.dump( netX , file , -1 ) ; file.close()
for day in options.days:
print ""
print "==== Day %d ====" % day
print ""
T0 = (day - 1) * duration
orfpaths = [
orfdir +
'tdiI_%s_tdiJ_%s_lmax_%d_f0_%f_df_%f_Nf_%d_g00_9/data/orf_d%03d.pkl' %
(IJ[0], IJ[1], options.lmax, options.f0, options.df, options.Nf, day)
for IJ in IJlist
]
orfs = [AS.OrfMultipleMoments(orfpath) for orfpath in orfpaths]
cspecs = [AS.Convolve(orf, skymap, options.GWslope) for orf in orfs]
cspec_dict = dict(zip(XYlist, cspecs))
""">>>>> Sort the covariance matrix elements into PSDs and CSDs and save them to disk """
psddict = {
'f': orf.f,
'AA': cspec_dict['11'],
'EE': cspec_dict['22'],
'TT': cspec_dict['33']
}
csddict = {
'f': orf.f,
'AE': cspec_dict['12'],
'AT': cspec_dict['13'],
'ET': cspec_dict['23']
action='store_true',
help=
'Plot the imaginary part as well and save in the same directory as the real part.'
)
(options, args) = parser.parse_args()
if len(args) < 2:
parser.error('You must specify PPATH and FIGPATH! ')
Ppath, figpath = args[:2]
file = open(Ppath, 'rb')
map_P = cpkl.load(file)
file.close()
Plm = AS.get_lmax_subset_from(map_P.xlm, options.lmax)
Pmap = AS.xlmSkyMap(xlm=options.mapnorm * Plm)
Pmap.xlm_to_plm()
Pmap.xlm_to_qlm()
Pmap.create_sky(nlon=options.nlon, nlat=options.nlat)
Pmap.plm_to_P()
Pmap.qlm_to_Q()
figdir = os.path.dirname(figpath)
PP.SkyMap_to_datfile(Pmap, 'temporary.dat')
if options.plot_imag:
PP.project_SkyMap('temporary.dat',
Ppath=figpath,
Qpath=figdir + '/P_imag.png')
else:
PP.project_SkyMap('temporary.dat', Ppath=figpath)
if tspath not in glob.glob(tspath):
print 'Time-series not found on day %d. Nothing to do.' % day
continue
csdpath = csddir + 'd%03d.pkl' % day
if csdpath in glob.glob(csdpath):
print '%s exists. Nothing to do.' % csdpath
continue
print "Time-series available on day %03d, calculating its CSDs... " % day,
file = open(tspath, 'rb')
tsdict = cpkl.load(file)
file.close()
ts = AS.TimeSeries(tsdict)
if options.scale_ts:
ts.scale_by(options.scale_ts)
t, n1, n2, n3 = ts.t.data, ts.A.data, ts.E.data, ts.T.data
stime = ts.t.Cadence1
inittime = ts.t.Offset1
N = t.shape[0]
nfft = int(options.segduration / stime)
noverlap = nfft / 2
fs = 1. / stime
P12data, fdata = mymlab.csd(n1, n2, nfft, fs, noverlap=noverlap)
P13data, fdata = mymlab.csd(n1, n3, nfft, fs, noverlap=noverlap)
P23data, fdata = mymlab.csd(n2, n3, nfft, fs, noverlap=noverlap)
orfpath = orfdir + '/d%03d.pkl' % day
psdpath = psddir + '/d%03d.pkl' % day
if csdpath not in glob.glob( csdpath ) :
print 'CSD not found at %s' % csdpath ; continue
if orfpath not in glob.glob( orfpath ) :
print 'Orf not found at %s' % orfpath ; continue
if psdpath not in glob.glob( psdpath ) :
print 'PSD not found at %s' % psdpath ; continue
orf = AS.OrfMultipleMoments( orfpath )
file = open( csdpath , 'rb' ) ; csddict = cpkl.load( file ) ; file.close()
file = open( psdpath , 'rb' ) ; psddict = cpkl.load( file ) ; file.close()
SSdata = AS.get_covariance_bias_matrix_for_the_day( orf , psddict , csddict ,
options.H0, options.GWslope ,
day , options.flow , options.fhigh , options.lmax )
if firstavailable :
Sdata = np.zeros( SSdata.shape , dtype = SSdata.dtype )
print 'Calculating normalisation factor due to coarsegraining and windowing'
tspath = tsdir + '/d%03d.pkl' % day
file = open( tspath , 'rb' ) ; tsdict = cpkl.load( file ) ; file.close() ; ts = AS.TimeSeries( tsdict )
N = ts.t.data.shape[0] ; T = ts.t.Cadence1 * N
fcoarse = AS.coarsefrequency( orf.f , psddict['f'] , csddict['f'] ) ; df = fcoarse.Cadence1
if options.window == 'None' :
window = np.ones( N )
elif options.window == 'hanning' :
window = np.hanning( N )
norm = ( np.sum( window**2 ) / N )**2 / ( np.sum( window**4 ) / N ) * T*df
firstavailable = False
[file.close() for file in files]
s1datas = [
float(options.mergs[k][0]) * tsdicts[k]['1'].data for k in range(Nmerg)
]
s2datas = [
float(options.mergs[k][0]) * tsdicts[k]['2'].data for k in range(Nmerg)
]
s3datas = [
float(options.mergs[k][0]) * tsdicts[k]['3'].data for k in range(Nmerg)
]
s1data = np.sum(np.array(s1datas), 0)
s2data = np.sum(np.array(s2datas), 0)
s3data = np.sum(np.array(s3datas), 0)
t = tsdicts[0]['t']
tscale = {'Offset1': t.Offset1, 'Cadence1': t.Cadence1}
s1 = AS.Coarsable(s1data, **tscale)
s2 = AS.Coarsable(s2data, **tscale)
s3 = AS.Coarsable(s3data, **tscale)
tsdict = {'t': t, '1': s1, '2': s2, '3': s3}
tsdir = os.path.dirname(tspath)
if tsdir not in glob.glob(tsdir):
os.system('mkdir -p %s' % tsdir)
file = open(tspath, 'wb')
cpkl.dump(tsdict, file, -1)
file.close()
lmax_max = setup['maxlike']['lmax']
Gdir = setup['maxlike']['Gdir']
figdir = setup['sigma_avg']['figdir']
nlon , nlat = setup['sigma_avg']['nlon'] , setup['sigma_avg']['nlat']
lmaxs = range( lmax_max + 1 )
sigma_avgs = []
for lmax in lmaxs :
print 'Calculating average sigma at lmax = %d' % lmax
fish = AS.FisherMatrix( Gdir + 'G.pkl' , lmax = lmax )
fishinv = fish.invert()
map_sigma , lats , lons = AS.getSigmaMap( fishinv , nlat , nlon )
dlon = lons[1] - lons[0] ; dlat = lats[0] - lats[nlon]
dOmega = np.radians( dlon ) * np.radians( dlat ) * np.sin( np.pi/2 - np.radians( lats ) )
sigma_avg = np.sum( dOmega * map_sigma ) / ( lmax + 1 )**2
sigma_avgs += [ sigma_avg ]
if figdir not in glob.glob( figdir ) :
os.system( 'mkdir %s' % figdir )
fig = plt.figure()
ax = fig.add_subplot( 111 )
ax.plot( lmaxs , sigma_avgs )
ax.set_title( 'average standard deviation vs lmax' )
import sys
import cPickle as cpkl
import AnisotropySearch as AS
import PostProcess as PP
mapdir = './'
l = 0 #of Ylm
m = 0 #of Ylm
Amplitude = 1e-38 #Real number only please!
nlon = 360
nlat = 181
ntrunc = 20
skymap = AS.xlmSkyMap(ntrunc=ntrunc)
if m % 2 == 0:
if m == 0:
skymap.alter_ml(False, (m, l, Amplitude))
else:
skymap.alter_ml(False, (m, l, Amplitude / 2.), (-m, l, Amplitude / 2.))
else:
skymap.alter_ml(False, (m, l, Amplitude / 2.), (-m, l, -Amplitude / 2.))
skymap.xlm_to_plm()
skymap.xlm_to_qlm()
skymap.create_sky(nlon=nlon, nlat=nlat)
skymap.plm_to_P()
skymap.qlm_to_Q()
skymap.PQ_to_X()
mapname = 'Y_l%d_m%d.pkl' % (l, m)
elif options.whichtdi == 'optimal':
IIs = ['AE', 'AT', 'ET']
if csddir not in glob.glob(csddir):
os.system('mkdir %s' % csddir)
for day in options.days:
print "~~~~~~~ Day %d ~~~~~~~" % day
orfids = [(options.tditype, options.tdigen, II[0], options.tditype,
options.tdigen, II[1], options.f0, options.df, options.Nf, day)
for II in IIs]
orfpaths = [(
orfdir +
'tdiI_%s_%s_%s_tdiJ_%s_%s_%s_lmax_20_f0_%f_df_%f_Nf_%d/data_nlon_120_nlat_61/orf_d%03d.pkl'
% orfid) for orfid in orfids]
orfs = [AS.OrfMultipleMoments(orfpath) for orfpath in orfpaths]
PIJs = [AS.Convolve(orf, skymap, options.GWslope) for orf in orfs]
P12, P13, P23 = PIJs
fdata = P12.Offset1 + P12.Cadence1 * np.arange(P12.data.shape[0])
f = AS.Coarsable(fdata, Offset1=P12.Offset1, Cadence1=P12.Cadence1)
csddict = {'f': f, 'AE': P12, 'AT': P13, 'ET': P23}
file = open(csddir + 'd%03d.pkl' % day, 'wb')
cpkl.dump(csddict, file, -1)
file.close()
parser = optparse.OptionParser( 'Usage: ./x_simulate_noise.py SETUP.pkl' )
( options , args ) = parser.parse_args()
if len( args ) < 1 :
parser.error( 'You must specify a SETUP.pkl containing input parameters!' )
file = open( args[0] , 'rb' ) ; setup = cpkl.load( file ) ; file.close()
tditype , tdigen , whichtdis = setup['tditype'] , setup['tdigen'] , setup['whichtdis']
stime , duration , inittime , seed = setup['stime'] , setup['duration'] , setup['inittime'] , setup['seed']
tspath = setup['tspath']
tsdir = '/'.join( re.split( '/' , tspath )[:-1] ) + '/'
print tsdir
if not tspath in glob.glob( tspath ) :
t , n = mlisar.get_tdiNoise_freq_domain_CovarMatrix( tditype , tdigen , whichtdis ,
stime , duration , inittime , seed )
tscale = { 'Cadence1':stime , 'Offset1':inittime }
tsdict = {}
tsdict['1'] , tsdict['2'] , tsdict['3'] = AS.Coarsable( n[0] , **tscale ) , AS.Coarsable( n[1] , **tscale ) , AS.Coarsable( n[2] , **tscale )
tsdict['t'] = AS.Coarsable( t , **tscale )
if tsdir not in glob.glob( tsdir ) :
os.system( 'mkdir %s' % tsdir )
print 'saving time-series to disk'
file = open( tspath , 'wb' )
cpkl.dump( tsdict , file , -1 ) ; file.close()
else :
print '%s already saved to disk. Nothing to do.' % tspath
