memory.tmpl

/**
 * \file  memory.c
 * \brief Holds memory functions.
 */

#include "header.h"

<?foreach xagent?><?foreach function?>
void unittest_$name_$current_state_$next_state()
{
	<?if function_input?>int rc;<?end if?>
	<?foreach function_input?>
	<?if filter?><?if nottree?>rc = MB_Iterator_CreateFiltered(b_$name, &i_$name, &$filter, current_xmachine_$agent_name);<?end if?><?end if?>
	<?if no_filter?>rc = MB_Iterator_Create(b_$name, &i_$name);<?end if?>
	#ifdef ERRCHECK
	if (rc != MB_SUCCESS)
	{
	   fprintf(stderr, "ERROR: Could not create Iterator for '$name'\n");
	   switch(rc) {
	       case MB_ERR_INVALID:
	           fprintf(stderr, "\t reason: '$name' board is invalid\n");
	           break;
	       case MB_ERR_LOCKED:
               fprintf(stderr, "\t reason: '$name' board is locked\n");
               break;
           case MB_ERR_MEMALLOC:
               fprintf(stderr, "\t reason: out of memory\n");
               break;
           case MB_ERR_INTERNAL:
               fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
               break;
	   }
	}
	#endif
	<?end foreach?>
	//return $name();
}
<?end foreach?><?end foreach?>

void free_messages()
{
	<?foreach message?><?if first?>int rc;
	<?end if?>
	    rc = MB_Clear(b_$name);
	    #ifdef ERRCHECK
	    if (rc != MB_SUCCESS)
	    {
	       fprintf(stderr, "ERROR: Could not clear '$name' board\n");
	       switch(rc) {
	           case MB_ERR_INVALID:
	               fprintf(stderr, "\t reason: '$name' board is invalid\n");
	               break;
	           case MB_ERR_LOCKED:
	               fprintf(stderr, "\t reason: '$name' board is locked\n");
	               break;
	           case MB_ERR_INTERNAL:
	               fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
	               break;
	           default:
                   fprintf(stderr, "\t MB_Clear returned error code: %d (see libmboard docs for details)\n", rc);
                   break;
	       }

	       <?if parallel?>MPI_Abort(MPI_COMM_WORLD, rc);<?end if?>
       	   exit(rc);
	    }
	    #endif
	<?end foreach?>
}

/** \fn void initialise_pointers()
 * \brief Initialises pointers to xmachine, message, and node lists.
 */
void initialise_pointers()
{
<?foreach message?><?if first?>int rc;
<?end if?>
	/* Initialise message sync composite params as NULL */
	FLAME_m_$name_composite_params = NULL;

	    rc = MB_Create(&b_$name, sizeof(m_$name));
	    #ifdef ERRCHECK
	    if (rc != MB_SUCCESS)
	    {
	       fprintf(stderr, "ERROR: Could not create '$name' board\n");
	       switch(rc) {
	           case MB_ERR_INVALID:
	               fprintf(stderr, "\t reason: Invalid message size\n");
	               break;
	           case MB_ERR_MEMALLOC:
	               fprintf(stderr, "\t reason: out of memory\n");
	               break;
	           case MB_ERR_INTERNAL:
	               fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
	               break;
	           default:
                   fprintf(stderr, "\t MB_Create returned error code: %d (see libmboard docs for details)\n", rc);
                   break;
	       }

	       <?if parallel?>MPI_Abort(MPI_COMM_WORLD, rc);<?end if?>
       	   exit(rc);
	    }
	    #endif
	<?end foreach?><?foreach xagent?><?foreach state?>
	$agent_name_$name_state = init_$agent_name_state();
<?end foreach?><?end foreach?>
	temp_node_info = NULL;
	p_node_info = &temp_node_info;
}

/** \fn void initialise_unit_testing()
 * \brief Initialises framework for unit testing.
 */
void initialise_unit_testing()
{
	int rc;

	rc = MB_Env_Init();
	#ifdef ERRCHECK
	if (rc != MB_SUCCESS)
	{
	   fprintf(stderr, "ERROR: Failed to initialise Message Board environment\n");
	   switch(rc) {
	       case MB_ERR_MPI:
	           fprintf(stderr, "\t reason: MPI library not initialised\n");
	           break;
	       case MB_ERR_MEMALLOC:
	           fprintf(stderr, "\t reason: out of memory\n");
	           break;
	       default:
               fprintf(stderr, "\t MB_Env_Init returned error code: %d (see libmboard docs for details)\n", rc);
               break;
	       }

	       <?if parallel?>MPI_Abort(MPI_COMM_WORLD, rc);<?end if?>
       	   exit(rc);

	}
	#endif

	initialise_pointers();
}

FLAME_output * add_FLAME_output(FLAME_output ** outputs)
{
	FLAME_output * current;

	current = (FLAME_output *)malloc(sizeof(FLAME_output));
	CHECK_POINTER(current);
	current->next = *outputs;
	*outputs = current;

	current->type = -1;
	current->format = -1;
	current->location = NULL;
	current->period = -1;
	current->phase = -1;
	current->flag = 0;

	return current;
}

void free_FLAME_outputs(FLAME_output ** outputs)
{
	FLAME_output * current, * next;

	current = *outputs;
	while(current)
	{
		next = current->next;
		free(current->location);
		free(current);
		current = next;
	}
	*outputs = NULL;
}

/* add_location */
/** \fn void add_location(double point, location ** p_location)
 * \brief Adds a location in order into the location list.
 * \param point Position of an agent.
 * \param p_location Pointer Pointer to the location list.
 */
void add_location(double point, location ** p_location)
{
	location * current = *p_location;
	location * tmp = NULL;
	location * newlocation = NULL;
	int found = 0;

	while(found == 0)
	{
		if(current == NULL) found = 1;
		else if(point > current->point) found = 1;
		else
		{
			tmp = current;
			current = current->next;
		}
	}

	newlocation = (location *)malloc(sizeof(location));
	CHECK_POINTER(newlocation);
	if(tmp)
	{
		tmp->next = newlocation;
	}
	else
	{
		*p_location = newlocation;
	}

	newlocation->next = current;
	newlocation->point = point;
}

