File: gmx_parallel_3dfft.h

package info (click to toggle)
gromacs 3.3.1-4
  • links: PTS
  • area: main
  • in suites: etch, etch-m68k
  • size: 57,284 kB
  • ctags: 26,126
  • sloc: asm: 844,363; ansic: 231,461; sh: 15,665; makefile: 1,514; fortran: 1,362; csh: 715; python: 264; perl: 261
file content (141 lines) | stat: -rw-r--r-- 4,819 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/* -*- mode: c; tab-width: 4; indent-tabs-mode: n; c-basic-offset: 4 -*-
 *
 * $Id: gmx_parallel_3dfft.h,v 1.1.2.2 2005/09/30 13:15:51 lindahl Exp $
 *
 * Gromacs                               Copyright (c) 1991-2005
 * David van der Spoel, Erik Lindahl, University of Groningen.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * To help us fund GROMACS development, we humbly ask that you cite
 * the research papers on the package. Check out http://www.gromacs.org
 * 
 * And Hey:
 * Gnomes, ROck Monsters And Chili Sauce
 */

#ifndef _gmx_parallel_3dfft_h_
#define _gmx_parallel_3dfft_h_

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef GMX_MPI

#include "types/simple.h"
#include "gmxcomplex.h"
#include "gmx_fft.h"

/* We NEED MPI here. */
#include <mpi.h>

typedef struct gmx_parallel_3dfft *
gmx_parallel_3dfft_t;



/*! \brief Initialize parallel MPI-based 3D-FFT.
 *
 *  This routine performs real-to-complex and complex-to-real parallel 3D FFTs,
 *  but not complex-to-complex.
 *
 *  The routine is optimized for small-to-medium size FFTs used for PME and
 *  PPPM algorithms, and do allocate extra workspace whenever it might improve
 *  performance. 
 *
 *  \param pfft_setup  Pointer to parallel 3dfft setup structure, previously
 *                     allocated or with automatic storage.
 *  \param ngridx      Global number of grid cells in the x direction. Must be
 *                     divisible by the number of nodes.
 *  \param ngridy      Global number of grid cells in the y direction. Must be
 *                     divisible by the number of nodes.
 *  \param ngridz      Global number of grid cells in the z direction.
 *  \param comm        MPI communicator, must have been initialized. 
 *    
 *  \return 0 or a standard error code.
 */
int
gmx_parallel_3dfft_init   (gmx_parallel_3dfft_t *    pfft_setup,
                           int                       ngridx,
                           int                       ngridy,
                           int                       ngridz,
                           MPI_Comm                  comm);
                           




/*! \brief Get direct space grid index limits
 *
 *  The z dimension is never distributed. In the direct space, the x dimension
 *  is distributed over nodes, and after the real-to-complex FFT we work with
 *  a transposed grid where the y dimension is partitioned over nodes.
 *
 *  The order is determined from the rank in the communicator used at
 *  initialization.
 */
int
gmx_parallel_3dfft_limits(gmx_parallel_3dfft_t      pfft_setup,
                          int *                     local_x_start,
                          int *                     local_nx,
                          int *                     local_y_start,
                          int *                     local_ny);


int
gmx_parallel_transpose(t_complex *   data,
                       t_complex *   work,
                       int           nx,
                       int           ny,
                       int           local_x_start,
                       int           local_nx,
                       int           local_y_start,
                       int           local_ny,
                       int           nelem,
                       MPI_Comm      comm);


/*! \brief Perform forward parallel MPI FFT.
 *
 *  Direction is either GMX_FFT_REAL_TO_COMPLEX or GMX_FFT_COMPLEX_TO_REAL.
 *
 *  If input and output arrays are separate there is no packing to consider.
 *  Input is simply nx*ny*nz in real, and output ny*nx*nzc in complex.
 *
 *  In they are identical we need to make sure there is room for the complex
 *  (length nzc=nz/2+1) in the array, so the _real_ space dimensions is
 *  always padded to nzc*2.
 *  In this case, the real dimensions are nx*ny*(nzc*2) while the complex
 *  dimensions is ny*nx*nzc (of type complex).
 *
 *  Note that the X and Y dimensions are transposed in the reciprocal space
 *  to avoid extra communication!
 */
int
gmx_parallel_3dfft(gmx_parallel_3dfft_t    pfft_setup,
                   enum gmx_fft_direction  dir,
                   void *                  in_data,
                   void *                  out_data);



/*! \brief Release all data in parallel fft setup
 *
 *  All temporary storage and FFT plans are released. The structure itself
 *  is not released, but the contents is invalid after this call.
 *
 *  \param pfft_setup Parallel 3dfft setup.
 *
 *  \return 0 or a standard error code.
 */
int
gmx_parallel_3dfft_destroy(gmx_parallel_3dfft_t    pfft_setup);

#endif /* GMX_MPI */

#endif /* _gmx_parallel_3dfft_h_ */