tntNetwork.c

/*
Authors: Sarah Al-Assam, Stephen Clark and Dieter Jaksch
$LastChangedDate: 2016-05-16 10:01:57 +0100 (Mon, 16 May 2016) $
(c) University of Oxford 2013
 */

#include "../headers/tnt_int.h"
#include "../headers/dec_public.h"
#include "../headers/dec_tnode.h"
#include "../headers/dec_network.h"

tntNetwork tntNetworkConjCopy(tntNetwork nw) 
{
    struct tnetwork *tnw_copy; /* Pointer to network structure for the copy of the network */
    
    TNT_ERR_RET_DEFS /* return value from internal function */
    
    /* Allocate memory for the new network */
    chk = tnw_copy = malloc(sizeof(struct tnetwork));
    TNT_PUB_MEM_CHK /* NO_COVERAGE */
    
    /* Call the function for taking a copy of the network */
    ret = _tnt_network_copy(nw->nw_start,nw->nw_end,&tnw_copy->nw_start,&tnw_copy->nw_end, 1);
    TNT_PUB_ERR_CHK /* NO_COVERAGE */
    
    /* Copy over any Schmidt data (note values will all be real) */
    if (NULL != nw->schmidt_vec) {
        ret = _tnt_tnarr_copy(tnw_copy->schmidt_vec, nw->schmidt_vec);
        TNT_PUB_ERR_CHK /* NO_COVERAGE */
    } else {
        tnw_copy->schmidt_vec = NULL;
    }
    
    /* Set the flags of the terminating nodes */
    nw->nw_start->flag = TNT_STARTNODE_FLAG;
    nw->nw_end->flag = TNT_ENDNODE_FLAG;
    
    /* Return the pointer to the network structure */
    return tnw_copy;
}


tntNetwork tntNetworkCopy(tntNetwork nw) 
{
    struct tnetwork *tnw_copy; /* Pointer to network structure for the copy of the network */
    
    TNT_ERR_RET_DEFS /* return value from internal function */

    /* Allocate memory for the new network */
    chk = tnw_copy = malloc(sizeof(struct tnetwork));
    TNT_PUB_MEM_CHK /* NO_COVERAGE */

    /* Call the function for taking a copy of the mps */
    ret = _tnt_network_copy(nw->nw_start,nw->nw_end,&tnw_copy->nw_start,&tnw_copy->nw_end, 0);
    TNT_PUB_ERR_CHK /* NO_COVERAGE */
    
    /* Set the flags of the terminating nodes */
    nw->nw_start->flag = TNT_STARTNODE_FLAG;
    nw->nw_end->flag = TNT_ENDNODE_FLAG;
    
    /* Copy over any Schmidt data */
    if (NULL != nw->schmidt_vec) {
        ret = _tnt_tnarr_copy(tnw_copy->schmidt_vec, nw->schmidt_vec);
        TNT_PUB_ERR_CHK /* NO_COVERAGE */
    } else {
        tnw_copy->schmidt_vec = NULL;
    }

    /* Return the pointer to the network structure */
    return tnw_copy;
}

tntNetwork tntNetworkCreate(void) 
{
    struct tnetwork *tnw; /* Pointer to network structure for the new of the network */
    TNT_ERR_RET_DEFS 
    
    /* Create the new network */
    ret = _tnt_network_create(&tnw);
    TNT_PUB_ERR_CHK /* NO_COVERAGE */
    
    /* Set the flags of the terminating nodes */
    tnw->nw_start->flag = TNT_STARTNODE_FLAG;
    tnw->nw_end->flag = TNT_ENDNODE_FLAG;
    
    /* Initialise pointer to vector for Schmidt data */
    tnw->schmidt_vec = NULL;

    /* Return the pointer to the network structure */
    return tnw;
}

void tntNetworkFree(tntNetwork *nwp) 
{
    struct tnetwork *tnw = *nwp; /* dereferenced network pointer */
    TNT_ERR_RET_DEFS /* return value from internal function */
    
    if (NULL == tnw) return;
    
    /* First call network_free, which frees every node in the network */
    ret = _tnt_network_free(&(tnw->nw_start));
    TNT_PUB_ERR_CHK /* NO_COVERAGE */
    
    /* Free any Schmidt data */
    if (NULL != tnw->schmidt_vec) {
        ret = _tnt_tnarr_free(tnw->schmidt_vec);
        TNT_PUB_ERR_CHK /* NO_COVERAGE */
        
        free(tnw->schmidt_vec);
    }

    /* Finally free the tnetwork structure itself */
    free(tnw);
    
    /* Set the value to NULL */
    *nwp = NULL;

}