/* freelocations */
/** \fn void freelocations(location ** p_location)
 * \brief Free locations from the location list.
 * \param p_location Pointer Pointer to the location list.
 */
void freelocations(location ** p_location)
{
	location * head = *p_location;
	location * tmp = NULL;

	while(head)
	{
		tmp = head->next;
		free(head);
		head = tmp;
	}

	*p_location = NULL;
}

void init_int_static_array(/*@out@*/ int * array, int size)
{
	int i;

	for(i = 0; i < size; i++) array[i] = 0;
}

void init_float_static_array(/*@out@*/ float * array, int size)
{
	int i;

	for(i = 0; i < size; i++) array[i] = 0.0;
}

void init_double_static_array(/*@out@*/ double* array, int size)
{
	int i;

	for(i = 0; i < size; i++) array[i] = 0.0;
}

void init_char_static_array(/*@out@*/ char * array, int size)
{
	int i;

	for(i = 0; i < size; i++) array[i] = '\0';
}

<?foreach datatype?>

void init_$name(/*@out@*/ $name * temp)
{
<?foreach datatypevar?><?if modeldatatype?><?if not_array?>	init_$type(&(*temp).$name);
<?end if?><?end if?><?if static_array?>	init_$type_static_array((*temp).$name, $arraylength);
<?end if?><?if dynamic_array?>	init_$type(&(*temp).$name);
<?end if?><?if not_modeldatatype?><?if not_array?>	(*temp).$name = $default_value;
<?end if?><?end if?><?end foreach?>
}

void init_$name_static_array(/*@out@*/ $name * array, int size)
{
	int i;

	for(i = 0; i < size; i++) init_$name(&array[i]);
}

void free_$name($name * temp)
{
<?foreach datatypevar?><?if modeldatatype?><?if not_array?>	free_$type(&(*temp).$name);
<?end if?><?if static_array?>	free_$type_static_array((*temp).$name, $arraylength);
<?end if?><?end if?><?if dynamic_array?>	free_$type(&(*temp).$name);
<?end if?><?end foreach?>
}

void free_$name_static_array($name * array, int size)
{
	int i;

	for(i = 0; i < size; i++) free_$name(&array[i]);
}

void copy_$name($name * from, $name * to)
{
<?foreach datatypevar?>	<?if modeldatatype?><?if not_array?>copy_$type(&(*from).$name, &(*to).$name);
<?end if?><?if dynamic_array?>copy_$type(&(*from).$name, &(*to).$name);
<?end if?><?if static_array?>copy_$type_static_array((*from).$name, (*to).$name, $arraylength);
<?end if?><?end if?><?if not_modeldatatype?><?if not_array?>(*to).$name = (*from).$name;
<?end if?><?if dynamic_array?>copy_$type(&(*from).$name, &(*to).$name);
<?end if?><?if static_array?>memcpy((*to).$name, (*from).$name, $arraylength*sizeof($type));
<?end if?><?end if?><?end foreach?>}

void copy_$name_static_array($name * from, $name * to, int size)
{
	int i;

	for(i = 0; i < size; i++)
	{
		copy_$name(&from[i], &to[i]);
	}
}
<?end foreach?>

<?foreach xagent?>
xmachine_memory_$name_state * init_$name_state()
{
	xmachine_memory_$name_state * current = (xmachine_memory_$name_state *)malloc(sizeof(xmachine_memory_$name_state));
	CHECK_POINTER(current);

	current->agents = NULL;
	current->count = 0;

	return current;
}

xmachine_memory_$name * init_$name_agent()
{
	xmachine_memory_$name * current = (xmachine_memory_$name *)malloc(sizeof(xmachine_memory_$name));
	CHECK_POINTER(current);

<?foreach xagentvar?><?if modeldatatype?><?if not_array?>	init_$type(&current->$name);
<?end if?><?end if?><?if static_array?>	init_$type_static_array(current->$name, $arraylength);
<?end if?><?if dynamic_array?>	init_$type(&current->$name);
<?end if?><?if not_modeldatatype?><?if not_array?>	current->$name = $default_value;
<?end if?><?end if?><?end foreach?>
	return current;
}

void free_$name_agent(xmachine_memory_$name_holder * tmp, xmachine_memory_$name_state * state)
{
	if(tmp->prev == NULL) state->agents = tmp->next;
	else tmp->prev->next = tmp->next;
	if(tmp->next != NULL) tmp->next->prev = tmp->prev;

	<?foreach xagentvar?><?if modeldatatype?><?if not_array?>free_$type(&tmp->agent->$name);
	<?end if?><?if static_array?>free_$type_static_array(tmp->agent->$name, $arraylength);
	<?end if?><?end if?><?if dynamic_array?>free_$type(&tmp->agent->$name);
	<?end if?><?end foreach?>

	free(tmp->agent);
	free(tmp);
}

void unittest_init_$name_agent()
{
	current_xmachine_$name = (xmachine_memory_$name *)malloc(sizeof(xmachine_memory_$name));
	CHECK_POINTER(current);

	<?foreach xagentvar?><?if modeldatatype?><?if not_array?>	init_$type(&current_xmachine_$agent_name->$name);
	<?end if?><?end if?><?if static_array?>	init_$type_static_array(current_xmachine_$agent_name->$name, $arraylength);
	<?end if?><?if dynamic_array?>	init_$type(&current_xmachine_$agent_name->$name);
	<?end if?><?if not_modeldatatype?><?if not_array?>	current_xmachine_$agent_name->$name = $default_value;
	<?end if?><?end if?><?end foreach?>
}

