java.lang.Object
- gov.nih.mipav.model.structures.Voro.voronoicell_base
- - gov.nih.mipav.model.structures.Voro.voronoicell_neighbor

Enclosing class:

Voro
```
class Voro.voronoicell_neighbor
extends Voro.voronoicell_base
```
\brief Extension of the voronoicell_base class to represent a Voronoi cell with neighbor information. This class is an extension of the voronoicell_base class, in cases when the IDs of neighboring particles associated with each face of the Voronoi cell. It contains additional data structures mne and ne for storing this information.

Field Summary

Fields
Modifier and Type Field Description

private int[] paux1ne

private int[] paux1nemne

private int[] paux2ne

private int[] paux2nemne
- Fields inherited from class gov.nih.mipav.model.structures.Voro.voronoicell_base
  big_tol, current_delete_size, current_delete2_size, current_vertex_order, current_vertices, current_xsearch_size, ed, edmep, mask, mec, mem, mep, mne, ne, nemne, nu, p, pts, q, stacke_index, stacke2_index, stacke3_index, stackp_index, stackp2_index, stackp3_index, tol, tol_cu, up

Constructor Summary

Constructors
Constructor	Description
`voronoicell_neighbor()`
`voronoicell_neighbor(double max_len_sq_)`
`voronoicell_neighbor(Voro.container_periodic_poly_radius_poly con)`
`voronoicell_neighbor(Voro.container_periodic_radius_mono con)`
`voronoicell_neighbor(Voro.container_poly_radius_poly con)`
`voronoicell_neighbor(Voro.container_radius_mono con)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`check_facets()`	This routine checks to make sure the neighbor information of each face is consistent.
`void`	`delete()`	The class destructor frees the dynamically allocated memory for storing neighbor information.
`void`	`init(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)`	This initializes the class to be a rectangular box.
`void`	`init_octahedron(double l)`	This initializes the class to be an octahedron.
`void`	`init_tetrahedron(double x0, double y0, double z0, double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3)`	This initializes the class to be a tetrahedron.
`private void`	`memory_setup()`	The class constructor allocates memory for storing neighbor information.
`private void`	`n_add_memory_vertices(int i)`
`private void`	`n_add_memory_vorder(int i)`
`private void`	`n_allocate(int i, int m)`
`private void`	`n_allocate_aux1(int i)`
`private void`	`n_copy(int a, int b, int c, int d)`
`private void`	`n_copy_aux1(int a, int b)`
`private void`	`n_copy_aux1_shift(int a, int b)`
`private void`	`n_copy_pointer(int a, int b)`
`private void`	`n_copy_to_aux1(int i, int m)`
`private void`	`n_set(int a, int b, int c)`
`private void`	`n_set_aux1(int k)`
`private void`	`n_set_aux2_copy(int a, int b)`
`private void`	`n_set_pointer(int p, int n)`
`private void`	`n_set_to_aux1(int j)`
`private void`	`n_set_to_aux1_offset(int k, int m)`
`private void`	`n_set_to_aux2(int j)`
`private void`	`n_switch_to_aux1(int i)`
`boolean`	`nplane(double x, double y, double z, double rsq, int p_id)`	Cuts the Voronoi cell by a particle whose center is at a separation of (x,y,z) from the cell center.
`boolean`	`nplane(double x, double y, double z, int p_id)`	This routine calculates the modulus squared of the vector before passing it to the main nplane() routine with full arguments.
`void`	`operatorEquals(Voro.voronoicell c)`
`void`	`operatorEquals(Voro.voronoicell_neighbor c)`	Copies the information from another voronoicell_neighbor class into this class, extending memory allocation if necessary.
`void`	`output_neighbors(java.io.RandomAccessFile raFile)`
`boolean`	`plane(double x, double y, double z)`	Cuts a Voronoi cell using the influence of a particle at (x,y,z), first calculating the modulus squared of this vector before passing it to the main nplane() routine.
`boolean`	`plane(double x, double y, double z, double rsq)`	This version of the plane routine just makes up the plane ID to be zero.
`void`	`print_edges_neighbors(int i)`	This prints out the neighbor information for vertex i.

Methods inherited from class gov.nih.mipav.model.structures.Voro.voronoicell_base
centroid, check_duplicates, check_memory_for_copy, check_memory_for_copy, check_relations, construct_relations, copy, cycle_down, cycle_up, draw_gnuplot, draw_gnuplot, draw_pov, draw_pov, draw_pov_mesh, draw_pov_mesh, edc, face_areas, face_freq_table, face_orders, face_perimeters, face_vertices, init_base, init_octahedron_base, init_tetrahedron_base, max_radius_squared, minkowski, neighbors, normals, nplane, nplane, number_of_edges, number_of_faces, output_custom, output_custom, output_face_areas, output_face_areas, output_face_freq_table, output_face_freq_table, output_face_orders, output_face_orders, output_face_perimeters, output_face_perimeters, output_face_vertices, output_face_vertices, output_normals, output_normals, output_solid_angles, output_vertex_orders, output_vertex_orders, output_vertices, output_vertices, output_vertices, plane_intersects, plane_intersects_guess, print_edges, reset_edges, solid_angles, surface_area, total_edge_distance, translate, vertex_orders, vertices, vertices, volume

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - paux1nemne
```
private int[] paux1nemne
```
  - paux1ne
```
private int[] paux1ne
```
  - paux2nemne
```
private int[] paux2nemne
```
  - paux2ne
```
private int[] paux2ne
```
- Constructor Detail
  - voronoicell_neighbor
```
public voronoicell_neighbor()
```
  - voronoicell_neighbor
```
public voronoicell_neighbor(double max_len_sq_)
```
  - voronoicell_neighbor
```
public voronoicell_neighbor(Voro.container_radius_mono con)
```
  - voronoicell_neighbor
```
public voronoicell_neighbor(Voro.container_periodic_radius_mono con)
```
  - voronoicell_neighbor
```
public voronoicell_neighbor(Voro.container_poly_radius_poly con)
```
  - voronoicell_neighbor
```
public voronoicell_neighbor(Voro.container_periodic_poly_radius_poly con)
```
- Method Detail
  - delete
```
public void delete()
```
    The class destructor frees the dynamically allocated memory for storing neighbor information.
    
    Overrides:
    
    delete in class Voro.voronoicell_base
  - operatorEquals
```
public void operatorEquals(Voro.voronoicell c)
```
  - operatorEquals
```
public void operatorEquals(Voro.voronoicell_neighbor c)
```
    Copies the information from another voronoicell_neighbor class into this class, extending memory allocation if necessary. \param[in] c the class to copy.
  - nplane
```
public boolean nplane(double x,
                      double y,
                      double z,
                      double rsq,
                      int p_id)
