std::vector<std::pair<std::string::size_type, std::string> > MRMDecoy::find_all_tryptic(std::string sequence)
{
std::vector<std::pair<std::string::size_type, std::string> > idx;
std::vector<std::string> pattern;
pattern.push_back("K");
pattern.push_back("R");
pattern.push_back("P");
for (Size i = 0; i < sequence.size(); i++)
{
for (Size j = 0; j < pattern.size(); j++)
{
if (sequence.substr(i, 1) == pattern[j])
{
std::pair<std::string::size_type, std::string> idx_pair(i, pattern[j]);
idx.push_back(idx_pair);
}
}
}
return idx;
}
connectivity::connectivity(const expr_tree& tree)
{
expr_tree::node_id_t root_id = tree.get_root();
const node& root = tree.get_vertex(root_id);
if(!root.check_type<node_assign>())
{
throw bad_parameter(g_ns,k_clazz,"batch_provider(...)",__FILE__, __LINE__,
"Invalid root node");
}
expr_tree::node_id_t n_op_id = tree.get_edges_out(root_id)[1];
expr_tree::edge_list_t op_children = tree.get_edges_out(n_op_id);
const node& n_op = tree.get_vertex(n_op_id);
size_t NC = root.get_n();
if(n_op.check_type<node_add>() ||
n_op.check_type<node_ident>() ||
n_op.check_type<node_unblock>() ||
n_op.check_type<node_reblock>())
{
size_t n_tensors;
if(n_op.check_type<node_add>())
{
n_tensors = 1+op_children.size();
}
else
{
n_tensors = 2;
}
m_conn.resize(n_tensors,std::vector<idx_pair_list>(NC));
for(size_t tensor_idx = 0; tensor_idx < m_conn.size(); ++tensor_idx)
{
for(size_t subspace_idx = 0; subspace_idx < m_conn[tensor_idx].size(); ++subspace_idx)
{
for(size_t other_tensor_idx = 0; other_tensor_idx < m_conn.size(); ++other_tensor_idx)
{
if(other_tensor_idx == tensor_idx) continue;
m_conn[tensor_idx][subspace_idx].push_back(idx_pair(other_tensor_idx,subspace_idx));
}
}
}
}
else if(n_op.check_type<node_contract>())
{
const node_contract& n_contr = dynamic_cast< const node_contract& >(n_op);
multimap<size_t,size_t> contr_map = n_contr.get_map();
multimap<size_t,size_t> contr_inv;
for(multimap<size_t,size_t>::const_iterator it = contr_map.begin(); it != contr_map.end(); ++it)
{
contr_inv.insert(idx_pair(it->second,it->first));
}
size_t NA = tree.get_vertex(op_children[0]).get_n();
size_t NB = tree.get_vertex(op_children[1]).get_n();
m_conn.push_back(std::vector<idx_pair_list>(NC));
m_conn.push_back(std::vector<idx_pair_list>(NA));
m_conn.push_back(std::vector<idx_pair_list>(NB));
size_t c_sub_idx = 0;
for(size_t input_sub_idx = 0; input_sub_idx < NA+NB; ++input_sub_idx)
{
if(input_sub_idx < NA)
{
multimap<size_t,size_t>::iterator it = contr_map.find(input_sub_idx);
if(it == contr_map.end())
{
m_conn[0][c_sub_idx].push_back(idx_pair(1,input_sub_idx));
m_conn[1][input_sub_idx].push_back(idx_pair(0,c_sub_idx));
++c_sub_idx;
}
else
{
m_conn[1][input_sub_idx].push_back(idx_pair(2,it->second - NA));
m_conn[2][it->second - NA].push_back(idx_pair(1,input_sub_idx));
}
}
else if(input_sub_idx >= NA && (contr_inv.find(input_sub_idx) == contr_inv.end()))
{
m_conn[0][c_sub_idx].push_back(idx_pair(2,input_sub_idx - NA));
m_conn[2][input_sub_idx - NA].push_back(idx_pair(0,c_sub_idx));
++c_sub_idx;
}
}
}
else if(n_op.check_type<node_transform_base>())
{
const node_transform_base& n_tf = dynamic_cast< const node_transform_base& >(n_op);
m_conn.resize(1+op_children.size(),std::vector<idx_pair_list>(NC));
vector<size_t> perm_entries = n_tf.get_perm();
for(size_t i = 0; i < NC; ++i)
{
m_conn[0][i].push_back(idx_pair(1,perm_entries[i]));
m_conn[1][perm_entries[i]].push_back(idx_pair(0,i));
}
}
else
{
throw bad_parameter(g_ns,k_clazz,"connectivity(...)",__FILE__, __LINE__,
"Unsupported node type");
}
}
sparsity_fuser::sparsity_fuser(const vector< block_loop >& loops,
const vector< sparse_bispace_any_order >& bispaces,
const idx_list& direct_tensors,
const map<size_t,idx_pair>& batches) : m_loops(loops),
m_bispaces(bispaces),
m_trees_for_loops(loops.size()),
m_direct_tensors(direct_tensors),
m_batches(batches)
{
//Extract all of the trees, tracking which loops access each one
//Also track the inverse - which trees a given loop accesses
for(size_t bispace_idx = 0; bispace_idx < bispaces.size(); ++bispace_idx)
{
const sparse_bispace_any_order& bispace = bispaces[bispace_idx];
for(size_t tree_idx = 0; tree_idx < bispace.get_n_sparse_groups(); ++tree_idx)
{
sparsity_data tree = bispace.get_sparse_group_tree(tree_idx);
m_sub_key_offsets_for_trees.push_back(vector<idx_list>(1,idx_list()));
for(size_t tree_sub_idx = 0; tree_sub_idx < tree.get_order(); ++tree_sub_idx)
{
m_sub_key_offsets_for_trees.back().back().push_back(tree_sub_idx);
}
m_loops_for_trees.push_back(idx_list());
size_t min = bispace.get_sparse_group_offset(tree_idx);
size_t max = min + tree.get_order();
idx_list perm_entries(tree.get_order());
size_t loops_accessing_tree_idx = 0;
for(size_t loop_idx = 0; loop_idx < loops.size(); ++loop_idx)
{
const block_loop& loop = loops[loop_idx];
if(!loop.is_bispace_ignored(bispace_idx))
{
//Does this loop touch this tree?
size_t subspace_looped = loop.get_subspace_looped(bispace_idx);
if((min <= subspace_looped) && (subspace_looped < max))
{
m_loops_for_trees.back().push_back(loop_idx);
m_trees_for_loops[loop_idx].push_back(m_trees.size());
perm_entries[loops_accessing_tree_idx] = subspace_looped - min;
++loops_accessing_tree_idx;
//Truncate the tree appropriately if the loop is batched
if(batches.find(loop_idx) != batches.end())
{
size_t tree_subspace = subspace_looped - min;
tree = tree.truncate_subspace(tree_subspace,batches.find(loop_idx)->second);
//If the tensor is direct, offsets must be recomputed relative to the CURRENT BATCH
//rather than the whole tensor
if(binary_search(direct_tensors.begin(),direct_tensors.end(),bispace_idx))
{
vector<sparse_bispace<1> > subspaces;
for(size_t tree_subspace_idx = 0; tree_subspace_idx < tree.get_order(); ++tree_subspace_idx)
{
subspaces.push_back(bispace[min+tree_subspace_idx]);
}
size_t grp_nnz = 0;
idx_list new_values;
for(size_t key_idx = 0; key_idx < tree.get_n_entries(); ++key_idx)
{
size_t ent_nnz = 1;
for(size_t i = 0; i < tree.get_order(); ++i)
ent_nnz *= subspaces[i].get_block_size(tree.get_keys()[key_idx*tree.get_order()+i]);
new_values.push_back(grp_nnz);
new_values.push_back(ent_nnz);
grp_nnz += ent_nnz;
}
tree.set_values(2,new_values);
}
}
}
}
}
//Save the tree permuted into loop order
m_trees.push_back(tree.permute(runtime_permutation(perm_entries)));
//Save the index group/bispace mapping information for the tree
size_t index_group = bispace.get_index_group_containing_subspace(min);
m_bispaces_and_index_groups_for_trees.push_back(idx_pair_list(1,idx_pair(bispace_idx,index_group)));
}
}
}
