/* header file for library 'libstokes'
* Copyright (C) 1993-2006 Kengo Ichiki <kichiki@users.sourceforge.net>
* $Id: libstokes.h,v 1.11 2006/10/19 04:32:17 ichiki Exp $
*
* 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef _LIBSTOKES_H_
#define _LIBSTOKES_H_
#include <stdio.h> // FILE
/***********************************
** system parameters **
***********************************/
struct stokes {
int np; /* number of all particles */
int nm; /* number of mobile particles */
double * pos; /* position of particles */
int version; /* 0 = F, 1 = FT, 2 = FTS */
/* imposed flow */
double Ui[3];
double Oi[3];
double Ei[5];
/* for ewald codes */
double rmax2;
int rmaxx, rmaxy, rmaxz; /* # of cell in real space */
double kmax;
int kmaxx, kmaxy, kmaxz; /* # of cell in reciprocal space */
double xi, xi2, xiaspi, xia2;
double pivol;
double lx, ly, lz;
double llx[27], lly[27], llz[27]; /* for regist and lub */
// self part
double self_a;
double self_c;
double self_m;
// table for lattice summation
int flag_table; // 0 = inactive, 1 = active
// real space
int nr; // number of lattice points
double * rlx;
double * rly;
double * rlz;
// reciprocal space
int nk; // number of lattice points
double * ex;
double * ey;
double * ez;
double * k;
double * k1;
double * k2;
double * k3;
double * ya;
double * yb;
double * yc;
double * yg;
double * yh;
double * ym;
/* for lubrication */
double lubcut;
/* for zeta program */
double cpu1, cpu2, cpu3;
/* for iterative solvers */
struct iter * it;
};
/* all elements are zero-cleared
*/
struct stokes *
stokes_init (void);
void
stokes_free (struct stokes * sys);
/* set np and nm and allocate the memory for pos[np*3]
*/
void
stokes_set_np (struct stokes * sys,
int np, int nm);
void
stokes_set_Ui (struct stokes * sys,
double uix, double uiy, double uiz);
void
stokes_set_Oi (struct stokes * sys,
double oix, double oiy, double oiz);
void
stokes_set_Ei (struct stokes * sys,
double eixx, double eixy, double eixz,
double eiyz, double eiyy);
void
stokes_set_l (struct stokes * sys,
double lx, double ly, double lz);
void
stokes_set_xi (struct stokes * sys,
double xi, double cutlim);
double
xi_by_tratio (struct stokes * sys,
double tratio);
/* set iter param
* INPUT
* solver : string indicating the solver
* sta, sta2, gpb, otmk, or gmres (default)
* eps and log10_eps
* max (and restart)
* debug = 0 : no debug info
* = 1 : iteration numbs and residue
* out : FILE * to output debug info.
*/
void
stokes_set_iter (struct stokes * sys,
const char * solver,
int max,
int restart,
double eps,
int debug,
FILE * out);
/* set pos safely by another array
* INPUT
* pos[np*3] :
*/
void
stokes_set_pos (struct stokes * sys,
const double * pos);
/************************************
** NetCDF interface for libstokes **
************************************/
struct stokes_nc {
int id;
int np; // only MOBILE particles here!!
int p_dim;
int p_id;
int npf; // number of fixed particles (stored separately)
int pf_dim;
int pf_id;
int nvec;
int vec_dim;
int vec_id;
int nstt;
int stt_dim;
int stt_id;
int time_dim;
int time_id;
int l_id;
int ui0_id;
int oi0_id;
int ei0_id;
int ui_id;
int oi_id;
int ei_id;
int x0_id;
int u0_id;
int o0_id;
int e0_id;
int f0_id;
int t0_id;
int s0_id;
int xf0_id;
int uf0_id;
int of0_id;
int ef0_id;
int ff0_id;
int tf0_id;
int sf0_id;
int x_id;
int u_id;
int o_id;
int e_id;
int f_id;
int t_id;
int s_id;
int xf_id;
int uf_id;
int of_id;
int ef_id;
int ff_id;
int tf_id;
int sf_id;
/* active/inactive flags : 0 = inactive
* 1 = active */
int flag_ui0;
int flag_oi0;
int flag_ei0;
int flag_ui;
int flag_oi;
int flag_ei;
int flag_x0;
int flag_u0;
int flag_o0;
int flag_e0;
int flag_f0;
int flag_t0;
int flag_s0;
int flag_xf0;
int flag_uf0;
int flag_of0;
int flag_ef0;
int flag_ff0;
int flag_tf0;
int flag_sf0;
int flag_x;
int flag_u;
int flag_o;
int flag_e;
int flag_f;
int flag_t;
int flag_s;
int flag_xf;
int flag_uf;
int flag_of;
int flag_ef;
int flag_ff;
int flag_tf;
int flag_sf;
};
void
stokes_nc_error (int status, const char * message, const char * varname);
void
stokes_nc_print_actives (struct stokes_nc * nc,
FILE * out);
/* initialize NetCDF file for libstokes for mob_F problem
* INPUT
* np : number of MOBILE particles
* OUTPUT
* (returned value) : ncid
* activated entries are, f0, x, u.
*/
struct stokes_nc *
stokes_nc_mob_f_init (const char * filename, int np);
/* initialize NetCDF file for libstokes for mob_FT problem
* INPUT
* np : number of MOBILE particles
* OUTPUT
* (returned value) : ncid
* activated entries are, f0, t0, x, u, o.
*/
struct stokes_nc *
stokes_nc_mob_ft_init (const char * filename, int np);
/* initialize NetCDF file for libstokes for mob_FTS problem
* INPUT
* np : number of MOBILE particles
* OUTPUT
* (returned value) : ncid
* activated entries are, f0, t0, e0, x, u, o, s.
*/
struct stokes_nc *
stokes_nc_mob_fts_init (const char * filename, int np);
/* initialize NetCDF file for libstokes for mob_fix_F problem
* with a constant imposed flow
* INPUT
* nm : number of MOBILE particles
* nf : number of fixed particles
* OUTPUT
* (returned value) : ncid
* activated entries are, ui0, xf0, f0, uf0, x, u, ff.
*/
struct stokes_nc *
stokes_nc_mob_fix_f_i0_init (const char * filename, int nm, int nf);
/* initialize NetCDF file for libstokes for mob_fix_FT problem
* with a constant imposed flow
* INPUT
* nm : number of MOBILE particles
* nf : number of fixed particles
* OUTPUT
* (returned value) : ncid
* activated entries are, ui0, oi0, xf0, f0, t0, uf0, of0, x, u, o, ff, tf.
*/
struct stokes_nc *
stokes_nc_mob_fix_ft_i0_init (const char * filename, int nm, int nf);
/* initialize NetCDF file for libstokes for mob_fix_FTS problem
* with a constant imposed flow
* INPUT
* nm : number of MOBILE particles
* nf : number of fixed particles
* OUTPUT
* (returned value) : ncid
* activated entries are, ui0, oi0, ei0,
* xf0, f0, t0, e0, uf0, of0, ef0,
* x, u, o, s, ff, tf, sf.
*/
struct stokes_nc *
stokes_nc_mob_fix_fts_i0_init (const char * filename, int nm, int nf);
/* initialize NetCDF file for libstokes for mob_fix_F problem
* with a time-changing imposed flow
* INPUT
* nm : number of MOBILE particles
* nf : number of fixed particles
* OUTPUT
* (returned value) : ncid
* activated entries are, ui, xf0, f0, uf0, x, u, ff.
*/
struct stokes_nc *
stokes_nc_mob_fix_f_it_init (const char * filename, int nm, int nf);
/* initialize NetCDF file for libstokes for mob_fix_FT problem
* with a time-changing imposed flow
* INPUT
* nm : number of MOBILE particles
* nf : number of fixed particles
* OUTPUT
* (returned value) : ncid
* activated entries are, ui, oi, xf0, f0, t0, uf0, of0, x, u, o, ff, tf.
*/
struct stokes_nc *
stokes_nc_mob_fix_ft_it_init (const char * filename, int nm, int nf);
/* initialize NetCDF file for libstokes for mob_fix_FTS problem
* with a time-changing imposed flow
* INPUT
* nm : number of MOBILE particles
* nf : number of fixed particles
* OUTPUT
* (returned value) : ncid
* activated entries are, ui, oi, ei,
* xf0, f0, t0, e0, uf0, of0, ef0,
* x, u, o, s, ff, tf, sf.
*/
struct stokes_nc *
stokes_nc_mob_fix_fts_it_init (const char * filename, int nm, int nf);
/* close (and write if necessary) NetCDF file for libstokes
*/
void
stokes_nc_free (struct stokes_nc * nc);
/** set nc data **/
/* set l = (lx, ly, lz)
*/
void
stokes_nc_set_l (struct stokes_nc * nc,
const double * l);
/* set ui
*/
void
stokes_nc_set_ui (struct stokes_nc * nc,
const double * ui);
/* set oi
*/
void
stokes_nc_set_oi (struct stokes_nc * nc,
const double * oi);
/* set ei
*/
void
stokes_nc_set_ei (struct stokes_nc * nc,
const double * ei);
/* set x0
*/
void
stokes_nc_set_x0 (struct stokes_nc * nc,
const double * x0);
/* set u0
*/
void
stokes_nc_set_u0 (struct stokes_nc * nc,
const double * u0);
/* set o0 data
*/
void
stokes_nc_set_o0 (struct stokes_nc * nc,
const double * o0);
/* set e0 data
*/
void
stokes_nc_set_e0 (struct stokes_nc * nc,
const double * e0);
/* set f0 data
*/
void
stokes_nc_set_f0 (struct stokes_nc * nc,
const double * f0);
/* set t0 data
*/
void
stokes_nc_set_t0 (struct stokes_nc * nc,
const double * t0);
/* set s0 data
*/
void
stokes_nc_set_s0 (struct stokes_nc * nc,
const double * s0);
/* set xf0
*/
void
stokes_nc_set_xf0 (struct stokes_nc * nc,
const double * xf0);
/* set uf0
*/
void
stokes_nc_set_uf0 (struct stokes_nc * nc,
const double * uf0);
/* set of0 data
*/
void
stokes_nc_set_of0 (struct stokes_nc * nc,
const double * of0);
/* set ef0 data
*/
void
stokes_nc_set_ef0 (struct stokes_nc * nc,
const double * ef0);
/* set ff0 data
*/
void
stokes_nc_set_ff0 (struct stokes_nc * nc,
const double * ff0);
/* set tf0 data
*/
void
stokes_nc_set_tf0 (struct stokes_nc * nc,
const double * tf0);
/* set sf0 data
*/
void
stokes_nc_set_sf0 (struct stokes_nc * nc,
const double * sf0);
/* set time (step)
*/
void
stokes_nc_set_time (struct stokes_nc * nc,
int step, double time);
/* set x at time (step)
*/
void
stokes_nc_set_x (struct stokes_nc * nc,
int step, double time,
const double * x);
/* set u at time (step)
*/
void
stokes_nc_set_u (struct stokes_nc * nc,
int step, double time,
const double * u);
/* set o at time (step)
*/
void
stokes_nc_set_o (struct stokes_nc * nc,
int step, double time,
const double * o);
/* set e at time (step)
*/
void
stokes_nc_set_e (struct stokes_nc * nc,
int step, double time,
const double * e);
/* set f at time (step)
*/
void
stokes_nc_set_f (struct stokes_nc * nc,
int step, double time,
const double * f);
/* set t at time (step)
*/
void
stokes_nc_set_t (struct stokes_nc * nc,
int step, double time,
const double * t);
/* set s at time (step)
*/
void
stokes_nc_set_s (struct stokes_nc * nc,
int step, double time,
const double * s);;
/* set xf at time (step)
*/
void
stokes_nc_set_xf (struct stokes_nc * nc,
int step, double time,
const double * xf);
/* set uf at time (step)
*/
void
stokes_nc_set_uf (struct stokes_nc * nc,
int step, double time,
const double * uf);
/* set of at time (step)
*/
void
stokes_nc_set_of (struct stokes_nc * nc,
int step, double time,
const double * of);
/* set ef at time (step)
*/
void
stokes_nc_set_ef (struct stokes_nc * nc,
int step, double time,
const double * ef);
/* set ff at time (step)
*/
void
stokes_nc_set_ff (struct stokes_nc * nc,
int step, double time,
const double * ff);
/* set tf at time (step)
*/
void
stokes_nc_set_tf (struct stokes_nc * nc,
int step, double time,
const double * tf);
/* set sf at time (step)
*/
void
stokes_nc_set_sf (struct stokes_nc * nc,
int step, double time,
const double * sf);
/* from stokes-nc-read.h
*/
void
stokes_nc_print_actives (struct stokes_nc * nc,
FILE * out);
struct stokes_nc *
stokes_nc_open (const char * filename);
void
stokes_nc_get_data0 (struct stokes_nc * nc,
const char * name,
double * x);
void
stokes_nc_get_data (struct stokes_nc * nc,
const char * name,
int step,
double * x);
/************************************
** Guile interface for libstokes **
************************************/
/* this utility function (original name is does_scm_symbol_exist)
* written by Michael Gran is taken from
* http://www.lonelycactus.com/guilebook/c319.html
*/
int
guile_check_symbol (const char *name);
/* check boolean
* INPUT
* var : string of the SCM variable
* OUTPUT
* true : if var is not nil
* false : if var is nil or even not defined
*/
int
guile_get_bool (const char * var);
/*
* INPUT
* var : string of the SCM variable
* i0 : default value (for the undefined case)
* OUTPUT
*/
int
guile_get_int (const char * var, int i0);
/*
* INPUT
* var : string of the SCM variable
* d0 : default value (for the undefined case)
* OUTPUT
*/
double
guile_get_double (const char * var, double d0);
/*
* OUTPUT
* returned value : 0 = failed (not defined)
* 1 = success
*/
int
guile_get_doubles (const char * var, int n, double * x);
/*
*/
char *
guile_get_string (const char * var);
/*
*/
FILE *
guile_open_file (const char * var, const char * mode);
/***********************************
** resistance problems **
***********************************/
/* solve natural resistance problem in F version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* OUTPUT
* f [np * 3] :
*/
void
solve_res_ewald_3f (struct stokes * sys,
const double *u,
double *f);
/* solve natural resistance problem with lubrication
* in F version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* OUTPUT
* f [np * 3] :
*/
void
solve_res_lub_ewald_3f (struct stokes * sys,
const double *u,
double *f);
/* solve natural resistance problem in F version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* OUTPUT
* f [np * 3] :
*/
void
solve_res_ewald_3f_matrix (struct stokes * sys,
const double *u,
double *f);
/* solve natural resistance problem in F version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* OUTPUT
* f [np * 3] :
*/
void
solve_res_lub_ewald_3f_matrix (struct stokes * sys,
const double *u,
double *f);
/* solve natural resistance problem in FT version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* o [np * 3] :
* OUTPUT
* f [np * 3] :
* t [np * 3] :
*/
void
solve_res_ewald_3ft (struct stokes * sys,
const double *u, const double *o,
double *f, double *t);
/* solve natural resistance problem with lubrication
* in FT version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* o [np * 3] :
* OUTPUT
* f [np * 3] :
* t [np * 3] :
*/
void
solve_res_lub_ewald_3ft (struct stokes * sys,
const double *u, const double *o,
double *f, double *t);
/* solve natural resistance problem in FT version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* o [np * 3] :
* OUTPUT
* f [np * 3] :
* t [np * 3] :
*/
void
solve_res_ewald_3ft_matrix (struct stokes * sys,
const double *u, const double *o,
double *f, double *t);
/* solve natural resistance problem in FT version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* o [np * 3] :
* OUTPUT
* f [np * 3] :
* t [np * 3] :
*/
void
solve_res_lub_ewald_3ft_matrix (struct stokes * sys,
const double *u, const double *o,
double *f, double *t);
/* solve natural resistance problem in FTS version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* o [np * 3] :
* e [np * 5] :
* OUTPUT
* f [np * 3] :
* t [np * 3] :
* s [np * 5] :
*/
void
solve_res_ewald_3fts (struct stokes * sys,
const double *u, const double *o, const double *e,
double *f, double *t, double *s);
/* solve natural resistance problem with lubrication
* in FTS version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* o [np * 3] :
* e [np * 5] :
* OUTPUT
* f [np * 3] :
* t [np * 3] :
* s [np * 5] :
*/
void
solve_res_lub_ewald_3fts (struct stokes * sys,
const double *u, const double *o, const double *e,
double *f, double *t, double *s);
/* solve natural resistance problem in FTS version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* o [np * 3] :
* e [np * 5] :
* OUTPUT
* f [np * 3] :
* t [np * 3] :
* s [np * 5] :
*/
void
solve_res_ewald_3fts_matrix (struct stokes * sys,
const double *u, const double *o, const double *e,
double *f, double *t, double *s);
/* solve natural resistance problem in FTS version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 3] :
* o [np * 3] :
* e [np * 5] :
* OUTPUT
* f [np * 3] :
* t [np * 3] :
* s [np * 5] :
*/
void
solve_res_lub_ewald_3fts_matrix (struct stokes * sys,
const double *u, const double *o,
const double *e,
double *f, double *t, double *s);
/* solve natural resistance problem in F version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* OUTPUT
* f [np * 3] : results are given in 3D form
*/
void
solve_res_ewald_2f (struct stokes * sys,
const double *u,
double *f);
/* solve natural resistance problem with lubrication
* in F version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* OUTPUT
* f [np * 3] : results are given in 3D form
*/
void
solve_res_lub_ewald_2f (struct stokes * sys,
const double *u,
double *f);
/* solve natural resistance problem in FT version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* o [np * 1] : o_z is given (and o_x = o_y = 0 is assumed)
* OUTPUT
* f [np * 3] : results are given in 3D form
* t [np * 3] :
*/
void
solve_res_ewald_2ft (struct stokes * sys,
const double *u, const double *o,
double *f, double *t);
/* solve natural resistance problem with lubrication
* in FT version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* o [np * 1] : o_z is given (and o_x = o_y = 0 is assumed)
* OUTPUT
* f [np * 3] : results are given in 3D form
* t [np * 3] :
*/
void
solve_res_lub_ewald_2ft (struct stokes * sys,
const double *u, const double *o,
double *f, double *t);
/* solve natural resistance problem in FTS version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* o [np * 1] : o_z is given (and o_x = o_y = 0 is assumed)
* e [np * 2] : e_xx, e_xy are given (e_?z = e_z? = 0 is assumed)
* OUTPUT
* f [np * 3] : results are given in 3D form
* t [np * 3] :
* s [np * 5] :
*/
void
solve_res_ewald_2fts (struct stokes * sys,
const double *u, const double *o, const double *e,
double *f, double *t, double *s);
/* solve natural resistance problem with lubrication
* in FTS version under Ewald sum
* INPUT
* sys : system parameters
* u [np * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* o [np * 1] : o_z is given (and o_x = o_y = 0 is assumed)
* e [np * 2] : e_xx, e_xy are given (e_?z = e_z? = 0 is assumed)
* OUTPUT
* f [np * 3] : results are given in 3D form
* t [np * 3] :
* s [np * 5] :
*/
void
solve_res_lub_ewald_2fts (struct stokes * sys,
const double *u, const double *o, const double *e,
double *f, double *t, double *s);
/***********************************
** mobility problems **
***********************************/
/* solve natural mobility problem in F version under Ewald sum
* INPUT
* sys : system parameters
* f [np * 3] :
* OUTPUT
* u [np * 3] :
*/
void
solve_mob_ewald_3f (struct stokes * sys,
const double *f,
double *u);
/* solve natural mobility problem in F version under Ewald sum
* INPUT
* sys : system parameters
* f [np * 3] :
* OUTPUT
* u [np * 3] :
*/
void
solve_mob_ewald_3f_matrix (struct stokes * sys,
const double *f,
double *u);
/* solve natural mobility problem in F version under Ewald sum
* INPUT
* sys : system parameters
* f [np * 3] :
* OUTPUT
* u [np * 3] :
*/
void
solve_mob_lub_ewald_3f_matrix (struct stokes * sys,
const double *f,
double *u);
/* solve natural mobility problem in FT version under Ewald sum
* INPUT
* sys : system parameters
* f [np * 3] :
* t [np * 3] :
* OUTPUT
* u [np * 3] :
* o [np * 3] :
*/
void
solve_mob_ewald_3ft (struct stokes * sys,
const double *f, const double *t,
double *u, double *o);
/* solve natural mobility problem in FT version under Ewald sum
* INPUT
* sys : system parameters
* f [np * 3] :
* t [np * 3] :
* OUTPUT
* u [np * 3] :
* o [np * 3] :
*/
void
solve_mob_ewald_3ft_matrix (struct stokes * sys,
const double *f, const double *t,
double *u, double *o);
/* solve natural mobility problem in FT version under Ewald sum
* INPUT
* sys : system parameters
* f [np * 3] :
* t [np * 3] :
* OUTPUT
* u [np * 3] :
* o [np * 3] :
*/
void
solve_mob_lub_ewald_3ft_matrix (struct stokes * sys,
const double *f, const double *t,
double *u, double *o);
/* solve natural mobility problem in FTS version under Ewald sum
* INPUT
* sys : system parameters
* f [np * 3] :
* t [np * 3] :
* e [np * 5] :
* OUTPUT
* u [np * 3] :
* o [np * 3] :
* s [np * 5] :
*/
void
solve_mob_ewald_3fts (struct stokes * sys,
const double *f, const double *t, const double *e,
double *u, double *o, double *s);
/* solve natural mobility problem in FTS version under Ewald sum
* INPUT
* sys : system parameters
* f [np * 3] :
* t [np * 3] :
* e [np * 5] :
* OUTPUT
* u [np * 3] :
* o [np * 3] :
* s [np * 5] :
*/
void
solve_mob_ewald_3fts_matrix (struct stokes * sys,
const double *f, const double *t, const double *e,
double *u, double *o, double *s);
/* solve natural mobility problem in FTS version under Ewald sum
* INPUT
* sys : system parameters
* f [np * 3] :
* t [np * 3] :
* e [np * 5] :
* OUTPUT
* u [np * 3] :
* o [np * 3] :
* s [np * 5] :
*/
void
solve_mob_lub_ewald_3fts_matrix (struct stokes * sys,
const double *f, const double *t,
const double *e,
double *u, double *o, double *s);
/* solve natural mobility problem in F version under Ewald sum
* sys : system parameters
* f [np * 2] : f_x, f_y are given (and f_z = 0 is assumed)
* OUTPUT
* u [np * 3] : results are given in 3D form
*/
void
solve_mob_ewald_2f (struct stokes * sys,
const double *f,
double *u);
/* solve natural mobility problem in FT version under Ewald sum
* sys : system parameters
* f [np * 2] : f_x, f_y are given (and f_z = 0 is assumed)
* t3 [np * 3] : OK, this is 3D form
* OUTPUT
* u [np * 3] : results are given in 3D form
* o [np * 3] :
*/
void
solve_mob_ewald_2ft (struct stokes * sys,
const double *f, const double *t3,
double *u, double *o);
/* solve natural mobility problem in FTS version under Ewald sum
* sys : system parameters
* f [np * 2] : f_x, f_y are given (and f_z = 0 is assumed)
* t3 [np * 3] : OK, this is 3D form
* e [np * 2] : e_xx, e_xy are given (e_?z = e_z? = 0 is assumed)
* OUTPUT
* u [np * 3] : results are given in 3D form
* o [np * 3] :
* s [np * 5] :
*/
void
solve_mob_ewald_2fts (struct stokes * sys,
const double *f, const double *t3, const double *e,
double *u, double *o, double *s);
/***********************************
** mixed problems **
***********************************/
/* solve natural mobility problem with fixed particles in F version
* under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* uf [nf * 3] :
* OUTPUT
* u [nm * 3] :
* ff [nf * 3] :
*/
void
solve_mix_ewald_3f (struct stokes * sys,
const double *f,
const double *uf,
double *u,
double *ff);
/* solve natural mobility problem with lubrication
* with fixed particles in F version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* uf [nf * 3] :
* OUTPUT
* u [nm * 3] :
* ff [nf * 3] :
*/
void
solve_mix_lub_ewald_3f (struct stokes * sys,
const double *f,
const double *uf,
double *u,
double *ff);
/* solve natural mobility problem with lubrication
* with fixed particles in FT version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* t [nm * 3] :
* uf [nf * 3] :
* of [nf * 3] :
* OUTPUT
* u [nm * 3] :
* o [nm * 3] :
* ff [nf * 3] :
* tf [nf * 3] :
*/
void
solve_mix_ewald_3f_matrix (struct stokes * sys,
const double *f, const double *uf,
double *u, double *ff);
/* solve natural mobility problem with lubrication
* with fixed particles in F version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* uf [nf * 3] :
* OUTPUT
* u [nm * 3] :
* ff [nf * 3] :
*/
void
solve_mix_lub_ewald_3f_matrix (struct stokes * sys,
const double *f, const double *uf,
double *u, double *ff);
/* solve natural mobility problem with fixed particles in FT version
* under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* t [nm * 3] :
* uf [nf * 3] :
* of [nf * 3] :
* OUTPUT
* u [nm * 3] :
* o [nm * 3] :
* ff [nf * 3] :
* tf [nf * 3] :
*/
void
solve_mix_ewald_3ft (struct stokes * sys,
const double *f, const double *t,
const double *uf, const double *of,
double *u, double *o,
double *ff, double *tf);
/* solve natural mobility problem with lubrication
* with fixed particles in FT version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* t [nm * 3] :
* uf [nf * 3] :
* of [nf * 3] :
* OUTPUT
* u [nm * 3] :
* o [nm * 3] :
* ff [nf * 3] :
* tf [nf * 3] :
*/
void
solve_mix_lub_ewald_3ft (struct stokes * sys,
const double *f, const double *t,
const double *uf, const double *of,
double *u, double *o,
double *ff, double *tf);
/* solve natural mobility problem with lubrication
* with fixed particles in FT version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* t [nm * 3] :
* uf [nf * 3] :
* of [nf * 3] :
* OUTPUT
* u [nm * 3] :
* o [nm * 3] :
* ff [nf * 3] :
* tf [nf * 3] :
*/
void
solve_mix_ewald_3ft_matrix (struct stokes * sys,
const double *f, const double *t,
const double *uf, const double *of,
double *u, double *o,
double *ff, double *tf);
/* solve natural mobility problem with lubrication
* with fixed particles in FT version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* t [nm * 3] :
* uf [nf * 3] :
* of [nf * 3] :
* OUTPUT
* u [nm * 3] :
* o [nm * 3] :
* ff [nf * 3] :
* tf [nf * 3] :
*/
void
solve_mix_lub_ewald_3ft_matrix (struct stokes * sys,
const double *f, const double *t,
const double *uf, const double *of,
double *u, double *o,
double *ff, double *tf);
/* solve natural mobility problem with fixed particles in FTS version
* under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* t [nm * 3] :
* e [nm * 5] :
* uf [nf * 3] :
* of [nf * 3] :
* ef [nf * 5] :
* OUTPUT
* u [nm * 3] :
* o [nm * 3] :
* s [nm * 5] :
* ff [nf * 3] :
* tf [nf * 3] :
* sf [nf * 5] :
*/
void
solve_mix_ewald_3fts (struct stokes * sys,
const double *f, const double *t, const double *e,
const double *uf, const double *of, const double *ef,
double *u, double *o, double *s,
double *ff, double *tf, double *sf);
/* solve natural mobility problem with lubrication
* with fixed particles in FTS version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* t [nm * 3] :
* e [nm * 5] :
* uf [nf * 3] :
* of [nf * 3] :
* ef [nf * 5] :
* OUTPUT
* u [nm * 3] :
* o [nm * 3] :
* s [nm * 5] :
* ff [nf * 3] :
* tf [nf * 3] :
* sf [nf * 5] :
*/
void
solve_mix_lub_ewald_3fts (struct stokes * sys,
const double *f, const double *t, const double *e,
const double *uf, const double *of,
const double *ef,
double *u, double *o, double *s,
double *ff, double *tf, double *sf);
/* solve natural mobility problem with lubrication
* with fixed particles in FTS version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* t [nm * 3] :
* e [nm * 5] :
* uf [nf * 3] :
* of [nf * 3] :
* ef [nf * 5] :
* OUTPUT
* u [nm * 3] :
* o [nm * 3] :
* s [nm * 5] :
* ff [nf * 3] :
* tf [nf * 3] :
* sf [nf * 5] :
*/
void
solve_mix_ewald_3fts_matrix (struct stokes * sys,
const double *f, const double *t,
const double *e,
const double *uf, const double *of,
const double *ef,
double *u, double *o, double *s,
double *ff, double *tf, double *sf);
/* solve natural mobility problem with lubrication
* with fixed particles in FTS version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 3] :
* t [nm * 3] :
* e [nm * 5] :
* uf [nf * 3] :
* of [nf * 3] :
* ef [nf * 5] :
* OUTPUT
* u [nm * 3] :
* o [nm * 3] :
* s [nm * 5] :
* ff [nf * 3] :
* tf [nf * 3] :
* sf [nf * 5] :
*/
void
solve_mix_lub_ewald_3fts_matrix (struct stokes * sys,
const double *f, const double *t,
const double *e,
const double *uf, const double *of,
const double *ef,
double *u, double *o, double *s,
double *ff, double *tf, double *sf);
/* solve natural mobility problem with fixed particles in F version
* under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 2] : f_x, f_y are given (and f_z = 0 is assumed)
* uf [nf * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* OUTPUT
* u [nm * 3] : results are given in 3D form
* ff [nf * 3] :
*/
void
solve_mix_ewald_2f (struct stokes * sys,
const double *f,
const double *uf,
double *u,
double *ff);
/* solve natural mobility problem with lubrication
* with fixed particles in F version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 2] : f_x, f_y are given (and f_z = 0 is assumed)
* uf [nf * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* OUTPUT
* u [nm * 3] : results are given in 3D form
* ff [nf * 3] :
*/
void
solve_mix_lub_ewald_2f (struct stokes * sys,
const double *f,
const double *uf,
double *u,
double *ff);
/* solve natural mobility problem with fixed particles in FT version
* under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 2] : f_x, f_y are given (and f_z = 0 is assumed)
* t3 [nm * 3] : OK, this is 3D form
* uf [nf * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* of [nf * 1] : o_z is given (and o_x = o_y = 0 is assumed)
* OUTPUT
* u [nm * 3] : results are given in 3D form
* o [nm * 3] :
* ff [nf * 3] :
* tf [nf * 3] :
*/
void
solve_mix_ewald_2ft (struct stokes * sys,
const double *f, const double *t3,
const double *uf, const double *of,
double *u, double *o,
double *ff, double *tf);
/* solve natural mobility problem with lubrication
* with fixed particles in FT version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 2] : f_x, f_y are given (and f_z = 0 is assumed)
* t3 [nm * 3] : OK, this is 3D form
* uf [nf * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* of [nf * 1] : o_z is given (and o_x = o_y = 0 is assumed)
* OUTPUT
* u [nm * 3] : results are given in 3D form
* o [nm * 3] :
* ff [nf * 3] :
* tf [nf * 3] :
*/
void
solve_mix_lub_ewald_2ft (struct stokes * sys,
const double *f, const double *t3,
const double *uf, const double *of,
double *u, double *o,
double *ff, double *tf);
/* solve natural mobility problem with fixed particles in FTS version
* under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 2] : f_x, f_y are given (and f_z = 0 is assumed)
* t3 [nm * 3] : OK, this is 3D form
* e [nm * 2] : e_xx, e_xy are given (e_?z = e_z? = 0 is assumed)
* uf [nf * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* of [nf * 1] : o_z is given (and o_x = o_y = 0 is assumed)
* ef [nf * 2] : e_xx, e_xy are given (e_?z = e_z? = 0 is assumed)
* OUTPUT
* u [nm * 3] : results are given in 3D form
* o [nm * 3] :
* s [nm * 5] :
* ff [nf * 3] :
* tf [nf * 3] :
* sf [nf * 5] :
*/
void
solve_mix_ewald_2fts (struct stokes * sys,
const double *f, const double *t3, const double *e,
const double *uf, const double *of, const double *ef,
double *u, double *o, double *s,
double *ff, double *tf, double *sf);
/* solve natural mobility problem with lubrication
* with fixed particles in FTS version under Ewald sum
* INPUT
* sys : system parameters
* f [nm * 2] : f_x, f_y are given (and f_z = 0 is assumed)
* t3 [nm * 3] : OK, this is 3D form
* e [nm * 2] : e_xx, e_xy are given (e_?z = e_z? = 0 is assumed)
* uf [nf * 2] : u_x, u_y are given (and u_z = 0 is assumed)
* of [nf * 1] : o_z is given (and o_x = o_y = 0 is assumed)
* ef [nf * 2] : e_xx, e_xy are given (e_?z = e_z? = 0 is assumed)
* OUTPUT
* u [nm * 3] : results are given in 3D form
* o [nm * 3] :
* s [nm * 5] :
* ff [nf * 3] :
* tf [nf * 3] :
* sf [nf * 5] :
*/
void
solve_mix_lub_ewald_2fts (struct stokes * sys,
const double *f, const double *t3,
const double *e,
const double *uf, const double *of,
const double *ef,
double *u, double *o, double *s,
double *ff, double *tf, double *sf);
/************************************************
** atimes forms (unnatural mobility problems) **
************************************************/
/** table version **/
/* ATIMES of calc ewald-summed mobility for F/FT/FTS versions
* with the ewald table
* INPUT
* n := np*3 (F), np*6 (FT), or np*11 (FTS)
* x [n] : F, FT, or FTS
* user_data = (struct stokes *) sys
* OUTPUT
* y [n] : U, UO, or UOE
*/
void
atimes_ewald_3all (int n, const double *x, double *y, void * user_data);
/* make ewald-summed mobility matrix for F/FT/FTS versions
* with the ewald table
* INPUT
* sys : system parameters
* OUTPUT
* mat [np * 3 * np * 3 ] : for F version
* mat [np * 6 * np * 6 ] : for FT version
* mat [np * 11 * np * 11] : for FTS version
*/
void
make_matrix_mob_ewald_3all (struct stokes * sys, double * mat);
/* ATIMES of calc ewald-summed mobility for F/FT/FTS versions
* through matrix with the ewald table
* INPUT
* n := np*3 (F), np*6 (FT), or np*11 (FTS)
* x [n] : F, FT, or FTS
* user_data = (struct stokes *) sys
* OUTPUT
* y [n] : U, UO, or UOE
*/
void
atimes_ewald_3all_matrix (int n, const double *x,
double *y, void * user_data);
/** non-table version **/
/* ATIMES of calc ewald-summed mobility for F/FT/FTS versions
* INPUT
* n := np*3 (F), np*6 (FT), or np*11 (FTS)
* x [n] : F, FT, or FTS
* user_data = (struct stokes *) sys
* OUTPUT
* y [n] : U, UO, or UOE
*/
void
atimes_ewald_3all_notbl (int n, const double *x,
double *y, void * user_data);
/* make ewald-summed mobility matrix for F/FT/FTS versions
* INPUT
* sys : system parameters
* OUTPUT
* mat [np * 3 * np * 3 ] : for F version
* mat [np * 6 * np * 6 ] : for FT version
* mat [np * 11 * np * 11] : for FTS version
*/
void
make_matrix_mob_ewald_3all_notbl (struct stokes * sys, double * mat);
/* ATIMES of calc ewald-summed mobility for F/FT/FTS versions
* through matrix
* INPUT
* n := np*3 (F), np*6 (FT), or np*11 (FTS)
* x [n] : F, FT, or FTS
* user_data = (struct stokes *) sys
* OUTPUT
* y [n] : U, UO, or UOE
*/
void
atimes_ewald_3all_matrix_notbl (int n, const double *x,
double *y, void * user_data);
#endif /* !_LIBSTOKES_H_ */
syntax highlighted by Code2HTML, v. 0.9.1