void unittest_free_$name_agent()
{
	<?foreach xagentvar?><?if modeldatatype?><?if not_array?>free_$type(&current_xmachine_$agent_name->$name);
	<?end if?><?if static_array?>free_$type_static_array(current_xmachine_$agent_name->$name, $arraylength);
	<?end if?><?end if?><?if dynamic_array?>free_$type(&current_xmachine_$agent_name->$name);
	<?end if?><?end foreach?>
	free(current_xmachine_$name);
}

void free_$name_agents()
{
<?foreach state?>	current_xmachine_$agent_name_holder = $agent_name_$name_state->agents;
	while(current_xmachine_$agent_name_holder)
	{
		temp_xmachine_$agent_name_holder = current_xmachine_$agent_name_holder->next;
		free_$agent_name_agent(current_xmachine_$agent_name_holder, $agent_name_$name_state);
		current_xmachine_$agent_name_holder = temp_xmachine_$agent_name_holder;
	}
	$agent_name_$name_state->count = 0;
<?end foreach?>}

void free_$name_states()
{
<?foreach state?>	free($agent_name_$name_state);
<?end foreach?>}

void transition_$name_agent(xmachine_memory_$name_holder * tmp, xmachine_memory_$name_state * from_state, xmachine_memory_$name_state * to_state)
{
	if(tmp->prev == NULL) from_state->agents = tmp->next;
	else tmp->prev->next = tmp->next;
	if(tmp->next != NULL) tmp->next->prev = tmp->prev;

	add_$name_agent_internal(tmp->agent, to_state);
	free(tmp);
}

void add_$name_agent_internal(xmachine_memory_$name * agent, xmachine_memory_$name_state * state)
{
	xmachine_memory_$name_holder * current = (xmachine_memory_$name_holder *)malloc(sizeof(xmachine_memory_$name_holder));
	CHECK_POINTER(current);

	current->next = state->agents;
	current->prev = NULL;
	state->agents = current;
	if(current->next != NULL) current->next->prev = current;
	current->agent = agent;

	state->count++;
<?if parallel?>    current_node->agent_total++;<?end if?>
}

/** \fn void add_$name_agent(<?foreach xagentvar?>$type <?if not_modeldatatype?><?if dynamic_array?>* <?end if?><?end if?><?if modeldatatype?><?if static_array?>*<?end if?>* <?end if?>$name<?if not_modeldatatype?><?if static_array?>[]<?end if?><?end if?><?if notlast?>, <?end if?><?end foreach?>)
 * \brief Add $name X-machine to the current being used X-machine list.
<?foreach xagentvar?> * \param $name Variable for the X-machine memory.
<?end foreach?> */
void add_$name_agent(<?foreach xagentvar?>$type <?if dynamic_array?>* <?end if?>$name<?if static_array?>[]<?end if?><?if notlast?>, <?end if?><?end foreach?>)
{
	xmachine_memory_$name * current;

	current = init_$name_agent();
	/* new line added to handle dynamic agent creation*/
	current_xmachine_$name_next_state = $name_$start_state_state;
	add_$name_agent_internal(current, current_xmachine_$name_next_state);

<?foreach xagentvar?>	<?if modeldatatype?><?if not_array?>copy_$type(&$name, &current->$name);
<?end if?><?if dynamic_array?>copy_$type($name, &current->$name);
<?end if?><?if static_array?>copy_$type_static_array($name, current->$name, $arraylength);
<?end if?><?end if?><?if not_modeldatatype?><?if not_array?>current->$name = $name;
<?end if?><?if dynamic_array?>copy_$type($name, &current->$name);
<?end if?><?if static_array?>memcpy(current->$name, $name, $arraylength*sizeof($type));
<?end if?><?end if?><?end foreach?>}
<?end foreach?>

/* freexmachines */
/** \fn void freexmachines()
 * \brief Free the currently being used X-machine list.
 */
void freexmachines()
{
	<?foreach xagent?>free_$name_agents();
	<?end foreach?>
}

<?foreach allvar?><?if not_modeldatatype?><?if not_array?>
/** \fn void set_$name($type $name)
 * \brief Set $name memory variable for current X-machine.
 * \param $name New value for variable.
 */
void set_$name($type <?if dynamic_array?>* <?end if?><?if static_array?>*<?end if?>$name<?if static_array?>[]<?end if?>)
{
<?foreach xagent?><?if allvar_in_agent?>	if(current_xmachine->xmachine_$name) (*current_xmachine->xmachine_$name).$allvar_name = $allvar_name;
<?end if?><?end foreach?>}
<?end if?><?end if?>
/** \fn $type get_$name()
 * \brief Get $name memory variable from current X-machine.
 * \return Value for variable.
 */
$type <?if modeldatatype?>* <?end if?><?if not_modeldatatype?><?if array?>* <?end if?><?end if?>get_$name()
{
<?foreach xagent?><?if allvar_in_agent?>	if(current_xmachine->xmachine_$name) return <?if modeldatatype?><?if not_static_array?>&<?end if?><?end if?><?if not_modeldatatype?><?if dynamic_array?>&<?end if?><?end if?>(*current_xmachine->xmachine_$name).$allvar_name;
<?end if?><?end foreach?>
    // suppress compiler warning by returning dummy value /
    // this statement should rightfully NEVER be reached /
    return <?if not_array?><?if not_modeldatatype?>($type)0<?end if?><?end if?><?if modeldatatype?>NULL<?end if?><?if not_modeldatatype?><?if array?>NULL<?end if?><?end if?>;
}
<?end foreach?>

/** \fn double agent_get_range()
 * \brief Fixed routine to get the range from current X-machine
  * \return Value of range
  */
double agent_get_range()
{
    double value = 0.0;
<?foreach xagent?>    /*if (current_xmachine->xmachine_$name) value = current_xmachine->xmachine_$name->$rangevar;*/
<?end foreach?>
    return value;
}

/** \fn int agent_get_id()
 * \brief Fixed routine to get the id for the current X-machine
  * \return Value of agent id
  */