tntNode tntNetworkMinSite(tntNode V, 
                          tntNetwork *nwMV,  
                          unsigned NM, 
                          tntNode (*eig_contract)(tntNode, tntNetwork), 
                          void (*eig_prep)(tntNode, tntNetwork), 
                          tntComplex *eigval) 
{

    struct tnode *eigNode;
    TNT_ERR_RET_DEFS /* return value from internal function */
    
    ret = _tnt_network_eig(&eigNode, V, nwMV,  NM, eig_contract, eig_prep, eigval);
    TNT_PUB_ERR_CHK /* NO_COVERAGE */
    
    return eigNode;
}

tntNetwork tntNetworkSplit(tntNetwork nw, 
                           tntNode tnFirst_1, 
                           tntLegLabel leg_start_1, 
                           tntNode tnLast_1, 
                           tntLegLabel leg_end_1, 
                           tntNode tnFirst_2, 
                           tntLegLabel leg_start_2, 
                           tntNode tnLast_2, 
                           tntLegLabel leg_end_2, 
                           unsigned numSplit_1, 
                           tntNode *tnSplit_1, 
                           unsigned numSplit_2, 
                           tntNode *tnSplit_2) 
{
    unsigned legid_start_1, legid_start_2, legid_end_1, legid_end_2;
    struct tnetwork *tnw_2; /* Pointer to network structure for the second network */
    TNT_ERR_RET_DEFS /* return value from internal function */
    
    /* Turn the leg labels into ids */
    ret = _tnt_node_id_chartonum(&legid_start_1,leg_start_1[0]);
    TNT_PUB_ERR_CHK /* NO_COVERAGE */
    ret = _tnt_node_id_chartonum(&legid_start_2,leg_start_2[0]);
    TNT_PUB_ERR_CHK /* NO_COVERAGE */
    ret = _tnt_node_id_chartonum(&legid_end_1,leg_end_1[0]);
    TNT_PUB_ERR_CHK /* NO_COVERAGE */
    ret = _tnt_node_id_chartonum(&legid_end_2,leg_end_2[0]);
    TNT_PUB_ERR_CHK /* NO_COVERAGE */
    
    /* Free the schmidt data on the network if it exists */
    if (NULL != nw->schmidt_vec) {
        ret = _tnt_tnarr_free(nw->schmidt_vec);
        TNT_PUB_ERR_CHK /* NO_COVERAGE */
        
        free(nw->schmidt_vec);
        nw->schmidt_vec = NULL;
    }
    
    /* Call the network function */
    ret = _tnt_network_split(nw, &tnw_2, tnFirst_1, legid_start_1, tnLast_1, legid_end_1, tnFirst_2, legid_start_2, tnLast_2, legid_end_2, numSplit_1, tnSplit_1, numSplit_2, tnSplit_2);
    TNT_PUB_ERR_CHK /* NO_COVERAGE */
    
    /* Set the flags of the terminating nodes */
    nw->nw_start->flag = TNT_STARTNODE_FLAG;
    nw->nw_end->flag = TNT_ENDNODE_FLAG;
    
    /* Set the flags of the terminating nodes */
    tnw_2->nw_start->flag = TNT_STARTNODE_FLAG;
    tnw_2->nw_end->flag = TNT_ENDNODE_FLAG;
    
    tnw_2->schmidt_vec = NULL;
    
    return tnw_2;
    
}

void tntNetworkToNodeGroup(tntNetwork *nwp, 
                           int strip_connections) 
{
    TNT_ERR_RET_DEFS /* return value from internal function */
    
    /* Free the schmidt data on the network if it exists */
    if (NULL != (*nwp)->schmidt_vec) {
        ret = _tnt_tnarr_free((*nwp)->schmidt_vec);
        TNT_PUB_ERR_CHK /* NO_COVERAGE */
        
        free((*nwp)->schmidt_vec);
        (*nwp)->schmidt_vec = NULL;
    }
    
    /* Call the network function */
    ret = _tnt_network_to_nodegroup(nwp, strip_connections);
    TNT_PUB_ERR_CHK /* NO_COVERAGE */
    
    return;
    
}


