def _meas4CorBump(cors, bpmins, bpmouts, bpmdx, **kwargs):
"""
superposition of two 3Cor bumps
cors - list of correctors (4)
bpmins - BPMs inside the bump
bpmouts -
bpmdx - desired change of orbit for bpmins
dA1 - change of one cor for ORM fitting, default 0.2
dA2 - change of one cor for ORM fitting, default 0.2
"""
dA1 = kwargs.pop("dA1", 0.2)
dA2 = kwargs.pop("dA2", 0.2)
plane = kwargs.get("plane", 'x')
# two bpms
if len(bpmins) != 2 or len(cors) != 4:
raise RuntimeError("wrong number of bpms/cors, {0}/{1}".format(
len(bpmins), len(cors)))
xv0 = fget(bpmins, plane, unitsys=None, sample=5)
cv0 = fget(cors, plane, unitsys=None, handle="setpoint")
m = np.zeros((2, 2), 'd')
dxout1, dxin1, dcls1 = set3CorBump(cors[:3], dA1, bpmins, bpmouts,
**kwargs)
fput([(cors[i], plane, cv0[i]) for i in range(len(cors))], unitsys=None)
time.sleep(0.5)
xv1 = fget(bpmins, plane, unitsys=None, sample=5)
cv1 = fget(cors, plane, unitsys=None, handle="setpoint")
dxout2, dxin2, dcls2 = set3CorBump(cors[1:], dA2, bpmins, bpmouts,
**kwargs)
fput([(cors[i], plane, cv0[i]) for i in range(len(cors))], unitsys=None)
time.sleep(0.5)
xv2 = fget(bpmins, plane, unitsys=None, sample=5)
cv2 = fget(cors, plane, unitsys=None, handle="setpoint")
m[:, 0] = dxin1 / dA1
m[:, 1] = dxin2 / dA2
mdet = np.linalg.det(m)
if mdet == 0.0:
raise RuntimeError("singular config of ({0},{1}) vs ({2},{3})".format(
bpmins[0].name, bpmins[1].name, cors[0].name, cors[1].name))
dc1 = (m[1, 1] * bpmdx[0] - m[0, 1] * bpmdx[1]) / mdet
dc2 = (-m[1, 0] * bpmdx[0] + m[0, 0] * bpmdx[1]) / mdet
dcs = np.zeros(4, 'd')
for i in range(3):
dcs[i] = dcs[i] + dcls1[i] / dA1 * dc1
dcs[i + 1] = dcs[i + 1] + dcls2[i] / dA2 * dc2
return dcs
def measure(self, respfields, kfield, **kwargs):
"""
Measure the RM by change one kicker.
:param respfields: response fields, a list
"""
verbose = kwargs.get('verbose', 0)
dklst = kwargs.get('dklst', None)
kx0 = self.kicker.get(kfield, unitsys=self.unit) # get EPICS value
wait = (self.minwait, self.stepwait, 0)
if verbose:
print("kicker: '%s.%s'= %e" % (self.kicker.name, kfield, kx0) )
points = self.points
if dklst is not None:
points = len(dklst)
print(("Using external dklst:", dklst))
else:
dklst = np.linspace(-self.maxdk, self.maxdk, points)
# bpm read out
ret = np.zeros((points+2, len(self.resplst)*len(respfields)), 'd')
# initial bpm data
v0, h = eget(self.resplst, respfields, unitsys=self.unit, header=True)
#print "v=", v0
#print "fields=", respfields, h
ret[0,:] = np.ravel(v0)
self.header = np.reshape(np.ravel(h), (-1, 2))
kstrength = np.ones(points+2, 'd') * kx0
kstrength[1:-1] = [dklst[i] + kx0 for i in range(points)]
print(("Kicker sp:", kstrength))
for i,kx in enumerate(kstrength[1:]):
v0 = np.ravel(eget(self.resplst, respfields, unitsys=self.unit))
#self.kicker.put(kfield, kx, unitsys=self.unit)
#st = waitChanged(self.resplst, respfields, v0,
# wait=wait, diffstd=self.bpmdiffstd)
fput([(self.kicker, kfield, kx),],
unitsys=self.unit, wait_readback = True)
v1 = np.ravel(eget(self.resplst, respfields, unitsys=self.unit))
ret[i+1,:] = v1[:]
if verbose:
print("kx= % .2e resp= [% .4e, % .4e], stable= %s" % (
kx, min(ret[i+1,:] - ret[0,:]), max(ret[i+1,:]-ret[0,:]),
str(st)))
sys.stdout.flush()
# fit the lines
p, self.residuals, rank, singular_values, rcond = np.polyfit(
kstrength[1:-1], ret[1:-1,:], 1, full=True)
# reset the kicker
#self.kicker.put(kfield, kx0, unitsys=self.unit)
fput([(self.kicker, kfield, kx0),],
unitsys=self.unit, wait_readback=True)
self.rawkick = kstrength
self.rawresp = ret
self.m = p[0,:] # the slope
self._c = p[1,:] # the constant
def measure(self, respfields, kfield, **kwargs):
"""
Measure the RM by change one kicker.
:param respfields: response fields, a list
"""
verbose = kwargs.get('verbose', 0)
dklst = kwargs.get('dklst', None)
kx0 = self.kicker.get(kfield, unitsys=self.unit) # get EPICS value
wait = (self.minwait, self.stepwait, 0)
if verbose:
print "kicker: '%s.%s'= %e" % (self.kicker.name, kfield, kx0)
points = self.points
if dklst is not None:
points = len(dklst)
print "Using external dklst:", dklst
else:
dklst = np.linspace(-self.maxdk, self.maxdk, points)
# bpm read out
ret = np.zeros((points+2, len(self.resplst)*len(respfields)), 'd')
# initial bpm data
v0, h = eget(self.resplst, respfields, unitsys=self.unit, header=True)
#print "v=", v0
#print "fields=", respfields, h
ret[0,:] = np.ravel(v0)
self.header = np.reshape(np.ravel(h), (-1, 2))
kstrength = np.ones(points+2, 'd') * kx0
kstrength[1:-1] = [dklst[i] + kx0 for i in range(points)]
print "Kicker sp:", kstrength
for i,kx in enumerate(kstrength[1:]):
v0 = np.ravel(eget(self.resplst, respfields, unitsys=self.unit))
#self.kicker.put(kfield, kx, unitsys=self.unit)
#st = waitChanged(self.resplst, respfields, v0,
# wait=wait, diffstd=self.bpmdiffstd)
fput([(self.kicker, kfield, kx),],
unitsys=self.unit, wait_readback = True)
v1 = np.ravel(eget(self.resplst, respfields, unitsys=self.unit))
ret[i+1,:] = v1[:]
if verbose:
print "kx= % .2e resp= [% .4e, % .4e], stable= %s" % (
kx, min(ret[i+1,:] - ret[0,:]), max(ret[i+1,:]-ret[0,:]),
str(st))
sys.stdout.flush()
# fit the lines
p, self.residuals, rank, singular_values, rcond = np.polyfit(
kstrength[1:-1], ret[1:-1,:], 1, full=True)
# reset the kicker
#self.kicker.put(kfield, kx0, unitsys=self.unit)
fput([(self.kicker, kfield, kx0),],
unitsys=self.unit, wait_readback=True)
self.rawkick = kstrength
self.rawresp = ret
self.m = p[0,:] # the slope
self._c = p[1,:] # the constant
def measRmCol(resp, kker, kfld, dklst, **kwargs):
"""
measure the response matrix of `resp` from `kicker`
:param list resp: list of the response (elem, field)
:param kker: the kicker object
:param kfld: the kicker field
:param list dklst: the kicker setpoints (ki0, ki1, ...)
:param int sample: observatins per kicker setpoint
:param int deg: degree of the fitting polynomial
:param int verbose:
returns slope, klst(readback), rawdata (nk, nresp, nsamle)
"""
unitsys = kwargs.pop("unitsys", None)
sample = kwargs.pop("sample", 3)
deg = kwargs.pop("deg", 1)
minwait = kwargs.pop("minwait", 0.0)
dat = np.zeros((len(dklst), len(resp), sample), 'd')
klstrb = np.zeros((len(dklst), sample), 'd')
k0 = kker.get(kfld, handle="setpoint", unitsys=None)
for i, dki in enumerate(dklst):
try:
fput([
(kker, kfld, k0 + dki),
],
unitsys=unitsys,
wait_readback=True,
verbose=1)
except:
#kker.put(kfld, k0, unitsys=None)
_logger.error("{0}".format(sys.exc_info()[0]))
_logger.error("{0}".format(sys.exc_info()[1]))
#_logger.error("{0}".format(sys.exc_info()[2]))
msg = "Timeout at setting {0}.{1}= {2}, i= {3}, delta= {4}".format(
kker.name, kfld, k0 + dki, i, dki)
_logger.warn(msg)
time.sleep(5.0)
print("{0}.{1}= {2} (set:{3}). continued after 5.0 second".format(
kker.name, kfld, kker.get(kfld, unitsys=unitsys), k0 + dki))
sys.stdout.flush()
time.sleep(minwait)
for j in range(sample):
klstrb[i, j] = kker.get(kfld, handle="readback", unitsys=unitsys)
if kwargs.get("verbose", 0) > 0:
print("Reading", kker, klstrb[i, j])
dat[i, :, j] = fget(resp, unitsys=None, **kwargs)
# nonblocking
kker.put(kfld, k0, unitsys=None)
p, resi, rank, sv, rcond = np.polyfit(dklst,
np.average(dat, axis=-1),
deg,
full=True)
# blocking
try:
fput([
(kker, kfld, k0),
], unitsys=None, wait_readback=True)
except:
kker.put(kfld, k0, unitsys=None)
msg = "Timeout at restoring {0}.{1}= {2}".format(kker.name, kfld, k0)
_logger.warn(msg)
print(msg)
sys.stdout.flush()
return p[-2, :], klstrb, dat
