src/gromacs/mdlib/broadcaststructs.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,2016,2017, 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 /* This file is completely threadsafe - keep it that way! */
  38 #include "gmxpre.h"
  39
  40 #include "broadcaststructs.h"
  41
  42 #include <string.h>
  43
  44 #include "gromacs/gmxlib/network.h"
  45 #include "gromacs/math/vec.h"
  46 #include "gromacs/mdlib/mdrun.h"
  47 #include "gromacs/mdlib/tgroup.h"
  48 #include "gromacs/mdtypes/awh-params.h"
  49 #include "gromacs/mdtypes/commrec.h"
  50 #include "gromacs/mdtypes/inputrec.h"
  51 #include "gromacs/mdtypes/md_enums.h"
  52 #include "gromacs/mdtypes/pull-params.h"
  53 #include "gromacs/mdtypes/state.h"
  54 #include "gromacs/topology/symtab.h"
  55 #include "gromacs/topology/topology.h"
  56 #include "gromacs/utility/fatalerror.h"
  57 #include "gromacs/utility/inmemoryserializer.h"
  58 #include "gromacs/utility/keyvaluetree.h"
  59 #include "gromacs/utility/keyvaluetreeserializer.h"
  60 #include "gromacs/utility/smalloc.h"
  61
  62 static void bc_cstring(const t_commrec *cr, char **s)
  63 {
  64     int size = 0;
  65
  66     if (MASTER(cr) && *s != nullptr)
  67     {
  68         /* Size of the char buffer is string length + 1 for '\0' */
  69         size = strlen(*s) + 1;
  70     }
  71     block_bc(cr, size);
  72     if (size > 0)
  73     {
  74         if (!MASTER(cr))
  75         {
  76             srenew(*s, size);
  77         }
  78         nblock_bc(cr, size, *s);
  79     }
  80     else if (!MASTER(cr) && *s != nullptr)
  81     {
  82         sfree(*s);
  83         *s = nullptr;
  84     }
  85 }
  86
  87 static void bc_string(const t_commrec *cr, t_symtab *symtab, char ***s)
  88 {
  89     int handle;
  90
  91     if (MASTER(cr))
  92     {
  93         handle = lookup_symtab(symtab, *s);
  94     }
  95     block_bc(cr, handle);
  96     if (!MASTER(cr))
  97     {
  98         *s = get_symtab_handle(symtab, handle);
  99     }
 100 }
 101
 102 static void bc_strings(const t_commrec *cr, t_symtab *symtab, int nr, char ****nm)
 103 {
 104     int     i;
 105     int    *handle;
 106
 107     snew(handle, nr);
 108     if (MASTER(cr))
 109     {
 110         for (i = 0; (i < nr); i++)
 111         {
 112             handle[i] = lookup_symtab(symtab, (*nm)[i]);
 113         }
 114     }
 115     nblock_bc(cr, nr, handle);
 116
 117     if (!MASTER(cr))
 118     {
 119         snew_bc(cr, *nm, nr);
 120         for (i = 0; (i < nr); i++)
 121         {
 122             (*nm)[i] = get_symtab_handle(symtab, handle[i]);
 123         }
 124     }
 125     sfree(handle);
 126 }
 127
 128 static void bc_strings_resinfo(const t_commrec *cr, t_symtab *symtab,
 129                                int nr, t_resinfo *resinfo)
 130 {
 131     int   i;
 132     int  *handle;
 133
 134     snew(handle, nr);
 135     if (MASTER(cr))
 136     {
 137         for (i = 0; (i < nr); i++)
 138         {
 139             handle[i] = lookup_symtab(symtab, resinfo[i].name);
 140         }
 141     }
 142     nblock_bc(cr, nr, handle);
 143
 144     if (!MASTER(cr))
 145     {
 146         for (i = 0; (i < nr); i++)
 147         {
 148             resinfo[i].name = get_symtab_handle(symtab, handle[i]);
 149         }
 150     }
 151     sfree(handle);
 152 }
 153
 154 static void bc_symtab(const t_commrec *cr, t_symtab *symtab)
 155 {
 156     int       i, nr, len;
 157     t_symbuf *symbuf;
 158
 159     block_bc(cr, symtab->nr);
 160     nr = symtab->nr;
 161     snew_bc(cr, symtab->symbuf, 1);
 162     symbuf          = symtab->symbuf;
 163     symbuf->bufsize = nr;
 164     snew_bc(cr, symbuf->buf, nr);
 165     for (i = 0; i < nr; i++)
 166     {
 167         if (MASTER(cr))
 168         {
 169             len = strlen(symbuf->buf[i]) + 1;
 170         }
 171         block_bc(cr, len);
 172         snew_bc(cr, symbuf->buf[i], len);
 173         nblock_bc(cr, len, symbuf->buf[i]);
 174     }
 175 }
 176
 177 static void bc_block(const t_commrec *cr, t_block *block)
 178 {
 179     block_bc(cr, block->nr);
 180     snew_bc(cr, block->index, block->nr+1);
 181     nblock_bc(cr, block->nr+1, block->index);
 182 }
 183
 184 static void bc_blocka(const t_commrec *cr, t_blocka *block)
 185 {
 186     block_bc(cr, block->nr);
 187     snew_bc(cr, block->index, block->nr+1);
 188     nblock_bc(cr, block->nr+1, block->index);
 189     block_bc(cr, block->nra);
 190     if (block->nra)
 191     {
 192         snew_bc(cr, block->a, block->nra);
 193         nblock_bc(cr, block->nra, block->a);
 194     }
 195 }
 196
 197 static void bc_grps(const t_commrec *cr, t_grps grps[])
 198 {
 199     int i;
 200
 201     for (i = 0; (i < egcNR); i++)
 202     {
 203         block_bc(cr, grps[i].nr);
 204         snew_bc(cr, grps[i].nm_ind, grps[i].nr);
 205         nblock_bc(cr, grps[i].nr, grps[i].nm_ind);
 206     }
 207 }
 208
 209 static void bc_atoms(const t_commrec *cr, t_symtab *symtab, t_atoms *atoms)
 210 {
 211     block_bc(cr, atoms->nr);
 212     snew_bc(cr, atoms->atom, atoms->nr);
 213     nblock_bc(cr, atoms->nr, atoms->atom);
 214     bc_strings(cr, symtab, atoms->nr, &atoms->atomname);
 215     block_bc(cr, atoms->nres);
 216     snew_bc(cr, atoms->resinfo, atoms->nres);
 217     nblock_bc(cr, atoms->nres, atoms->resinfo);
 218     bc_strings_resinfo(cr, symtab, atoms->nres, atoms->resinfo);
 219     /* QMMM requires atomtypes to be known on all nodes as well */
 220     bc_strings(cr, symtab, atoms->nr, &atoms->atomtype);
 221     bc_strings(cr, symtab, atoms->nr, &atoms->atomtypeB);
 222 }
 223
 224 static void bc_groups(const t_commrec *cr, t_symtab *symtab,
 225                       int natoms, gmx_groups_t *groups)
 226 {
 227     int g, n;
 228
 229     bc_grps(cr, groups->grps);
 230     block_bc(cr, groups->ngrpname);
 231     bc_strings(cr, symtab, groups->ngrpname, &groups->grpname);
 232     for (g = 0; g < egcNR; g++)
 233     {
 234         if (MASTER(cr))
 235         {
 236             if (groups->grpnr[g])
 237             {
 238                 n = natoms;
 239             }
 240             else
 241             {
 242                 n = 0;
 243             }
 244         }
 245         block_bc(cr, n);
 246         if (n == 0)
 247         {
 248             groups->grpnr[g] = nullptr;
 249         }
 250         else
 251         {
 252             snew_bc(cr, groups->grpnr[g], n);
 253             nblock_bc(cr, n, groups->grpnr[g]);
 254         }
 255     }
 256     if (debug)
 257     {
 258         fprintf(debug, "after bc_groups\n");
 259     }
 260 }
 261
 262 static void bcastPaddedRVecVector(const t_commrec *cr, PaddedRVecVector *v, int numAtoms)
 263 {
 264     v->resize(gmx::paddedRVecVectorSize(numAtoms));
 265     nblock_bc(cr, numAtoms, as_rvec_array(v->data()));
 266 }
 267
 268 void broadcastStateWithoutDynamics(const t_commrec *cr, t_state *state)
 269 {
 270     GMX_RELEASE_ASSERT(!DOMAINDECOMP(cr), "broadcastStateWithoutDynamics should only be used for special cases without domain decomposition");
 271
 272     if (!PAR(cr))
 273     {
 274         return;
 275     }
 276
 277     /* Broadcasts the state sizes and flags from the master to all ranks
 278      * in cr->mpi_comm_mygroup.
 279      */
 280     block_bc(cr, state->natoms);
 281     block_bc(cr, state->flags);
 282
 283     for (int i = 0; i < estNR; i++)
 284     {
 285         if (state->flags & (1 << i))
 286         {
 287             switch (i)
 288             {
 289                 case estLAMBDA:
 290                     nblock_bc(cr, efptNR, state->lambda.data());
 291                     break;
 292                 case estFEPSTATE:
 293                     block_bc(cr, state->fep_state);
 294                     break;
 295                 case estBOX:
 296                     block_bc(cr, state->box);
 297                     break;
 298                 case estX:
 299                     bcastPaddedRVecVector(cr, &state->x, state->natoms);
 300                     break;
 301                 default:
 302                     GMX_RELEASE_ASSERT(false, "The state has a dynamic entry, while no dynamic entries should be present");
 303                     break;
 304             }
 305         }
 306     }
 307 }
 308
 309 static void bc_ilists(const t_commrec *cr, t_ilist *ilist)
 310 {
 311     int ftype;
 312
 313     /* Here we only communicate the non-zero length ilists */
 314     if (MASTER(cr))
 315     {
 316         for (ftype = 0; ftype < F_NRE; ftype++)
 317         {
 318             if (ilist[ftype].nr > 0)
 319             {
 320                 block_bc(cr, ftype);
 321                 block_bc(cr, ilist[ftype].nr);
 322                 nblock_bc(cr, ilist[ftype].nr, ilist[ftype].iatoms);
 323             }
 324         }
 325         ftype = -1;
 326         block_bc(cr, ftype);
 327     }
 328     else
 329     {
 330         for (ftype = 0; ftype < F_NRE; ftype++)
 331         {
 332             ilist[ftype].nr = 0;
 333         }
 334         do
 335         {
 336             block_bc(cr, ftype);
 337             if (ftype >= 0)
 338             {
 339                 block_bc(cr, ilist[ftype].nr);
 340                 snew_bc(cr, ilist[ftype].iatoms, ilist[ftype].nr);
 341                 nblock_bc(cr, ilist[ftype].nr, ilist[ftype].iatoms);
 342             }
 343         }
 344         while (ftype >= 0);
 345     }
 346
 347     if (debug)
 348     {
 349         fprintf(debug, "after bc_ilists\n");
 350     }
 351 }
 352
 353 static void bc_cmap(const t_commrec *cr, gmx_cmap_t *cmap_grid)
 354 {
 355     int i, nelem, ngrid;
 356
 357     block_bc(cr, cmap_grid->ngrid);
 358     block_bc(cr, cmap_grid->grid_spacing);
 359
 360     ngrid = cmap_grid->ngrid;
 361     nelem = cmap_grid->grid_spacing * cmap_grid->grid_spacing;
 362
 363     if (ngrid > 0)
 364     {
 365         snew_bc(cr, cmap_grid->cmapdata, ngrid);
 366
 367         for (i = 0; i < ngrid; i++)
 368         {
 369             snew_bc(cr, cmap_grid->cmapdata[i].cmap, 4*nelem);
 370             nblock_bc(cr, 4*nelem, cmap_grid->cmapdata[i].cmap);
 371         }
 372     }
 373 }
 374
 375 static void bc_ffparams(const t_commrec *cr, gmx_ffparams_t *ffp)
 376 {
 377     block_bc(cr, ffp->ntypes);
 378     block_bc(cr, ffp->atnr);
 379     snew_bc(cr, ffp->functype, ffp->ntypes);
 380     snew_bc(cr, ffp->iparams, ffp->ntypes);
 381     nblock_bc(cr, ffp->ntypes, ffp->functype);
 382     nblock_bc(cr, ffp->ntypes, ffp->iparams);
 383     block_bc(cr, ffp->reppow);
 384     block_bc(cr, ffp->fudgeQQ);
 385     bc_cmap(cr, &ffp->cmap_grid);
 386 }
 387
 388 static void bc_grpopts(const t_commrec *cr, t_grpopts *g)
 389 {
 390     int i, n;
 391
 392     block_bc(cr, g->ngtc);
 393     block_bc(cr, g->ngacc);
 394     block_bc(cr, g->ngfrz);
 395     block_bc(cr, g->ngener);
 396     snew_bc(cr, g->nrdf, g->ngtc);
 397     snew_bc(cr, g->tau_t, g->ngtc);
 398     snew_bc(cr, g->ref_t, g->ngtc);
 399     snew_bc(cr, g->acc, g->ngacc);
 400     snew_bc(cr, g->nFreeze, g->ngfrz);
 401     snew_bc(cr, g->egp_flags, g->ngener*g->ngener);
 402
 403     nblock_bc(cr, g->ngtc, g->nrdf);
 404     nblock_bc(cr, g->ngtc, g->tau_t);
 405     nblock_bc(cr, g->ngtc, g->ref_t);
 406     nblock_bc(cr, g->ngacc, g->acc);
 407     nblock_bc(cr, g->ngfrz, g->nFreeze);
 408     nblock_bc(cr, g->ngener*g->ngener, g->egp_flags);
 409     snew_bc(cr, g->annealing, g->ngtc);
 410     snew_bc(cr, g->anneal_npoints, g->ngtc);
 411     snew_bc(cr, g->anneal_time, g->ngtc);
 412     snew_bc(cr, g->anneal_temp, g->ngtc);
 413     nblock_bc(cr, g->ngtc, g->annealing);
 414     nblock_bc(cr, g->ngtc, g->anneal_npoints);
 415     for (i = 0; (i < g->ngtc); i++)
 416     {
 417         n = g->anneal_npoints[i];
 418         if (n > 0)
 419         {
 420             snew_bc(cr, g->anneal_time[i], n);
 421             snew_bc(cr, g->anneal_temp[i], n);
 422             nblock_bc(cr, n, g->anneal_time[i]);
 423             nblock_bc(cr, n, g->anneal_temp[i]);
 424         }
 425     }
 426
 427     /* QMMM stuff, see inputrec */
 428     block_bc(cr, g->ngQM);
 429     snew_bc(cr, g->QMmethod, g->ngQM);
 430     snew_bc(cr, g->QMbasis, g->ngQM);
 431     snew_bc(cr, g->QMcharge, g->ngQM);
 432     snew_bc(cr, g->QMmult, g->ngQM);
 433     snew_bc(cr, g->bSH, g->ngQM);
 434     snew_bc(cr, g->CASorbitals, g->ngQM);
 435     snew_bc(cr, g->CASelectrons, g->ngQM);
 436     snew_bc(cr, g->SAon, g->ngQM);
 437     snew_bc(cr, g->SAoff, g->ngQM);
 438     snew_bc(cr, g->SAsteps, g->ngQM);
 439
 440     if (g->ngQM)
 441     {
 442         nblock_bc(cr, g->ngQM, g->QMmethod);
 443         nblock_bc(cr, g->ngQM, g->QMbasis);
 444         nblock_bc(cr, g->ngQM, g->QMcharge);
 445         nblock_bc(cr, g->ngQM, g->QMmult);
 446         nblock_bc(cr, g->ngQM, g->bSH);
 447         nblock_bc(cr, g->ngQM, g->CASorbitals);
 448         nblock_bc(cr, g->ngQM, g->CASelectrons);
 449         nblock_bc(cr, g->ngQM, g->SAon);
 450         nblock_bc(cr, g->ngQM, g->SAoff);
 451         nblock_bc(cr, g->ngQM, g->SAsteps);
 452         /* end of QMMM stuff */
 453     }
 454 }
 455
 456 static void bc_awhBias(const t_commrec *cr, gmx::AwhBiasParams *awhBiasParams)
 457 {
 458     block_bc(cr, *awhBiasParams);
 459
 460     snew_bc(cr, awhBiasParams->dimParams, awhBiasParams->ndim);
 461     nblock_bc(cr, awhBiasParams->ndim, awhBiasParams->dimParams);
 462 }
 463
 464 static void bc_awh(const t_commrec *cr, gmx::AwhParams *awhParams)
 465 {
 466     int k;
 467
 468     block_bc(cr, *awhParams);
 469     snew_bc(cr, awhParams->awhBiasParams, awhParams->numBias);
 470     for (k = 0; k < awhParams->numBias; k++)
 471     {
 472         bc_awhBias(cr, &awhParams->awhBiasParams[k]);
 473     }
 474 }
 475
 476 static void bc_pull_group(const t_commrec *cr, t_pull_group *pgrp)
 477 {
 478     block_bc(cr, *pgrp);
 479     if (pgrp->nat > 0)
 480     {
 481         snew_bc(cr, pgrp->ind, pgrp->nat);
 482         nblock_bc(cr, pgrp->nat, pgrp->ind);
 483     }
 484     if (pgrp->nweight > 0)
 485     {
 486         snew_bc(cr, pgrp->weight, pgrp->nweight);
 487         nblock_bc(cr, pgrp->nweight, pgrp->weight);
 488     }
 489 }
 490
 491 static void bc_pull(const t_commrec *cr, pull_params_t *pull)
 492 {
 493     int g;
 494
 495     block_bc(cr, *pull);
 496     snew_bc(cr, pull->group, pull->ngroup);
 497     for (g = 0; g < pull->ngroup; g++)
 498     {
 499         bc_pull_group(cr, &pull->group[g]);
 500     }
 501     snew_bc(cr, pull->coord, pull->ncoord);
 502     nblock_bc(cr, pull->ncoord, pull->coord);
 503     for (int c = 0; c < pull->ncoord; c++)
 504     {
 505         if (!MASTER(cr))
 506         {
 507             pull->coord[c].externalPotentialProvider = nullptr;
 508         }
 509         if (pull->coord[c].eType == epullEXTERNAL)
 510         {
 511             bc_cstring(cr, &pull->coord[c].externalPotentialProvider);
 512         }
 513     }
 514 }
 515
 516 static void bc_rotgrp(const t_commrec *cr, t_rotgrp *rotg)
 517 {
 518     block_bc(cr, *rotg);
 519     if (rotg->nat > 0)
 520     {
 521         snew_bc(cr, rotg->ind, rotg->nat);
 522         nblock_bc(cr, rotg->nat, rotg->ind);
 523         snew_bc(cr, rotg->x_ref, rotg->nat);
 524         nblock_bc(cr, rotg->nat, rotg->x_ref);
 525     }
 526 }
 527
 528 static void bc_rot(const t_commrec *cr, t_rot *rot)
 529 {
 530     int g;
 531
 532     block_bc(cr, *rot);
 533     snew_bc(cr, rot->grp, rot->ngrp);
 534     for (g = 0; g < rot->ngrp; g++)
 535     {
 536         bc_rotgrp(cr, &rot->grp[g]);
 537     }
 538 }
 539
 540 static void bc_imd(const t_commrec *cr, t_IMD *imd)
 541 {
 542     block_bc(cr, *imd);
 543     snew_bc(cr, imd->ind, imd->nat);
 544     nblock_bc(cr, imd->nat, imd->ind);
 545 }
 546
 547 static void bc_fepvals(const t_commrec *cr, t_lambda *fep)
 548 {
 549     int      i;
 550
 551     block_bc(cr, fep->nstdhdl);
 552     block_bc(cr, fep->init_lambda);
 553     block_bc(cr, fep->init_fep_state);
 554     block_bc(cr, fep->delta_lambda);
 555     block_bc(cr, fep->edHdLPrintEnergy);
 556     block_bc(cr, fep->n_lambda);
 557     if (fep->n_lambda > 0)
 558     {
 559         snew_bc(cr, fep->all_lambda, efptNR);
 560         nblock_bc(cr, efptNR, fep->all_lambda);
 561         for (i = 0; i < efptNR; i++)
 562         {
 563             snew_bc(cr, fep->all_lambda[i], fep->n_lambda);
 564             nblock_bc(cr, fep->n_lambda, fep->all_lambda[i]);
 565         }
 566     }
 567     block_bc(cr, fep->sc_alpha);
 568     block_bc(cr, fep->sc_power);
 569     block_bc(cr, fep->sc_r_power);
 570     block_bc(cr, fep->sc_sigma);
 571     block_bc(cr, fep->sc_sigma_min);
 572     block_bc(cr, fep->bScCoul);
 573     nblock_bc(cr, efptNR, &(fep->separate_dvdl[0]));
 574     block_bc(cr, fep->dhdl_derivatives);
 575     block_bc(cr, fep->dh_hist_size);
 576     block_bc(cr, fep->dh_hist_spacing);
 577     if (debug)
 578     {
 579         fprintf(debug, "after bc_fepvals\n");
 580     }
 581 }
 582
 583 static void bc_expandedvals(const t_commrec *cr, t_expanded *expand, int n_lambda)
 584 {
 585     block_bc(cr, expand->nstexpanded);
 586     block_bc(cr, expand->elamstats);
 587     block_bc(cr, expand->elmcmove);
 588     block_bc(cr, expand->elmceq);
 589     block_bc(cr, expand->equil_n_at_lam);
 590     block_bc(cr, expand->equil_wl_delta);
 591     block_bc(cr, expand->equil_ratio);
 592     block_bc(cr, expand->equil_steps);
 593     block_bc(cr, expand->equil_samples);
 594     block_bc(cr, expand->lmc_seed);
 595     block_bc(cr, expand->minvar);
 596     block_bc(cr, expand->minvar_const);
 597     block_bc(cr, expand->c_range);
 598     block_bc(cr, expand->bSymmetrizedTMatrix);
 599     block_bc(cr, expand->nstTij);
 600     block_bc(cr, expand->lmc_repeats);
 601     block_bc(cr, expand->lmc_forced_nstart);
 602     block_bc(cr, expand->gibbsdeltalam);
 603     block_bc(cr, expand->wl_scale);
 604     block_bc(cr, expand->wl_ratio);
 605     block_bc(cr, expand->init_wl_delta);
 606     block_bc(cr, expand->bInit_weights);
 607     snew_bc(cr, expand->init_lambda_weights, n_lambda);
 608     nblock_bc(cr, n_lambda, expand->init_lambda_weights);
 609     block_bc(cr, expand->mc_temp);
 610     if (debug)
 611     {
 612         fprintf(debug, "after bc_expandedvals\n");
 613     }
 614 }
 615
 616 static void bc_simtempvals(const t_commrec *cr, t_simtemp *simtemp, int n_lambda)
 617 {
 618     block_bc(cr, simtemp->simtemp_low);
 619     block_bc(cr, simtemp->simtemp_high);
 620     block_bc(cr, simtemp->eSimTempScale);
 621     snew_bc(cr, simtemp->temperatures, n_lambda);
 622     nblock_bc(cr, n_lambda, simtemp->temperatures);
 623     if (debug)
 624     {
 625         fprintf(debug, "after bc_simtempvals\n");
 626     }
 627 }
 628
 629
 630 static void bc_swapions(const t_commrec *cr, t_swapcoords *swap)
 631 {
 632     block_bc(cr, *swap);
 633
 634     /* Broadcast atom indices for split groups, solvent group, and for all user-defined swap groups */
 635     snew_bc(cr, swap->grp, swap->ngrp);
 636     for (int i = 0; i < swap->ngrp; i++)
 637     {
 638         t_swapGroup *g = &swap->grp[i];
 639
 640         block_bc(cr, *g);
 641         snew_bc(cr, g->ind, g->nat);
 642         nblock_bc(cr, g->nat, g->ind);
 643
 644         int len = 0;
 645         if (MASTER(cr))
 646         {
 647             len = strlen(g->molname);
 648         }
 649         block_bc(cr, len);
 650         snew_bc(cr, g->molname, len);
 651         nblock_bc(cr, len, g->molname);
 652     }
 653 }
 654
 655
 656 static void bc_inputrec(const t_commrec *cr, t_inputrec *inputrec)
 657 {
 658     // Note that this overwrites pointers in inputrec, so all pointer fields
 659     // Must be initialized separately below.
 660     block_bc(cr, *inputrec);
 661     if (SIMMASTER(cr))
 662     {
 663         gmx::InMemorySerializer serializer;
 664         gmx::serializeKeyValueTree(*inputrec->params, &serializer);
 665         std::vector<char>       buffer = serializer.finishAndGetBuffer();
 666         size_t                  size   = buffer.size();
 667         block_bc(cr, size);
 668         nblock_bc(cr, size, buffer.data());
 669     }
 670     else
 671     {
 672         // block_bc() above overwrites the old pointer, so set it to a
 673         // reasonable value in case code below throws.
 674         // cppcheck-suppress redundantAssignment
 675         inputrec->params = nullptr;
 676         std::vector<char> buffer;
 677         size_t            size;
 678         block_bc(cr, size);
 679         nblock_abc(cr, size, &buffer);
 680         gmx::InMemoryDeserializer serializer(buffer);
 681         // cppcheck-suppress redundantAssignment
 682         inputrec->params = new gmx::KeyValueTreeObject(
 683                     gmx::deserializeKeyValueTree(&serializer));
 684     }
 685
 686     bc_grpopts(cr, &(inputrec->opts));
 687
 688     /* even if efep is efepNO, we need to initialize to make sure that
 689      * n_lambda is set to zero */
 690
 691     snew_bc(cr, inputrec->fepvals, 1);
 692     if (inputrec->efep != efepNO || inputrec->bSimTemp)
 693     {
 694         bc_fepvals(cr, inputrec->fepvals);
 695     }
 696     /* need to initialize this as well because of data checked for in the logic */
 697     snew_bc(cr, inputrec->expandedvals, 1);
 698     if (inputrec->bExpanded)
 699     {
 700         bc_expandedvals(cr, inputrec->expandedvals, inputrec->fepvals->n_lambda);
 701     }
 702     snew_bc(cr, inputrec->simtempvals, 1);
 703     if (inputrec->bSimTemp)
 704     {
 705         bc_simtempvals(cr, inputrec->simtempvals, inputrec->fepvals->n_lambda);
 706     }
 707     if (inputrec->bPull)
 708     {
 709         snew_bc(cr, inputrec->pull, 1);
 710         bc_pull(cr, inputrec->pull);
 711     }
 712     if (inputrec->bDoAwh)
 713     {
 714         snew_bc(cr, inputrec->awhParams, 1);
 715         bc_awh(cr, inputrec->awhParams);
 716     }
 717
 718     if (inputrec->bRot)
 719     {
 720         snew_bc(cr, inputrec->rot, 1);
 721         bc_rot(cr, inputrec->rot);
 722     }
 723     if (inputrec->bIMD)
 724     {
 725         snew_bc(cr, inputrec->imd, 1);
 726         bc_imd(cr, inputrec->imd);
 727     }
 728     if (inputrec->eSwapCoords != eswapNO)
 729     {
 730         snew_bc(cr, inputrec->swap, 1);
 731         bc_swapions(cr, inputrec->swap);
 732     }
 733 }
 734
 735 static void bc_moltype(const t_commrec *cr, t_symtab *symtab,
 736                        gmx_moltype_t *moltype)
 737 {
 738     bc_string(cr, symtab, &moltype->name);
 739     bc_atoms(cr, symtab, &moltype->atoms);
 740     if (debug)
 741     {
 742         fprintf(debug, "after bc_atoms\n");
 743     }
 744
 745     bc_ilists(cr, moltype->ilist);
 746     bc_block(cr, &moltype->cgs);
 747     bc_blocka(cr, &moltype->excls);
 748 }
 749
 750 static void bc_molblock(const t_commrec *cr, gmx_molblock_t *molb)
 751 {
 752     block_bc(cr, *molb);
 753     if (molb->nposres_xA > 0)
 754     {
 755         snew_bc(cr, molb->posres_xA, molb->nposres_xA);
 756         nblock_bc(cr, molb->nposres_xA*DIM, molb->posres_xA[0]);
 757     }
 758     if (molb->nposres_xB > 0)
 759     {
 760         snew_bc(cr, molb->posres_xB, molb->nposres_xB);
 761         nblock_bc(cr, molb->nposres_xB*DIM, molb->posres_xB[0]);
 762     }
 763     if (debug)
 764     {
 765         fprintf(debug, "after bc_molblock\n");
 766     }
 767 }
 768
 769 static void bc_atomtypes(const t_commrec *cr, t_atomtypes *atomtypes)
 770 {
 771     int nr;
 772
 773     block_bc(cr, atomtypes->nr);
 774
 775     nr = atomtypes->nr;
 776
 777     snew_bc(cr, atomtypes->radius, nr);
 778     snew_bc(cr, atomtypes->vol, nr);
 779     snew_bc(cr, atomtypes->surftens, nr);
 780     snew_bc(cr, atomtypes->gb_radius, nr);
 781     snew_bc(cr, atomtypes->S_hct, nr);
 782
 783     nblock_bc(cr, nr, atomtypes->radius);
 784     nblock_bc(cr, nr, atomtypes->vol);
 785     nblock_bc(cr, nr, atomtypes->surftens);
 786     nblock_bc(cr, nr, atomtypes->gb_radius);
 787     nblock_bc(cr, nr, atomtypes->S_hct);
 788 }
 789
 790 /*! \brief Broadcasts ir and mtop from the master to all nodes in
 791  * cr->mpi_comm_mygroup. */
 792 static
 793 void bcast_ir_mtop(const t_commrec *cr, t_inputrec *inputrec, gmx_mtop_t *mtop)
 794 {
 795     int i;
 796     if (debug)
 797     {
 798         fprintf(debug, "in bc_data\n");
 799     }
 800     bc_inputrec(cr, inputrec);
 801     if (debug)
 802     {
 803         fprintf(debug, "after bc_inputrec\n");
 804     }
 805     bc_symtab(cr, &mtop->symtab);
 806     if (debug)
 807     {
 808         fprintf(debug, "after bc_symtab\n");
 809     }
 810     bc_string(cr, &mtop->symtab, &mtop->name);
 811     if (debug)
 812     {
 813         fprintf(debug, "after bc_name\n");
 814     }
 815
 816     bc_ffparams(cr, &mtop->ffparams);
 817
 818     block_bc(cr, mtop->nmoltype);
 819     snew_bc(cr, mtop->moltype, mtop->nmoltype);
 820     for (i = 0; i < mtop->nmoltype; i++)
 821     {
 822         bc_moltype(cr, &mtop->symtab, &mtop->moltype[i]);
 823     }
 824
 825     block_bc(cr, mtop->bIntermolecularInteractions);
 826     if (mtop->bIntermolecularInteractions)
 827     {
 828         snew_bc(cr, mtop->intermolecular_ilist, F_NRE);
 829         bc_ilists(cr, mtop->intermolecular_ilist);
 830     }
 831
 832     block_bc(cr, mtop->nmolblock);
 833     snew_bc(cr, mtop->molblock, mtop->nmolblock);
 834     for (i = 0; i < mtop->nmolblock; i++)
 835     {
 836         bc_molblock(cr, &mtop->molblock[i]);
 837     }
 838
 839     block_bc(cr, mtop->natoms);
 840
 841     bc_atomtypes(cr, &mtop->atomtypes);
 842
 843     bc_block(cr, &mtop->mols);
 844     bc_groups(cr, &mtop->symtab, mtop->natoms, &mtop->groups);
 845 }
 846
 847 void init_parallel(t_commrec *cr, t_inputrec *inputrec,
 848                    gmx_mtop_t *mtop)
 849 {
 850     bcast_ir_mtop(cr, inputrec, mtop);
 851 }