M2 library

SUSUKITA, Ryutaro¹

The M2 library is used to access and manipulate the MDGRAPE-2 boards from C programs. The library can be linked with the parameters "-L/usr/local/lib -lm2"

Units
m2_allocate_unit
m2_allocate_periodic_unit
m2_free_unit
m2_get_num_pipelines
m2_set_host_function
m2_set_positions
m2_set_rscale
m2_set_rscales
m2_set_rscale_matrix
m2_set_charge
m2_set_charges
m2_set_charge_matrix
m2_set_types
m2_set_pipeline_types
m2_set_softening
m2_set_softenings
m2_set_softening_matrix
m2_set_pipeline_softenings
m2_set_particle_offset
m2_set_cells
m2_set_neighbor_radius
m2_set_neighbor_radii
m2_set_neighbor_radius_matrix
m2_set_pipeline_neighbor_radii
m2_calculate_forces
m2_calculate_potentials
m2_start_force_calculation
m2_start_potential_calculation
m2_wait_calculation
m2_get_neighbors

Groups
m2_allocate_group
m2_allocate_member
m2_allocate_periodic_member
m2_free_group
m2_get_num_group_pipelines
m2_set_member_positions
m2_wait_member_calculation

Units

A unit is a logical unit resources of one or more MDGRAPE-2 boards are allocated for. Units have all data necessary to use MDGRAPE-2. For units, M2 library provides the following functions and subroutines. The function names and constant names used for the functions and the subroutines are declared in 'm2_unit.h'.

• INTEGER FUNCTION M2_ALLOCATE_UNIT(FUNCTION, MODE, LOWER, UPPER, NUM_PIPELINES)

  CHARACTER*(*) FUNCTION
  INTEGER MODE
  DOUBLE PRECISION LOWER
  DOUBLE PRECISION UPPER
  INTEGER NUM_PIPELINES

  M2_ALLOCATE_UNIT allocates a unit. Resources which are not currently allocated for other units and groups (see section 2) are allocated.

  
  

  Table 1: Function tables and Fortran functions included in M2 library.

  function table

  Fortran function

  force or potential function

  grav.table

  M2_GRAV

  $-w^{-1.5}$

  gravpot.table

  M2_GRAVPOT

  $w^{-0.5}$

  lj.table

  M2_LJ

  $-2 w^{-7} + w^{-4}$	if $0.25 \leq w \leq 64$
  $0$	otherwise

  ljpot.table

  M2_LJPOT

  $w^{-6} - w^{-3}$	if $0.25 \leq w \leq 64$
  $0$	otherwise

  real.table

  M2_REAL

  $-(2 e^{-w} / (\sqrt{\pi} w) + {\rm erfc}(\sqrt{w}) w^{-1.5})$

  realpot.table

  M2_REALPOT

  ${\rm erfc}(\sqrt{w}) w^{-0.5}$

  
  

  FUNCTION specifies the function table which corresponds the force function or a potential function calculated by the unit. M2 library includes the function tables listed in Table 1.

  MODE must be M2_FORCE or M2_POTENTIAL if the function represents a force or a potential, respectively.

  LOWER and UPPER specify the range which includes coordinates of positions of particles which appear in the calculation of force or potential. LOWER and UPPER must be less and greater than all the coordinates, respectively. If the specified range is wider than it must be, the accuracy of the calculation may not be optimized.

  NUM_PIPELINES specifies the number of pipelines allocated for the unit.

  The environment variable M2_ON specifies a list of boards. The pipelines on only the boards are allowed to be allocated for the unit. M2_ON must be a list of board numbers or ranges of board numbers. The numbers or the ranges must be separated by ,. A range of $b_1$-$b_2$ is equivalent to $b_1$,...,$b_2$. If M2_ON is not set, all boards are allowed to be allocated.

  The environment variable M2_SIZE specifies the number of boards if NUM_PIPELINES is NULL_INTEGER. The pipelines on boards of the number are allocated for the unit. If M2_SIZE is not set, pipelines on all boards are allocated.

  The particle offset of the unit is set to 0.

  M2_ALLOCATE_UNIT returns a non-zero integer which points to the unit on success. It returns 0 on failure.