int agent_get_id()
{
    int value = 0;
<?foreach xagent?>    /*if (current_xmachine->xmachine_$name) value = current_xmachine->xmachine_$name->$idvar;*/
<?end foreach?>
    return value;
}

/** \fn double agent_get_x()
 * \brief Fixed routine to get the x coordinate from current X-machine
  * \return Value of x coordinate
  */
double agent_get_x()
{
    double value = 0.0;
<?foreach xagent?>    /*if (current_xmachine->xmachine_$name) value = current_xmachine->xmachine_$name->$xvar;*/
<?end foreach?>
    return value;
}
/** \fn double agent_get_y()
 * \brief Fixed routine to get the y coordinate from current X-machine
  * \return Value of y coordinate
  */
double agent_get_y()
{
    double value = 0.0;
<?foreach xagent?>    /*if (current_xmachine->xmachine_$name) value = current_xmachine->xmachine_$name->$yvar;*/
<?end foreach?>
    return value;
}
/** \fn double agent_get_z()
 * \brief Fixed routine to get the z coordinate from current X-machine
  * \return Value of z coordinate
  */
double agent_get_z()
{
    double value = 0.0;
<?foreach xagent?><?if use_zvar?>    /*if (current_xmachine->xmachine_$name) value = current_xmachine->xmachine_$name->$zvar;*/
<?end if?><?end foreach?>
    return value;
}

/** \fn void add_node(int node_id, double minx, double maxx, double miny, double maxy, double minz, double maxz)
 * \brief Add a node to the node list.
 * \param node_id The node ID.
 * \param minx The minumum value on the x-axis of the bounding volume.
 * \param maxx The maximum value on the x-axis of the bounding volume.
 * \param miny The minumum value on the y-axis of the bounding volume.
 * \param maxy The maximum value on the y-axis of the bounding volume.
 * \param minz The minumum value on the z-axis of the bounding volume.
 * \param maxz The maximum value on the z-axis of the bounding volume.
 */
void add_node(int node_id, double minx, double maxx, double miny, double maxy, double minz, double maxz)
{
	node_information * current = *p_node_info;
	node_information * tmp = NULL;

	while(current)
	{
		tmp = current;
		current = current->next;
	}

	current = (node_information *)malloc(sizeof(node_information));
		CHECK_POINTER(current);
<?if parallel?>	if(node_id == node_number) current_node = current;<?end if?>
	if(tmp)
	{
		tmp->next = current;
	}
	else
	{
		*p_node_info = current;
	}

	current->next = NULL;
	current->node_id = node_id;
	current->agents_in_halo = 0;
	current->agent_total = 0;
	current->agents = NULL;
<?foreach message?>	current->$name_messages = NULL;
<?end foreach?>
<?if parallel?><?foreach message?>	current->$name_message_no = 0;
<?end foreach?><?foreach xagent?>	current->$name_agents = NULL;
	current->$name_agent_no = 0;
<?end foreach?>
<?end if?>
	current->partition_data[0] = minx;
	current->partition_data[1] = maxx;
	current->partition_data[2] = miny;
	current->partition_data[3] = maxy;
	current->partition_data[4] = minz;
	current->partition_data[5] = maxz;
}

/**\fn void free_node_info()
 * \brief Free the node list.
 */
void free_node_info()
{
	node_information * tmp, * head;
	head = *p_node_info;

	while(head)
	{
		tmp = head->next;
		free(head);
		head = tmp;
	}

	*p_node_info = NULL;
}

/** \fn void clean_up(int code)
 * \brief Add a node to the node list.
 * \param code The error code (zero is no error).
 */
void clean_up(int code)
{
    int rc;
	FILE *file;
	char data[100];

	free(current_xmachine);
	/* Free x-machine memory */
	freexmachines();
	/* Free space partitions linked list */
	free_node_info();
	/* Free output list */
	free_FLAME_outputs(&FLAME_outputs);
	/* Free agent states */
<?foreach xagent?>	free_$name_states();
<?end foreach?>

	/* Free index maps */
<?foreach constant_filter_variable?>
	rc = MB_IndexMap_Delete(&FLAME_map_$agent_name_$name);
	if (rc != MB_SUCCESS)
	{
		fprintf(stderr, "ERROR: Could not delete map of $agent_name $name\n");
		/* Add reason for error using error codes here */
		<?if parallel?>MPI_Abort(MPI_COMM_WORLD, rc);<?end if?>
		exit(rc);
	}
<?end foreach?>

	/* Free message boards */
<?foreach message?>
	rc = MB_Delete(&b_$name);
	#ifdef ERRCHECK
    if (rc != MB_SUCCESS)
    {
       fprintf(stderr, "ERROR: Could not delete '$name' board\n");
       switch(rc) {
           case MB_ERR_INVALID:
               fprintf(stderr, "\t reason: '$name' board has not been created?\n");
               break;
           case MB_ERR_LOCKED:
               fprintf(stderr, "\t reason: '$name' board is locked\n");
               break;
           case MB_ERR_INTERNAL:
               fprintf(stderr, "\t reason: internal error. Recompile libmoard in debug mode for more info \n");
               break;
	       default:
               fprintf(stderr, "\t MB_Delete returned error code: %d (see libmboard docs for details)\n", rc);
               break;
	       }

	       <?if parallel?>MPI_Abort(MPI_COMM_WORLD, rc);<?end if?>
       	   exit(rc);
    }
    #endif
<?end foreach?>

    rc = MB_Env_Finalise();
    #ifdef ERRCHECK
    if (rc != MB_SUCCESS)
    {
       fprintf(stderr, "ERROR: Could not finalise MB environment\n");
       switch(rc) {
           case MB_ERR_ENV:
               fprintf(stderr, "\t reason: MB environment not yet started?\n");
               break;
	       default:
               fprintf(stderr, "\t MB_Env_Finalise returned error code: %d (see libmboard docs for details)\n", rc);
               break;
	       }

	       <?if parallel?>MPI_Abort(MPI_COMM_WORLD, rc);<?end if?>
       	   exit(rc);
    }
    #endif


<?if parallel?>
        /* Clear MPI_Datatypes */
        MPI_Type_free(&spacePartitionType);
        <?foreach xagent?>
        /* MPI_Type_free(&xmachine$nameType); */
        <?end foreach?>
        <?foreach message?>
        /* MPI_Type_free(&message$nameType); */
        <?end foreach?>


		/* MPI finalise routine */
		MPI_Finalize();

		if(node_number == 0)
		{
<?end if?>
	/* Write log file */
	sprintf(data, "%slog.xml", outputpath);
	file = fopen(data, "a");
	fputs("<!-- <totaltime> unit: seconds -->\n", file);
	fputs("<totaltime>", file);
	sprintf(data, "%.3f", total_time);
	fputs(data, file);
	fputs("</totaltime>\n", file);
	/*fputs("<totalmessages>", file);
	sprintf(data, "%i", total_messages);
	fputs(data, file);
	fputs("</totalmessages>", file);*/
	fputs("</model_run>", file);
	fclose(file);
<?if parallel?>	}<?end if?>

	if(code != 0)
	{
		printf("*** Error: ");
		if(code == 100) printf("cannot handle specified number of space partitions");
		if(code == 101) printf("could not find number of space partitions config in file");

		printf(" ***");
		exit(0);
	}
}