```
    Cuts the Voronoi cell by a particle whose center is at a separation of (x,y,z) from the cell center. The value of rsq should be initially set to \f$x^2+y^2+z^2\f$. \param[in] (x,y,z) the normal vector to the plane. \param[in] rsq the distance along this vector of the plane. \param[in] p_id the plane ID (for neighbor tracking only). \return False if the plane cut deleted the cell entirely, true otherwise.
  - nplane
```
public boolean nplane(double x,
                      double y,
                      double z,
                      int p_id)
```
    This routine calculates the modulus squared of the vector before passing it to the main nplane() routine with full arguments. \param[in] (x,y,z) the vector to cut the cell by. \param[in] p_id the plane ID (for neighbor tracking only). \return False if the plane cut deleted the cell entirely, true otherwise.
  - plane
```
public boolean plane(double x,
                     double y,
                     double z,
                     double rsq)
```
    This version of the plane routine just makes up the plane ID to be zero. It will only be referenced if neighbor tracking is enabled. \param[in] (x,y,z) the vector to cut the cell by. \param[in] rsq the modulus squared of the vector. \return False if the plane cut deleted the cell entirely, true otherwise.
  - plane
```
public boolean plane(double x,
                     double y,
                     double z)
```
    Cuts a Voronoi cell using the influence of a particle at (x,y,z), first calculating the modulus squared of this vector before passing it to the main nplane() routine. Zero is supplied as the plane ID, which will be ignored unless neighbor tracking is enabled. \param[in] (x,y,z) the vector to cut the cell by. \return False if the plane cut deleted the cell entirely, true otherwise.
  - init
```
public void init(double xmin,
                 double xmax,
                 double ymin,
                 double ymax,
                 double zmin,
                 double zmax)
