static void bc_symtab(const t_commrec *cr, t_symtab *symtab)
{
int i, nr, len;
t_symbuf *symbuf;
block_bc(cr, symtab->nr);
nr = symtab->nr;
snew_bc(cr, symtab->symbuf, 1);
symbuf = symtab->symbuf;
symbuf->bufsize = nr;
snew_bc(cr, symbuf->buf, nr);
for (i = 0; i < nr; i++)
{
if (MASTER(cr))
{
len = strlen(symbuf->buf[i]) + 1;
}
block_bc(cr, len);
snew_bc(cr, symbuf->buf[i], len);
nblock_bc(cr, len, symbuf->buf[i]);
}
}
static void bc_pull(const t_commrec *cr, pull_params_t *pull)
{
int g;
block_bc(cr, *pull);
snew_bc(cr, pull->group, pull->ngroup);
for (g = 0; g < pull->ngroup; g++)
{
bc_pull_group(cr, &pull->group[g]);
}
snew_bc(cr, pull->coord, pull->ncoord);
nblock_bc(cr, pull->ncoord, pull->coord);
}
static void bc_molblock(const t_commrec *cr, gmx_molblock_t *molb)
{
block_bc(cr, molb->type);
block_bc(cr, molb->nmol);
block_bc(cr, molb->natoms_mol);
block_bc(cr, molb->nposres_xA);
if (molb->nposres_xA > 0)
{
snew_bc(cr, molb->posres_xA, molb->nposres_xA);
nblock_bc(cr, molb->nposres_xA*DIM, molb->posres_xA[0]);
}
block_bc(cr, molb->nposres_xB);
if (molb->nposres_xB > 0)
{
snew_bc(cr, molb->posres_xB, molb->nposres_xB);
nblock_bc(cr, molb->nposres_xB*DIM, molb->posres_xB[0]);
}
if (debug)
{
fprintf(debug, "after bc_molblock\n");
}
}
static void bc_groups(const t_commrec *cr, t_symtab *symtab,
int natoms, gmx_groups_t *groups)
{
int dummy;
int g, n;
bc_grps(cr, groups->grps);
block_bc(cr, groups->ngrpname);
bc_strings(cr, symtab, groups->ngrpname, &groups->grpname);
for (g = 0; g < egcNR; g++)
{
if (MASTER(cr))
{
if (groups->grpnr[g])
{
n = natoms;
}
else
{
n = 0;
}
}
block_bc(cr, n);
if (n == 0)
{
groups->grpnr[g] = NULL;
}
else
{
snew_bc(cr, groups->grpnr[g], n);
nblock_bc(cr, n, groups->grpnr[g]);
}
}
if (debug)
{
fprintf(debug, "after bc_groups\n");
}
}
static void bc_pull_group(const t_commrec *cr, t_pull_group *pgrp)
{
block_bc(cr, *pgrp);
if (pgrp->nat > 0)
{
snew_bc(cr, pgrp->ind, pgrp->nat);
nblock_bc(cr, pgrp->nat, pgrp->ind);
}
if (pgrp->nweight > 0)
{
snew_bc(cr, pgrp->weight, pgrp->nweight);
nblock_bc(cr, pgrp->nweight, pgrp->weight);
}
}
static void bc_adress(const t_commrec *cr, t_adress *adress)
{
block_bc(cr, *adress);
if (adress->n_tf_grps > 0)
{
snew_bc(cr, adress->tf_table_index, adress->n_tf_grps);
nblock_bc(cr, adress->n_tf_grps, adress->tf_table_index);
}
if (adress->n_energy_grps > 0)
{
snew_bc(cr, adress->group_explicit, adress->n_energy_grps);
nblock_bc(cr, adress->n_energy_grps, adress->group_explicit);
}
}
static void bc_string(const t_commrec *cr, t_symtab *symtab, char ***s)
{
int handle;
if (MASTER(cr))
{
handle = lookup_symtab(symtab, *s);
}
block_bc(cr, handle);
if (!MASTER(cr))
{
*s = get_symtab_handle(symtab, handle);
}
}
static void bc_swapions(const t_commrec *cr, t_swapcoords *swap)
{
block_bc(cr, *swap);
/* Broadcast atom indices for split groups, solvent group, and for all user-defined swap groups */
snew_bc(cr, swap->grp, swap->ngrp);
for (int i = 0; i < swap->ngrp; i++)
{
t_swapGroup *g = &swap->grp[i];
block_bc(cr, *g);
snew_bc(cr, g->ind, g->nat);
nblock_bc(cr, g->nat, g->ind);
int len = 0;
if (MASTER(cr))
{
len = strlen(g->molname);
}
block_bc(cr, len);
snew_bc(cr, g->molname, len);
nblock_bc(cr, len, g->molname);
}
}
static void bc_inputrec(const t_commrec *cr,t_inputrec *inputrec)
{
bool bAlloc=TRUE;
int i;
block_bc(cr,*inputrec);
snew_bc(cr,inputrec->flambda,inputrec->n_flambda);
nblock_bc(cr,inputrec->n_flambda,inputrec->flambda);
bc_grpopts(cr,&(inputrec->opts));
if (inputrec->ePull != epullNO) {
snew_bc(cr,inputrec->pull,1);
bc_pull(cr,inputrec->pull);
}
for(i=0; (i<DIM); i++) {
bc_cosines(cr,&(inputrec->ex[i]));
bc_cosines(cr,&(inputrec->et[i]));
}
}
/* Allocate and fill an array with coordinates and charges,
* returns the number of charges found
*/
static int prepare_x_q(real *q[], rvec *x[], gmx_mtop_t *mtop, rvec x_orig[], t_commrec *cr)
{
int i;
int nq; /* number of charged particles */
gmx_mtop_atomloop_all_t aloop;
t_atom *atom;
if (MASTER(cr))
{
snew(*q, mtop->natoms);
snew(*x, mtop->natoms);
nq = 0;
aloop = gmx_mtop_atomloop_all_init(mtop);
while (gmx_mtop_atomloop_all_next(aloop, &i, &atom))
{
if (is_charge(atom->q))
{
(*q)[nq] = atom->q;
(*x)[nq][XX] = x_orig[i][XX];
(*x)[nq][YY] = x_orig[i][YY];
(*x)[nq][ZZ] = x_orig[i][ZZ];
nq++;
}
}
/* Give back some unneeded memory */
srenew(*q, nq);
srenew(*x, nq);
}
/* Broadcast x and q in the parallel case */
if (PAR(cr))
{
/* Transfer the number of charges */
block_bc(cr, nq);
snew_bc(cr, *x, nq);
snew_bc(cr, *q, nq);
nblock_bc(cr, nq, *x);
nblock_bc(cr, nq, *q);
}
return nq;
}
/* Transfer what we need for parallelizing the reciprocal error estimate */
static void bcast_info(t_inputinfo *info, t_commrec *cr)
{
nblock_bc(cr, info->n_entries, info->nkx);
nblock_bc(cr, info->n_entries, info->nky);
nblock_bc(cr, info->n_entries, info->nkz);
nblock_bc(cr, info->n_entries, info->ewald_beta);
nblock_bc(cr, info->n_entries, info->pme_order);
nblock_bc(cr, info->n_entries, info->e_dir);
nblock_bc(cr, info->n_entries, info->e_rec);
block_bc(cr, info->volume);
block_bc(cr, info->recipbox);
block_bc(cr, info->natoms);
block_bc(cr, info->fracself);
block_bc(cr, info->bTUNE);
block_bc(cr, info->q2all);
block_bc(cr, info->q2allnr);
}
/* Allocate and fill an array with coordinates and charges,
* returns the number of charges found
*/
static int prepare_x_q(real *q[], rvec *x[], gmx_mtop_t *mtop, rvec x_orig[], t_commrec *cr)
{
int i,anr_global;
int nq; /* number of charged particles */
t_atom *atom;
if (MASTER(cr))
{
snew(*q, mtop->natoms);
snew(*x, mtop->natoms);
nq=0;
for (i=0; i<mtop->natoms; i++)
{
anr_global = i;
gmx_mtop_atomnr_to_atom(mtop,anr_global,&atom);
if (is_charge(atom->q))
{
(*q)[nq] = atom->q;
(*x)[nq][XX] = x_orig[i][XX];
(*x)[nq][YY] = x_orig[i][YY];
(*x)[nq][ZZ] = x_orig[i][ZZ];
nq++;
}
}
/* Give back some unneeded memory */
srenew(*q, nq);
srenew(*x, nq);
}
/* Broadcast x and q in the parallel case */
if (PAR(cr))
{
/* Transfer the number of charges */
block_bc(cr,nq);
snew_bc(cr, *x, nq);
snew_bc(cr, *q, nq);
nblock_bc(cr,nq,*x);
nblock_bc(cr,nq,*q);
}
return nq;
}
static void bc_atomtypes(const t_commrec *cr, t_atomtypes *atomtypes)
{
int nr;
block_bc(cr, atomtypes->nr);
nr = atomtypes->nr;
snew_bc(cr, atomtypes->radius, nr);
snew_bc(cr, atomtypes->vol, nr);
snew_bc(cr, atomtypes->surftens, nr);
snew_bc(cr, atomtypes->gb_radius, nr);
snew_bc(cr, atomtypes->S_hct, nr);
nblock_bc(cr, nr, atomtypes->radius);
nblock_bc(cr, nr, atomtypes->vol);
nblock_bc(cr, nr, atomtypes->surftens);
nblock_bc(cr, nr, atomtypes->gb_radius);
nblock_bc(cr, nr, atomtypes->S_hct);
}
static void bc_swapions(const t_commrec *cr, t_swapcoords *swap)
{
int i;
block_bc(cr, *swap);
/* Broadcast ion group atom indices */
snew_bc(cr, swap->ind, swap->nat);
nblock_bc(cr, swap->nat, swap->ind);
/* Broadcast split groups atom indices */
for (i = 0; i < 2; i++)
{
snew_bc(cr, swap->ind_split[i], swap->nat_split[i]);
nblock_bc(cr, swap->nat_split[i], swap->ind_split[i]);
}
/* Broadcast solvent group atom indices */
snew_bc(cr, swap->ind_sol, swap->nat_sol);
nblock_bc(cr, swap->nat_sol, swap->ind_sol);
}
static void bc_cstring(const t_commrec *cr, char **s)
{
int size = 0;
if (MASTER(cr) && *s != NULL)
{
/* Size of the char buffer is string length + 1 for '\0' */
size = strlen(*s) + 1;
}
block_bc(cr, size);
if (size > 0)
{
if (!MASTER(cr))
{
srenew(*s, size);
}
nblock_bc(cr, size, *s);
}
else if (!MASTER(cr) && *s != NULL)
{
sfree(*s);
*s = NULL;
}
}
static void bc_pull(const t_commrec *cr, pull_params_t *pull)
{
int g;
block_bc(cr, *pull);
snew_bc(cr, pull->group, pull->ngroup);
for (g = 0; g < pull->ngroup; g++)
{
bc_pull_group(cr, &pull->group[g]);
}
snew_bc(cr, pull->coord, pull->ncoord);
nblock_bc(cr, pull->ncoord, pull->coord);
for (int c = 0; c < pull->ncoord; c++)
{
if (!MASTER(cr))
{
pull->coord[c].externalPotentialProvider = NULL;
}
if (pull->coord[c].eType == epullEXTERNAL)
{
bc_cstring(cr, &pull->coord[c].externalPotentialProvider);
}
}
}
void bcast_state(const t_commrec *cr,t_state *state,gmx_bool bAlloc)
{
int i,nnht,nnhtp;
bcast_state_setup(cr,state);
nnht = (state->ngtc)*(state->nhchainlength);
nnhtp = (state->nnhpres)*(state->nhchainlength);
if (MASTER(cr)) {
bAlloc = FALSE;
}
if (bAlloc) {
state->nalloc = state->natoms;
}
for(i=0; i<estNR; i++) {
if (state->flags & (1<<i)) {
switch (i) {
case estLAMBDA: block_bc(cr,state->lambda); break;
case estBOX: block_bc(cr,state->box); break;
case estBOX_REL: block_bc(cr,state->box_rel); break;
case estBOXV: block_bc(cr,state->boxv); break;
case estPRES_PREV: block_bc(cr,state->pres_prev); break;
case estSVIR_PREV: block_bc(cr,state->svir_prev); break;
case estFVIR_PREV: block_bc(cr,state->fvir_prev); break;
case estNH_XI: nblock_abc(cr,nnht,state->nosehoover_xi); break;
case estNH_VXI: nblock_abc(cr,nnht,state->nosehoover_vxi); break;
case estNHPRES_XI: nblock_abc(cr,nnhtp,state->nhpres_xi); break;
case estNHPRES_VXI: nblock_abc(cr,nnhtp,state->nhpres_vxi); break;
case estTC_INT: nblock_abc(cr,state->ngtc,state->therm_integral); break;
case estVETA: block_bc(cr,state->veta); break;
case estVOL0: block_bc(cr,state->vol0); break;
case estX: nblock_abc(cr,state->natoms,state->x); break;
case estV: nblock_abc(cr,state->natoms,state->v); break;
case estSDX: nblock_abc(cr,state->natoms,state->sd_X); break;
case estCGP: nblock_abc(cr,state->natoms,state->cg_p); break;
case estLD_RNG: if(state->nrngi == 1) nblock_abc(cr,state->nrng,state->ld_rng); break;
case estLD_RNGI: if(state->nrngi == 1) nblock_abc(cr,state->nrngi,state->ld_rngi); break;
case estDISRE_INITF: block_bc(cr,state->hist.disre_initf); break;
case estDISRE_RM3TAV:
block_bc(cr,state->hist.ndisrepairs);
nblock_abc(cr,state->hist.ndisrepairs,state->hist.disre_rm3tav);
break;
case estORIRE_INITF: block_bc(cr,state->hist.orire_initf); break;
case estORIRE_DTAV:
block_bc(cr,state->hist.norire_Dtav);
nblock_abc(cr,state->hist.norire_Dtav,state->hist.orire_Dtav);
break;
default:
gmx_fatal(FARGS,
"Communication is not implemented for %s in bcast_state",
est_names[i]);
}
}
}
}
static void bc_expandedvals(const t_commrec *cr, t_expanded *expand, int n_lambda)
{
gmx_bool bAlloc = TRUE;
int i;
block_bc(cr, expand->nstexpanded);
block_bc(cr, expand->elamstats);
block_bc(cr, expand->elmcmove);
block_bc(cr, expand->elmceq);
block_bc(cr, expand->equil_n_at_lam);
block_bc(cr, expand->equil_wl_delta);
block_bc(cr, expand->equil_ratio);
block_bc(cr, expand->equil_steps);
block_bc(cr, expand->equil_samples);
block_bc(cr, expand->lmc_seed);
block_bc(cr, expand->minvar);
block_bc(cr, expand->minvar_const);
block_bc(cr, expand->c_range);
block_bc(cr, expand->bSymmetrizedTMatrix);
block_bc(cr, expand->nstTij);
block_bc(cr, expand->lmc_repeats);
block_bc(cr, expand->lmc_forced_nstart);
block_bc(cr, expand->gibbsdeltalam);
block_bc(cr, expand->wl_scale);
block_bc(cr, expand->wl_ratio);
block_bc(cr, expand->init_wl_delta);
block_bc(cr, expand->bInit_weights);
snew_bc(cr, expand->init_lambda_weights, n_lambda);
nblock_bc(cr, n_lambda, expand->init_lambda_weights);
block_bc(cr, expand->mc_temp);
if (debug)
{
fprintf(debug, "after bc_expandedvals\n");
}
}
static void bc_fepvals(const t_commrec *cr, t_lambda *fep)
{
gmx_bool bAlloc = TRUE;
int i;
block_bc(cr, fep->nstdhdl);
block_bc(cr, fep->init_lambda);
block_bc(cr, fep->init_fep_state);
block_bc(cr, fep->delta_lambda);
block_bc(cr, fep->bPrintEnergy);
block_bc(cr, fep->n_lambda);
if (fep->n_lambda > 0)
{
snew_bc(cr, fep->all_lambda, efptNR);
nblock_bc(cr, efptNR, fep->all_lambda);
for (i = 0; i < efptNR; i++)
{
snew_bc(cr, fep->all_lambda[i], fep->n_lambda);
nblock_bc(cr, fep->n_lambda, fep->all_lambda[i]);
}
}
block_bc(cr, fep->sc_alpha);
block_bc(cr, fep->sc_power);
block_bc(cr, fep->sc_r_power);
block_bc(cr, fep->sc_sigma);
block_bc(cr, fep->sc_sigma_min);
block_bc(cr, fep->bScCoul);
nblock_bc(cr, efptNR, &(fep->separate_dvdl[0]));
block_bc(cr, fep->dhdl_derivatives);
block_bc(cr, fep->dh_hist_size);
block_bc(cr, fep->dh_hist_spacing);
if (debug)
{
fprintf(debug, "after bc_fepvals\n");
}
}
static void bc_imd(const t_commrec *cr, t_IMD *imd)
{
block_bc(cr, *imd);
snew_bc(cr, imd->ind, imd->nat);
nblock_bc(cr, imd->nat, imd->ind);
}
static void bc_grpopts(const t_commrec *cr, t_grpopts *g)
{
int i, n;
block_bc(cr, g->ngtc);
block_bc(cr, g->ngacc);
block_bc(cr, g->ngfrz);
block_bc(cr, g->ngener);
snew_bc(cr, g->nrdf, g->ngtc);
snew_bc(cr, g->tau_t, g->ngtc);
snew_bc(cr, g->ref_t, g->ngtc);
snew_bc(cr, g->acc, g->ngacc);
snew_bc(cr, g->nFreeze, g->ngfrz);
snew_bc(cr, g->egp_flags, g->ngener*g->ngener);
nblock_bc(cr, g->ngtc, g->nrdf);
nblock_bc(cr, g->ngtc, g->tau_t);
nblock_bc(cr, g->ngtc, g->ref_t);
nblock_bc(cr, g->ngacc, g->acc);
nblock_bc(cr, g->ngfrz, g->nFreeze);
nblock_bc(cr, g->ngener*g->ngener, g->egp_flags);
snew_bc(cr, g->annealing, g->ngtc);
snew_bc(cr, g->anneal_npoints, g->ngtc);
snew_bc(cr, g->anneal_time, g->ngtc);
snew_bc(cr, g->anneal_temp, g->ngtc);
nblock_bc(cr, g->ngtc, g->annealing);
nblock_bc(cr, g->ngtc, g->anneal_npoints);
for (i = 0; (i < g->ngtc); i++)
{
n = g->anneal_npoints[i];
if (n > 0)
{
snew_bc(cr, g->anneal_time[i], n);
snew_bc(cr, g->anneal_temp[i], n);
nblock_bc(cr, n, g->anneal_time[i]);
nblock_bc(cr, n, g->anneal_temp[i]);
}
}
/* QMMM stuff, see inputrec */
block_bc(cr, g->ngQM);
snew_bc(cr, g->QMmethod, g->ngQM);
snew_bc(cr, g->QMbasis, g->ngQM);
snew_bc(cr, g->QMcharge, g->ngQM);
snew_bc(cr, g->QMmult, g->ngQM);
snew_bc(cr, g->bSH, g->ngQM);
snew_bc(cr, g->CASorbitals, g->ngQM);
snew_bc(cr, g->CASelectrons, g->ngQM);
snew_bc(cr, g->SAon, g->ngQM);
snew_bc(cr, g->SAoff, g->ngQM);
snew_bc(cr, g->SAsteps, g->ngQM);
if (g->ngQM)
{
nblock_bc(cr, g->ngQM, g->QMmethod);
nblock_bc(cr, g->ngQM, g->QMbasis);
nblock_bc(cr, g->ngQM, g->QMcharge);
nblock_bc(cr, g->ngQM, g->QMmult);
nblock_bc(cr, g->ngQM, g->bSH);
nblock_bc(cr, g->ngQM, g->CASorbitals);
nblock_bc(cr, g->ngQM, g->CASelectrons);
nblock_bc(cr, g->ngQM, g->SAon);
nblock_bc(cr, g->ngQM, g->SAoff);
nblock_bc(cr, g->ngQM, g->SAsteps);
/* end of QMMM stuff */
}
}
void bcast_state(const t_commrec *cr, t_state *state)
{
int i, nnht, nnhtp;
gmx_bool bAlloc;
if (!PAR(cr))
{
return;
}
/* Broadcasts the state sizes and flags from the master to all nodes
* in cr->mpi_comm_mygroup. The arrays are not broadcasted. */
block_bc(cr, state->natoms);
block_bc(cr, state->ngtc);
block_bc(cr, state->nnhpres);
block_bc(cr, state->nhchainlength);
block_bc(cr, state->flags);
if (state->lambda == NULL)
{
snew_bc(cr, state->lambda, efptNR)
}
if (cr->dd)
{
/* We allocate dynamically in dd_partition_system. */
return;
}
/* The code below is reachable only by TPI and NM, so it is not
tested by anything. */
nnht = (state->ngtc)*(state->nhchainlength);
nnhtp = (state->nnhpres)*(state->nhchainlength);
/* We still need to allocate the arrays in state for non-master
* ranks, which is done (implicitly via bAlloc) in the dirty,
* dirty nblock_abc macro. */
bAlloc = !MASTER(cr);
if (bAlloc)
{
state->nalloc = state->natoms;
}
for (i = 0; i < estNR; i++)
{
if (state->flags & (1<<i))
{
switch (i)
{
case estLAMBDA: nblock_bc(cr, efptNR, state->lambda); break;
case estFEPSTATE: block_bc(cr, state->fep_state); break;
case estBOX: block_bc(cr, state->box); break;
case estBOX_REL: block_bc(cr, state->box_rel); break;
case estBOXV: block_bc(cr, state->boxv); break;
case estPRES_PREV: block_bc(cr, state->pres_prev); break;
case estSVIR_PREV: block_bc(cr, state->svir_prev); break;
case estFVIR_PREV: block_bc(cr, state->fvir_prev); break;
case estNH_XI: nblock_abc(cr, nnht, state->nosehoover_xi); break;
case estNH_VXI: nblock_abc(cr, nnht, state->nosehoover_vxi); break;
case estNHPRES_XI: nblock_abc(cr, nnhtp, state->nhpres_xi); break;
case estNHPRES_VXI: nblock_abc(cr, nnhtp, state->nhpres_vxi); break;
case estTC_INT: nblock_abc(cr, state->ngtc, state->therm_integral); break;
case estVETA: block_bc(cr, state->veta); break;
case estVOL0: block_bc(cr, state->vol0); break;
case estX: nblock_abc(cr, state->natoms, state->x); break;
case estV: nblock_abc(cr, state->natoms, state->v); break;
case estSDX: nblock_abc(cr, state->natoms, state->sd_X); break;
case estCGP: nblock_abc(cr, state->natoms, state->cg_p); break;
case estDISRE_INITF: block_bc(cr, state->hist.disre_initf); break;
case estDISRE_RM3TAV:
block_bc(cr, state->hist.ndisrepairs);
nblock_abc(cr, state->hist.ndisrepairs, state->hist.disre_rm3tav);
break;
case estORIRE_INITF: block_bc(cr, state->hist.orire_initf); break;
case estORIRE_DTAV:
block_bc(cr, state->hist.norire_Dtav);
nblock_abc(cr, state->hist.norire_Dtav, state->hist.orire_Dtav);
break;
default:
gmx_fatal(FARGS,
"Communication is not implemented for %s in bcast_state",
est_names[i]);
}
}
}
}
void bcast_state(const t_commrec *cr, t_state *state)
{
int i, nnht, nnhtp;
if (!PAR(cr) || (cr->nnodes - cr->npmenodes <= 1))
{
return;
}
/* Broadcasts the state sizes and flags from the master to all nodes
* in cr->mpi_comm_mygroup. The arrays are not broadcasted. */
block_bc(cr, state->natoms);
block_bc(cr, state->ngtc);
block_bc(cr, state->nnhpres);
block_bc(cr, state->nhchainlength);
block_bc(cr, state->flags);
state->lambda.resize(efptNR);
if (cr->dd)
{
/* We allocate dynamically in dd_partition_system. */
return;
}
/* The code below is reachable only by TPI and NM, so it is not
tested by anything. */
nnht = (state->ngtc)*(state->nhchainlength);
nnhtp = (state->nnhpres)*(state->nhchainlength);
for (i = 0; i < estNR; i++)
{
if (state->flags & (1<<i))
{
switch (i)
{
case estLAMBDA: nblock_bc(cr, efptNR, state->lambda.data()); break;
case estFEPSTATE: block_bc(cr, state->fep_state); break;
case estBOX: block_bc(cr, state->box); break;
case estBOX_REL: block_bc(cr, state->box_rel); break;
case estBOXV: block_bc(cr, state->boxv); break;
case estPRES_PREV: block_bc(cr, state->pres_prev); break;
case estSVIR_PREV: block_bc(cr, state->svir_prev); break;
case estFVIR_PREV: block_bc(cr, state->fvir_prev); break;
case estNH_XI: nblock_abc(cr, nnht, &state->nosehoover_xi); break;
case estNH_VXI: nblock_abc(cr, nnht, &state->nosehoover_vxi); break;
case estNHPRES_XI: nblock_abc(cr, nnhtp, &state->nhpres_xi); break;
case estNHPRES_VXI: nblock_abc(cr, nnhtp, &state->nhpres_vxi); break;
case estTC_INT: nblock_abc(cr, state->ngtc, &state->therm_integral); break;
case estVETA: block_bc(cr, state->veta); break;
case estVOL0: block_bc(cr, state->vol0); break;
case estX: bcastPaddedRVecVector(cr, &state->x, state->natoms);
case estV: bcastPaddedRVecVector(cr, &state->v, state->natoms);
case estCGP: bcastPaddedRVecVector(cr, &state->cg_p, state->natoms);
case estDISRE_INITF: block_bc(cr, state->hist.disre_initf); break;
case estDISRE_RM3TAV:
block_bc(cr, state->hist.ndisrepairs);
nblock_abc(cr, state->hist.ndisrepairs, &state->hist.disre_rm3tav);
break;
case estORIRE_INITF: block_bc(cr, state->hist.orire_initf); break;
case estORIRE_DTAV:
block_bc(cr, state->hist.norire_Dtav);
nblock_abc(cr, state->hist.norire_Dtav, &state->hist.orire_Dtav);
break;
default:
gmx_fatal(FARGS,
"Communication is not implemented for %s in bcast_state",
est_names[i]);
}
}
}
}
static void bc_block(const t_commrec *cr, t_block *block)
{
block_bc(cr, block->nr);
snew_bc(cr, block->index, block->nr+1);
nblock_bc(cr, block->nr+1, block->index);
}