<?if serial?>
/** \fn void propagate_agents()
 * \brief Check agent positions to see if any need to be moved to a another node.
 */
void propagate_agents()
{
/*	node_information * node_info;
	xmachine * before_xmachine, * temp_xmachine;
	xmachine ** p_temp_xmachine;
	double x_xmachine, y_xmachine, z_xmachine;
	current_xmachine = *p_xmachine;
	before_xmachine = NULL;
	while(current_xmachine)
	{
<?foreach xagent?>		<?if notfirst?>else <?end if?>if(current_xmachine->xmachine_$name != NULL)
		{
			x_xmachine = current_xmachine->xmachine_$name->$xvar;
			y_xmachine = current_xmachine->xmachine_$name->$yvar;
<?if use_zvar?>			z_xmachine = current_xmachine->xmachine_$name->$zvar;<?end if?><?if no_zvar?>			z_xmachine = 0.0;<?end if?>
		}
<?end foreach?>
		if(x_xmachine < current_node->partition_data[0] ||
		   x_xmachine > current_node->partition_data[1] ||
		   y_xmachine < current_node->partition_data[2] ||
		   y_xmachine > current_node->partition_data[3] ||
		   z_xmachine < current_node->partition_data[4] ||
		   z_xmachine > current_node->partition_data[5])
		{
			node_info = *p_node_info;
			while(node_info)
			{
				if(node_info->node_id != current_node->node_id &&
				node_info->partition_data[0] < x_xmachine && node_info->partition_data[1] > x_xmachine &&
				node_info->partition_data[2] < y_xmachine && node_info->partition_data[3] > y_xmachine &&
				node_info->partition_data[4] < z_xmachine && node_info->partition_data[5] > z_xmachine)
				{
                    // Remove agent
                    if(before_xmachine) before_xmachine->next = current_xmachine->next;
                    else *p_xmachine = current_xmachine->next;
                    current_node->agent_total--;
                    // Add agent
                    p_temp_xmachine = &node_info->agents;
                    temp_xmachine = *p_temp_xmachine;
                    current_xmachine->next = temp_xmachine;
                    *p_temp_xmachine = current_xmachine;
                    node_info->agent_total++;
                    node_info = NULL;
				}
				else node_info = node_info->next;
				}
			}
			else before_xmachine = current_xmachine;

			if(before_xmachine) current_xmachine = before_xmachine->next;
			else current_xmachine = NULL;
		}*/
}
<?end if?>

/** \fn int_array * init_int_array()
 * \brief Allocate memory for a dynamic integer array.
 * \return int_array Pointer to the new dynamic integer array.
 */
void init_int_array(int_array * array)
{
	(*array).size = 0;
	(*array).total_size = ARRAY_BLOCK_SIZE;
	(*array).array = (int *)malloc(ARRAY_BLOCK_SIZE * sizeof(int));
	CHECK_POINTER((*array).array);
}

/** \fn void reset_int_array(int_array * array)
* \brief Reset the int array to hold nothing.
* \param array Pointer to the dynamic integer array.
*/
void reset_int_array(int_array * array)
{
	(*array).size = 0;
}

/** \fn void free_int_array(int_array * array)
* \brief Free the memory of a dynamic integer array.
* \param array Pointer to the dynamic integer array.
*/
void free_int_array(int_array * array)
{
	free((*array).array);
}

void copy_int_array(int_array * from, int_array * to)
{
	int i;
	//to = init_int_array();

	for (i = 0; i < (*from).size; i++)
	{
		add_int(to, (*from).array[i]);
	}
}

/** \fn void sort_int_array(int_array * array)
* \brief Sort the elements of a dynamic integer array with smallest first.
* \param array Pointer to the dynamic integer array.
*/
/*void sort_int_array(int_array * array)
{
	int i, j, temp;

	for(i=0; i<((*array).size-1); i++)
	{
		for(j=0; j<((*array).size-1)-i; j++)
		{
			if(*((*array).array+j+1) < *((*array).array+j))
			{
                temp = *((*array).(*array)+j);
                *((*array).array+j) = *((*array).array+j+1);
                *((*array).array+j+1) = temp;
			}
		}
	}
}*/

/** \fn int quicksort_int(int *array, int elements)
 *  \brief Sorts the elements of the integer array in ascending order.
 *  \param Pointer to integer array
 *  \param Number of elements that must be sorted
 *  \return integer value indicating success(0) or failure(1)
 */
