def mini(x, q, qn, d, delta, finac, data, ausf, einf,\
m0, m1, m1c, m2, m2c, typ1_ges, typ2_ges,\
param, nap, step, dt, npts,\
x0, sr0, si0, resid0, residi0):
# import ipdb; ipdb.set_trace()
xl = np.zeros(nap)
xr = np.zeros(nap)
xm, qm = move(x, q, nap)
for k in range(nap):
xl[k] = x[k] - step * d[k]
xr[k] = x[k] + step * d[k]
#left
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(xl, param, delta, m1c, m2c)
sysl, m0_l, m1_l, m2_l = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(sysl, sr0, si0, resid0, residi0,\
m0_l, m1_l, m2_l)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_l, m1_l, m2_l, dt, npts)
ql = quad(qn, sim, npts)
#right
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(xr, param, delta, m1c, m2c)
sysr, m0_r, m1_r, m2_r = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(sysr, sr0, si0, resid0, residi0,\
m0_r, m1_r, m2_r)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_r, m1_r, m2_r, dt, npts)
qr = quad(qn, sim, npts)
#maximum?
if ql < qm and qr < qm:
print 'Maximum encountered! Try again with different start parameters!'
sys.exit(1)
while ql >= qm and qr >= qm and step >= 8. * finac:
step = step / 8.
for k in range(nap):
xl[k] = xm[k] - step * d[k]
xr[k] = xm[k] + step * d[k]
#left
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(xl, param, delta, m1c, m2c)
sysl, m0_l, m1_l, m2_l = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(sysl, sr0, si0, resid0, residi0,\
m0_l, m1_l, m2_l)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_l, m1_l, m2_l, dt, npts)
ql = quad(qn, sim, npts)
#right
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(xr, param, delta, m1c, m2c)
sysr, m0_r, m1_r, m2_r = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(sysr, sr0, si0, resid0, residi0,\
m0_r, m1_r, m2_r)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_r, m1_r, m2_r, dt, npts)
qr = quad(qn, sim, npts)
if ql < qm and qr < qm:
print 'Maximum encountered! Try again with different start parameters!'
sys.exit(1)
#witch side of the minimum?
if ql < qm or qr < qm:
if ql < qr:
#turn around
x, q = move(xl, ql, nap)
xl, ql = move(xr, qr, nap)
xr, qr = move(x, q, nap)
for k in range(nap):
d[k] = -d[k]
if step > 1.:
x, q = move(xr, qr, nap)
axi = step
return x, q, step, axi, amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp
else:
step = 2. * step
xm, qm = move(xr, qr, nap)
for k in range(nap):
xr[k] = xm[k] + step * d[k]
#right
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(xr, param, delta, m1c, m2c)
sysr, m0_r, m1_r, m2_r = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(sysr, sr0, si0, resid0, residi0,\
m0_r, m1_r, m2_r)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_r, m1_r, m2_r, dt, npts)
qr = quad(qn, sim, npts)
while qr < qm:
if step > 1.:
x, q = move(xr, qr, nap)
axi = step
return x, q, step, axi, amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp
else:
step = 2. * step
xm, qm = move(xr, qr, nap)
for k in range(nap):
xr[k] = xm[k] + step * d[k]
#right
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(xr, param, delta, m1c, m2c)
sysr, m0_r, m1_r, m2_r = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(sysr, sr0, si0, resid0, residi0,\
m0_r, m1_r, m2_r)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_r, m1_r, m2_r, dt, npts)
qr = quad(qn, sim, npts)
#interpolate
xi = (ql - qr) / (ql -2. * qm + qr) / 2. * step
axi = np.abs(xi)
for k in range(nap):
x[k] = xm[k] + xi * d[k]
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(x, param, delta, m1c, m2c)
sysp, m0_i, m1_i, m2_i = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(sysp, sr0, si0, resid0, residi0,\
m0_i, m1_i, m2_i)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_i, m1_i, m2_i, dt, npts)
q = quad(qn, sim, npts)
return x, q, step, axi, amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp
if step < 8.*finac:
xi = (ql - qr) / (ql -2. * qm + qr) / 2. * step
axi = np.abs(xi)
for k in range(nap):
x[k] = xm[k] + xi * d[k]
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(x, param, delta, m1c, m2c)
sysp, m0_i, m1_i, m2_i = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(sysp, sr0, si0, resid0, residi0,\
m0_i, m1_i, m2_i)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_i, m1_i, m2_i, dt, npts)
q = quad(qn, sim, npts)
return x, q, step, axi, amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp
print 'Residual error...'
print 'Try again with other start parameters!'
sys.exit(1)
def RelCalTime(st1, st2, DataType, alias,\
AMP='0.+/-0.', DELAY='0.+/-0.', SUB='0.+/-0.', TIL='0.+/-0.',\
maxit=100, qac=1e-5, finac=1e-3, ns1=0, ns2=60000):
########################################################
# For writing comunication not only to stdout but also
# to the file "calex.out" a new write method is
# defined.
class SplitWriter():
"""
Implements a write method that writes a given message on all children
"""
def __init__(self, filehandle):
"""
Remember provided objects as children.
"""
self.file = filehandle
self.stdout = sys.stdout
def write(self, msg):
"""
Sends msg to all childrens write method.
"""
self.stdout.write(msg)
self.file.write(msg)
f = open("RelCalTime.out", "wt")
sys.stdout = SplitWriter(f)
########################################################
# read input
eing_st = st1
if len(eing_st) > 1:
print 'more than one traces found in stream 1!'
f.close()
sys.exit(1)
eing = eing_st[0]
ausg_st = st2
if len(ausg_st) > 1:
print 'more than one traces found in stream 2!'
f.close()
sys.exit(1)
ausg = ausg_st[0]
# make sure that the stype is what cython expects later!
for tr in eing, ausg:
tr.data = tr.data.astype(np.float64)
##########################################################
# The arrays with raw data are now stored in eing.data / #
# ausg.data #
##########################################################
#########################################################
# read input parameters - from command line
#DataType = sys.argv[3]
#alias = float(sys.argv[4])
#AMP = sys.argv[5]
#DELAY = sys.argv[6]
#SUB = sys.argv[7]
#TIL = sys.argv[8]
#maxit = int(sys.argv[9])
#qac = float(sys.argv[10])
#finac = float(sys.argv[11])
#ns1 = int(sys.argv[12])
#ns2 = int(sys.argv[13])
#MaxPer = float(sys.argv[14])
if DataType not in ('Dsp', 'Vel', 'Acc'):
print 'Data type not recognized! Has to be "Dsp", "Vel" or "Acc"!'
sys.exit(1)
param = []
delta = []
name = []
amp = float(AMP.split("+/-")[0])
param.append(amp)
damp = float(AMP.split("+/-")[1])
delta.append(damp)
name.append('amp')
delay = float(DELAY.split("+/-")[0])
param.append(delay)
ddelay = float(DELAY.split("+/-")[1])
delta.append(ddelay)
name.append('delay')
sub = float(SUB.split("+/-")[0])
param.append(sub)
dsub = float(SUB.split("+/-")[1])
delta.append(dsub)
name.append('sub')
til = float(TIL.split("+/-")[0])
param.append(til)
dtil = float(TIL.split("+/-")[1])
delta.append(dtil)
name.append('til')
samprate_eing = eing.stats.sampling_rate
samprate_ausg = ausg.stats.sampling_rate
if samprate_eing != samprate_ausg:
print 'Sampling of input and output is inconsistent!'
f.close()
sys.exit(1)
samprate = samprate_ausg
dt = 1/samprate
npts = ns2 - ns1
# create new miniseed header
stats = {'network': ausg.stats.network,\
'station': ausg.stats.station,\
'location': '',\
'channel': ausg.stats.channel,\
'npts': npts,\
'sampling_rate': samprate,\
'starttime': ausg.stats.starttime+ns1/samprate ,\
'mseed' : {'dataquality' : 'D'}}
t = np.linspace(ns1,ns2,num=npts,endpoint='true')*dt
# system start parameters
typ1_sta = []
corn_freqs1_sta = []
delta_corn_freqs1_sta = []
typ2_sta = []
corn_freqs2_sta = []
delta_corn_freqs2_sta = []
dmp_sta = []
delta_dmp_sta = []
m0_sta = int(raw_input("Give number of additional"\
" powers of s in nominator: "))
m1_sta = int(raw_input("Give number of 1st order subsystems: "))
for i in np.arange(0,m1_sta,1):
Type1, F, Df = str(raw_input("Give type of 1st"\
" order system nr. "+str(i+1)+": ")),\
float(raw_input("Give start value for corner period"\
" of subsystem nr. "+str(i+1)+": ")),\
float(raw_input("and now its estimated uncertainty: "))
if Type1 in ('hp1','lp1'):
typ1_sta.append(Type1)
corn_freqs1_sta.append(F)
delta_corn_freqs1_sta.append(Df)
else:
print 'Wrong system type! Must be <hp1> or <lp1>!'
f.close()
sys.exit(1)
m2_sta = int(raw_input("Give number of 2nd order subsystems: "))
for i in np.arange(0,m2_sta,1):
Type2, F, Df = str(raw_input("Give type of 2nd"\
" order system nr. "+str(i+1)+": ")),\
float(raw_input("Give start value for corner period"\
" of subsystem nr. "+str(i+1)+": ")),\
float(raw_input("and now its estimated uncertainty: "))
Dmp, Ddmp = float(raw_input("Give start value for damping"\
" constant of subsystem nr. "+str(i+1)+": ")),\
float(raw_input("and now its estimated uncertainty: "))
if Type2 in ('hp2','bp2','lp2'):
typ2_sta.append(Type2)
corn_freqs2_sta.append(F)
delta_corn_freqs2_sta.append(Df)
dmp_sta.append(Dmp)
delta_dmp_sta.append(Ddmp)
else:
print 'Wrong system type! Must be <hp2>, <bp2> or <lp2>!'
f.close()
sys.exit(1)
m1a = len(corn_freqs1_sta)
m2a = len(corn_freqs2_sta)
##########################################################
# Print start parameters
print ''
print 'System start parameters:'
print '------------------------'
print 'amp: ', amp, ' +/-', damp
print 'del: ', delay, ' +/-', ddelay
print 'sub: ', sub, ' +/-', dsub
print 'til: ', til, ' +/-', dtil
if m1_sta > 0:
for i in np.arange(0,m1_sta,1):
print ''
print '1st order subsystem nr. ' + str(i+1) + \
':' + ' ' + str(typ1_sta[i])
print 'per: ', corn_freqs1_sta[i], ' +/-',\
delta_corn_freqs1_sta[i]
if m2_sta > 0:
for i in np.arange(0,m2_sta,1):
print ''
print '2nd order subsystem nr. ' + str(i+1) +\
':' + ' ' + str(typ2_sta[i])
print 'per: ', corn_freqs2_sta[i],\
' +/-', delta_corn_freqs2_sta[i]
print 'dmp: ', dmp_sta[i], ' +/-', delta_dmp_sta[i]
print '------------------------'
##########################################################
# Preparation of data
eing.data = eing.data[ns1:ns2]
ausg.data = ausg.data[ns1:ns2]
# Anti alias-filter
syspar0 = np.zeros(30)
sr0 = np.zeros(30)
si0 = np.zeros(30)
resid0 = np.zeros(30)
residi0 = np.zeros(30)
m_alias = int(6. / np.log10((1. / alias) / dt) + 1.)
n_alias = int(floor(m_alias / 2))
m1_alias = 0
typ1_alias = []
corn_freqs1_alias = []
for i in range(m1a):
param.append(corn_freqs1_sta[i])
delta.append(delta_corn_freqs1_sta[i])
number = str(i+1)
name.append('Fc1['+number+']')
if m_alias > 2 * n_alias:
m1_alias = 1
typ1_alias.append('lp1')
corn_freqs1_alias.append(alias)
param.append(alias)
delta.append(0.)
name.append('F1ali')
for i in range(m2a):
param.append(corn_freqs2_sta[i])
delta.append(delta_corn_freqs2_sta[i])
param.append(dmp_sta[i])
delta.append(delta_dmp_sta[i])
number = str(i+1)
name.append('Fc2['+number+']')
name.append('dmp['+number+']')
m2_alias = n_alias
wi = 2. * np.arctan(1.) / m_alias
corn_freqs2_alias = []
dmp_alias = []
typ2_alias = []
for i in np.arange(1,n_alias+1,1):
typ2_alias.append('lp2')
corn_freqs2_alias.append(alias)
dmp_alias.append(np.sin(wi * (2. * i - 1)))
param.append(alias)
param.append(np.sin(wi * (2. * i - 1)))
delta.append(0.)
delta.append(0.)
name.append('F2ali')
name.append('dali')
m1c = m1a + len(corn_freqs1_alias)
m2c = m2a + len(corn_freqs2_alias)
einf0 = np.zeros(npts)
ausf0 = np.zeros(npts)
syspar_alias, m0_alias, m1_alias, m2_alias =\
def_sys_par(syspar0, dt, 0, m1_alias, m2_alias,\
1., delay, sub, til,\
typ1_alias, typ2_alias,\
corn_freqs1_alias,\
corn_freqs2_alias, dmp_alias)
sr_alias, si_alias, resid_alias, residi_alias =\
freqDamp2paz(syspar_alias, sr0, si0, resid0,\
residi0, 0, m1_alias, m2_alias)
einf = ltisim(1, eing.data, ausf0, einf0, 0., 0., 0.,\
sr_alias, si_alias, resid_alias,\
residi_alias, 0, m1_alias, m2_alias, dt, npts)
ausf = ltisim(1, ausg.data, ausf0, einf0, 0., 0., 0.,\
sr_alias, si_alias, resid_alias,\
residi_alias, 0, m1_alias, m2_alias, dt, npts)
print ''
print 'Anti alias-filter of order ',m_alias,\
' and corner frequency ',alias,'Hz applied to data!'
print '... writing files "' + st1[0].stats.station + '.' + st1[0].stats.channel + \
'.f.msd" and "' + st2[0].stats.station + '.' + st2[0].stats.channel + '.f.msd"'
st_einf = Stream([Trace(data=einf, header=stats)])
st_einf.write(st1[0].stats.station + '.' + st1[0].stats.channel + ".f.msd", format='MSEED')
st_ausf = Stream([Trace(data=ausf, header=stats)])
st_ausf.write(st2[0].stats.station + '.' + st2[0].stats.channel + ".f.msd", format='MSEED')
###########################################################
# Start model
m0_ges = m0_sta
m1_ges = m1_sta + m1_alias
m2_ges = m2_sta + m2_alias
typ1_ges = []
corn_freqs1_ges = []
for i in np.arange(0,m1_sta,1):
typ1_ges.append(typ1_sta[i])
corn_freqs1_ges.append(corn_freqs1_sta[i])
for i in np.arange(0,m1_alias,1):
typ1_ges.append(typ1_alias[i])
corn_freqs1_ges.append(corn_freqs1_alias[i])
typ2_ges = []
corn_freqs2_ges = []
dmp_ges = []
for i in np.arange(0,m2_sta,1):
typ2_ges.append(typ2_sta[i])
corn_freqs2_ges.append(corn_freqs2_sta[i])
dmp_ges.append(dmp_sta[i])
for i in np.arange(0,m2_alias,1):
typ2_ges.append(typ2_alias[i])
corn_freqs2_ges.append(corn_freqs2_alias[i])
dmp_ges.append(dmp_alias[i])
# simulate model with start parameters
syspar_ges, m0_sim, m1_sim, m2_sim =\
def_sys_par(syspar0, dt, m0_ges, m1_ges, m2_ges,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1_ges,\
corn_freqs2_ges, dmp_ges)
sr_sta, si_sta, resid_sta, residi_sta =\
freqDamp2paz(syspar_ges, sr0, si0, resid0, residi0,\
m0_sim, m1_sim, m2_sim)
diff = ltisim(0, eing.data, ausf, einf, delay, sub, til,\
sr_sta, si_sta, resid_sta,\
residi_sta, m0_sim, m1_sim, m2_sim, dt, npts)
qnorm = 0.
for i in np.arange(0,npts,1):
qnorm = qnorm + ausf[i]**2
qn = qnorm
q = quad(qn, diff, npts)
st_diff = Stream([Trace(data=diff, header=stats)])
st_diff.write("diff.msd", format='MSEED')
simulate = ausf - diff
print ''
print 'Output simulated with system start parameters '\
'from sample ' + str(ns1) + ' to ' + str(ns2) + '!'
print '... writing file "' + ausg.stats.station + '.' +\
ausg.stats.channel + '.sim.msd"'
st_simulate = Stream([Trace(data=simulate, header=stats)])
st_simulate.write(ausg.stats.station + '.' + ausg.stats.channel +\
'.sim.msd', format='MSEED')
print '----------------------------------------------'
print ''
##########################################################
# iteration with conjugate gradientes method
noimp = 0
step = 1.
gnorm = 0.
mp = len(param)
nap = 0
act_name = []
corn_freqs1_fin = []
corn_freqs2_fin = []
dmp_fin = []
for i in range(mp):
if delta[i] > 0:
nap = nap +1
act_name.append(name[i])
x = np.zeros(nap)
print 'Iteration stops when in ' + str(nap) + ' successive steps'
print 'RMS did not improve more than ' + str(qac) + ' and'
print 'step is lower than ' + str(finac) + '!'
print ' i', ' step ', ' RMS ',
for i in range(nap):
print '%15s' % act_name[i],
print ''
for niter in range(maxit):
qalt = q
x, q, d, fin_diff, step, axi, gnorm,\
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp =\
congrad(niter, mp, nap, x, q, qn, finac, delta, eing.data, ausf, einf,\
m0_ges, m1_ges, m1c, m2_ges, m2c,\
typ1_ges, typ2_ges, gnorm, step, dt, npts, param,\
syspar0, sr0, si0, resid0, residi0)
RMS = np.sqrt(q)
noimp = noimp + 1
print '%(niter)4i %(step)9e %(RMS)9e' \
% {"niter": niter, "step": axi, "RMS": RMS}, ' ',
if 'amp' in act_name:
print '%9e' % amp, ' ',
if 'delay' in act_name:
print '%9e' % delay, ' ',
if 'sub' in act_name:
print '%9e' % sub, ' ',
if 'til' in act_name:
print '%9e' % til, ' ',
for i in range(m1a):
if 'Fc1['+str(i+1)+']'in act_name:
if i == m1a - 1:
############################################################
if m2a > 0:
print '%9e' % corn_freqs1[i], ' ',
else:
print '%9e' % corn_freqs1[i], ' '
else:
print '%9e' % corn_freqs1[i], ' ',
for i in range(m2a):
if 'Fc2['+str(i+1)+']'in act_name:
print '%9e' % corn_freqs2[i], ' ',
print '%9e' % dmp[i],' ',
print ''
if np.mod(niter+1,nap) == 0:
print ''
# Stop the iteration
if np.sqrt(qalt) - np.sqrt(q) > qac or axi > finac:
noimp = 0
if noimp >= nap:
print 'CONVERGED'
print '-----------------------------------------------'
print 'final system parameters:'
print '%(niter)4i %(step)9e %(RMS)9e' \
% {"niter": niter, "step": axi, "RMS": RMS}, ' ',
if 'amp' in act_name:
print '%9e' % amp, ' ',
if 'delay' in act_name:
print '%9e' % delay, ' ',
if 'sub' in act_name:
print '%9e' % sub, ' ',
if 'til' in act_name:
print '%9e' % til, ' ',
for i in range(m1a):
if 'Fc1['+str(i+1)+']'in act_name:
if m2a > 0:
print '%9e' % corn_freqs1[i], ' ',
else:
print '%9e' % corn_freqs1[i], ' '
corn_freqs1_fin.append(corn_freqs1[i])
for i in range(m2a):
if 'Fc2['+str(i+1)+']'in act_name:
print '%9e' % corn_freqs2[i], ' ',
print '%9e' % dmp[i],' ',
corn_freqs2_fin.append(corn_freqs2[i])
dmp_fin.append(dmp[i])
print ''
print '-----------------------------------------------'
print ''
print '... writing file "' + ausg.stats.station + '.' +\
ausg.stats.channel + '.finfit.msd"'
fin_sim = ausf - fin_diff
st_final = Stream([Trace(data=fin_sim, header=stats)])
st_final.write(ausg.stats.station + '.' + ausg.stats.channel +\
'.finfit.msd', format='MSEED')
print '... writing file "' + ausg.stats.station + '.' +\
ausg.stats.channel + '.findiff.msd"'
st_diff = Stream([Trace(data=fin_diff, header=stats)])
st_diff.write(ausg.stats.station + '.' + ausg.stats.channel +\
'.findiff.msd', format='MSEED')
# calculate poles of final system
print '... writing file ' + ausg.stats.station + '.' + ausg.stats.channel + '.paz'
syspar_fin, m0_fin, m1_fin, m2_fin =\
def_sys_par(syspar0, dt, m0_sta, m1_sta, m2_sta,\
amp, delay, sub, til,\
typ1_sta, typ2_sta,\
corn_freqs1_fin,\
corn_freqs2_fin, dmp_fin)
sr_fin, si_fin, resid_fin, residi_fin =\
freqDamp2paz(syspar_fin, sr0, si0, resid0, residi0,\
m0_fin, m1_fin, m2_fin)
sr_fin = sr_fin[m0_fin+1:m0_fin+1+m1_fin+2*m2_fin]
si_fin = si_fin[m0_fin+1:m0_fin+1+m1_fin+2*m2_fin]
#resid_fin = resid_fin[m0_fin+1:m0_fin+1+m1_fin+2*m2_fin]
#residi_fin = residi_fin[m0_fin+1:m0_fin+1+m1_fin+2*m2_fin]
# write paz file according to GSE2 standard
paz_file_name = ausg.stats.station + '.'\
+ ausg.stats.channel + '.paz'
firstLine = 'CAL1 %(station)5s %(channel)3s PAZ\n'\
% {'station': ausg.stats.station, 'channel': ausg.stats.channel}
if DataType == 'Dsp':
nzeros = 3
if DataType == 'Vel':
nzeros = 2
if DataType == 'Acc':
nzeros = 1
poles = []
zeros = []
paz_file = open(paz_file_name, 'w')
paz_file.write(firstLine)
paz_file.write(str(len(sr_fin))+'\n')
for i in range(len(sr_fin)):
paz_file.write(str(sr_fin[i]) + ' ' + str(si_fin[i]) + '\n')
poles.append(complex(sr_fin[i], si_fin[i]))
paz_file.write(str(nzeros)+'\n')
for i in range(nzeros):
paz_file.write('0.0 0.0\n')
zeros.append(complex(0.0, 0.0))
paz_file.write('1.0')
paz_file.close()
print 'finished!'
f.close()
return st_final, st_diff, poles, zeros
# plot resulting transfer function
# CalcResp(poles, zeros, 1.0, MaxPer, samprate)
# sys.exit(1)
print ''
print 'NOT CONVERGED!'
print ''
print '... writing file "' + ausg.stats.station + '.' +\
ausg.stats.channel + '.finfit.msd"'
fin_sim = ausf - fin_diff
st_final = Stream([Trace(data=fin_sim, header=stats)])
st_final.write(ausg.stats.station + '.' + ausg.stats.channel +\
'.finfit.msd', format='MSEED')
print '... writing file "' + ausg.stats.station + '.' +\
ausg.stats.channel +'.findiff.msd"'
st_diff = Stream([Trace(data=fin_diff, header=stats)])
st_diff.write(ausg.stats.station + '.' + ausg.stats.channel +\
'.findiff.msd', format='MSEED')
f.close()
poles = []
zeros = []
return st_final, st_diff, poles, zeros
def congrad(niter, mp, nap, x, q, qn, finac, delta, data, ausf, einf,\
m0, m1, m1c, m2, m2c, typ1_ges, typ2_ges, gnorm, step, dt, npts,\
param, x0, sr0, si0, resid0, residi0):
g = np.zeros(nap)
d = np.zeros(nap)
dd = np.zeros(nap)
#partial derivatives
for k in range(nap):
x[k] = x[k] + finac
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(x, param, delta, m1c, m2c)
#print 'corn_freqs1', corn_freqs1
#print 'corn_freqs2', corn_freqs2
#print 'dmp', dmp
syspar_p, m0_p, m1_p, m2_p = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(syspar_p, sr0, si0, resid0, residi0,\
m0_p, m1_p, m2_p)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_p, m1_p, m2_p, dt, npts)
q_p = quad(qn, sim, npts)
x[k] = x[k] - finac - finac
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(x, param, delta, m1c, m2c)
syspar_m, m0_m, m1_m, m2_m = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(syspar_m, sr0, si0, resid0, residi0,\
m0_m, m1_m, m2_m)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_m, m1_m, m2_m, dt, npts)
q_m = quad(qn, sim, npts)
x[k] = x[k] + finac
g[k] = (q_p - q_m) / 2. / finac
#new direction of decent
if np.mod(niter, nap) == 0:
gnorm = 0.
for k in range(nap):
gnorm = gnorm + g[k]**2
d[k] = -g[k]
else:
ga = gnorm
gnorm = 0.
for k in range(nap):
gnorm = gnorm + g[k]**2
beta = gnorm / ga
for k in range(nap):
d[k] = -g[k] + beta * d[k]
dlen = 0.
for k in range(nap):
dlen = dlen + d[k]**2
dlen = np.sqrt(dlen)
for k in range(nap):
dd[k] = d[k] / dlen
x, q, step, axi, amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp =\
mini(x, q, qn, dd, delta, finac, data, ausf, einf,\
m0, m1, m1c, m2, m2c, typ1_ges, typ2_ges,\
param, nap, step, dt, npts,\
x0, sr0, si0, resid0, residi0)
return x, q, d, sim, step, axi, gnorm, \
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp
def RelCalTime(st1, st2, DataType, alias,\
AMP='0.+/-0.', DELAY='0.+/-0.', SUB='0.+/-0.', TIL='0.+/-0.',\
maxit=100, qac=1e-5, finac=1e-3, ns1=0, ns2=60000):
########################################################
# For writing comunication not only to stdout but also
# to the file "calex.out" a new write method is
# defined.
class SplitWriter():
"""
Implements a write method that writes a given message on all children
"""
def __init__(self, filehandle):
"""
Remember provided objects as children.
"""
self.file = filehandle
self.stdout = sys.stdout
def write(self, msg):
"""
Sends msg to all childrens write method.
"""
self.stdout.write(msg)
self.file.write(msg)
f = open("RelCalTime.out", "wt")
sys.stdout = SplitWriter(f)
########################################################
# read input
eing_st = st1
if len(eing_st) > 1:
print 'more than one traces found in stream 1!'
f.close()
sys.exit(1)
eing = eing_st[0]
ausg_st = st2
if len(ausg_st) > 1:
print 'more than one traces found in stream 2!'
f.close()
sys.exit(1)
ausg = ausg_st[0]
# make sure that the stype is what cython expects later!
for tr in eing, ausg:
tr.data = tr.data.astype(np.float64)
##########################################################
# The arrays with raw data are now stored in eing.data / #
# ausg.data #
##########################################################
#########################################################
# read input parameters - from command line
#DataType = sys.argv[3]
#alias = float(sys.argv[4])
#AMP = sys.argv[5]
#DELAY = sys.argv[6]
#SUB = sys.argv[7]
#TIL = sys.argv[8]
#maxit = int(sys.argv[9])
#qac = float(sys.argv[10])
#finac = float(sys.argv[11])
#ns1 = int(sys.argv[12])
#ns2 = int(sys.argv[13])
#MaxPer = float(sys.argv[14])
if DataType not in ('Dsp', 'Vel', 'Acc'):
print 'Data type not recognized! Has to be "Dsp", "Vel" or "Acc"!'
sys.exit(1)
param = []
delta = []
name = []
amp = float(AMP.split("+/-")[0])
param.append(amp)
damp = float(AMP.split("+/-")[1])
delta.append(damp)
name.append('amp')
delay = float(DELAY.split("+/-")[0])
param.append(delay)
ddelay = float(DELAY.split("+/-")[1])
delta.append(ddelay)
name.append('delay')
sub = float(SUB.split("+/-")[0])
param.append(sub)
dsub = float(SUB.split("+/-")[1])
delta.append(dsub)
name.append('sub')
til = float(TIL.split("+/-")[0])
param.append(til)
dtil = float(TIL.split("+/-")[1])
delta.append(dtil)
name.append('til')
samprate_eing = eing.stats.sampling_rate
samprate_ausg = ausg.stats.sampling_rate
if samprate_eing != samprate_ausg:
print 'Sampling of input and output is inconsistent!'
f.close()
sys.exit(1)
samprate = samprate_ausg
dt = 1 / samprate
npts = ns2 - ns1
# create new miniseed header
stats = {'network': ausg.stats.network,\
'station': ausg.stats.station,\
'location': '',\
'channel': ausg.stats.channel,\
'npts': npts,\
'sampling_rate': samprate,\
'starttime': ausg.stats.starttime+ns1/samprate ,\
'mseed' : {'dataquality' : 'D'}}
t = np.linspace(ns1, ns2, num=npts, endpoint='true') * dt
# system start parameters
typ1_sta = []
corn_freqs1_sta = []
delta_corn_freqs1_sta = []
typ2_sta = []
corn_freqs2_sta = []
delta_corn_freqs2_sta = []
dmp_sta = []
delta_dmp_sta = []
m0_sta = int(raw_input("Give number of additional"\
" powers of s in nominator: "))
m1_sta = int(raw_input("Give number of 1st order subsystems: "))
for i in np.arange(0, m1_sta, 1):
Type1, F, Df = str(raw_input("Give type of 1st"\
" order system nr. "+str(i+1)+": ")),\
float(raw_input("Give start value for corner period"\
" of subsystem nr. "+str(i+1)+": ")),\
float(raw_input("and now its estimated uncertainty: "))
if Type1 in ('hp1', 'lp1'):
typ1_sta.append(Type1)
corn_freqs1_sta.append(F)
delta_corn_freqs1_sta.append(Df)
else:
print 'Wrong system type! Must be <hp1> or <lp1>!'
f.close()
sys.exit(1)
m2_sta = int(raw_input("Give number of 2nd order subsystems: "))
for i in np.arange(0, m2_sta, 1):
Type2, F, Df = str(raw_input("Give type of 2nd"\
" order system nr. "+str(i+1)+": ")),\
float(raw_input("Give start value for corner period"\
" of subsystem nr. "+str(i+1)+": ")),\
float(raw_input("and now its estimated uncertainty: "))
Dmp, Ddmp = float(raw_input("Give start value for damping"\
" constant of subsystem nr. "+str(i+1)+": ")),\
float(raw_input("and now its estimated uncertainty: "))
if Type2 in ('hp2', 'bp2', 'lp2'):
typ2_sta.append(Type2)
corn_freqs2_sta.append(F)
delta_corn_freqs2_sta.append(Df)
dmp_sta.append(Dmp)
delta_dmp_sta.append(Ddmp)
else:
print 'Wrong system type! Must be <hp2>, <bp2> or <lp2>!'
f.close()
sys.exit(1)
m1a = len(corn_freqs1_sta)
m2a = len(corn_freqs2_sta)
##########################################################
# Print start parameters
print ''
print 'System start parameters:'
print '------------------------'
print 'amp: ', amp, ' +/-', damp
print 'del: ', delay, ' +/-', ddelay
print 'sub: ', sub, ' +/-', dsub
print 'til: ', til, ' +/-', dtil
if m1_sta > 0:
for i in np.arange(0, m1_sta, 1):
print ''
print '1st order subsystem nr. ' + str(i+1) + \
':' + ' ' + str(typ1_sta[i])
print 'per: ', corn_freqs1_sta[i], ' +/-',\
delta_corn_freqs1_sta[i]
if m2_sta > 0:
for i in np.arange(0, m2_sta, 1):
print ''
print '2nd order subsystem nr. ' + str(i+1) +\
':' + ' ' + str(typ2_sta[i])
print 'per: ', corn_freqs2_sta[i],\
' +/-', delta_corn_freqs2_sta[i]
print 'dmp: ', dmp_sta[i], ' +/-', delta_dmp_sta[i]
print '------------------------'
##########################################################
# Preparation of data
eing.data = eing.data[ns1:ns2]
ausg.data = ausg.data[ns1:ns2]
# Anti alias-filter
syspar0 = np.zeros(30)
sr0 = np.zeros(30)
si0 = np.zeros(30)
resid0 = np.zeros(30)
residi0 = np.zeros(30)
m_alias = int(6. / np.log10((1. / alias) / dt) + 1.)
n_alias = int(floor(m_alias / 2))
m1_alias = 0
typ1_alias = []
corn_freqs1_alias = []
for i in range(m1a):
param.append(corn_freqs1_sta[i])
delta.append(delta_corn_freqs1_sta[i])
number = str(i + 1)
name.append('Fc1[' + number + ']')
if m_alias > 2 * n_alias:
m1_alias = 1
typ1_alias.append('lp1')
corn_freqs1_alias.append(alias)
param.append(alias)
delta.append(0.)
name.append('F1ali')
for i in range(m2a):
param.append(corn_freqs2_sta[i])
delta.append(delta_corn_freqs2_sta[i])
param.append(dmp_sta[i])
delta.append(delta_dmp_sta[i])
number = str(i + 1)
name.append('Fc2[' + number + ']')
name.append('dmp[' + number + ']')
m2_alias = n_alias
wi = 2. * np.arctan(1.) / m_alias
corn_freqs2_alias = []
dmp_alias = []
typ2_alias = []
for i in np.arange(1, n_alias + 1, 1):
typ2_alias.append('lp2')
corn_freqs2_alias.append(alias)
dmp_alias.append(np.sin(wi * (2. * i - 1)))
param.append(alias)
param.append(np.sin(wi * (2. * i - 1)))
delta.append(0.)
delta.append(0.)
name.append('F2ali')
name.append('dali')
m1c = m1a + len(corn_freqs1_alias)
m2c = m2a + len(corn_freqs2_alias)
einf0 = np.zeros(npts)
ausf0 = np.zeros(npts)
syspar_alias, m0_alias, m1_alias, m2_alias =\
def_sys_par(syspar0, dt, 0, m1_alias, m2_alias,\
1., delay, sub, til,\
typ1_alias, typ2_alias,\
corn_freqs1_alias,\
corn_freqs2_alias, dmp_alias)
sr_alias, si_alias, resid_alias, residi_alias =\
freqDamp2paz(syspar_alias, sr0, si0, resid0,\
residi0, 0, m1_alias, m2_alias)
einf = ltisim(1, eing.data, ausf0, einf0, 0., 0., 0.,\
sr_alias, si_alias, resid_alias,\
residi_alias, 0, m1_alias, m2_alias, dt, npts)
ausf = ltisim(1, ausg.data, ausf0, einf0, 0., 0., 0.,\
sr_alias, si_alias, resid_alias,\
residi_alias, 0, m1_alias, m2_alias, dt, npts)
print ''
print 'Anti alias-filter of order ',m_alias,\
' and corner frequency ',alias,'Hz applied to data!'
print '... writing files "' + st1[0].stats.station + '.' + st1[0].stats.channel + \
'.f.msd" and "' + st2[0].stats.station + '.' + st2[0].stats.channel + '.f.msd"'
st_einf = Stream([Trace(data=einf, header=stats)])
st_einf.write(st1[0].stats.station + '.' + st1[0].stats.channel + ".f.msd",
format='MSEED')
st_ausf = Stream([Trace(data=ausf, header=stats)])
st_ausf.write(st2[0].stats.station + '.' + st2[0].stats.channel + ".f.msd",
format='MSEED')
###########################################################
# Start model
m0_ges = m0_sta
m1_ges = m1_sta + m1_alias
m2_ges = m2_sta + m2_alias
typ1_ges = []
corn_freqs1_ges = []
for i in np.arange(0, m1_sta, 1):
typ1_ges.append(typ1_sta[i])
corn_freqs1_ges.append(corn_freqs1_sta[i])
for i in np.arange(0, m1_alias, 1):
typ1_ges.append(typ1_alias[i])
corn_freqs1_ges.append(corn_freqs1_alias[i])
typ2_ges = []
corn_freqs2_ges = []
dmp_ges = []
for i in np.arange(0, m2_sta, 1):
typ2_ges.append(typ2_sta[i])
corn_freqs2_ges.append(corn_freqs2_sta[i])
dmp_ges.append(dmp_sta[i])
for i in np.arange(0, m2_alias, 1):
typ2_ges.append(typ2_alias[i])
corn_freqs2_ges.append(corn_freqs2_alias[i])
dmp_ges.append(dmp_alias[i])
# simulate model with start parameters
syspar_ges, m0_sim, m1_sim, m2_sim =\
def_sys_par(syspar0, dt, m0_ges, m1_ges, m2_ges,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1_ges,\
corn_freqs2_ges, dmp_ges)
sr_sta, si_sta, resid_sta, residi_sta =\
freqDamp2paz(syspar_ges, sr0, si0, resid0, residi0,\
m0_sim, m1_sim, m2_sim)
diff = ltisim(0, eing.data, ausf, einf, delay, sub, til,\
sr_sta, si_sta, resid_sta,\
residi_sta, m0_sim, m1_sim, m2_sim, dt, npts)
qnorm = 0.
for i in np.arange(0, npts, 1):
qnorm = qnorm + ausf[i]**2
qn = qnorm
q = quad(qn, diff, npts)
st_diff = Stream([Trace(data=diff, header=stats)])
st_diff.write("diff.msd", format='MSEED')
simulate = ausf - diff
print ''
print 'Output simulated with system start parameters '\
'from sample ' + str(ns1) + ' to ' + str(ns2) + '!'
print '... writing file "' + ausg.stats.station + '.' +\
ausg.stats.channel + '.sim.msd"'
st_simulate = Stream([Trace(data=simulate, header=stats)])
st_simulate.write(ausg.stats.station + '.' + ausg.stats.channel +\
'.sim.msd', format='MSEED')
print '----------------------------------------------'
print ''
##########################################################
# iteration with conjugate gradientes method
noimp = 0
step = 1.
gnorm = 0.
mp = len(param)
nap = 0
act_name = []
corn_freqs1_fin = []
corn_freqs2_fin = []
dmp_fin = []
for i in range(mp):
if delta[i] > 0:
nap = nap + 1
act_name.append(name[i])
x = np.zeros(nap)
print 'Iteration stops when in ' + str(nap) + ' successive steps'
print 'RMS did not improve more than ' + str(qac) + ' and'
print 'step is lower than ' + str(finac) + '!'
print ' i', ' step ', ' RMS ',
for i in range(nap):
print '%15s' % act_name[i],
print ''
for niter in range(maxit):
qalt = q
x, q, d, fin_diff, step, axi, gnorm,\
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp =\
congrad(niter, mp, nap, x, q, qn, finac, delta, eing.data, ausf, einf,\
m0_ges, m1_ges, m1c, m2_ges, m2c,\
typ1_ges, typ2_ges, gnorm, step, dt, npts, param,\
syspar0, sr0, si0, resid0, residi0)
RMS = np.sqrt(q)
noimp = noimp + 1
print '%(niter)4i %(step)9e %(RMS)9e' \
% {"niter": niter, "step": axi, "RMS": RMS}, ' ',
if 'amp' in act_name:
print '%9e' % amp, ' ',
if 'delay' in act_name:
print '%9e' % delay, ' ',
if 'sub' in act_name:
print '%9e' % sub, ' ',
if 'til' in act_name:
print '%9e' % til, ' ',
for i in range(m1a):
if 'Fc1[' + str(i + 1) + ']' in act_name:
if i == m1a - 1:
############################################################
if m2a > 0:
print '%9e' % corn_freqs1[i], ' ',
else:
print '%9e' % corn_freqs1[i], ' '
else:
print '%9e' % corn_freqs1[i], ' ',
for i in range(m2a):
if 'Fc2[' + str(i + 1) + ']' in act_name:
print '%9e' % corn_freqs2[i], ' ',
print '%9e' % dmp[i], ' ',
print ''
if np.mod(niter + 1, nap) == 0:
print ''
# Stop the iteration
if np.sqrt(qalt) - np.sqrt(q) > qac or axi > finac:
noimp = 0
if noimp >= nap:
print 'CONVERGED'
print '-----------------------------------------------'
print 'final system parameters:'
print '%(niter)4i %(step)9e %(RMS)9e' \
% {"niter": niter, "step": axi, "RMS": RMS}, ' ',
if 'amp' in act_name:
print '%9e' % amp, ' ',
if 'delay' in act_name:
print '%9e' % delay, ' ',
if 'sub' in act_name:
print '%9e' % sub, ' ',
if 'til' in act_name:
print '%9e' % til, ' ',
for i in range(m1a):
if 'Fc1[' + str(i + 1) + ']' in act_name:
if m2a > 0:
print '%9e' % corn_freqs1[i], ' ',
else:
print '%9e' % corn_freqs1[i], ' '
corn_freqs1_fin.append(corn_freqs1[i])
for i in range(m2a):
if 'Fc2[' + str(i + 1) + ']' in act_name:
print '%9e' % corn_freqs2[i], ' ',
print '%9e' % dmp[i], ' ',
corn_freqs2_fin.append(corn_freqs2[i])
dmp_fin.append(dmp[i])
print ''
print '-----------------------------------------------'
print ''
print '... writing file "' + ausg.stats.station + '.' +\
ausg.stats.channel + '.finfit.msd"'
fin_sim = ausf - fin_diff
st_final = Stream([Trace(data=fin_sim, header=stats)])
st_final.write(ausg.stats.station + '.' + ausg.stats.channel +\
'.finfit.msd', format='MSEED')
print '... writing file "' + ausg.stats.station + '.' +\
ausg.stats.channel + '.findiff.msd"'
st_diff = Stream([Trace(data=fin_diff, header=stats)])
st_diff.write(ausg.stats.station + '.' + ausg.stats.channel +\
'.findiff.msd', format='MSEED')
# calculate poles of final system
print '... writing file ' + ausg.stats.station + '.' + ausg.stats.channel + '.paz'
syspar_fin, m0_fin, m1_fin, m2_fin =\
def_sys_par(syspar0, dt, m0_sta, m1_sta, m2_sta,\
amp, delay, sub, til,\
typ1_sta, typ2_sta,\
corn_freqs1_fin,\
corn_freqs2_fin, dmp_fin)
sr_fin, si_fin, resid_fin, residi_fin =\
freqDamp2paz(syspar_fin, sr0, si0, resid0, residi0,\
m0_fin, m1_fin, m2_fin)
sr_fin = sr_fin[m0_fin + 1:m0_fin + 1 + m1_fin + 2 * m2_fin]
si_fin = si_fin[m0_fin + 1:m0_fin + 1 + m1_fin + 2 * m2_fin]
#resid_fin = resid_fin[m0_fin+1:m0_fin+1+m1_fin+2*m2_fin]
#residi_fin = residi_fin[m0_fin+1:m0_fin+1+m1_fin+2*m2_fin]
# write paz file according to GSE2 standard
paz_file_name = ausg.stats.station + '.'\
+ ausg.stats.channel + '.paz'
firstLine = 'CAL1 %(station)5s %(channel)3s PAZ\n'\
% {'station': ausg.stats.station, 'channel': ausg.stats.channel}
if DataType == 'Dsp':
nzeros = 3
if DataType == 'Vel':
nzeros = 2
if DataType == 'Acc':
nzeros = 1
poles = []
zeros = []
paz_file = open(paz_file_name, 'w')
paz_file.write(firstLine)
paz_file.write(str(len(sr_fin)) + '\n')
for i in range(len(sr_fin)):
paz_file.write(str(sr_fin[i]) + ' ' + str(si_fin[i]) + '\n')
poles.append(complex(sr_fin[i], si_fin[i]))
paz_file.write(str(nzeros) + '\n')
for i in range(nzeros):
paz_file.write('0.0 0.0\n')
zeros.append(complex(0.0, 0.0))
paz_file.write('1.0')
paz_file.close()
print 'finished!'
f.close()
return st_final, st_diff, poles, zeros
# plot resulting transfer function
# CalcResp(poles, zeros, 1.0, MaxPer, samprate)
# sys.exit(1)
print ''
print 'NOT CONVERGED!'
print ''
print '... writing file "' + ausg.stats.station + '.' +\
ausg.stats.channel + '.finfit.msd"'
fin_sim = ausf - fin_diff
st_final = Stream([Trace(data=fin_sim, header=stats)])
st_final.write(ausg.stats.station + '.' + ausg.stats.channel +\
'.finfit.msd', format='MSEED')
print '... writing file "' + ausg.stats.station + '.' +\
ausg.stats.channel +'.findiff.msd"'
st_diff = Stream([Trace(data=fin_diff, header=stats)])
st_diff.write(ausg.stats.station + '.' + ausg.stats.channel +\
'.findiff.msd', format='MSEED')
f.close()
poles = []
zeros = []
return st_final, st_diff, poles, zeros
def mini(
x,
q,
qn,
d,
delta,
finac,
data,
ausf,
einf,
m0,
m1,
m1c,
m2,
m2c,
typ1_ges,
typ2_ges,
param,
nap,
step,
dt,
npts,
x0,
sr0,
si0,
resid0,
residi0,
):
# import ipdb; ipdb.set_trace()
xl = np.zeros(nap)
xr = np.zeros(nap)
xm, qm = move(x, q, nap)
for k in range(nap):
xl[k] = x[k] - step * d[k]
xr[k] = x[k] + step * d[k]
# left
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap = def_act_sys_par(xl, param, delta, m1c, m2c)
sysl, m0_l, m1_l, m2_l = def_sys_par(
x0, dt, m0, m1, m2, amp, delay, sub, til, typ1_ges, typ2_ges, corn_freqs1, corn_freqs2, dmp
)
sr, si, resid, residi = freqDamp2paz(sysl, sr0, si0, resid0, residi0, m0_l, m1_l, m2_l)
sim = ltisim(0, data, ausf, einf, delay, sub, til, sr, si, resid, residi, m0_l, m1_l, m2_l, dt, npts)
ql = quad(qn, sim, npts)
# right
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap = def_act_sys_par(xr, param, delta, m1c, m2c)
sysr, m0_r, m1_r, m2_r = def_sys_par(
x0, dt, m0, m1, m2, amp, delay, sub, til, typ1_ges, typ2_ges, corn_freqs1, corn_freqs2, dmp
)
sr, si, resid, residi = freqDamp2paz(sysr, sr0, si0, resid0, residi0, m0_r, m1_r, m2_r)
sim = ltisim(0, data, ausf, einf, delay, sub, til, sr, si, resid, residi, m0_r, m1_r, m2_r, dt, npts)
qr = quad(qn, sim, npts)
# maximum?
if ql < qm and qr < qm:
print "Maximum encountered! Try again with different start parameters!"
sys.exit(1)
while ql >= qm and qr >= qm and step >= 8.0 * finac:
step = step / 8.0
for k in range(nap):
xl[k] = xm[k] - step * d[k]
xr[k] = xm[k] + step * d[k]
# left
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap = def_act_sys_par(xl, param, delta, m1c, m2c)
sysl, m0_l, m1_l, m2_l = def_sys_par(
x0, dt, m0, m1, m2, amp, delay, sub, til, typ1_ges, typ2_ges, corn_freqs1, corn_freqs2, dmp
)
sr, si, resid, residi = freqDamp2paz(sysl, sr0, si0, resid0, residi0, m0_l, m1_l, m2_l)
sim = ltisim(0, data, ausf, einf, delay, sub, til, sr, si, resid, residi, m0_l, m1_l, m2_l, dt, npts)
ql = quad(qn, sim, npts)
# right
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap = def_act_sys_par(xr, param, delta, m1c, m2c)
sysr, m0_r, m1_r, m2_r = def_sys_par(
x0, dt, m0, m1, m2, amp, delay, sub, til, typ1_ges, typ2_ges, corn_freqs1, corn_freqs2, dmp
)
sr, si, resid, residi = freqDamp2paz(sysr, sr0, si0, resid0, residi0, m0_r, m1_r, m2_r)
sim = ltisim(0, data, ausf, einf, delay, sub, til, sr, si, resid, residi, m0_r, m1_r, m2_r, dt, npts)
qr = quad(qn, sim, npts)
if ql < qm and qr < qm:
print "Maximum encountered! Try again with different start parameters!"
sys.exit(1)
# witch side of the minimum?
if ql < qm or qr < qm:
if ql < qr:
# turn around
x, q = move(xl, ql, nap)
xl, ql = move(xr, qr, nap)
xr, qr = move(x, q, nap)
for k in range(nap):
d[k] = -d[k]
if step > 1.0:
x, q = move(xr, qr, nap)
axi = step
return x, q, step, axi, amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp
else:
step = 2.0 * step
xm, qm = move(xr, qr, nap)
for k in range(nap):
xr[k] = xm[k] + step * d[k]
# right
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap = def_act_sys_par(xr, param, delta, m1c, m2c)
sysr, m0_r, m1_r, m2_r = def_sys_par(
x0, dt, m0, m1, m2, amp, delay, sub, til, typ1_ges, typ2_ges, corn_freqs1, corn_freqs2, dmp
)
sr, si, resid, residi = freqDamp2paz(sysr, sr0, si0, resid0, residi0, m0_r, m1_r, m2_r)
sim = ltisim(0, data, ausf, einf, delay, sub, til, sr, si, resid, residi, m0_r, m1_r, m2_r, dt, npts)
qr = quad(qn, sim, npts)
while qr < qm:
if step > 1.0:
x, q = move(xr, qr, nap)
axi = step
return x, q, step, axi, amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp
else:
step = 2.0 * step
xm, qm = move(xr, qr, nap)
for k in range(nap):
xr[k] = xm[k] + step * d[k]
# right
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap = def_act_sys_par(xr, param, delta, m1c, m2c)
sysr, m0_r, m1_r, m2_r = def_sys_par(
x0, dt, m0, m1, m2, amp, delay, sub, til, typ1_ges, typ2_ges, corn_freqs1, corn_freqs2, dmp
)
sr, si, resid, residi = freqDamp2paz(sysr, sr0, si0, resid0, residi0, m0_r, m1_r, m2_r)
sim = ltisim(0, data, ausf, einf, delay, sub, til, sr, si, resid, residi, m0_r, m1_r, m2_r, dt, npts)
qr = quad(qn, sim, npts)
# interpolate
xi = (ql - qr) / (ql - 2.0 * qm + qr) / 2.0 * step
axi = np.abs(xi)
for k in range(nap):
x[k] = xm[k] + xi * d[k]
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap = def_act_sys_par(x, param, delta, m1c, m2c)
sysp, m0_i, m1_i, m2_i = def_sys_par(
x0, dt, m0, m1, m2, amp, delay, sub, til, typ1_ges, typ2_ges, corn_freqs1, corn_freqs2, dmp
)
sr, si, resid, residi = freqDamp2paz(sysp, sr0, si0, resid0, residi0, m0_i, m1_i, m2_i)
sim = ltisim(0, data, ausf, einf, delay, sub, til, sr, si, resid, residi, m0_i, m1_i, m2_i, dt, npts)
q = quad(qn, sim, npts)
return x, q, step, axi, amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp
if step < 8.0 * finac:
xi = (ql - qr) / (ql - 2.0 * qm + qr) / 2.0 * step
axi = np.abs(xi)
for k in range(nap):
x[k] = xm[k] + xi * d[k]
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap = def_act_sys_par(x, param, delta, m1c, m2c)
sysp, m0_i, m1_i, m2_i = def_sys_par(
x0, dt, m0, m1, m2, amp, delay, sub, til, typ1_ges, typ2_ges, corn_freqs1, corn_freqs2, dmp
)
sr, si, resid, residi = freqDamp2paz(sysp, sr0, si0, resid0, residi0, m0_i, m1_i, m2_i)
sim = ltisim(0, data, ausf, einf, delay, sub, til, sr, si, resid, residi, m0_i, m1_i, m2_i, dt, npts)
q = quad(qn, sim, npts)
return x, q, step, axi, amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp
print "Residual error..."
print "Try again with other start parameters!"
sys.exit(1)
residi0 = np.zeros(30)
npts = eing.stats.npts
dt = 0.005
amp = 0.02
delay = 0.
sub = 0.
til = 0
m0_ges = 0
m1_ges = 1
m2_ges = 3
typ1_ges = ['lp1']
typ2_ges = ['bp2', 'lp2', 'lp2']
corn_freqs1_ges = [10.0]
corn_freqs2_ges = [1.0, 10.0, 10.0]
dmp_ges = [0.59999999999999998, 0.3090169943749474, 0.80901699437494745]
syspar_ges, m0_sim, m1_sim, m2_sim =\
def_sys_par(syspar0, dt, m0_ges, m1_ges, m2_ges,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1_ges,\
corn_freqs2_ges, dmp_ges)
sr_sta, si_sta, resid_sta, residi_sta =\
freqDamp2paz(syspar_ges, sr0, si0, resid0, residi0,\
m0_sim, m1_sim, m2_sim)
diff = ltisim(0, eing.data, ausf, einf, delay, sub, til,\
sr_sta, si_sta, resid_sta,\
residi_sta, m0_sim, m1_sim, m2_sim, dt, npts)
def congrad(niter, mp, nap, x, q, qn, finac, delta, data, ausf, einf,\
m0, m1, m1c, m2, m2c, typ1_ges, typ2_ges, gnorm, step, dt, npts,\
param, x0, sr0, si0, resid0, residi0):
g = np.zeros(nap)
d = np.zeros(nap)
dd = np.zeros(nap)
#partial derivatives
for k in range(nap):
x[k] = x[k] + finac
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(x, param, delta, m1c, m2c)
#print 'corn_freqs1', corn_freqs1
#print 'corn_freqs2', corn_freqs2
#print 'dmp', dmp
syspar_p, m0_p, m1_p, m2_p = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(syspar_p, sr0, si0, resid0, residi0,\
m0_p, m1_p, m2_p)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_p, m1_p, m2_p, dt, npts)
q_p = quad(qn, sim, npts)
x[k] = x[k] - finac - finac
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp, nap =\
def_act_sys_par(x, param, delta, m1c, m2c)
syspar_m, m0_m, m1_m, m2_m = def_sys_par(x0, dt, m0, m1, m2,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1, corn_freqs2, dmp)
sr, si, resid, residi =\
freqDamp2paz(syspar_m, sr0, si0, resid0, residi0,\
m0_m, m1_m, m2_m)
sim = ltisim(0, data, ausf, einf, delay, sub, til,\
sr, si, resid, residi, m0_m, m1_m, m2_m, dt, npts)
q_m = quad(qn, sim, npts)
x[k] = x[k] + finac
g[k] = (q_p - q_m) / 2. / finac
#new direction of decent
if np.mod(niter, nap) == 0:
gnorm = 0.
for k in range(nap):
gnorm = gnorm + g[k]**2
d[k] = -g[k]
else:
ga = gnorm
gnorm = 0.
for k in range(nap):
gnorm = gnorm + g[k]**2
beta = gnorm / ga
for k in range(nap):
d[k] = -g[k] + beta * d[k]
dlen = 0.
for k in range(nap):
dlen = dlen + d[k]**2
dlen = np.sqrt(dlen)
for k in range(nap):
dd[k] = d[k] / dlen
x, q, step, axi, amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp =\
mini(x, q, qn, dd, delta, finac, data, ausf, einf,\
m0, m1, m1c, m2, m2c, typ1_ges, typ2_ges,\
param, nap, step, dt, npts,\
x0, sr0, si0, resid0, residi0)
return x, q, d, sim, step, axi, gnorm, \
amp, delay, sub, til, corn_freqs1, corn_freqs2, dmp
residi0 = np.zeros(30)
npts = eing.stats.npts
dt = 0.005
amp = 0.02
delay = 0.
sub = 0.
til = 0
m0_ges = 0
m1_ges = 1
m2_ges = 3
typ1_ges = ['lp1']
typ2_ges = ['bp2', 'lp2', 'lp2']
corn_freqs1_ges = [10.0]
corn_freqs2_ges = [1.0, 10.0, 10.0]
dmp_ges = [0.59999999999999998, 0.3090169943749474, 0.80901699437494745]
syspar_ges, m0_sim, m1_sim, m2_sim =\
def_sys_par(syspar0, dt, m0_ges, m1_ges, m2_ges,\
amp, delay, sub, til,\
typ1_ges, typ2_ges,\
corn_freqs1_ges,\
corn_freqs2_ges, dmp_ges)
sr_sta, si_sta, resid_sta, residi_sta =\
freqDamp2paz(syspar_ges, sr0, si0, resid0, residi0,\
m0_sim, m1_sim, m2_sim)
diff = ltisim(0, eing.data, ausf, einf, delay, sub, til,\
sr_sta, si_sta, resid_sta,\
residi_sta, m0_sim, m1_sim, m2_sim, dt, npts)