• INTEGER FUNCTION M2_ALLOCATE_PERIODIC_UNIT(FUNCTION, MODE, PERIOD, NUM_PIPELINES)

  CHARACTER*(*) FUNCTION
  INTEGER MODE
  DOUBLE PRECISION PERIOD
  INTEGER NUM_PIPELINES

  M2_ALLOCATE_PERIODIC_UNIT is similar to M2_ALLOCATE_UNIT except that PERIOD specifies the period of the unit.

• SUBROUTINE M2_FREE_UNIT(UNIT)

  INTEGER UNIT

  M2_FREE_UNIT frees the unit UNIT.

• INTEGER FUNCTION M2_GET_NUM_PIPELINES(UNIT)

  INTEGER UNIT

  M2_GET_NUM_PIPELINES returns the number of pipelines allocated for the unit UNIT.

• SUBROUTINE M2_SET_HOST_FUNCTION(UNIT, F)

  INTEGER UNIT
  DOUBLE PRECISION FUNCTION F(W)
  DOUBLE PRECISION W

  M2_SET_HOST_FUNCTION sets the Fortran function which corresponds to a force function or a potential function calculated by the unit UNIT to F. M2 library includes the Fortran functions listed in Table 1.

• SUBROUTINE M2_SET_POSITIONS(UNIT, RJ, N)

  INTEGER UNIT
  DOUBLE PRECISION RJ(3, N)
  INTEGER N

  M2_SET_POSITIONS sets the position of particle $j_0$, ..., the position of particle $j_0 + {\tt N} - 1$ of the unit UNIT to RJ, where $j_0$ is the particle offset of the unit. RJ(1, J), RJ(2, J) and RJ(3, J) specify the x, y and z coordinates of the position of particle $j_0 + {\tt J} - 1$, respectively. If M2_SET_CELLS was not called and the particle offset of the unit is 0, M2_SET_POSITIONS sets the number of the cells of the unit to 1 and the base and sets the number of the particles of cell 0 to 0 and N, respectively.

• SUBROUTINE M2_SET_RSCALE(UNIT, A)

  INTEGER UNIT
  DOUBLE PRECISION A

  M2_SET_RSCALE set the rscale of the unit UNIT to A. A must be 0 or positive.

• SUBROUTINE M2_SET_RSCALES(UNIT, AJ, N)

  INTEGER UNIT
  DOUBLE PRECISION AJ(N)
  INTEGER N

  M2_SET_RSCALES sets the rscale of particle $j_0$, ..., the rscale of particle $j_0 + {\tt N} - 1$ of the unit UNIT to AJ(1), ..., AJ(N), respectively, where $j_0$ is the particle offset of the unit. AJ(1), ..., AJ(N) must be 0 or positive. If any two of the charge, the softening and the neighbor radius of each particle of the unit were set, M2_SET_RSCALES fails.

• SUBROUTINE M2_SET_RSCALE_MATRIX(UNIT, ACICJ, NCI, NCJ)

  INTEGER UNIT
  DOUBLE PRECISION ACICJ(NCJ, NCI)
  INTEGER NCI
  INTEGER NCJ

  M2_SET_RSCALE_MATRIX sets the rscale matrix of the unit UNIT to an ${\tt NCI} \times {\tt NCJ}$ matrix whose component (${\tt I} - 1$, ${\tt J} - 1$) is specified by ACICJ(J, I). ACICJ(1, 1), ..., ACICJ(NCJ, 1), ..., ACICJ(1, NCI), ..., ACICJ(NCJ, NCI) must be 0 or positive. If any two of charge matrix, softening matrix and neighbor radius matrix of the unit were set, M2_SET_RSCALE_MATRIX fails.

