def _setup_transfers(group, recurse=True):
"""
Compute all transfers that are owned by our parent group.
Parameters
----------
group : <Group>
Parent group.
recurse : bool
Whether to call this method in subsystems.
"""
group._transfers = {}
iproc = group.comm.rank
rev = group._mode == 'rev' or group._mode == 'auto'
def merge(indices_list):
if len(indices_list) > 0:
return np.concatenate(indices_list)
else:
return _empty_idx_array
if recurse:
for subsys in group._subgroups_myproc:
subsys._setup_transfers(recurse)
# Pre-compute map from abs_names to the index of the containing subsystem
abs2isub = {}
for subsys, isub in zip(group._subsystems_myproc,
group._subsystems_myproc_inds):
for type_ in ['input', 'output']:
for abs_name in subsys._var_allprocs_abs_names[type_]:
abs2isub[abs_name] = isub
abs2meta = group._var_abs2meta
allprocs_abs2meta = group._var_allprocs_abs2meta
transfers = group._transfers
vectors = group._vectors
offsets = _global2local_offsets(group._get_var_offsets())
for vec_name in group._lin_rel_vec_name_list:
relvars, _ = group._relevant[vec_name]['@all']
relvars_in = relvars['input']
relvars_out = relvars['output']
# Initialize empty lists for the transfer indices
nsub_allprocs = len(group._subsystems_allprocs)
xfer_in = []
xfer_out = []
fwd_xfer_in = [[] for i in range(nsub_allprocs)]
fwd_xfer_out = [[] for i in range(nsub_allprocs)]
if rev:
rev_xfer_in = [[] for i in range(nsub_allprocs)]
rev_xfer_out = [[] for i in range(nsub_allprocs)]
allprocs_abs2idx = group._var_allprocs_abs2idx[vec_name]
sizes_in = group._var_sizes[vec_name]['input']
sizes_out = group._var_sizes[vec_name]['output']
offsets_in = offsets[vec_name]['input']
offsets_out = offsets[vec_name]['output']
# Loop through all explicit / implicit connections owned by this system
for abs_in, abs_out in iteritems(group._conn_abs_in2out):
if abs_out not in relvars_out or abs_in not in relvars_in:
continue
# Only continue if the input exists on this processor
if abs_in in abs2meta and abs_in in relvars['input']:
# Get meta
meta_in = abs2meta[abs_in]
meta_out = allprocs_abs2meta[abs_out]
idx_in = allprocs_abs2idx[abs_in]
idx_out = allprocs_abs2idx[abs_out]
# Read in and process src_indices
shape_in = meta_in['shape']
shape_out = meta_out['shape']
global_size_out = meta_out['global_size']
src_indices = meta_in['src_indices']
if src_indices is None:
pass
elif src_indices.ndim == 1:
src_indices = convert_neg(src_indices, global_size_out)
else:
if len(shape_out
) == 1 or shape_in == src_indices.shape:
src_indices = src_indices.flatten()
src_indices = convert_neg(src_indices,
global_size_out)
else:
# TODO: this duplicates code found
# in System._setup_scaling.
entries = [list(range(x)) for x in shape_in]
cols = np.vstack(src_indices[i]
for i in product(*entries))
dimidxs = [
convert_neg(cols[:, i], shape_out[i])
for i in range(cols.shape[1])
]
src_indices = np.ravel_multi_index(
dimidxs, shape_out)
# 1. Compute the output indices
offset = offsets_out[iproc, idx_out]
if src_indices is None:
output_inds = np.arange(offset,
offset + meta_in['size'],
dtype=INT_DTYPE)
else:
output_inds = src_indices + offset
# 2. Compute the input indices
input_inds = np.arange(offsets_in[iproc, idx_in],
offsets_in[iproc, idx_in] +
sizes_in[iproc, idx_in],
dtype=INT_DTYPE)
# Now the indices are ready - input_inds, output_inds
xfer_in.append(input_inds)
xfer_out.append(output_inds)
isub = abs2isub[abs_in]
fwd_xfer_in[isub].append(input_inds)
fwd_xfer_out[isub].append(output_inds)
if rev and abs_out in abs2isub:
isub = abs2isub[abs_out]
rev_xfer_in[isub].append(input_inds)
rev_xfer_out[isub].append(output_inds)
xfer_in = merge(xfer_in)
xfer_out = merge(xfer_out)
for isub in range(nsub_allprocs):
fwd_xfer_in[isub] = merge(fwd_xfer_in[isub])
fwd_xfer_out[isub] = merge(fwd_xfer_out[isub])
if rev:
rev_xfer_in[isub] = merge(rev_xfer_in[isub])
rev_xfer_out[isub] = merge(rev_xfer_out[isub])
out_vec = vectors['output'][vec_name]
transfers[vec_name] = {}
xfer_all = DefaultTransfer(vectors['input'][vec_name], out_vec,
xfer_in, xfer_out, group.comm)
transfers[vec_name]['fwd', None] = xfer_all
if rev:
transfers[vec_name]['rev', None] = xfer_all
for isub in range(nsub_allprocs):
transfers[vec_name]['fwd', isub] = DefaultTransfer(
vectors['input'][vec_name], vectors['output'][vec_name],
fwd_xfer_in[isub], fwd_xfer_out[isub], group.comm)
if rev:
transfers[vec_name]['rev', isub] = DefaultTransfer(
vectors['input'][vec_name],
vectors['output'][vec_name], rev_xfer_in[isub],
rev_xfer_out[isub], group.comm)
transfers['nonlinear'] = transfers['linear']
def _setup_transfers(group, recurse=True):
"""
Compute all transfers that are owned by our parent group.
Parameters
----------
group : <Group>
Parent group.
recurse : bool
Whether to call this method in subsystems.
"""
group._transfers = {}
iproc = group.comm.rank
rev = group._mode == 'rev' or group._mode == 'auto'
def merge(indices_list):
if len(indices_list) > 0:
return np.concatenate(indices_list)
else:
return _empty_idx_array
if recurse:
for subsys in group._subgroups_myproc:
subsys._setup_transfers(recurse)
# Pre-compute map from abs_names to the index of the containing subsystem
abs2isub = {}
for subsys, isub in zip(group._subsystems_myproc, group._subsystems_myproc_inds):
for type_ in ['input', 'output']:
for abs_name in subsys._var_allprocs_abs_names[type_]:
abs2isub[abs_name] = isub
abs2meta = group._var_abs2meta
allprocs_abs2meta = group._var_allprocs_abs2meta
transfers = group._transfers
vectors = group._vectors
offsets = _global2local_offsets(group._get_var_offsets())
vec_names = group._lin_rel_vec_name_list if group._use_derivatives else group._vec_names
for vec_name in vec_names:
relvars, _ = group._relevant[vec_name]['@all']
relvars_in = relvars['input']
relvars_out = relvars['output']
# Initialize empty lists for the transfer indices
nsub_allprocs = len(group._subsystems_allprocs)
xfer_in = []
xfer_out = []
fwd_xfer_in = [[] for i in range(nsub_allprocs)]
fwd_xfer_out = [[] for i in range(nsub_allprocs)]
if rev:
rev_xfer_in = [[] for i in range(nsub_allprocs)]
rev_xfer_out = [[] for i in range(nsub_allprocs)]
allprocs_abs2idx = group._var_allprocs_abs2idx[vec_name]
sizes_in = group._var_sizes[vec_name]['input']
sizes_out = group._var_sizes[vec_name]['output']
offsets_in = offsets[vec_name]['input']
offsets_out = offsets[vec_name]['output']
# Loop through all explicit / implicit connections owned by this system
for abs_in, abs_out in iteritems(group._conn_abs_in2out):
if abs_out not in relvars_out or abs_in not in relvars_in:
continue
# Only continue if the input exists on this processor
if abs_in in abs2meta and abs_in in relvars['input']:
# Get meta
meta_in = abs2meta[abs_in]
meta_out = allprocs_abs2meta[abs_out]
idx_in = allprocs_abs2idx[abs_in]
idx_out = allprocs_abs2idx[abs_out]
# Read in and process src_indices
src_indices = meta_in['src_indices']
if src_indices is None:
pass
elif src_indices.ndim == 1:
src_indices = convert_neg(src_indices, meta_out['global_size'])
else:
src_indices = _flatten_src_indices(src_indices, meta_in['shape'],
meta_out['global_shape'],
meta_out['global_size'])
# 1. Compute the output indices
offset = offsets_out[iproc, idx_out]
if src_indices is None:
output_inds = np.arange(offset, offset + meta_in['size'], dtype=INT_DTYPE)
else:
output_inds = src_indices + offset
# 2. Compute the input indices
input_inds = np.arange(offsets_in[iproc, idx_in],
offsets_in[iproc, idx_in] +
sizes_in[iproc, idx_in], dtype=INT_DTYPE)
# Now the indices are ready - input_inds, output_inds
xfer_in.append(input_inds)
xfer_out.append(output_inds)
isub = abs2isub[abs_in]
fwd_xfer_in[isub].append(input_inds)
fwd_xfer_out[isub].append(output_inds)
if rev and abs_out in abs2isub:
isub = abs2isub[abs_out]
rev_xfer_in[isub].append(input_inds)
rev_xfer_out[isub].append(output_inds)
xfer_in = merge(xfer_in)
xfer_out = merge(xfer_out)
for isub in range(nsub_allprocs):
fwd_xfer_in[isub] = merge(fwd_xfer_in[isub])
fwd_xfer_out[isub] = merge(fwd_xfer_out[isub])
if rev:
rev_xfer_in[isub] = merge(rev_xfer_in[isub])
rev_xfer_out[isub] = merge(rev_xfer_out[isub])
out_vec = vectors['output'][vec_name]
transfers[vec_name] = {}
xfer_all = DefaultTransfer(vectors['input'][vec_name], out_vec,
xfer_in, xfer_out, group.comm)
transfers[vec_name]['fwd', None] = xfer_all
if rev:
transfers[vec_name]['rev', None] = xfer_all
for isub in range(nsub_allprocs):
transfers[vec_name]['fwd', isub] = DefaultTransfer(
vectors['input'][vec_name], vectors['output'][vec_name],
fwd_xfer_in[isub], fwd_xfer_out[isub], group.comm)
if rev:
transfers[vec_name]['rev', isub] = DefaultTransfer(
vectors['input'][vec_name], vectors['output'][vec_name],
rev_xfer_in[isub], rev_xfer_out[isub], group.comm)
if group._use_derivatives:
transfers['nonlinear'] = transfers['linear']
def _setup_transfers(group):
"""
Compute all transfers that are owned by our parent group.
Parameters
----------
group : <Group>
Parent group.
"""
iproc = group.comm.rank
rev = group._mode == 'rev' or group._mode == 'auto'
for subsys in group._subgroups_myproc:
subsys._setup_transfers()
abs2meta = group._var_abs2meta
allprocs_abs2meta_out = group._var_allprocs_abs2meta['output']
group._transfers = transfers = {}
vectors = group._vectors
offsets = _global2local_offsets(group._get_var_offsets())
vec_names = group._lin_rel_vec_name_list if group._use_derivatives else group._vec_names
allsubs = group._subsystems_allprocs
mypathlen = len(group.pathname + '.' if group.pathname else '')
for vec_name in vec_names:
relvars, _ = group._relevant[vec_name]['@all']
relvars_in = relvars['input']
relvars_out = relvars['output']
# Initialize empty lists for the transfer indices
nsub_allprocs = len(allsubs)
xfer_in = []
xfer_out = []
fwd_xfer_in = defaultdict(list)
fwd_xfer_out = defaultdict(list)
if rev:
rev_xfer_in = defaultdict(list)
rev_xfer_out = defaultdict(list)
allprocs_abs2idx = group._var_allprocs_abs2idx[vec_name]
sizes_in = group._var_sizes[vec_name]['input']
sizes_out = group._var_sizes[vec_name]['output']
offsets_in = offsets[vec_name]['input']
offsets_out = offsets[vec_name]['output']
# Loop through all connections owned by this group
for abs_in, abs_out in group._conn_abs_in2out.items():
if abs_out not in relvars_out or abs_in not in relvars_in:
continue
# Only continue if the input exists on this processor
if abs_in in abs2meta['input']:
indices = None
# Get meta
meta_in = abs2meta['input'][abs_in]
meta_out = allprocs_abs2meta_out[abs_out]
idx_in = allprocs_abs2idx[abs_in]
idx_out = allprocs_abs2idx[abs_out]
# Read in and process src_indices
src_indices = meta_in['src_indices']
if src_indices is not None:
if src_indices.ndim == 1:
src_indices = convert_neg(src_indices, meta_out['global_size'])
# 1. Compute the output indices
offset = offsets_out[iproc, idx_out]
if src_indices is None:
output_inds = np.arange(offset, offset + meta_in['size'], dtype=INT_DTYPE)
else:
output_inds = src_indices + offset
# 2. Compute the input indices
input_inds = np.arange(offsets_in[iproc, idx_in],
offsets_in[iproc, idx_in] +
sizes_in[iproc, idx_in], dtype=INT_DTYPE)
if indices is not None:
input_inds = input_inds.reshape(indices.shape)
# Now the indices are ready - input_inds, output_inds
sub_in = abs_in[mypathlen:].split('.', 1)[0]
fwd_xfer_in[sub_in].append(input_inds)
fwd_xfer_out[sub_in].append(output_inds)
if rev and abs_out in abs2meta['output']:
sub_out = abs_out[mypathlen:].split('.', 1)[0]
rev_xfer_in[sub_out].append(input_inds)
rev_xfer_out[sub_out].append(output_inds)
tot_size = 0
for sname, inds in fwd_xfer_in.items():
fwd_xfer_in[sname] = arr = _merge(inds)
fwd_xfer_out[sname] = _merge(fwd_xfer_out[sname])
tot_size += arr.size
if rev:
for sname, inds in rev_xfer_in.items():
rev_xfer_in[sname] = _merge(inds)
rev_xfer_out[sname] = _merge(rev_xfer_out[sname])
transfers[vec_name] = {}
if tot_size > 0:
try:
xfer_in = np.concatenate(list(fwd_xfer_in.values()))
xfer_out = np.concatenate(list(fwd_xfer_out.values()))
except ValueError:
xfer_in = xfer_out = np.zeros(0, dtype=INT_DTYPE)
out_vec = vectors['output'][vec_name]
xfer_all = DefaultTransfer(vectors['input'][vec_name], out_vec,
xfer_in, xfer_out, group.comm)
else:
xfer_all = None
transfers[vec_name]['fwd'] = xfwd = {}
xfwd[None] = xfer_all
if rev:
transfers[vec_name]['rev'] = xrev = {}
xrev[None] = xfer_all
for sname, inds in fwd_xfer_in.items():
if inds.size > 0:
xfwd[sname] = DefaultTransfer(vectors['input'][vec_name],
vectors['output'][vec_name],
inds, fwd_xfer_out[sname], group.comm)
else:
xfwd[sname] = None
if rev:
for sname, inds in rev_xfer_out.items():
if inds.size > 0:
xrev[sname] = DefaultTransfer(vectors['input'][vec_name],
vectors['output'][vec_name],
rev_xfer_in[sname], inds, group.comm)
else:
xrev[sname] = None
if group._use_derivatives:
transfers['nonlinear'] = transfers['linear']
def _setup_transfers(group, recurse=True):
"""
Compute all transfers that are owned by our parent group.
Parameters
----------
group : <Group>
Parent group.
recurse : bool
Whether to call this method in subsystems.
"""
iproc = group.comm.rank
rev = group._mode == 'rev' or group._mode == 'auto'
if recurse:
for subsys in group._subgroups_myproc:
subsys._setup_transfers(recurse)
abs2meta = group._var_abs2meta
allprocs_abs2meta = group._var_allprocs_abs2meta
group._transfers = transfers = {}
vectors = group._vectors
offsets = _global2local_offsets(group._get_var_offsets())
vec_names = group._lin_rel_vec_name_list if group._use_derivatives else group._vec_names
mypathlen = len(group.pathname + '.' if group.pathname else '')
sub_inds = group._subsystems_inds
for vec_name in vec_names:
relvars, _ = group._relevant[vec_name]['@all']
relvars_in = relvars['input']
relvars_out = relvars['output']
# Initialize empty lists for the transfer indices
nsub_allprocs = len(group._subsystems_allprocs)
xfer_in = []
xfer_out = []
fwd_xfer_in = [[] for s in group._subsystems_allprocs]
fwd_xfer_out = [[] for s in group._subsystems_allprocs]
if rev:
rev_xfer_in = [[] for s in group._subsystems_allprocs]
rev_xfer_out = [[] for s in group._subsystems_allprocs]
allprocs_abs2idx = group._var_allprocs_abs2idx[vec_name]
sizes_in = group._var_sizes[vec_name]['input']
sizes_out = group._var_sizes[vec_name]['output']
offsets_in = offsets[vec_name]['input']
offsets_out = offsets[vec_name]['output']
# Loop through all connections owned by this group
for abs_in, abs_out in group._conn_abs_in2out.items():
if abs_out not in relvars_out or abs_in not in relvars_in:
continue
# Only continue if the input exists on this processor
if abs_in in abs2meta:
# Get meta
meta_in = abs2meta[abs_in]
meta_out = allprocs_abs2meta[abs_out]
idx_in = allprocs_abs2idx[abs_in]
idx_out = allprocs_abs2idx[abs_out]
# Read in and process src_indices
src_indices = meta_in['src_indices']
if src_indices is None:
pass
elif src_indices.ndim == 1:
src_indices = convert_neg(src_indices,
meta_out['global_size'])
else:
src_indices = _flatten_src_indices(
src_indices, meta_in['shape'],
meta_out['global_shape'], meta_out['global_size'])
# 1. Compute the output indices
offset = offsets_out[iproc, idx_out]
if src_indices is None:
output_inds = np.arange(offset,
offset + meta_in['size'],
dtype=INT_DTYPE)
else:
output_inds = src_indices + offset
# 2. Compute the input indices
input_inds = np.arange(offsets_in[iproc, idx_in],
offsets_in[iproc, idx_in] +
sizes_in[iproc, idx_in],
dtype=INT_DTYPE)
# Now the indices are ready - input_inds, output_inds
sub_in = abs_in[mypathlen:].split('.', 1)[0]
isub = sub_inds[sub_in]
fwd_xfer_in[isub].append(input_inds)
fwd_xfer_out[isub].append(output_inds)
if rev and abs_out in abs2meta:
sub_out = abs_out[mypathlen:].split('.', 1)[0]
isub = sub_inds[sub_out]
rev_xfer_in[isub].append(input_inds)
rev_xfer_out[isub].append(output_inds)
tot_size = 0
for isub in range(nsub_allprocs):
fwd_xfer_in[isub] = _merge(fwd_xfer_in[isub])
fwd_xfer_out[isub] = _merge(fwd_xfer_out[isub])
tot_size += fwd_xfer_in[isub].size
if rev:
rev_xfer_in[isub] = _merge(rev_xfer_in[isub])
rev_xfer_out[isub] = _merge(rev_xfer_out[isub])
transfers[vec_name] = {}
if tot_size > 0:
xfer_in = np.concatenate(fwd_xfer_in)
xfer_out = np.concatenate(fwd_xfer_out)
out_vec = vectors['output'][vec_name]
xfer_all = DefaultTransfer(vectors['input'][vec_name], out_vec,
xfer_in, xfer_out, group.comm)
else:
xfer_all = None
transfers[vec_name]['fwd', None] = xfer_all
if rev:
transfers[vec_name]['rev', None] = xfer_all
for isub in range(nsub_allprocs):
if fwd_xfer_in[isub].size > 0:
transfers[vec_name]['fwd', isub] = DefaultTransfer(
vectors['input'][vec_name],
vectors['output'][vec_name], fwd_xfer_in[isub],
fwd_xfer_out[isub], group.comm)
else:
transfers[vec_name]['fwd', isub] = None
if rev:
if rev_xfer_out[isub].size > 0:
transfers[vec_name]['rev', isub] = DefaultTransfer(
vectors['input'][vec_name],
vectors['output'][vec_name], rev_xfer_in[isub],
rev_xfer_out[isub], group.comm)
else:
transfers[vec_name]['rev', isub] = None
if group._use_derivatives:
transfers['nonlinear'] = transfers['linear']
def _setup_transfers(group):
"""
Compute all transfers that are owned by our parent group.
Parameters
----------
group : <Group>
Parent group.
"""
iproc = group.comm.rank
rev = group._mode == 'rev' or group._mode == 'auto'
for subsys in group._subgroups_myproc:
subsys._setup_transfers()
abs2meta = group._var_abs2meta
group._transfers = transfers = {}
vectors = group._vectors
offsets = _global2local_offsets(group._get_var_offsets())
mypathlen = len(group.pathname + '.' if group.pathname else '')
# Initialize empty lists for the transfer indices
xfer_in = []
xfer_out = []
fwd_xfer_in = defaultdict(list)
fwd_xfer_out = defaultdict(list)
if rev:
rev_xfer_in = defaultdict(list)
rev_xfer_out = defaultdict(list)
allprocs_abs2idx = group._var_allprocs_abs2idx
sizes_in = group._var_sizes['input']
offsets_in = offsets['input']
if sizes_in.size > 0:
sizes_in = sizes_in[iproc]
offsets_in = offsets_in[iproc]
offsets_out = offsets['output']
if offsets_out.size > 0:
offsets_out = offsets_out[iproc]
# Loop through all connections owned by this group
for abs_in, abs_out in group._conn_abs_in2out.items():
# This weeds out discrete vars (all vars are local if using this Transfer)
if abs_in in abs2meta['input']:
indices = None
# Get meta
meta_in = abs2meta['input'][abs_in]
idx_in = allprocs_abs2idx[abs_in]
idx_out = allprocs_abs2idx[abs_out]
# Read in and process src_indices
src_indices = meta_in['src_indices']
if src_indices is not None:
src_indices = src_indices.shaped_array()
# 1. Compute the output indices
offset = offsets_out[idx_out]
if src_indices is None:
output_inds = np.arange(offset, offset + meta_in['size'], dtype=INT_DTYPE)
else:
output_inds = src_indices + offset
# 2. Compute the input indices
input_inds = np.arange(offsets_in[idx_in],
offsets_in[idx_in] + sizes_in[idx_in], dtype=INT_DTYPE)
if indices is not None:
input_inds = input_inds.reshape(indices.shape)
# Now the indices are ready - input_inds, output_inds
sub_in = abs_in[mypathlen:].split('.', 1)[0]
fwd_xfer_in[sub_in].append(input_inds)
fwd_xfer_out[sub_in].append(output_inds)
if rev and abs_out in abs2meta['output']:
sub_out = abs_out[mypathlen:].split('.', 1)[0]
rev_xfer_in[sub_out].append(input_inds)
rev_xfer_out[sub_out].append(output_inds)
tot_size = 0
for sname, inds in fwd_xfer_in.items():
fwd_xfer_in[sname] = arr = _merge(inds)
fwd_xfer_out[sname] = _merge(fwd_xfer_out[sname])
tot_size += arr.size
if rev:
for sname, inds in rev_xfer_in.items():
rev_xfer_in[sname] = _merge(inds)
rev_xfer_out[sname] = _merge(rev_xfer_out[sname])
if tot_size > 0:
try:
xfer_in = np.concatenate(list(fwd_xfer_in.values()))
xfer_out = np.concatenate(list(fwd_xfer_out.values()))
except ValueError:
xfer_in = xfer_out = np.zeros(0, dtype=INT_DTYPE)
xfer_all = DefaultTransfer(vectors['input']['nonlinear'],
vectors['output']['nonlinear'], xfer_in, xfer_out,
group.comm)
else:
xfer_all = None
transfers['fwd'] = xfwd = {}
xfwd[None] = xfer_all
if rev:
transfers['rev'] = xrev = {}
xrev[None] = xfer_all
for sname, inds in fwd_xfer_in.items():
if inds.size > 0:
xfwd[sname] = DefaultTransfer(vectors['input']['nonlinear'],
vectors['output']['nonlinear'],
inds, fwd_xfer_out[sname], group.comm)
else:
xfwd[sname] = None
if rev:
for sname, inds in rev_xfer_out.items():
if inds.size > 0:
xrev[sname] = DefaultTransfer(vectors['input']['nonlinear'],
vectors['output']['nonlinear'],
rev_xfer_in[sname], inds, group.comm)
else:
xrev[sname] = None