void fill_node_data_structures( int tr,
int type)
{/* Init fill_node_data_structures */
Node_p list = NULL;
Node_p node_ptr = NULL;
list = node_ptr = get_place_list(tr,type);
for( ; node_ptr != NULL ; node_ptr = NEXT_NODE(node_ptr))
{/* Per ogni nodo della lista */
#ifdef SWN
node_ptr->type = get_node_type(node_ptr,tr);
node_ptr->fun_card = get_node_cardinality(node_ptr,tr);
node_ptr->skip = is_independent_from_instance(node_ptr);
#endif
if(type==INPUT || type==OUTPUT)
node_ptr->test_arc = is_test_arc(node_ptr,type,tr);
#ifdef SWN
if(!node_ptr->skip && type == INHIBITOR)
node_ptr->type = COMPLEX;
#endif
}/* Per ogni nodo della lista */
#ifdef SWN
order_nodes(list,type);
#endif
}/* End fill_node_data_structures */
void generate_R_dendrogram(int * const merge, double * const height, int * const order, cluster_result & Z2, const int N) {
// The array "nodes" is a union-find data structure for the cluster
// identites (only needed for unsorted cluster_result input).
union_find nodes(sorted ? 0 : N);
if (!sorted) {
std::stable_sort(Z2[0], Z2[N-1]);
}
t_index node1, node2;
auto_array_ptr<t_index> node_size(N-1);
for (t_index i=0; i<N-1; ++i) {
// Get two data points whose clusters are merged in step i.
// Find the cluster identifiers for these points.
if (sorted) {
node1 = Z2[i]->node1;
node2 = Z2[i]->node2;
}
else {
node1 = nodes.Find(Z2[i]->node1);
node2 = nodes.Find(Z2[i]->node2);
// Merge the nodes in the union-find data structure by making them
// children of a new node.
nodes.Union(node1, node2);
}
// Sort the nodes in the output array.
if (node1>node2) {
t_index tmp = node1;
node1 = node2;
node2 = tmp;
}
/* Conversion between labeling conventions.
Input: singleton nodes 0,...,N-1
compound nodes N,...,2N-2
Output: singleton nodes -1,...,-N
compound nodes 1,...,N
*/
merge[i] = (node1<N) ? -static_cast<int>(node1)-1
: static_cast<int>(node1)-N+1;
merge[i+N-1] = (node2<N) ? -static_cast<int>(node2)-1
: static_cast<int>(node2)-N+1;
height[i] = Z2[i]->dist;
node_size[i] = size_(node1) + size_(node2);
}
order_nodes(N, merge, node_size, order);
}
sint read_tree(char *treefile, sint first_seq, sint last_seq)
{
char c;
char name1[MAXNAMES+1], name2[MAXNAMES+1];
sint i, j, k;
Boolean found;
numseq = 0;
nnodes = 0;
ntotal = 0;
rooted_tree = TRUE;
#ifdef VMS
if ((fd = fopen(treefile,"r","rat=cr","rfm=var")) == NULL)
#else
if ((fd = fopen(treefile, "r")) == NULL)
#endif
{
error("cannot open %s", treefile);
return((sint)0);
}
skip_space(fd);
ch = (char)getc(fd);
if (ch != '(')
{
error("Wrong format in tree file %s", treefile);
return((sint)0);
}
rewind(fd);
distance_tree = TRUE;
/*
Allocate memory for tree
*/
nptr = (treeptr *)ckalloc(3*(last_seq-first_seq+1) * sizeof(treeptr));
ptrs = (treeptr *)ckalloc(3*(last_seq-first_seq+1) * sizeof(treeptr));
lptr = (treeptr *)ckalloc((last_seq-first_seq+1) * sizeof(treeptr));
olptr = (treeptr *)ckalloc((last_seq+1) * sizeof(treeptr));
seq_tree = avail();
set_info(seq_tree, NULL, 0, "", 0.0);
create_tree(seq_tree,NULL);
fclose(fd);
if (numseq != last_seq-first_seq)
{
error("tree not compatible with alignment\n(%d sequences in alignment and %d in tree", (pint)last_seq-first_seq,(pint)numseq);
return((sint)0);
}
/*
If the tree is unrooted, reroot the tree - ie. minimise the difference
between the mean root->leaf distances for the left and right branches of
the tree.
*/
if (distance_tree == FALSE)
{
if (rooted_tree == FALSE)
{
error("input tree is unrooted and has no distances.\nCannot align sequences");
return((sint)0);
}
}
if (rooted_tree == FALSE)
{
root = reroot(seq_tree, last_seq-first_seq+1);
}
else
{
root = seq_tree;
}
/*
calculate the 'order' of each node.
*/
order_nodes();
if (numseq >= 2)
{
/*
If there are more than three sequences....
*/
/*
assign the sequence nodes (in the same order as in the alignment file)
*/
for (i=first_seq; i<last_seq; i++)
{
if (strlen(names[i+1]) > MAXNAMES)
warning("name %s is too long for PHYLIP tree format (max %d chars)", names[i+1],MAXNAMES);
for (k=0; k< strlen(names[i+1]) && k<MAXNAMES ; k++)
{
c = names[i+1][k];
if ((c>0x40) && (c<0x5b)) c=c | 0x20;
if (c == ' ') c = '_';
name2[k] = c;
}
name2[k]='\0';
found = FALSE;
for (j=0; j<numseq; j++)
{
for (k=0; k< strlen(lptr[j]->name) && k<MAXNAMES ; k++)
{
c = lptr[j]->name[k];
if ((c>0x40) && (c<0x5b)) c=c | 0x20;
name1[k] = c;
}
name1[k]='\0';
if (strcmp(name1, name2) == 0)
{
olptr[i] = lptr[j];
found = TRUE;
}
}
if (found == FALSE)
{
error("tree not compatible with alignment:\n%s not found", name2);
return((sint)0);
}
}
}
return((sint)1);
}