• SUBROUTINE M2_SET_CHARGE(UNIT, B)

  INTEGER UNIT
  DOUBLE PRECISION B

  M2_SET_CHARGE set the charge of the unit UNIT to B.

• SUBROUTINE M2_SET_CHARGES(UNIT, BJ, N)

  INTEGER UNIT
  DOUBLE PRECISION BJ(N)
  INTEGER N

  M2_SET_CHARGES sets the charge of particle $j_0$, ..., the charge of particle $j_0 + {\tt N} - 1$ of the unit UNIT to BJ(1), ..., BJ(N), respectively, where $j_0$ is the particle offset of the unit. If any two of the rscale, the softening and the neighbor radius of each particle of the unit were set, M2_SET_CHARGES fails.

• SUBROUTINE M2_SET_CHARGE_MATRIX(UNIT, BCICJ, NCI, NCJ)

  INTEGER UNIT
  DOUBLE PRECISION BCICJ(NCJ, NCI)
  INTEGER NCI
  INTEGER NCJ

  M2_SET_CHARGE_MATRIX sets the charge matrix of the unit UNIT to an ${\tt NCI} \times {\tt NCJ}$ matrix whose component (${\tt I} - 1$, ${\tt J} - 1$) is specified by BCICJ(J, I). If any two of rscale matrix, softening matrix and neighbor radius matrix of the unit were set, M2_SET_CHARGE_MATRIX fails.

• SUBROUTINE M2_SET_TYPES(UNIT, CJ, N)

  INTEGER UNIT
  INTEGER CJ(N)
  INTEGER N

  M2_SET_TYPES sets the types of particle $j_0$, ..., the type of particle $j_0 + {\tt N} - 1$ of the unit UNIT to CJ(1), ..., CJ(N), respectively, where $j_0$ is the particle offset of the unit.

• SUBROUTINE M2_SET_PIPELINE_TYPES(UNIT, CI, N)

  INTEGER UNIT
  INTEGER CI(N)
  INTEGER N

  M2_SET_PIPELINE_TYPES sets the types of the particles on which forces are calculated by M2_CALCULATE_FORCES or whose potentials are calculated by M2_CALCULATE_POTENTIAL afterwards. UNIT specifies the unit. CI(1), ..., CI(N) specify the type of particle 0, ..., the type of particle ${\tt N} - 1$, respectively.

• SUBROUTINE M2_SET_SOFTENING(UNIT, E)

  INTEGER UNIT
  DOUBLE PRECISION E

  M2_SET_SOFTENING sets the softening of the unit UNIT to E.

• SUBROUTINE M2_SET_SOFTENINGS(UNIT, EJ, N)

  INTEGER UNIT
  DOUBLE PRECISION EJ(N)
  INTEGER N

  M2_SET_SOFTENINGS sets the softening of particle $j_0$, ..., the softening of particle $j_0 + {\tt N} - 1$ of the unit UNIT to EJ(1), ..., EJ(N), respectively, where $j_0$ is the particle offset of the unit. If any two of the rscale, the charge and the neighbor radius of each particle of the unit were set, M2_SET_SOFTENINGS fails.

• SUBROUTINE M2_SET_SOFTENING_MATRIX(UNIT, ECICJ, NCI, NCJ)

  INTEGER UNIT
  DOUBLE PRECISION ECICJ(NCJ, NCI)
  INTEGER NCI
  INTEGER NCJ

  M2_SET_SOFTENING_MATRIX sets the softening matrix of the unit UNIT to an ${\tt NCI} \times {\tt NCJ}$ matrix whose component (${\tt I} - 1$, ${\tt J} - 1$) is specified by ECICJ(J, I). If any two of rscale matrix, charge matrix and neighbor radius matrix of the unit were set, m2_set_softening_matrix fails.