/*void tntNetworkSchmidtVecInit(tntNetwork nw,    
//                               unsigned N,       
//                               tntNode A)        
// {
//     TNT_ERR_RET_DEFS /* return value from internal function */
//     unsigned loop;
//     
//     /* Check if schmidt data already exists */
//     if (NULL != nw->schmidt_vec) {
//         sprintf(tnt_err.errinfostr,"The Schmidt vectors have already been initialised"); /* NO_COVERAGE */
//         sprintf(tnt_err.pubfuncname,__FUNCTION__); /* NO_COVERAGE */
//         _tnt_print_error(); /* NO_COVERAGE */
//     } /* NO_COVERAGE */
//     
//     chk = nw->schmidt_vec = malloc(sizeof(struct tn_arr));
//     TNT_PUB_MEM_CHK /* NO_COVERAGE */
//     
//     ret = _tnt_tnarr_alloc(nw->schmidt_vec, N);
//     TNT_PUB_ERR_CHK /* NO_COVERAGE */
//     
//     for (loop = 0; loop < N; loop++) {
//         ret = _tnt_tnode_copy(nw->schmidt_vec->vals  + loop, A, 0);
//         TNT_PUB_ERR_CHK /* NO_COVERAGE */
//     }
//     
//     return;
//     
// }


// tntNode tntNetworkSchmidtVecGet(tntNetwork nw,   /*!< The network */
//                                 unsigned j)      /*!< Site number to get schmidt vector for */
// {
//     TNT_ERR_RET_DEFS /* return value from internal function */
//     tntNode tnreturn; /* The node to return */
//     
//     /* Check whether schmidt data already exists */
//     if (NULL == nw->schmidt_vec) {
//         sprintf(tnt_err.errinfostr,"The Schmidt vectors have not yet been initialised!| Call tntNetworkSchmidtVecInit() to initialise."); /* NO_COVERAGE */
//         sprintf(tnt_err.pubfuncname,__FUNCTION__); /* NO_COVERAGE */
//         _tnt_print_error(); /* NO_COVERAGE */
//     } /* NO_COVERAGE */
//     
//     /* Check the site number is valid */
//     if (j >= nw->schmidt_vec->sz) {
//         sprintf(tnt_err.errinfostr,"The site number (%d) exceeds the number of sites for which Schmidt vectors are stored (%d)",j,nw->schmidt_vec->sz); /* NO_COVERAGE */
//         sprintf(tnt_err.pubfuncname,__FUNCTION__); /* NO_COVERAGE */
//         _tnt_print_error(); /* NO_COVERAGE */
//     }               /* NO_COVERAGE */
//     
//     ret = _tnt_tnode_copy(&tnreturn, nw->schmidt_vec->vals[j], 0);
//     TNT_PUB_ERR_CHK /* NO_COVERAGE */
//     
//     return tnreturn;
//     
// }

// void tntNetworkSchmidtVecSet(tntNetwork nw,   /*!< The network */
//                              unsigned j,      /*!< Site number to set schmidt vector for */
//                              tntNode lambda)  /*!< The node containing the schmidt vector */
// {
//     TNT_ERR_RET_DEFS /* return value from internal function */
//     tntNode tnreturn; /* The node to return */
//     
//     /* Check whether schmidt data already exists */
//     if (NULL == nw->schmidt_vec) {
//         sprintf(tnt_err.errinfostr,"The Schmidt vectors have not yet been initialised!| Call tntNetworkSchmidtVecInit() to initialise."); /* NO_COVERAGE */
//         sprintf(tnt_err.pubfuncname,__FUNCTION__); /* NO_COVERAGE */
//         _tnt_print_error(); /* NO_COVERAGE */
//     } /* NO_COVERAGE */
//     
//     /* Check that the site number is valid */
//     if (j >= nw->schmidt_vec->sz) {
//         sprintf(tnt_err.errinfostr,"The site number (%d) exceeds the number of sites for which Schmidt vectors are stored (%d)",j,nw->schmidt_vec->sz); /* NO_COVERAGE */
//         sprintf(tnt_err.pubfuncname,__FUNCTION__); /* NO_COVERAGE */
//         _tnt_print_error(); /* NO_COVERAGE */
//     } /* NO_COVERAGE */
//     
//     /* Free the current node for that site */
//     ret = _tnt_tnode_free(nw->schmidt_vec->vals + j);
//     TNT_PUB_ERR_CHK /* NO_COVERAGE */
//     
//     /* Copy over the new node */
//     ret = _tnt_tnode_copy(nw->schmidt_vec->vals + j, lambda, 0);
//     TNT_PUB_ERR_CHK /* NO_COVERAGE */
//     
//     return;
//     
// }