```
    This initializes the class to be a rectangular box. It calls the base class initialization routine to set up the edge and vertex information, and then sets up the neighbor information, with initial faces being assigned ID numbers from -1 to -6. \param[in] (xmin,xmax) the minimum and maximum x coordinates. \param[in] (ymin,ymax) the minimum and maximum y coordinates. \param[in] (zmin,zmax) the minimum and maximum z coordinates.
  - init_octahedron
```
public void init_octahedron(double l)
```
    This initializes the class to be an octahedron. It calls the base class initialization routine to set up the edge and vertex information, and then sets up the neighbor information, with the initial faces being assigned ID numbers from -1 to -8. \param[in] l The distance from the octahedron center to a vertex. Six vertices are initialized at (-l,0,0), (l,0,0), (0,-l,0), (0,l,0), (0,0,-l), and (0,0,l).
  - init_tetrahedron
```
public void init_tetrahedron(double x0,
                             double y0,
                             double z0,
                             double x1,
                             double y1,
                             double z1,
                             double x2,
                             double y2,
                             double z2,
                             double x3,
                             double y3,
                             double z3)
```
    This initializes the class to be a tetrahedron. It calls the base class initialization routine to set up the edge and vertex information, and then sets up the neighbor information, with the initial faces being assigned ID numbers from -1 to -4. \param (x0,y0,z0) a position vector for the first vertex. \param (x1,y1,z1) a position vector for the second vertex. \param (x2,y2,z2) a position vector for the third vertex. \param (x3,y3,z3) a position vector for the fourth vertex.
  - check_facets
```
public void check_facets()
```
    This routine checks to make sure the neighbor information of each face is consistent.
  - print_edges_neighbors
```
public void print_edges_neighbors(int i)
```
    This prints out the neighbor information for vertex i.
  - output_neighbors
```
public void output_neighbors(java.io.RandomAccessFile raFile)
```
  - memory_setup
```
private void memory_setup()
```
    The class constructor allocates memory for storing neighbor information.
  - n_allocate
```
private void n_allocate(int i,
                        int m)
```
  - n_add_memory_vertices
```
private void n_add_memory_vertices(int i)
```
  - n_add_memory_vorder
```
private void n_add_memory_vorder(int i)
```
  - n_set_pointer
```
private void n_set_pointer(int p,
                           int n)
```
  - n_copy
```
private void n_copy(int a,
                    int b,
                    int c,
                    int d)
```
  - n_set
```
private void n_set(int a,
                   int b,
                   int c)
```
  - n_set_aux1
```
private void n_set_aux1(int k)
```
  - n_copy_aux1
```
private void n_copy_aux1(int a,
                         int b)
```
  - n_copy_aux1_shift
```
private void n_copy_aux1_shift(int a,
                               int b)
```
  - n_set_aux2_copy
```
private void n_set_aux2_copy(int a,
                             int b)
```
  - n_copy_pointer
```
private void n_copy_pointer(int a,
                            int b)
```
  - n_set_to_aux1
```
private void n_set_to_aux1(int j)
```
  - n_set_to_aux2
```
private void n_set_to_aux2(int j)
```
  - n_allocate_aux1
```
private void n_allocate_aux1(int i)
```
  - n_switch_to_aux1
```
private void n_switch_to_aux1(int i)
```
  - n_copy_to_aux1
```
private void n_copy_to_aux1(int i,
                            int m)
```
  - n_set_to_aux1_offset
```
private void n_set_to_aux1_offset(int k,
                                  int m)
```

Modifier and Type	Field	Description
`private int[]`	`paux1ne`
`private int[]`	`paux1nemne`
`private int[]`	`paux2ne`
`private int[]`	`paux2nemne`

Class Voro.voronoicell_neighbor

Field Summary

Fields inherited from class gov.nih.mipav.model.structures.Voro.voronoicell_base

Constructor Summary

Method Summary

Methods inherited from class gov.nih.mipav.model.structures.Voro.voronoicell_base

Methods inherited from class java.lang.Object

Field Detail

paux1nemne

paux1ne

paux2nemne

paux2ne

Constructor Detail

voronoicell_neighbor

voronoicell_neighbor

voronoicell_neighbor

voronoicell_neighbor

voronoicell_neighbor

voronoicell_neighbor

Method Detail

delete

operatorEquals

operatorEquals

nplane

nplane

plane

plane

init

init_octahedron

init_tetrahedron

check_facets

print_edges_neighbors

output_neighbors

memory_setup

n_allocate

n_add_memory_vertices

n_add_memory_vorder

n_set_pointer

n_copy

n_set

n_set_aux1

n_copy_aux1

n_copy_aux1_shift

n_set_aux2_copy

n_copy_pointer

n_set_to_aux1

n_set_to_aux2

n_allocate_aux1

n_switch_to_aux1

n_copy_to_aux1

n_set_to_aux1_offset