• SUBROUTINE M2_SET_PIPELINE_SOFTENINGS(UNIT, EI, N)

  INTEGER UNIT
  INTEGER EI(N)
  INTEGER N

  M2_SET_PIPELINE_SOFTENINGS sets the softenings of the particles on which forces are calculated by M2_CALCULATE_FORCES or whose potentials are calculated by M2_CALCULATE_POTENTIAL afterwards. UNIT specifies the unit. EI(1), ..., EI(N) specify the softening of particle 0, ..., the softening of particle ${\tt N} - 1$, respectively.

• SUBROUTINE M2_SET_PARTICLE_OFFSET(UNIT, OFFSET)

  INTEGER UNIT
  INTEGER OFFSET

  M2_SET_PARTICLE_OFFSET sets the particle offset of the unit UNIT to OFFSET.

• SUBROUTINE M2_SET_CELLS(UNIT, BASES, SIZES, N)

  INTEGER UNIT
  INTEGER BASES(N)
  INTEGER SIZES(N)
  INTEGER N

  M2_SET_CELLS sets cell 0, ..., cell ${\tt N} - 1$ of the unit UNIT to BASES(1), SIZES(1), ..., BASES(N), SIZES(N), respectively. BASES(K) and SIZES(K) specify the base and the number of the particles of cell K, respectively.

• SUBROUTINE M2_SET_NEIGHBOR_RADIUS(UNIT, H)

  INTEGER UNIT
  DOUBLE PRECISION H

  M2_SET_NEIGHBOR_RADIUS sets the neighbor radius of the unit UNIT to H. H must be 0 or positive.

• SUBROUTINE M2_SET_NEIGHBOR_RADII(UNIT, HJ, N)

  INTEGER UNIT
  DOUBLE PRECISION HJ(N)
  INTEGER N

  M2_SET_NEIGHBOR_RADII sets the neighbor radius of particle $j_0$, ..., the neighbor radius of particle $j_0 + {\tt N} - 1$ of the unit UNIT to HJ(1), ..., HJ(N), respectively, where $j_0$ is the particle offset of the unit. HJ(1), ..., HJ(N) must be 0 or positive. If any two of the rscale, the charge and the softening of each particle of the unit were set, M2_SET_NEIGHBOR_RADII fails.

• SUBROUTINE M2_SET_NEIGHBOR_RADIUS_MATRIX(UNIT, HCICJ, NCI, NCJ)

  INTEGER UNIT
  DOUBLE PRECISION HCICJ(NCJ, NCI)
  INTEGER NCI
  INTEGER NCJ

  M2_SET_NEIGHBOR_RADIUS_MATRIX sets the neighbor radius matrix of the unit UNIT to an ${\tt NCI} \times {\tt NCJ}$ matrix whose component (${\tt I} - 1$, ${\tt J} - 1$) is specified by HCICJ(J, I). HCICJ(1, 1), ..., HCICJ(NCJ, 1), ..., HCICJ(1, NCI), ..., HCICJ(NCJ, NCI) must be 0 or positive. If any two of rscale matrix, charge matrix and softening matrix of the unit were set, M2_SET_NEIGHBOR_RADIUS_MATRIX fails.

• SUBROUTINE M2_SET_PIPELINE_NEIGHBOR_RADII(UNIT, HI, N)

  INTEGER UNIT
  INTEGER HI(N)
  INTEGER N

  M2_SET_PIPELINE_NEIGHBOR_RADII sets the neighbor radii of the particles on which forces are calculated by M2_CALCULATE_FORCES or whose potentials are calculated by M2_CALCULATE_POTENTIAL afterwards. UNIT specifies the unit. HI(1), ..., HI(N) specify the neighbor radius of particle 0, ..., the neighbor radius of particle ${\tt N} - 1$, respectively. HI(1), ..., HI(N) must be 0 or positive.

