2 * This file is part of the GROMACS molecular simulation package.
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,2016,2017 by the GROMACS development team.
7 * Copyright (c) 2018,2019,2020, by the GROMACS development team, led by
8 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
9 * and including many others, as listed in the AUTHORS file in the
10 * top-level source directory and at http://www.gromacs.org.
12 * GROMACS is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public License
14 * as published by the Free Software Foundation; either version 2.1
15 * of the License, or (at your option) any later version.
17 * GROMACS is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with GROMACS; if not, see
24 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
25 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
27 * If you want to redistribute modifications to GROMACS, please
28 * consider that scientific software is very special. Version
29 * control is crucial - bugs must be traceable. We will be happy to
30 * consider code for inclusion in the official distribution, but
31 * derived work must not be called official GROMACS. Details are found
32 * in the README & COPYING files - if they are missing, get the
33 * official version at http://www.gromacs.org.
35 * To help us fund GROMACS development, we humbly ask that you cite
36 * the research papers on the package. Check out http://www.gromacs.org.
38 /* This file is completely threadsafe - keep it that way! */
51 #include "gromacs/gmxlib/network.h"
52 #include "gromacs/math/functions.h"
53 #include "gromacs/math/vec.h"
54 #include "gromacs/mdrunutility/multisim.h"
55 #include "gromacs/mdtypes/commrec.h"
56 #include "gromacs/mdtypes/fcdata.h"
57 #include "gromacs/mdtypes/inputrec.h"
58 #include "gromacs/mdtypes/md_enums.h"
59 #include "gromacs/mdtypes/state.h"
60 #include "gromacs/pbcutil/ishift.h"
61 #include "gromacs/pbcutil/pbc.h"
62 #include "gromacs/topology/mtop_util.h"
63 #include "gromacs/topology/topology.h"
64 #include "gromacs/utility/fatalerror.h"
65 #include "gromacs/utility/futil.h"
66 #include "gromacs/utility/gmxassert.h"
67 #include "gromacs/utility/pleasecite.h"
68 #include "gromacs/utility/smalloc.h"
70 void init_disres(FILE* fplog
,
71 const gmx_mtop_t
* mtop
,
73 DisResRunMode disResRunMode
,
76 MPI_Comm communicator
,
77 const gmx_multisim_t
* ms
,
82 int fa
, nmol
, npair
, np
;
84 gmx_mtop_ilistloop_t iloop
;
86 int type_min
, type_max
;
88 if (gmx_mtop_ftype_count(mtop
, F_DISRES
) == 0)
97 fprintf(fplog
, "Initializing the distance restraints\n");
100 dd
->dr_weighting
= ir
->eDisreWeighting
;
101 dd
->dr_fc
= ir
->dr_fc
;
102 if (EI_DYNAMICS(ir
->eI
))
104 dd
->dr_tau
= ir
->dr_tau
;
110 if (dd
->dr_tau
== 0.0)
112 dd
->dr_bMixed
= FALSE
;
117 /* We store the r^-6 time averages in an array that is indexed
118 * with the local disres iatom index, so this doesn't work with DD.
119 * Note that DD is not initialized yet here, so we check that we are on multiple ranks,
120 * but there are probably also issues with e.g. NM MPI parallelization.
122 if ((disResRunMode
== DisResRunMode::MDRun
) && (numRanks
== NumRanks::Multiple
))
125 "Time-averaged distance restraints are not supported with MPI "
126 "parallelization. You can use OpenMP parallelization on a single node.");
129 dd
->dr_bMixed
= ir
->bDisreMixed
;
130 dd
->ETerm
= std::exp(-(ir
->delta_t
/ ir
->dr_tau
));
132 dd
->ETerm1
= 1.0 - dd
->ETerm
;
138 iloop
= gmx_mtop_ilistloop_init(mtop
);
139 while (const InteractionLists
* il
= gmx_mtop_ilistloop_next(iloop
, &nmol
))
141 if (nmol
> 1 && !(*il
)[F_DISRES
].empty() && ir
->eDisre
!= edrEnsemble
)
144 "NMR distance restraints with multiple copies of the same molecule are "
145 "currently only supported with ensemble averaging. If you just want to "
146 "restrain distances between atom pairs using a flat-bottomed potential, use "
147 "a restraint potential (bonds type 10) instead.");
151 for (fa
= 0; fa
< (*il
)[F_DISRES
].size(); fa
+= 3)
155 type
= (*il
)[F_DISRES
].iatoms
[fa
];
158 npair
= mtop
->ffparams
.iparams
[type
].disres
.npair
;
161 dd
->nres
+= (ir
->eDisre
== edrEnsemble
? 1 : nmol
);
162 dd
->npair
+= nmol
* npair
;
165 type_min
= std::min(type_min
, type
);
166 type_max
= std::max(type_max
, type
);
171 if ((disResRunMode
== DisResRunMode::MDRun
) && (numRanks
== NumRanks::Multiple
) && ir
->nstdisreout
> 0)
173 /* With DD we currently only have local pair information available */
175 "With MPI parallelization distance-restraint pair output is not supported. Use "
176 "nstdisreout=0 or use OpenMP parallelization on a single node.");
179 /* For communicating and/or reducing (sums of) r^-6 for pairs over threads
180 * we use multiple arrays in t_disresdata. We need to have unique indices
181 * for each restraint that work over threads and MPI ranks. To this end
182 * we use the type index. These should all be in one block and there should
183 * be dd->nres types, but we check for this here.
184 * This setup currently does not allow for multiple copies of the same
185 * molecule without ensemble averaging, this is check for above.
188 type_max
- type_min
+ 1 == dd
->nres
,
189 "All distance restraint parameter entries in the topology should be consecutive");
191 dd
->type_min
= type_min
;
193 snew(dd
->rt
, dd
->npair
);
195 if (dd
->dr_tau
!= 0.0)
197 GMX_RELEASE_ASSERT(state
!= nullptr,
198 "We need a valid state when using time-averaged distance restraints");
201 /* Set the "history lack" factor to 1 */
202 state
->flags
|= (1 << estDISRE_INITF
);
203 hist
->disre_initf
= 1.0;
204 /* Allocate space for the r^-3 time averages */
205 state
->flags
|= (1 << estDISRE_RM3TAV
);
206 hist
->ndisrepairs
= dd
->npair
;
207 snew(hist
->disre_rm3tav
, hist
->ndisrepairs
);
209 /* Allocate space for a copy of rm3tav,
210 * so we can call do_force without modifying the state.
212 snew(dd
->rm3tav
, dd
->npair
);
214 /* Allocate Rt_6 and Rtav_6 consecutively in memory so they can be
215 * averaged over the processors in one call (in calc_disre_R_6)
217 snew(dd
->Rt_6
, 2 * dd
->nres
);
218 dd
->Rtav_6
= &(dd
->Rt_6
[dd
->nres
]);
220 ptr
= getenv("GMX_DISRE_ENSEMBLE_SIZE");
221 if ((disResRunMode
== DisResRunMode::MDRun
) && ms
!= nullptr && ptr
!= nullptr && !bIsREMD
)
225 sscanf(ptr
, "%d", &dd
->nsystems
);
228 fprintf(fplog
, "Found GMX_DISRE_ENSEMBLE_SIZE set to %d systems per ensemble\n", dd
->nsystems
);
230 /* This check is only valid on MASTER(cr), so probably
231 * ensemble-averaged distance restraints are broken on more
232 * than one processor per simulation system. */
233 if (ddRole
== DDRole::Master
)
235 check_multi_int(fplog
, ms
, dd
->nsystems
, "the number of systems per ensemble", FALSE
);
237 gmx_bcast(sizeof(int), &dd
->nsystems
, communicator
);
239 /* We use to allow any value of nsystems which was a divisor
240 * of ms->numSimulations_. But this required an extra communicator which
241 * pulled in mpi.h in nearly all C files.
243 if (!(ms
->numSimulations_
== 1 || ms
->numSimulations_
== dd
->nsystems
))
246 "GMX_DISRE_ENSEMBLE_SIZE (%d) is not equal to 1 or the number of systems "
247 "(option -multidir) %d",
248 dd
->nsystems
, ms
->numSimulations_
);
252 fprintf(fplog
, "Our ensemble consists of systems:");
253 for (int i
= 0; i
< dd
->nsystems
; i
++)
255 fprintf(fplog
, " %d", (ms
->simulationIndex_
/ dd
->nsystems
) * dd
->nsystems
+ i
);
257 fprintf(fplog
, "\n");
260 GMX_UNUSED_VALUE(communicator
);
268 if (dd
->nsystems
== 1)
270 dd
->Rtl_6
= dd
->Rt_6
;
274 snew(dd
->Rtl_6
, dd
->nres
);
281 fprintf(fplog
, "There are %d distance restraints involving %d atom pairs\n", dd
->nres
,
284 /* Have to avoid g_disre de-referencing cr blindly, mdrun not
285 * doing consistency checks for ensemble-averaged distance
286 * restraints when that's not happening, and only doing those
287 * checks from appropriate processes (since check_multi_int is
288 * too broken to check whether the communication will
290 if ((disResRunMode
== DisResRunMode::MDRun
) && ms
&& dd
->nsystems
> 1 && (ddRole
== DDRole::Master
))
292 check_multi_int(fplog
, ms
, dd
->nres
, "the number of distance restraints", FALSE
);
294 please_cite(fplog
, "Tropp80a");
295 please_cite(fplog
, "Torda89a");
299 void calc_disres_R_6(const t_commrec
* cr
,
300 const gmx_multisim_t
* ms
,
302 const t_iatom forceatoms
[],
309 real
* rt
, *rm3tav
, *Rtl_6
, *Rt_6
, *Rtav_6
;
310 real ETerm
, ETerm1
, cf1
= 0, cf2
= 0;
313 bTav
= (dd
->dr_tau
!= 0);
324 /* scaling factor to smoothly turn on the restraint forces *
325 * when using time averaging */
326 dd
->exp_min_t_tau
= hist
->disre_initf
* ETerm
;
328 cf1
= dd
->exp_min_t_tau
;
329 cf2
= 1.0 / (1.0 - dd
->exp_min_t_tau
);
332 for (int res
= 0; res
< dd
->nres
; res
++)
338 /* 'loop' over all atom pairs (pair_nr=fa/3) involved in restraints, *
339 * the total number of atoms pairs is nfa/3 */
340 for (int fa
= 0; fa
< nfa
; fa
+= 3)
342 int type
= forceatoms
[fa
];
343 int res
= type
- dd
->type_min
;
345 int ai
= forceatoms
[fa
+ 1];
346 int aj
= forceatoms
[fa
+ 2];
350 pbc_dx_aiuc(pbc
, x
[ai
], x
[aj
], dx
);
354 rvec_sub(x
[ai
], x
[aj
], dx
);
356 real rt2
= iprod(dx
, dx
);
357 real rt_1
= gmx::invsqrt(rt2
);
358 real rt_3
= rt_1
* rt_1
* rt_1
;
360 rt
[pair
] = rt2
* rt_1
;
363 /* Here we update rm3tav in t_disresdata using the data
365 * Thus the results stay correct when this routine
366 * is called multiple times.
368 rm3tav
[pair
] = cf2
* ((ETerm
- cf1
) * hist
->disre_rm3tav
[pair
] + ETerm1
* rt_3
);
375 /* Currently divide_bondeds_over_threads() ensures that pairs within
376 * the same restraint get assigned to the same thread, so we could
377 * run this loop thread-parallel.
379 Rt_6
[res
] += rt_3
* rt_3
;
380 Rtav_6
[res
] += rm3tav
[pair
] * rm3tav
[pair
];
383 /* NOTE: Rt_6 and Rtav_6 are stored consecutively in memory */
384 if (cr
&& DOMAINDECOMP(cr
))
386 gmx_sum(2 * dd
->nres
, dd
->Rt_6
, cr
);
389 if (dd
->nsystems
> 1)
391 real invn
= 1.0 / dd
->nsystems
;
393 for (int res
= 0; res
< dd
->nres
; res
++)
395 Rtl_6
[res
] = Rt_6
[res
];
400 GMX_ASSERT(cr
!= nullptr && ms
!= nullptr, "We need multisim with nsystems>1");
401 gmx_sum_sim(2 * dd
->nres
, dd
->Rt_6
, ms
);
403 if (DOMAINDECOMP(cr
))
405 gmx_bcast(2 * dd
->nres
, dd
->Rt_6
, cr
->mpi_comm_mygroup
);
409 /* Store the base forceatoms pointer, so we can re-calculate the pair
410 * index in ta_disres() for indexing pair data in t_disresdata when
411 * using thread parallelization.
413 dd
->forceatomsStart
= forceatoms
;
418 real
ta_disres(int nfa
,
419 const t_iatom forceatoms
[],
420 const t_iparams ip
[],
425 real gmx_unused lambda
,
426 real gmx_unused
* dvdlambda
,
427 const t_mdatoms gmx_unused
* md
,
429 int gmx_unused
* global_atom_index
)
431 const real seven_three
= 7.0 / 3.0;
435 real smooth_fc
, Rt
, Rtav
, rt2
, *Rtl_6
, *Rt_6
, *Rtav_6
;
436 real k0
, f_scal
= 0, fmax_scal
, fk_scal
, fij
;
437 real tav_viol
, instant_viol
, mixed_viol
, violtot
, vtot
;
438 real tav_viol_Rtav7
, instant_viol_Rtav7
;
440 gmx_bool bConservative
, bMixed
, bViolation
;
446 dr_weighting
= dd
->dr_weighting
;
447 dr_bMixed
= dd
->dr_bMixed
;
452 tav_viol
= instant_viol
= mixed_viol
= tav_viol_Rtav7
= instant_viol_Rtav7
= 0;
454 smooth_fc
= dd
->dr_fc
;
457 /* scaling factor to smoothly turn on the restraint forces *
458 * when using time averaging */
459 smooth_fc
*= (1.0 - dd
->exp_min_t_tau
);
465 /* 'loop' over all atom pairs (pair_nr=fa/3) involved in restraints, *
466 * the total number of atoms pairs is nfa/3 */
467 int faOffset
= static_cast<int>(forceatoms
- dd
->forceatomsStart
);
468 for (int fa
= 0; fa
< nfa
; fa
+= 3)
470 int type
= forceatoms
[fa
];
471 int npair
= ip
[type
].disres
.npair
;
472 up1
= ip
[type
].disres
.up1
;
473 up2
= ip
[type
].disres
.up2
;
474 low
= ip
[type
].disres
.low
;
475 k0
= smooth_fc
* ip
[type
].disres
.kfac
;
477 int res
= type
- dd
->type_min
;
479 /* save some flops when there is only one pair */
480 if (ip
[type
].disres
.type
!= 2)
482 bConservative
= (dr_weighting
== edrwConservative
) && (npair
> 1);
484 Rt
= gmx::invsixthroot(Rt_6
[res
]);
485 Rtav
= gmx::invsixthroot(Rtav_6
[res
]);
489 /* When rtype=2 use instantaneous not ensemble averaged distance */
490 bConservative
= (npair
> 1);
492 Rt
= gmx::invsixthroot(Rtl_6
[res
]);
499 tav_viol
= Rtav
- up1
;
504 tav_viol
= Rtav
- low
;
513 /* Add 1/npair energy and violation for each of the npair pairs */
514 real pairFac
= 1 / static_cast<real
>(npair
);
517 * there is no real potential when time averaging is applied
519 vtot
+= 0.5 * k0
* gmx::square(tav_viol
) * pairFac
;
522 f_scal
= -k0
* tav_viol
;
523 violtot
+= fabs(tav_viol
) * pairFac
;
531 instant_viol
= Rt
- up1
;
542 instant_viol
= Rt
- low
;
555 mixed_viol
= std::sqrt(tav_viol
* instant_viol
);
556 f_scal
= -k0
* mixed_viol
;
557 violtot
+= mixed_viol
* pairFac
;
564 fmax_scal
= -k0
* (up2
- up1
);
565 /* Correct the force for the number of restraints */
568 f_scal
= std::max(f_scal
, fmax_scal
);
571 f_scal
*= Rtav
/ Rtav_6
[res
];
575 f_scal
/= 2 * mixed_viol
;
576 tav_viol_Rtav7
= tav_viol
* Rtav
/ Rtav_6
[res
];
577 instant_viol_Rtav7
= instant_viol
* Rt
/ Rt_6
[res
];
583 f_scal
= std::max(f_scal
, fmax_scal
);
586 /* Exert the force ... */
588 int pair
= (faOffset
+ fa
) / 3;
589 int ai
= forceatoms
[fa
+ 1];
590 int aj
= forceatoms
[fa
+ 2];
594 ki
= pbc_dx_aiuc(pbc
, x
[ai
], x
[aj
], dx
);
598 rvec_sub(x
[ai
], x
[aj
], dx
);
602 weight_rt_1
= gmx::invsqrt(rt2
);
608 weight_rt_1
*= std::pow(dd
->rm3tav
[pair
], seven_three
);
612 weight_rt_1
*= tav_viol_Rtav7
* std::pow(dd
->rm3tav
[pair
], seven_three
)
613 + instant_viol_Rtav7
/ (dd
->rt
[pair
] * gmx::power6(dd
->rt
[pair
]));
617 fk_scal
= f_scal
* weight_rt_1
;
619 for (int m
= 0; m
< DIM
; m
++)
621 fij
= fk_scal
* dx
[m
];
627 fshift
[ki
][m
] += fij
;
628 fshift
[CENTRAL
][m
] -= fij
;
635 dd
->sumviol
+= violtot
;
641 void update_disres_history(const t_disresdata
& dd
, history_t
* hist
)
645 /* Copy the new time averages that have been calculated
646 * in calc_disres_R_6.
648 hist
->disre_initf
= dd
.exp_min_t_tau
;
649 for (int pair
= 0; pair
< dd
.npair
; pair
++)
651 hist
->disre_rm3tav
[pair
] = dd
.rm3tav
[pair
];