src/gromacs/gmxana/gmx_spol.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
   5  * Copyright (c) 2001-2004, The GROMACS development team.
   6  * Copyright (c) 2013,2014,2015, by the GROMACS development team, led by
   7  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   8  * and including many others, as listed in the AUTHORS file in the
   9  * top-level source directory and at http://www.gromacs.org.
  10  *
  11  * GROMACS is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public License
  13  * as published by the Free Software Foundation; either version 2.1
  14  * of the License, or (at your option) any later version.
  15  *
  16  * GROMACS is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with GROMACS; if not, see
  23  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  24  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  25  *
  26  * If you want to redistribute modifications to GROMACS, please
  27  * consider that scientific software is very special. Version
  28  * control is crucial - bugs must be traceable. We will be happy to
  29  * consider code for inclusion in the official distribution, but
  30  * derived work must not be called official GROMACS. Details are found
  31  * in the README & COPYING files - if they are missing, get the
  32  * official version at http://www.gromacs.org.
  33  *
  34  * To help us fund GROMACS development, we humbly ask that you cite
  35  * the research papers on the package. Check out http://www.gromacs.org.
  36  */
  37 #include "gmxpre.h"
  38
  39 #include <cmath>
  40
  41 #include "gromacs/commandline/pargs.h"
  42 #include "gromacs/fileio/tpxio.h"
  43 #include "gromacs/fileio/trxio.h"
  44 #include "gromacs/fileio/xvgr.h"
  45 #include "gromacs/gmxana/gmx_ana.h"
  46 #include "gromacs/gmxana/gstat.h"
  47 #include "gromacs/legacyheaders/macros.h"
  48 #include "gromacs/legacyheaders/viewit.h"
  49 #include "gromacs/math/units.h"
  50 #include "gromacs/math/vec.h"
  51 #include "gromacs/pbcutil/pbc.h"
  52 #include "gromacs/pbcutil/rmpbc.h"
  53 #include "gromacs/topology/index.h"
  54 #include "gromacs/utility/cstringutil.h"
  55 #include "gromacs/utility/fatalerror.h"
  56 #include "gromacs/utility/smalloc.h"
  57
  58 static void calc_com_pbc(int nrefat, t_topology *top, rvec x[], t_pbc *pbc,
  59                          atom_id index[], rvec xref, int ePBC)
  60 {
  61     const real tol = 1e-4;
  62     gmx_bool   bChanged;
  63     int        m, j, ai, iter;
  64     real       mass, mtot;
  65     rvec       dx, xtest;
  66
  67     /* First simple calculation */
  68     clear_rvec(xref);
  69     mtot = 0;
  70     for (m = 0; (m < nrefat); m++)
  71     {
  72         ai   = index[m];
  73         mass = top->atoms.atom[ai].m;
  74         for (j = 0; (j < DIM); j++)
  75         {
  76             xref[j] += mass*x[ai][j];
  77         }
  78         mtot += mass;
  79     }
  80     svmul(1/mtot, xref, xref);
  81     /* Now check if any atom is more than half the box from the COM */
  82     if (ePBC != epbcNONE)
  83     {
  84         iter = 0;
  85         do
  86         {
  87             bChanged = FALSE;
  88             for (m = 0; (m < nrefat); m++)
  89             {
  90                 ai   = index[m];
  91                 mass = top->atoms.atom[ai].m/mtot;
  92                 pbc_dx(pbc, x[ai], xref, dx);
  93                 rvec_add(xref, dx, xtest);
  94                 for (j = 0; (j < DIM); j++)
  95                 {
  96                     if (std::abs(xtest[j]-x[ai][j]) > tol)
  97                     {
  98                         /* Here we have used the wrong image for contributing to the COM */
  99                         xref[j] += mass*(xtest[j]-x[ai][j]);
 100                         x[ai][j] = xtest[j];
 101                         bChanged = TRUE;
 102                     }
 103                 }
 104             }
 105             if (bChanged)
 106             {
 107                 printf("COM: %8.3f  %8.3f  %8.3f  iter = %d\n", xref[XX], xref[YY], xref[ZZ], iter);
 108             }
 109             iter++;
 110         }
 111         while (bChanged);
 112     }
 113 }
 114
 115 void spol_atom2molindex(int *n, int *index, t_block *mols)
 116 {
 117     int nmol, i, j, m;
 118
 119     nmol = 0;
 120     i    = 0;
 121     while (i < *n)
 122     {
 123         m = 0;
 124         while (m < mols->nr && index[i] != mols->index[m])
 125         {
 126             m++;
 127         }
 128         if (m == mols->nr)
 129         {
 130             gmx_fatal(FARGS, "index[%d]=%d does not correspond to the first atom of a molecule", i+1, index[i]+1);
 131         }
 132         for (j = mols->index[m]; j < mols->index[m+1]; j++)
 133         {
 134             if (i >= *n || index[i] != j)
 135             {
 136                 gmx_fatal(FARGS, "The index group is not a set of whole molecules");
 137             }
 138             i++;
 139         }
 140         /* Modify the index in place */
 141         index[nmol++] = m;
 142     }
 143     printf("There are %d molecules in the selection\n", nmol);
 144
 145     *n = nmol;
 146 }
 147
 148 int gmx_spol(int argc, char *argv[])
 149 {
 150     t_topology  *top;
 151     t_inputrec  *ir;
 152     t_atom      *atom;
 153     t_trxstatus *status;
 154     int          nrefat, natoms, nf, ntot;
 155     real         t;
 156     rvec        *x, xref, trial, dx = {0}, dip, dir;
 157     matrix       box;
 158
 159     FILE        *fp;
 160     int         *isize, nrefgrp;
 161     atom_id    **index, *molindex;
 162     char       **grpname;
 163     real         rmin2, rmax2, rcut, rcut2, rdx2 = 0, rtry2, qav, q, dip2, invbw;
 164     int          nbin, i, m, mol, a0, a1, a, d;
 165     double       sdip, sdip2, sinp, sdinp, nmol;
 166     int         *hist;
 167     t_pbc        pbc;
 168     gmx_rmpbc_t  gpbc = NULL;
 169
 170
 171     const char     *desc[] = {
 172         "[THISMODULE] analyzes dipoles around a solute; it is especially useful",
 173         "for polarizable water. A group of reference atoms, or a center",
 174         "of mass reference (option [TT]-com[tt]) and a group of solvent",
 175         "atoms is required. The program splits the group of solvent atoms",
 176         "into molecules. For each solvent molecule the distance to the",
 177         "closest atom in reference group or to the COM is determined.",
 178         "A cumulative distribution of these distances is plotted.",
 179         "For each distance between [TT]-rmin[tt] and [TT]-rmax[tt]",
 180         "the inner product of the distance vector",
 181         "and the dipole of the solvent molecule is determined.",
 182         "For solvent molecules with net charge (ions), the net charge of the ion",
 183         "is subtracted evenly from all atoms in the selection of each ion.",
 184         "The average of these dipole components is printed.",
 185         "The same is done for the polarization, where the average dipole is",
 186         "subtracted from the instantaneous dipole. The magnitude of the average",
 187         "dipole is set with the option [TT]-dip[tt], the direction is defined",
 188         "by the vector from the first atom in the selected solvent group",
 189         "to the midpoint between the second and the third atom."
 190     };
 191
 192     output_env_t    oenv;
 193     static gmx_bool bCom   = FALSE;
 194     static int      srefat = 1;
 195     static real     rmin   = 0.0, rmax = 0.32, refdip = 0, bw = 0.01;
 196     t_pargs         pa[]   = {
 197         { "-com",  FALSE, etBOOL,  {&bCom},
 198           "Use the center of mass as the reference postion" },
 199         { "-refat",  FALSE, etINT, {&srefat},
 200           "The reference atom of the solvent molecule" },
 201         { "-rmin",  FALSE, etREAL, {&rmin}, "Maximum distance (nm)" },
 202         { "-rmax",  FALSE, etREAL, {&rmax}, "Maximum distance (nm)" },
 203         { "-dip",   FALSE, etREAL, {&refdip}, "The average dipole (D)" },
 204         { "-bw",    FALSE, etREAL, {&bw}, "The bin width" }
 205     };
 206
 207     t_filenm        fnm[] = {
 208         { efTRX, NULL,  NULL,  ffREAD },
 209         { efTPR, NULL,  NULL,  ffREAD },
 210         { efNDX, NULL,  NULL,  ffOPTRD },
 211         { efXVG, NULL,  "scdist",  ffWRITE }
 212     };
 213 #define NFILE asize(fnm)
 214
 215     if (!parse_common_args(&argc, argv, PCA_CAN_TIME | PCA_CAN_VIEW,
 216                            NFILE, fnm, asize(pa), pa, asize(desc), desc, 0, NULL, &oenv))
 217     {
 218         return 0;
 219     }
 220
 221     snew(top, 1);
 222     snew(ir, 1);
 223     read_tpx_top(ftp2fn(efTPR, NFILE, fnm),
 224                  ir, box, &natoms, NULL, NULL, NULL, top);
 225
 226     /* get index groups */
 227     printf("Select a group of reference particles and a solvent group:\n");
 228     snew(grpname, 2);
 229     snew(index, 2);
 230     snew(isize, 2);
 231     get_index(&top->atoms, ftp2fn_null(efNDX, NFILE, fnm), 2, isize, index, grpname);
 232
 233     if (bCom)
 234     {
 235         nrefgrp = 1;
 236         nrefat  = isize[0];
 237     }
 238     else
 239     {
 240         nrefgrp = isize[0];
 241         nrefat  = 1;
 242     }
 243
 244     spol_atom2molindex(&(isize[1]), index[1], &(top->mols));
 245     srefat--;
 246
 247     /* initialize reading trajectory:                         */
 248     natoms = read_first_x(oenv, &status, ftp2fn(efTRX, NFILE, fnm), &t, &x, box);
 249
 250     rcut  = 0.99*std::sqrt(max_cutoff2(ir->ePBC, box));
 251     if (rcut == 0)
 252     {
 253         rcut = 10*rmax;
 254     }
 255     rcut2 = sqr(rcut);
 256     invbw = 1/bw;
 257     nbin  = static_cast<int>(rcut*invbw)+2;
 258     snew(hist, nbin);
 259
 260     rmin2 = sqr(rmin);
 261     rmax2 = sqr(rmax);
 262
 263     nf    = 0;
 264     ntot  = 0;
 265     sdip  = 0;
 266     sdip2 = 0;
 267     sinp  = 0;
 268     sdinp = 0;
 269
 270     molindex = top->mols.index;
 271     atom     = top->atoms.atom;
 272
 273     gpbc = gmx_rmpbc_init(&top->idef, ir->ePBC, natoms);
 274
 275     /* start analysis of trajectory */
 276     do
 277     {
 278         /* make molecules whole again */
 279         gmx_rmpbc(gpbc, natoms, box, x);
 280
 281         set_pbc(&pbc, ir->ePBC, box);
 282         if (bCom)
 283         {
 284             calc_com_pbc(nrefat, top, x, &pbc, index[0], xref, ir->ePBC);
 285         }
 286
 287         for (m = 0; m < isize[1]; m++)
 288         {
 289             mol = index[1][m];
 290             a0  = molindex[mol];
 291             a1  = molindex[mol+1];
 292             for (i = 0; i < nrefgrp; i++)
 293             {
 294                 pbc_dx(&pbc, x[a0+srefat], bCom ? xref : x[index[0][i]], trial);
 295                 rtry2 = norm2(trial);
 296                 if (i == 0 || rtry2 < rdx2)
 297                 {
 298                     copy_rvec(trial, dx);
 299                     rdx2 = rtry2;
 300                 }
 301             }
 302             if (rdx2 < rcut2)
 303             {
 304                 hist[static_cast<int>(std::sqrt(rdx2)*invbw)+1]++;
 305             }
 306             if (rdx2 >= rmin2 && rdx2 < rmax2)
 307             {
 308                 unitv(dx, dx);
 309                 clear_rvec(dip);
 310                 qav = 0;
 311                 for (a = a0; a < a1; a++)
 312                 {
 313                     qav += atom[a].q;
 314                 }
 315                 qav /= (a1 - a0);
 316                 for (a = a0; a < a1; a++)
 317                 {
 318                     q = atom[a].q - qav;
 319                     for (d = 0; d < DIM; d++)
 320                     {
 321                         dip[d] += q*x[a][d];
 322                     }
 323                 }
 324                 for (d = 0; d < DIM; d++)
 325                 {
 326                     dir[d] = -x[a0][d];
 327                 }
 328                 for (a = a0+1; a < a0+3; a++)
 329                 {
 330                     for (d = 0; d < DIM; d++)
 331                     {
 332                         dir[d] += 0.5*x[a][d];
 333                     }
 334                 }
 335                 unitv(dir, dir);
 336
 337                 svmul(ENM2DEBYE, dip, dip);
 338                 dip2   = norm2(dip);
 339                 sdip  += std::sqrt(dip2);
 340                 sdip2 += dip2;
 341                 for (d = 0; d < DIM; d++)
 342                 {
 343                     sinp  += dx[d]*dip[d];
 344                     sdinp += dx[d]*(dip[d] - refdip*dir[d]);
 345                 }
 346
 347                 ntot++;
 348             }
 349         }
 350         nf++;
 351
 352     }
 353     while (read_next_x(oenv, status, &t, x, box));
 354
 355     gmx_rmpbc_done(gpbc);
 356
 357     /* clean up */
 358     sfree(x);
 359     close_trj(status);
 360
 361     fprintf(stderr, "Average number of molecules within %g nm is %.1f\n",
 362             rmax, static_cast<real>(ntot)/nf);
 363     if (ntot > 0)
 364     {
 365         sdip  /= ntot;
 366         sdip2 /= ntot;
 367         sinp  /= ntot;
 368         sdinp /= ntot;
 369         fprintf(stderr, "Average dipole:                               %f (D), std.dev. %f\n",
 370                 sdip, std::sqrt(sdip2-sqr(sdip)));
 371         fprintf(stderr, "Average radial component of the dipole:       %f (D)\n",
 372                 sinp);
 373         fprintf(stderr, "Average radial component of the polarization: %f (D)\n",
 374                 sdinp);
 375     }
 376
 377     fp = xvgropen(opt2fn("-o", NFILE, fnm),
 378                   "Cumulative solvent distribution", "r (nm)", "molecules", oenv);
 379     nmol = 0;
 380     for (i = 0; i <= nbin; i++)
 381     {
 382         nmol += hist[i];
 383         fprintf(fp, "%g %g\n", i*bw, nmol/nf);
 384     }
 385     xvgrclose(fp);
 386
 387     do_view(oenv, opt2fn("-o", NFILE, fnm), NULL);
 388
 389     return 0;
 390 }