/*int quicksort_int(int array, int elements)
{
	#define  LEVEL  1000
	int  pivot, begin[LEVEL], end[LEVEL], i=0, left, right ;
	begin[0]=0; end[0]=elements;
	while (i>=0)
	{
		left=begin[i]; right=end[i]-1;
		if (left<right)
		{
			pivot=array[left]; if (i==LEVEL-1) return 1;
			while (left<right)
			{
				while (array[right]>=pivot && left<right) right--;
				if (left<right) array[left++]=array[right];
				while (array[left]<=pivot && left<right) left++;
				if (left<right) array[right--]=array[left];
			}
			array[left]=pivot;
			begin[i+1]=left+1;
			end[i+1]=end[i];
			end[i++]=left;
		}
	    else
	    {
	      i--;
	    }
	}
	return 0;
}*/

/** \fn void add_int(int_array * array, int new_int)
* \brief Add an integer to the dynamic integer array.
* \param array Pointer to the dynamic integer array.
* \param new_int The integer to add
*/
void add_int(int_array * array, int new_int)
{
	if((*array).size == (*array).total_size)
	{
		(*array).total_size = (int)((*array).total_size * ARRAY_GROWTH_RATE);
		(*array).array = (int *)realloc((*array).array, ((*array).total_size * sizeof(int)));
	}
	(*array).array[(*array).size] = new_int;
	(*array).size++;
}

/** \fn void remove_int(int_array * array, int index)
 * \brief Remove an integer from a dynamic integer array.
 * \param array Pointer to the dynamic integer array.
 * \param index The index of the integer to remove.
 */
void remove_int(int_array * array, int index)
{
	int i;

	if(index < (*array).size)
	{
		/* memcopy?? */
		for(i = index; i < (*array).size - 1; i++)
		{
			(*array).array[i] = (*array).array[i+1];
		}
		(*array).size--;
	}
}

/** \fn void print_int_array(int_array * array)
 * \brief Print the elements of a dynamic integer array.
 * \param array Pointer to the dynamic integer array.
 */
void print_int_array(int_array * array)
{
	int i;

	for(i=0; i<(*array).size; i++)
	{
		printf("%d> %d", i, (*array).array[i]);
	}
}

/** \fn float_array * init_float_array()
 * \brief Allocate memory for a dynamic float array.
 * \return float_array Pointer to the new dynamic float array.
 */
void init_float_array(float_array * array)
{
	(*array).size = 0;
	(*array).total_size = ARRAY_BLOCK_SIZE;
	(*array).array = (float *)malloc(ARRAY_BLOCK_SIZE * sizeof(float));
	CHECK_POINTER((*array).array);
}

/** \fn void reset_float_array(float_array * array)
* \brief Reset the float array to hold nothing.
* \param array Pointer to the dynamic float array.
*/
void reset_float_array(float_array * array)
{
	(*array).size = 0;
}

/** \fn void free_float_array(float_array * array)
* \brief Free the memory of a dynamic float array.
* \param array Pointer to the dynamic float array.
*/
void free_float_array(float_array * array)
{
	free((*array).array);
}

void copy_float_array(float_array * from, float_array * to)
{
	int i;
	//to = init_float_array();

	for (i = 0; i < (*from).size; i++)
	{
		add_float(to, (*from).array[i]);
	}
}

/** \fn void sort_float_array(float_array * array)
* \brief Sort the elements of a dynamic float array with smallest first.
* \param array Pointer to the dynamic float array.
*/
/*void sort_float_array(float_array array)
{
	int i, j;
	float temp;
	// Using bubble sorts nested loops //
	for(i=0; i<(array.size-1); i++)
	{
		for(j=0; j<(array.size-1)-i; j++)
		{
			// Comparing the values between neighbours //
			if(*(array.array+j+1) < *(array.array+j))
			{
                // Swap neighbours //
                temp = *(array.array+j);
                *(array.array+j) = *(array.array+j+1);
                *(array.array+j+1) = temp;
			}
		}
	}
}*/

/** \fn int quicksort_float(float *array, int elements)
 *  \brief Sorts the elements of the float array in ascending order.
 *  \param Pointer to float array
 *  \param Number of elements that must be sorted
 *  \return integer value indicating success(0) or failure(1)
 */
/*int quicksort_float(float array, int elements)
{
	#define  LEVEL  1000
	int i=0, left, right ;
	float pivot, begin[LEVEL], end[LEVEL];
	begin[0]=0; end[0]=elements;
	while (i>=0)
	{
		left=begin[i]; right=end[i]-1;
		if (left<right)
		{
			pivot=array[left]; if (i==LEVEL-1) return 1;
			while (left<right)
			{
				while (array[right]>=pivot && left<right) right--;
				if (left<right) array[left++]=array[right];
				while (array[left]<=pivot && left<right) left++;
				if (left<right) array[right--]=array[left];
			}
			array[left]=pivot;
			begin[i+1]=left+1;
			end[i+1]=end[i];
			end[i++]=left;
		}
	    else
	    {
	      i--;
	    }
	}
	return 0;
}*/

/** \fn void add_float(float_array * array, float new_float)
* \brief Add an floateger to the dynamic float array.
* \param array Pointer to the dynamic float array.
* \param new_float The float to add
*/
void add_float(float_array * array, float new_float)
{
	if((*array).size == (*array).total_size)
	{
		(*array).total_size = (int)((*array).total_size * ARRAY_GROWTH_RATE);
		(*array).array = (float *)realloc((*array).array, ((*array).total_size * sizeof(float)));
	}
	(*array).array[(*array).size] = new_float;
	(*array).size++;
}

/** \fn void remove_float(float_array * array, int index)
 * \brief Remove an floateger from a dynamic float array.
 * \param array Pointer to the dynamic float array.
 * \param index The index of the float to remove.
 */
void remove_float(float_array * array, int index)
{
	int i;

	if(index < (*array).size)
	{
		/* memcopy?? */
		for(i = index; i < (*array).size - 1; i++)
		{
			(*array).array[i] = (*array).array[i+1];
		}
		(*array).size--;
	}
}