• SUBROUTINE M2_CALCULATE_FORCES(UNIT, RI, N, FI)

  INTEGER UNIT
  DOUBLE PRECISION RI(3, N)
  INTEGER N
  DOUBLE PRECISION FI(3, N)

  M2_CALCULATE_FORCES calculates the force exerted on each given particle and searches for neighbors of the particle.

  UNIT specifies the unit which calculates and searches.

  RI specifies the position of particle 0, ..., the position of particle ${\tt N} - 1$. RI(1, I), RI(2, I) and RI(3, I) specify the x, y and z coordinates of the position of particle ${\tt I} - 1$, respectively.

  The force exerted on the given particle $i$ is calculated as
  

  $$\mbox{\boldmath$f$}_i = \sum_{c = 0}^{N - 1} \: \sum_{j = j_{... ...r$}_{ij}\vert^2 + {\epsilon_{ij}}^2))\mbox{\boldmath$r$}_{ij},$$
  
  
  where terms with $r$$_{ij} = 0$ are excluded. These quantities represent as follows:

  $N$	the number of the cells
  $j_{0_c}$	the base of cell $c$
  $n_c$	the number of the particles of cell $c$
  $g(w)$	the force function

  If the unit was allocated by M2_ALLOCATE_UNIT,
  
  $$\mbox{\boldmath$r$}_{ij} = \mbox{\boldmath$r$}_j' - \mbox{\boldmath$r$}_i,$$
  
  
  where $\mbox{\boldmath$r$}_j'$ is the position of particle $j$ of the unit and $\mbox{\boldmath$r$}_i$ is the position of the given particle $i$. If the unit was allocated by M2_ALLOCATE_PERIODIC_UNIT,
  
  $$\mbox{\boldmath$r$}_{ij} = \mbox{\boldmath$r$}_j' - \mbox{\boldmath$r$}_i + (n_xl, \: n_yl, \: n_zl),$$
  
  
  where $l$ is the period of the unit and the integers $n_x$, $n_y$ and $n_z$ are chosen such that each coordinate of $r$$_{ij}$ is equal to or greater than $-l / 2$ and less than $l / 2$. If the rscale of the unit was set to $A$,
  
  $$a_{ij} = A.$$
  
  
  If the rscale of each particle $j$ of the unit was set to $A'_j$,
  
  $$a_{ij} = A'_j.$$
  
  
  If the rscale matrix of the unit was set to $\bf A''$, the type of each particle $j$ of the unit was set to $c_j$ and the type of each given particle $i$ was set to $c_i$,
  
  $$a_{ij} = A''_{c_ic_j}.$$
  
  
  Otherwise,
  
  $$a_{ij} = 1.$$
  
  
  The coefficient $b_{ij}$ is determined in a similar way to $a_{ij}$ except that $b_{ij}$ is determined from charge. If the softening of the unit was set to $E$,
  
  $$\epsilon_{ij} = E.$$
  
  
  If the softening of each particle $j$ of the unit was set to $E'_j$,
  
  $$\epsilon_{ij} = E'_j.$$
  
  
  If the softening matrix of the unit was set to $\bf E''$, the type of each particle $j$ of the unit was set to $c_j$ and the type of each given particle $i$ was set to $c_i$,
  
  $$\epsilon_{ij} = E''_{c_ic_j}.$$
  
  
  If the softening of each given particle $i$ was set to $E'''_i$,
  
  $$\epsilon_{ij} = E'''_i.$$
  
  
  Otherwise,
  
  $$\epsilon_{ij} = 0.$$
  
  

  As neighbors of the given particle $i$, particles of the unit which satisfy $\vert\mbox{\boldmath$r$}_{ij}\vert < h_{ij}$ are searched for, where the coefficient $h_{ij}$ is determined in a similar way to $\epsilon_{ij}$ except that $h_{ij}$ is determined from neighbor radius.

  FI returns $\mbox{\boldmath$f$}_0$, ..., $\mbox{\boldmath$f$}_{\tt {N} - 1}$. FI(1, I), FI(2, I) and FI(3, I) returns the x, y and z coordinate of $\mbox{\boldmath$f$}_{{\tt I} - 1}$, respectively.

