def gen_ring_network(network, size=None):
if not size:
size = DEFAULT_SIZE
first = next = Server('id-0', network.distribute)
network.servers.append(first)
for i in xrange(1, size):
_next = Server('id-%d' % (i), network.distribute)
link(next, _next)
next = _next
network.servers.append(next)
next.link(first)
def gen_torus_network(network, size=None):
if not size:
size = DEFAULT_SIZE
# Generate all servers
for i in xrange(size**2):
network.servers.append(Server('id-%d' % (i), network.distribute))
# Link across rows
for i in xrange(size**2):
if i % size != 0:
s1 = network.servers[i]
s2 = network.servers[i - 1]
link(s1, s2)
# Link across row edges
i = 0
while i < size**2:
s1 = network.servers[i]
s2 = network.servers[i + size - 1]
link(s1, s2)
i += size
# Link down columns
for i in xrange(size**2 - size):
s1 = network.servers[i]
s2 = network.servers[i + size]
link(s1, s2)
# Link down column edges
for i in xrange(size):
s1 = network.servers[i]
s2 = network.servers[-1 * size + i]
link(s1, s2)
def forwardVariable(th, linkparam):
"""
Calculate the forward transformation by
angle(theta) and it's link parameters.
"""
T = Transform()
i = 0
for p in linkparam:
if p[2] is None:
T = T * link(p[0], p[1], th[i], p[3])
i += 1
elif p[3] is None:
T = T * link(p[0], p[1], p[2], th[i])
i += 1
else:
T = T * link(p[0], p[1], p[2], p[3])
return T
def sim(self, th, text=""):
# init
trans = [Transform()]
pos = [Translation()]
dirs = [np.identity(4)]
# main
for i in range(len(th)):
L = self.linkparam[i]
T = link(L[0], L[1], th[i], L[3])
trans.append(trans[-1] * T)
pos.append(trans[-1] * pos[0])
dirs.append(trans[-1].mat)
# save it
self.trans.append(trans)
self.poses.append(np.array([p.mat for p in pos]))
self.dirs.append(dirs)
self.text.append(text)
#just grab the first item in keys to lookup dirname..
first_key = input["keys"][0]
input_dir = os.path.dirname(input["_key2path"][first_key])
dest = path + "/" + name
short_dest = path + "/" + short_name #does not contain task and run
##################################################
##
## now handle each datatype
##
if input["datatype"] == utils.ANAT_T1W:
src = os.path.join(input_dir, 't1.nii.gz')
utils.link(src, dest + "_T1w.nii.gz")
utils.outputSidecar(dest + "_T1w.json", input)
elif input["datatype"] == utils.ANAT_T2W:
src = os.path.join(input_dir, 't2.nii.gz')
utils.link(src, dest + "_T2w.nii.gz")
utils.outputSidecar(dest + "_T2w.json", input)
elif input["datatype"] == utils.DWI:
src = os.path.join(input_dir, 'dwi.nii.gz')
utils.link(src, dest + "_dwi.nii.gz")
src = os.path.join(input_dir, 'dwi.bvals')
utils.link(src, dest + "_dwi.bval")
src = os.path.join(input_dir, 'dwi.bvecs')
utils.link(src, dest + "_dwi.bvec")
src = os.path.join(input_dir, 'sbref.nii.gz')
def gen_dual_server_network(network, size=None):
s0 = Server('id-0', network.distribute)
s1 = Server('id-1', network.distribute)
link(s0, s1)
network.servers += [s0, s1]
v = [vTranslate()]
a = [vTranslate(v=Translation(0, g, 0))]
xy = [Translation()]
ac = [Translation()]
F = [Translation()]
N = [Translation()]
f = [Translation()] * (len(linkparam) + 1)
n = [Translation()] * (len(linkparam) + 1)
# joint
for i in range(len(linkparam)):
# set angle of joint
linkparam[i][2] = th[i]
# transform matrix for angle
T = link(*linkparam[i])
Ts.append(T)
Ts0.append(Ts0[-1] * T)
# Space location i+1
xy.append(Ts0[-1] * Translation())
# transform matrix for velcoity
T_v = vTransform(Rotation(mat=T.rot.mat.T), T.loc)
# velcoity i+1 (R-joint)
new_v = T_v * v[i]
new_v.mat[5] += vth[i] / 180 * np.pi
v.append(new_v)
# acceleration i+1 (R-joint)