/** \fn void print_float_array(float_array * array)
 * \brief Print the elements of a dynamic float array.
 * \param array Pointer to the dynamic float array.
 */
void print_float_array(float_array * array)
{
	int i;
	/* printf(""); // compiler does not like empty prfloats */
	for(i=0; i<(*array).size; i++)
	{
		printf("%d> %f", i, (*array).array[i]);
	}
}

/** \fn double_array * init_double_array()
 * \brief Allocate memory for a dynamic double array.
 * \return double_array Pointer to the new dynamic double array.
 */
void init_double_array(double_array * array)
{
	(*array).size = 0;
	(*array).total_size = ARRAY_BLOCK_SIZE;
	(*array).array = (double *)malloc(ARRAY_BLOCK_SIZE * sizeof(double));
	CHECK_POINTER((*array).array);
}

/** \fn void reset_double_array(double_array * array)
* \brief Reset the double array to hold nothing.
* \param array Pointer to the dynamic double array.
*/
void reset_double_array(double_array * array)
{
	(*array).size = 0;
}

/** \fn void free_double_array(double_array * array)
 * \brief Free the memory of a dynamic double array.
 * \param array Pointer to the dynamic double array.
 */
void free_double_array(double_array * array)
{
	free((*array).array);
}

void copy_double_array(double_array * from, double_array * to)
{
	int i;
	//to = init_double_array();

	for (i = 0; i < (*from).size; i++)
	{
		add_double(to, (*from).array[i]);
	}
}

/** \fn void sort_double_array(double_array * array)
 * \brief Sort the elements of a dynamic double array with smallest first.
 * \param array Pointer to the dynamic double array.
 */
/*void sort_double_array(double_array array)
{
	int i, j;
	double temp;

	// Using bubble sorts nested loops //
	for(i=0; i<(array.size-1); i++)
	{
		for(j=0; j<(array.size-1)-i; j++)
		{
			// Comparing the values between neighbours //
			if(*(array.array+j+1) < *(array.array+j))
			{
                // Swap neighbours //
                temp = *(array.array+j);
                *(array.array+j) = *(array.array+j+1);
                *(array.array+j+1) = temp;
			}
		}
	}
}*/

/** \fn int quicksort_double(double *array, int elements)
 *  \brief Sorts the elements of the double array in ascending order.
 *  \param Pointer to double array
 *  \param Number of elements that must be sorted
 *  \return integer value indicating success(0) or failure(1)
 */
/*int quicksort_double(double array, int elements)
{
	#define  LEVEL  1000
	double pivot, begin[LEVEL], end[LEVEL];
	int  i=0, left, right ;
	begin[0]=0; end[0]=elements;
	while (i>=0)
	{
		left=begin[i]; right=end[i]-1;
		if (left<right)
		{
			pivot=array[left]; if (i==LEVEL-1) return 1;
			while (left<right)
			{
				while (array[right]>=pivot && left<right) right--;
				if (left<right) array[left++]=array[right];
				while (array[left]<=pivot && left<right) left++;
				if (left<right) array[right--]=array[left];
			}
			array[left]=pivot;
			begin[i+1]=left+1;
			end[i+1]=end[i];
			end[i++]=left;
		}
	    else
	    {
	      i--;
	    }
	}
	return 0;
}*/

/** \fn void add_double(double_array * array, double new_double)
 * \brief Add an double to the dynamic double array.
 * \param array Pointer to the dynamic double array.
 * \param new_double The double to add
 */
void add_double(double_array * array, double new_double)
{
	if((*array).size == (*array).total_size)
	{
		(*array).total_size = (int)((*array).total_size * ARRAY_GROWTH_RATE);
		(*array).array = (double *)realloc((*array).array, ((*array).total_size * sizeof(double)));
	}
	(*array).array[(*array).size] = new_double;
	(*array).size++;
}

/** \fn void remove_double(double_array * array, int index)
 * \brief Remove an double from a dynamic double array.
 * \param array Pointer to the dynamic double array.
 * \param index The index of the double to remove.
 */
void remove_double(double_array * array, int index)
{
	int i;
	if(index < (*array).size)
	{
		/* memcopy?? */
		for(i = index; i < (*array).size - 1; i++)
		{
			(*array).array[i] = (*array).array[i+1];
		}
		(*array).size--;
	}
}

/** \fn void print_double_array(double_array * array)
 * \brief Print the elements of a dynamic double array.
 * \param array Pointer to the dynamic double array.
 */
void print_double_array(double_array * array)
{
	int i;

	for(i=0; i<(*array).size; i++)
	{
		printf("%d> %f", i, (*array).array[i]);
	}
}

/** \fn char_array * init_char_array()
 * \brief Allocate memory for a dynamic char array.
 * \return char_array Pointer to the new dynamic char array.
 */
void init_char_array(char_array * array)
{
	(*array).size = 0;
	(*array).total_size = ARRAY_BLOCK_SIZE;
	(*array).array = (char *)malloc(ARRAY_BLOCK_SIZE * sizeof(char));
	CHECK_POINTER((*array).array);
	(*array).array[0] = '\0';
}

/** \fn void reset_char_array(char_array * array)
* \brief Reset the char array to hold nothing.
* \param array Pointer to the dynamic char array.
*/
void reset_char_array(char_array * array)
{
	(*array).size = 0;
}

/** \fn void free_char_array(char_array * array)
 * \brief Free the memory of a dynamic char array.
 * \param array Pointer to the dynamic char array.
 */
void free_char_array(char_array * array)
{
	free((*array).array);
}

void copy_char_array(char_array * from, char_array * to)
{
	int i;

	for (i = 0; i < (*from).size; i++)
	{
		add_char(to, (*from).array[i]);
	}
}

/** \fn void add_char(char_array * array, char new_char)
 * \brief Add an char to the dynamic char array.
 * \param array Pointer to the dynamic char array.
 * \param new_char The char to add
 */