• SUBROUTINE M2_CALCULATE_POTENTIALS(UNIT, RI, N, PI)

  INTEGERS UNIT
  DOUBLE PRECISION RI(3, N)
  INTEGERS N
  DOUBLE PRECISION PI(N)

  M2_CALCULATE_POTENTIALS is similar to M2_CALCULATE_FORCES except that the potential of each given particle is calculated. The potential of the given particle $i$ is calculated as
  

  $$\phi_i = \sum_{c = 0}^{N - 1} \: \sum_{j = j_{0_c}}^{j_{0_c} ... ...} (\vert\mbox{\boldmath$r$}_{ij}\vert^2 + {\epsilon_{ij}}^2)),$$
  
  
  where terms with $r$$_{ij} = 0$ are excluded. PI(1), ..., PI(N) returns $\phi_0$, ..., $\phi_{\tt {N} - 1}$, respectively.

• SUBROUTINE M2_START_FORCE_CALCULATION(UNIT, RI, N, FI)

  INTEGER UNIT
  DOUBLE PRECISION RI(3, N)
  INTEGER N
  DOUBLE PRECISION FI(3, N)

  M2_START_FORCE_CALCULATION is similar to M2_CALCULATE_FORCES except that FI returns the forces after M2_WAIT_CALCULATION is called for the unit UNIT and FI may not return the forces if any elements of RI is changed before m2_wait_calculation is called for the unit UNIT.

• SUBROUTINE M2_START_POTENTIAL_CALCULATION(UNIT, RI, N, PI)

  INTEGERS UNIT
  DOUBLE PRECISION RI(3, N)
  INTEGERS N
  DOUBLE PRECISION PI(N)

  M2_START_POTENTIAL_CALCULATION is similar to M2_CALCULATE_POTENTIALS except that PI returns the potentials after M2_WAIT_CALCULATION is called for the unit UNIT and PI may not return the potentials if any element of RI is changed before m2_wait_calculation is called for the unit UNIT.

• SUBROUTINE M2_WAIT_CALCULATION(UNIT)

  INTEGER UNIT

  See M2_START_FORCE_CALCULATION and M2_START_POTENTIAL_CALCULATION.

• SUBROUTINE M2_GET_NEIGHBORS(UNIT, NLI, N, L, NL)

  INTEGER UNIT
  INTEGER NLI(N)
  INTEGER N
  INTEGER L(NL)
  INTEGER NL

  M2_GET_NEIGHBORS is called to get the neighbors which were found by M2_CALCULATE_FORCES or M2_CALCULATE_POTENTIALS.

  UNIT specifies the unit which found the neighbors.

  NLI(1), ..., NLI(N) returns offsets in L to be referred to as follows: L(1), ..., L(NLI(1)) return the particle numbers of the neighbors of particle 0, respectively. ... L(NLI(N - 1) + 1), ..., L(NLI(N)) return the particle numbers of the neighbors of particle N - 1, respectively. If ${\tt NLI(J)} > {\tt NL}$, the particle numbers of the neighbors of particle ${\tt J} - 1$ are not returned.

Groups

A group is a group of units resources of one or more MDGRAPE-2 boards are allocated for. For groups, M2 library provides the following functions. The function names and constant names for the functions are declared in 'm2_group.h'.

• INTEGER FUNCTION M2_ALLOCATE_GROUP(NUM_PIPELINES)

  INTEGER NUM_PIPELINES

  M2_ALLOCATE_GROUP allocates a group which has no units. Pipelines which are not currently allocated for other unit groups and units are allocated. The number of allocated pipelines is determined in a similar way to M2_ALLOCATE_UNIT. M2_ALLOCATE_GROUP returns a non-zero integer which points to the group on success. It returns 0 on failure.