void add_char(char_array * array, char new_char)
{
	if((*array).size + 1 == (*array).total_size)
	{
		(*array).total_size = (int)((*array).total_size * ARRAY_GROWTH_RATE);
		(*array).array = (char *)realloc((*array).array, ((*array).total_size * sizeof(char)));
	}
	(*array).array[(*array).size] = new_char;
	(*array).array[(*array).size + 1] = '\0';
	(*array).size++;
}

/** \fn void remove_char(char_array * array, int index)
 * \brief Remove an char from a dynamic char array.
 * \param array Pointer to the dynamic char array.
 * \param index The index of the char to remove.
 */
void remove_char(char_array * array, int index)
{
	int i;
	if(index < (*array).size)
	{
		/* memcopy?? */
		for(i = index; i < (*array).size - 1; i++)
		{
			(*array).array[i] = (*array).array[i+1];
		}
		(*array).size--;
	}
}

/** \fn char * copy_array_to_str(char_array * array)
 * \brief Return pointer to string from a char_array.
 * \param array Pointer to the dynamic integer array.
 * \return char Pointer to the new string.
 */
char * copy_array_to_str(char_array * array)
{
	char * new_string = (char *)malloc( ((*array).size + 1) * sizeof(char));
	CHECK_POINTER(new_string);
	return strcpy(new_string, (*array).array);
}

/** \fn void print_char_array(char_array * array)
 * \brief Print the elements of a dynamic char array.
 * \param array Pointer to the dynamic char array.
 */
void print_char_array(char_array * array)
{
	printf("%s", (*array).array);
}

<?foreach datatype?>/* Functions for the $name datatype */
/** \fn $name_array * init_$name_array()
 * \brief Allocate memory for a dynamic $name array.
 * \return $name_array Pointer to the new dynamic $name array.
 */
void init_$name_array($name_array * array)
{
	(*array).size = 0;
	(*array).total_size = ARRAY_BLOCK_SIZE;
	(*array).array = ($name *)malloc(ARRAY_BLOCK_SIZE * sizeof($name));
	CHECK_POINTER((*array).array);
}

/** \fn void reset_$name_array($name_array* array)
* \brief Reset the $name array to hold nothing.
* \param array Pointer to the dynamic $name array.
*/
void reset_$name_array($name_array * array)
{
	(*array).size = 0;
}

/** \fn void free_$name_array($name_array * array)
* \brief Free the memory of a dynamic $name array.
* \param array Pointer to the dynamic $name array.
*/
void free_$name_array($name_array * array)
{
	int i;
	
	for(i = 0; i < array->size; i++)
	{
		free_$name(&(*array).array[i]);
	}
	
	free((*array).array);
}

void copy_$name_array($name_array * from, $name_array * to)
{
	int i;

	//to = init_$name_array();

	for(i = 0; i < (*from).size; i++)
	{
		add_$name(to<?foreach datatypevar?>, <?if modeldatatype?><?if not_array?>&<?end if?><?end if?><?if dynamic_array?>&<?end if?>(*from).array[i].$name<?end foreach?>);
	}
}

/** \fn void add_$name($name_array * array<?foreach datatypevar?>, $type <?if modeldatatype?>* <?end if?>$name<?end foreach?>)
* \brief Add an $name to the dynamic $name array.
* \param array Pointer to the dynamic $name array.
* \param new_int The $name to add
*/
void add_$name($name_array * array<?foreach datatypevar?>, <?if modeldatatype?><?if not_array?>/*@out@*/<?end if?><?end if?><?if array?>/*@out@*/<?end if?> $type <?if modeldatatype?><?if not_array?>* <?end if?><?end if?><?if array?>* <?end if?>$name<?end foreach?>)
{
	if((*array).size == (*array).total_size)
	{
		(*array).total_size = (int)((*array).total_size * ARRAY_GROWTH_RATE);
		(*array).array = ($name *)realloc((*array).array, ((*array).total_size * sizeof($name)));
	}
	init_$name(&(*array).array[(*array).size]);
<?foreach datatypevar?><?if modeldatatype?><?if not_array?>	copy_$type($name, &(*array).array[(*array).size].$name);<?end if?><?if static_array?>	if($name != NULL) copy_$type_static_array($name, (*array).array[(*array).size].$name, $arraylength);<?end if?><?end if?><?if not_modeldatatype?><?if not_array?>	(*array).array[(*array).size].$name = $name;<?end if?><?if static_array?>	if($name != NULL) memcpy((*array).array[(*array).size].$name, $name, $arraylength*sizeof($type));<?end if?><?end if?><?if dynamic_array?>	if($name != NULL) copy_$type($name, &(*array).array[(*array).size].$name);<?end if?>
<?end foreach?>
	(*array).size++;
}

/** \fn void remove_$name($name_array * array, int index)
 * \brief Remove an $name from a dynamic $name array.
 * \param array Pointer to the dynamic $name array.
 * \param index The index of the $name to remove.
 */
void remove_$name($name_array * array, int index)
{
	int i;

	/* Free element at index index */
	free_$name(&(*array).array[index]);

	/* Copy all elements up by one */
	if(index < (*array).size)
	{
		for(i = index; i < (*array).size - 1; i++)
		{
			copy_$name(&(*array).array[i+1], &(*array).array[i]);
		}
		(*array).size--;
	}
}
<?end foreach?>
/** \fn int idle()
 * \brief an idle function for use by agents.
 */
int idle()
{
	return 0;
}

<?foreach envvar?>$type FLAME_get_environment_variable_$name()
{
	return FLAME_environment_variable_$name;
}
<?end foreach?>
<?foreach xagent?><?foreach xagentvar?><?if constant?>$type FLAME_get_$agent_name_variable_$name()
{
	return current_xmachine_$agent_name->$name;
}
<?end if?><?end foreach?><?end foreach?>