• INTEGER FUNCTION M2_ALLOCATE_MEMBER(GROUP, FUNCTION, MODE, LOWER, UPPER, NUM_PIPELINES, PRIVATE)

  INTEGER GROUP
  CHARACTER*(*) FUNCTION
  INTEGER MODE
  DOUBLE PRECISION LOWER
  DOUBLE PRECISION UPPER
  INTEGER NUM_PIPELINES
  INTEGER PRIVATE

  M2_ALLOCATE_MEMBER is similar to M2_ALLOCATE_UNIT except that the allocated unit becomes a member of the group GROUP and quantities of the unit PRIVATE does not specify may be shared. If a quantity is shared, a library function called to set the quantity of the unit also set the same quantities of other member units of the group. If a quantity is not shared, it is private. PRIVATE must be 0, NULL_INTEGER or the sum of one or more of the following flags:

  flag	quantity of unit
  M2_POSITIONS	positions of particles
  M2_RSCALE	rscale
  M2_RSCALES	rscales of particles
  M2_RSCALE_MATRIX	rscale matrix
  M2_CHARGE	charge
  M2_CHARGES	charges of particles
  M2_CHARGE_MATRIX	charge matrix
  M2_NEIGHBOR_RADIUS	neighbor radius
  M2_NEIGHBOR_RADII	neighbor radii of particles
  M2_NEIGHBOR_RADIUS_MATRIX	neighbor radius matrix
  M2_SOFTENING	softening
  M2_SOFTENINGS	softenings of particles
  M2_SOFTENING_MATRIX	softening matrix
  M2_TYPES	types of particles
  M2_CELLS	cells
  M2_PARTICLE_OFFSET	particle offset

  If PRIVATE is 0, no quantities are private. If PRIVATE is NULL_INTEGER, all quantities are private. If PRIVATE is the sum of one or more of these flags, the quantity which corresponds to each flag is private. If NUM_PIPELINES is too large or the number of the private quantities are larger than it must be, M2_ALLOCATE_MEMBER may fails.

• INTEGER FUNCTION M2_ALLOCATE_PERIODIC_MEMBER(GROUP, FUNCTION, MODE, PERIOD, NUM_PIPELINES, PRIVATE)

  INTEGER GROUP
  CHARACTER*(*) FUNCTION
  INTEGER MODE
  DOUBLE PRECISION PERIOD
  INTEGER NUM_PIPELINES
  INTEGER PRIVATE

  M2_ALLOCATE_PERIODIC_MEMBER is similar to M2_ALLOCATE_MEMBER except that PERIOD specifies the period of the unit.

• SUBROUTINE M2_FREE_GROUP(GROUP)

  INTEGER GROUP

  M2_FREE_GROUP frees all member units of the group GROUP and the group.

• INTEGER FUNCTION M2_GET_NUM_GROUP_PIPELINES(GROUP)

  INTEGER GROUP

  M2_GET_NUM_GROUP_PIPELINES returns the number of pipelines allocated for the group GROUP.

• SUBROUTINE M2_SET_MEMBER_POSITIONS(GROUP, RJ, N)

  INTEGER GROUP
  DOUBLE PRECISION RJ(3, N)
  INTEGER N

  M2_SET_MEMBER_POSITIONS is equivalent to calling M2_SET_POSITIONS for each member unit of the group GROUP.

• SUBROUTINE M2_WAIT_MEMBER_CALCULATION(GROUP)

  INTEGER GROUP

  M2_WAIT_MEMBER_CALCULATION is equivalent to calling M2_WAIT_CALCULATION for each member unit of the group GROUP.

About this document ...

M2 library

This document was generated using the LaTeX2HTML translator Version 99.2beta6 (1.42)

Copyright © 1993, 1994, 1995, 1996, Nikos Drakos, Computer Based Learning Unit, University of Leeds.
Copyright © 1997, 1998, 1999, Ross Moore, Mathematics Department, Macquarie University, Sydney.

The command line arguments were:
latex2html -split 0 fortran_document

The translation was initiated by on 2001-05-10

Footnotes

... Ryutaro¹

susukita@postman.riken.go.jp