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 * check out http://www.gromacs.org for more information.
7 * Copyright (c) 2012, by the GROMACS development team, led by
8 * David van der Spoel, Berk Hess, Erik Lindahl, and including many
9 * others, as listed in the AUTHORS file in the top-level source
10 * 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! */
50 #include "gmx_fatal.h"
55 #define block_bc(cr, d) gmx_bcast( sizeof(d), &(d),(cr))
56 /* Probably the test for (nr) > 0 in the next macro is only needed
57 * on BlueGene(/L), where IBM's MPI_Bcast will segfault after
58 * dereferencing a null pointer, even when no data is to be transferred. */
59 #define nblock_bc(cr,nr,d) { if ((nr) > 0) gmx_bcast((nr)*sizeof((d)[0]), (d),(cr)); }
60 #define snew_bc(cr,d,nr) { if (!MASTER(cr)) snew((d),(nr)); }
61 /* Dirty macro with bAlloc not as an argument */
62 #define nblock_abc(cr,nr,d) { if (bAlloc) snew((d),(nr)); nblock_bc(cr,(nr),(d)); }
64 static void bc_string(const t_commrec *cr,t_symtab *symtab,char ***s)
69 handle = lookup_symtab(symtab,*s);
73 *s = get_symtab_handle(symtab,handle);
77 static void bc_strings(const t_commrec *cr,t_symtab *symtab,int nr,char ****nm)
87 handle[i] = lookup_symtab(symtab,NM[i]);
89 nblock_bc(cr,nr,handle);
94 for (i=0; (i<nr); i++)
95 (*nm)[i] = get_symtab_handle(symtab,handle[i]);
100 static void bc_strings_resinfo(const t_commrec *cr,t_symtab *symtab,
101 int nr,t_resinfo *resinfo)
108 for(i=0; (i<nr); i++)
109 handle[i] = lookup_symtab(symtab,resinfo[i].name);
111 nblock_bc(cr,nr,handle);
114 for (i=0; (i<nr); i++)
115 resinfo[i].name = get_symtab_handle(symtab,handle[i]);
120 static void bc_symtab(const t_commrec *cr,t_symtab *symtab)
125 block_bc(cr,symtab->nr);
127 snew_bc(cr,symtab->symbuf,1);
128 symbuf = symtab->symbuf;
129 symbuf->bufsize = nr;
130 snew_bc(cr,symbuf->buf,nr);
131 for (i=0; i<nr; i++) {
133 len = strlen(symbuf->buf[i]) + 1;
135 snew_bc(cr,symbuf->buf[i],len);
136 nblock_bc(cr,len,symbuf->buf[i]);
140 static void bc_block(const t_commrec *cr,t_block *block)
142 block_bc(cr,block->nr);
143 snew_bc(cr,block->index,block->nr+1);
144 nblock_bc(cr,block->nr+1,block->index);
147 static void bc_blocka(const t_commrec *cr,t_blocka *block)
149 block_bc(cr,block->nr);
150 snew_bc(cr,block->index,block->nr+1);
151 nblock_bc(cr,block->nr+1,block->index);
152 block_bc(cr,block->nra);
154 snew_bc(cr,block->a,block->nra);
155 nblock_bc(cr,block->nra,block->a);
159 static void bc_grps(const t_commrec *cr,t_grps grps[])
163 for(i=0; (i<egcNR); i++) {
164 block_bc(cr,grps[i].nr);
165 snew_bc(cr,grps[i].nm_ind,grps[i].nr);
166 nblock_bc(cr,grps[i].nr,grps[i].nm_ind);
170 static void bc_atoms(const t_commrec *cr,t_symtab *symtab,t_atoms *atoms)
174 block_bc(cr,atoms->nr);
175 snew_bc(cr,atoms->atom,atoms->nr);
176 nblock_bc(cr,atoms->nr,atoms->atom);
177 bc_strings(cr,symtab,atoms->nr,&atoms->atomname);
178 block_bc(cr,atoms->nres);
179 snew_bc(cr,atoms->resinfo,atoms->nres);
180 nblock_bc(cr,atoms->nres,atoms->resinfo);
181 bc_strings_resinfo(cr,symtab,atoms->nres,atoms->resinfo);
182 /* QMMM requires atomtypes to be known on all nodes as well */
183 bc_strings(cr,symtab,atoms->nr,&atoms->atomtype);
184 bc_strings(cr,symtab,atoms->nr,&atoms->atomtypeB);
187 static void bc_groups(const t_commrec *cr,t_symtab *symtab,
188 int natoms,gmx_groups_t *groups)
193 bc_grps(cr,groups->grps);
194 block_bc(cr,groups->ngrpname);
195 bc_strings(cr,symtab,groups->ngrpname,&groups->grpname);
196 for(g=0; g<egcNR; g++) {
198 if (groups->grpnr[g]) {
206 groups->grpnr[g] = NULL;
208 snew_bc(cr,groups->grpnr[g],n);
209 nblock_bc(cr,n,groups->grpnr[g]);
212 if (debug) fprintf(debug,"after bc_groups\n");
215 void bcast_state_setup(const t_commrec *cr,t_state *state)
217 block_bc(cr,state->natoms);
218 block_bc(cr,state->ngtc);
219 block_bc(cr,state->nnhpres);
220 block_bc(cr,state->nhchainlength);
221 block_bc(cr,state->nrng);
222 block_bc(cr,state->nrngi);
223 block_bc(cr,state->flags);
224 if (state->lambda==NULL)
226 snew_bc(cr,state->lambda,efptNR)
230 void bcast_state(const t_commrec *cr,t_state *state,gmx_bool bAlloc)
234 bcast_state_setup(cr,state);
236 nnht = (state->ngtc)*(state->nhchainlength);
237 nnhtp = (state->nnhpres)*(state->nhchainlength);
243 state->nalloc = state->natoms;
245 for(i=0; i<estNR; i++) {
246 if (state->flags & (1<<i)) {
248 case estLAMBDA: nblock_bc(cr,efptNR,state->lambda); break;
249 case estFEPSTATE: block_bc(cr,state->fep_state); break;
250 case estBOX: block_bc(cr,state->box); break;
251 case estBOX_REL: block_bc(cr,state->box_rel); break;
252 case estBOXV: block_bc(cr,state->boxv); break;
253 case estPRES_PREV: block_bc(cr,state->pres_prev); break;
254 case estSVIR_PREV: block_bc(cr,state->svir_prev); break;
255 case estFVIR_PREV: block_bc(cr,state->fvir_prev); break;
256 case estNH_XI: nblock_abc(cr,nnht,state->nosehoover_xi); break;
257 case estNH_VXI: nblock_abc(cr,nnht,state->nosehoover_vxi); break;
258 case estNHPRES_XI: nblock_abc(cr,nnhtp,state->nhpres_xi); break;
259 case estNHPRES_VXI: nblock_abc(cr,nnhtp,state->nhpres_vxi); break;
260 case estTC_INT: nblock_abc(cr,state->ngtc,state->therm_integral); break;
261 case estVETA: block_bc(cr,state->veta); break;
262 case estVOL0: block_bc(cr,state->vol0); break;
263 case estX: nblock_abc(cr,state->natoms,state->x); break;
264 case estV: nblock_abc(cr,state->natoms,state->v); break;
265 case estSDX: nblock_abc(cr,state->natoms,state->sd_X); break;
266 case estCGP: nblock_abc(cr,state->natoms,state->cg_p); break;
267 case estLD_RNG: if(state->nrngi == 1) nblock_abc(cr,state->nrng,state->ld_rng); break;
268 case estLD_RNGI: if(state->nrngi == 1) nblock_abc(cr,state->nrngi,state->ld_rngi); break;
269 case estDISRE_INITF: block_bc(cr,state->hist.disre_initf); break;
270 case estDISRE_RM3TAV:
271 block_bc(cr,state->hist.ndisrepairs);
272 nblock_abc(cr,state->hist.ndisrepairs,state->hist.disre_rm3tav);
274 case estORIRE_INITF: block_bc(cr,state->hist.orire_initf); break;
276 block_bc(cr,state->hist.norire_Dtav);
277 nblock_abc(cr,state->hist.norire_Dtav,state->hist.orire_Dtav);
281 "Communication is not implemented for %s in bcast_state",
288 static void bc_ilists(const t_commrec *cr,t_ilist *ilist)
292 /* Here we only communicate the non-zero length ilists */
294 for(ftype=0; ftype<F_NRE; ftype++) {
295 if (ilist[ftype].nr > 0) {
297 block_bc(cr,ilist[ftype].nr);
298 nblock_bc(cr,ilist[ftype].nr,ilist[ftype].iatoms);
304 for(ftype=0; ftype<F_NRE; ftype++) {
310 block_bc(cr,ilist[ftype].nr);
311 snew_bc(cr,ilist[ftype].iatoms,ilist[ftype].nr);
312 nblock_bc(cr,ilist[ftype].nr,ilist[ftype].iatoms);
314 } while (ftype >= 0);
317 if (debug) fprintf(debug,"after bc_ilists\n");
320 static void bc_cmap(const t_commrec *cr, gmx_cmap_t *cmap_grid)
324 block_bc(cr,cmap_grid->ngrid);
325 block_bc(cr,cmap_grid->grid_spacing);
327 ngrid = cmap_grid->ngrid;
328 nelem = cmap_grid->grid_spacing * cmap_grid->grid_spacing;
332 snew_bc(cr,cmap_grid->cmapdata,ngrid);
336 snew_bc(cr,cmap_grid->cmapdata[i].cmap,4*nelem);
337 nblock_bc(cr,4*nelem,cmap_grid->cmapdata[i].cmap);
342 static void bc_ffparams(const t_commrec *cr,gmx_ffparams_t *ffp)
346 block_bc(cr,ffp->ntypes);
347 block_bc(cr,ffp->atnr);
348 snew_bc(cr,ffp->functype,ffp->ntypes);
349 snew_bc(cr,ffp->iparams,ffp->ntypes);
350 nblock_bc(cr,ffp->ntypes,ffp->functype);
351 nblock_bc(cr,ffp->ntypes,ffp->iparams);
352 block_bc(cr,ffp->reppow);
353 block_bc(cr,ffp->fudgeQQ);
354 bc_cmap(cr,&ffp->cmap_grid);
357 static void bc_grpopts(const t_commrec *cr,t_grpopts *g)
361 block_bc(cr,g->ngtc);
362 block_bc(cr,g->ngacc);
363 block_bc(cr,g->ngfrz);
364 block_bc(cr,g->ngener);
365 snew_bc(cr,g->nrdf,g->ngtc);
366 snew_bc(cr,g->tau_t,g->ngtc);
367 snew_bc(cr,g->ref_t,g->ngtc);
368 snew_bc(cr,g->acc,g->ngacc);
369 snew_bc(cr,g->nFreeze,g->ngfrz);
370 snew_bc(cr,g->egp_flags,g->ngener*g->ngener);
372 nblock_bc(cr,g->ngtc,g->nrdf);
373 nblock_bc(cr,g->ngtc,g->tau_t);
374 nblock_bc(cr,g->ngtc,g->ref_t);
375 nblock_bc(cr,g->ngacc,g->acc);
376 nblock_bc(cr,g->ngfrz,g->nFreeze);
377 nblock_bc(cr,g->ngener*g->ngener,g->egp_flags);
378 snew_bc(cr,g->annealing,g->ngtc);
379 snew_bc(cr,g->anneal_npoints,g->ngtc);
380 snew_bc(cr,g->anneal_time,g->ngtc);
381 snew_bc(cr,g->anneal_temp,g->ngtc);
382 nblock_bc(cr,g->ngtc,g->annealing);
383 nblock_bc(cr,g->ngtc,g->anneal_npoints);
384 for(i=0;(i<g->ngtc); i++) {
385 n = g->anneal_npoints[i];
387 snew_bc(cr,g->anneal_time[i],n);
388 snew_bc(cr,g->anneal_temp[i],n);
389 nblock_bc(cr,n,g->anneal_time[i]);
390 nblock_bc(cr,n,g->anneal_temp[i]);
394 /* QMMM stuff, see inputrec */
395 block_bc(cr,g->ngQM);
396 snew_bc(cr,g->QMmethod,g->ngQM);
397 snew_bc(cr,g->QMbasis,g->ngQM);
398 snew_bc(cr,g->QMcharge,g->ngQM);
399 snew_bc(cr,g->QMmult,g->ngQM);
400 snew_bc(cr,g->bSH,g->ngQM);
401 snew_bc(cr,g->CASorbitals,g->ngQM);
402 snew_bc(cr,g->CASelectrons,g->ngQM);
403 snew_bc(cr,g->SAon,g->ngQM);
404 snew_bc(cr,g->SAoff,g->ngQM);
405 snew_bc(cr,g->SAsteps,g->ngQM);
409 nblock_bc(cr,g->ngQM,g->QMmethod);
410 nblock_bc(cr,g->ngQM,g->QMbasis);
411 nblock_bc(cr,g->ngQM,g->QMcharge);
412 nblock_bc(cr,g->ngQM,g->QMmult);
413 nblock_bc(cr,g->ngQM,g->bSH);
414 nblock_bc(cr,g->ngQM,g->CASorbitals);
415 nblock_bc(cr,g->ngQM,g->CASelectrons);
416 nblock_bc(cr,g->ngQM,g->SAon);
417 nblock_bc(cr,g->ngQM,g->SAoff);
418 nblock_bc(cr,g->ngQM,g->SAsteps);
419 /* end of QMMM stuff */
423 static void bc_cosines(const t_commrec *cr,t_cosines *cs)
426 snew_bc(cr,cs->a,cs->n);
427 snew_bc(cr,cs->phi,cs->n);
429 nblock_bc(cr,cs->n,cs->a);
430 nblock_bc(cr,cs->n,cs->phi);
434 static void bc_pullgrp(const t_commrec *cr,t_pullgrp *pgrp)
438 snew_bc(cr,pgrp->ind,pgrp->nat);
439 nblock_bc(cr,pgrp->nat,pgrp->ind);
441 if (pgrp->nweight > 0) {
442 snew_bc(cr,pgrp->weight,pgrp->nweight);
443 nblock_bc(cr,pgrp->nweight,pgrp->weight);
447 static void bc_pull(const t_commrec *cr,t_pull *pull)
452 snew_bc(cr,pull->grp,pull->ngrp+1);
453 for(g=0; g<pull->ngrp+1; g++)
455 bc_pullgrp(cr,&pull->grp[g]);
459 static void bc_rotgrp(const t_commrec *cr,t_rotgrp *rotg)
463 snew_bc(cr,rotg->ind,rotg->nat);
464 nblock_bc(cr,rotg->nat,rotg->ind);
465 snew_bc(cr,rotg->x_ref,rotg->nat);
466 nblock_bc(cr,rotg->nat,rotg->x_ref);
470 static void bc_rot(const t_commrec *cr,t_rot *rot)
475 snew_bc(cr,rot->grp,rot->ngrp);
476 for(g=0; g<rot->ngrp; g++)
477 bc_rotgrp(cr,&rot->grp[g]);
480 static void bc_adress(const t_commrec *cr,t_adress *adress)
482 block_bc(cr,*adress);
483 if (adress->n_tf_grps > 0) {
484 snew_bc(cr, adress->tf_table_index, adress->n_tf_grps);
485 nblock_bc(cr, adress->n_tf_grps, adress->tf_table_index);
487 if (adress->n_energy_grps > 0) {
488 snew_bc(cr, adress->group_explicit, adress->n_energy_grps);
489 nblock_bc(cr, adress->n_energy_grps, adress->group_explicit);
492 static void bc_fepvals(const t_commrec *cr,t_lambda *fep)
494 gmx_bool bAlloc=TRUE;
497 block_bc(cr,fep->nstdhdl);
498 block_bc(cr,fep->init_lambda);
499 block_bc(cr,fep->init_fep_state);
500 block_bc(cr,fep->delta_lambda);
501 block_bc(cr,fep->bPrintEnergy);
502 block_bc(cr,fep->n_lambda);
503 snew_bc(cr,fep->all_lambda,efptNR);
504 nblock_bc(cr,efptNR,fep->all_lambda);
505 for (i=0;i<efptNR;i++) {
506 snew_bc(cr,fep->all_lambda[i],fep->n_lambda);
507 nblock_bc(cr,fep->n_lambda,fep->all_lambda[i]);
509 block_bc(cr,fep->sc_alpha);
510 block_bc(cr,fep->sc_power);
511 block_bc(cr,fep->sc_r_power);
512 block_bc(cr,fep->sc_sigma);
513 block_bc(cr,fep->sc_sigma_min);
514 block_bc(cr,fep->bScCoul);
515 nblock_bc(cr,efptNR,&(fep->separate_dvdl[0]));
516 block_bc(cr,fep->dhdl_derivatives);
517 block_bc(cr,fep->dh_hist_size);
518 block_bc(cr,fep->dh_hist_spacing);
521 fprintf(debug,"after bc_fepvals\n");
525 static void bc_expandedvals(const t_commrec *cr,t_expanded *expand, int n_lambda)
527 gmx_bool bAlloc=TRUE;
530 block_bc(cr,expand->nstexpanded);
531 block_bc(cr,expand->elamstats);
532 block_bc(cr,expand->elmcmove);
533 block_bc(cr,expand->elmceq);
534 block_bc(cr,expand->equil_n_at_lam);
535 block_bc(cr,expand->equil_wl_delta);
536 block_bc(cr,expand->equil_ratio);
537 block_bc(cr,expand->equil_steps);
538 block_bc(cr,expand->equil_samples);
539 block_bc(cr,expand->lmc_seed);
540 block_bc(cr,expand->minvar);
541 block_bc(cr,expand->minvar_const);
542 block_bc(cr,expand->c_range);
543 block_bc(cr,expand->bSymmetrizedTMatrix);
544 block_bc(cr,expand->nstTij);
545 block_bc(cr,expand->lmc_repeats);
546 block_bc(cr,expand->lmc_forced_nstart);
547 block_bc(cr,expand->gibbsdeltalam);
548 block_bc(cr,expand->wl_scale);
549 block_bc(cr,expand->wl_ratio);
550 block_bc(cr,expand->init_wl_delta);
551 block_bc(cr,expand->bInit_weights);
552 snew_bc(cr,expand->init_lambda_weights,n_lambda);
553 nblock_bc(cr,n_lambda,expand->init_lambda_weights);
554 block_bc(cr,expand->mc_temp);
557 fprintf(debug,"after bc_expandedvals\n");
561 static void bc_simtempvals(const t_commrec *cr,t_simtemp *simtemp, int n_lambda)
563 gmx_bool bAlloc=TRUE;
566 block_bc(cr,simtemp->simtemp_low);
567 block_bc(cr,simtemp->simtemp_high);
568 block_bc(cr,simtemp->eSimTempScale);
569 snew_bc(cr,simtemp->temperatures,n_lambda);
570 nblock_bc(cr,n_lambda,simtemp->temperatures);
573 fprintf(debug,"after bc_simtempvals\n");
577 static void bc_inputrec(const t_commrec *cr,t_inputrec *inputrec)
579 gmx_bool bAlloc=TRUE;
582 block_bc(cr,*inputrec);
584 bc_grpopts(cr,&(inputrec->opts));
586 /* even if efep is efepNO, we need to initialize to make sure that
587 * n_lambda is set to zero */
589 snew_bc(cr,inputrec->fepvals,1);
590 if (inputrec->efep != efepNO || inputrec->bSimTemp)
592 bc_fepvals(cr,inputrec->fepvals);
594 /* need to initialize this as well because of data checked for in the logic */
595 snew_bc(cr,inputrec->expandedvals,1);
596 if (inputrec->bExpanded)
598 bc_expandedvals(cr,inputrec->expandedvals,inputrec->fepvals->n_lambda);
600 snew_bc(cr,inputrec->simtempvals,1);
601 if (inputrec->bSimTemp)
603 bc_simtempvals(cr,inputrec->simtempvals,inputrec->fepvals->n_lambda);
605 if (inputrec->ePull != epullNO) {
606 snew_bc(cr,inputrec->pull,1);
607 bc_pull(cr,inputrec->pull);
609 if (inputrec->bRot) {
610 snew_bc(cr,inputrec->rot,1);
611 bc_rot(cr,inputrec->rot);
613 for(i=0; (i<DIM); i++) {
614 bc_cosines(cr,&(inputrec->ex[i]));
615 bc_cosines(cr,&(inputrec->et[i]));
617 if (inputrec->bAdress) {
618 snew_bc(cr,inputrec->adress,1);
619 bc_adress(cr,inputrec->adress);
623 static void bc_moltype(const t_commrec *cr,t_symtab *symtab,
624 gmx_moltype_t *moltype)
626 bc_string(cr,symtab,&moltype->name);
627 bc_atoms(cr,symtab,&moltype->atoms);
628 if (debug) fprintf(debug,"after bc_atoms\n");
630 bc_ilists(cr,moltype->ilist);
631 bc_block(cr,&moltype->cgs);
632 bc_blocka(cr,&moltype->excls);
635 static void bc_molblock(const t_commrec *cr,gmx_molblock_t *molb)
637 gmx_bool bAlloc=TRUE;
639 block_bc(cr,molb->type);
640 block_bc(cr,molb->nmol);
641 block_bc(cr,molb->natoms_mol);
642 block_bc(cr,molb->nposres_xA);
643 if (molb->nposres_xA > 0) {
644 snew_bc(cr,molb->posres_xA,molb->nposres_xA);
645 nblock_bc(cr,molb->nposres_xA*DIM,molb->posres_xA[0]);
647 block_bc(cr,molb->nposres_xB);
648 if (molb->nposres_xB > 0) {
649 snew_bc(cr,molb->posres_xB,molb->nposres_xB);
650 nblock_bc(cr,molb->nposres_xB*DIM,molb->posres_xB[0]);
652 if (debug) fprintf(debug,"after bc_molblock\n");
655 static void bc_atomtypes(const t_commrec *cr, t_atomtypes *atomtypes)
659 block_bc(cr,atomtypes->nr);
663 snew_bc(cr,atomtypes->radius,nr);
664 snew_bc(cr,atomtypes->vol,nr);
665 snew_bc(cr,atomtypes->surftens,nr);
666 snew_bc(cr,atomtypes->gb_radius,nr);
667 snew_bc(cr,atomtypes->S_hct,nr);
669 nblock_bc(cr,nr,atomtypes->radius);
670 nblock_bc(cr,nr,atomtypes->vol);
671 nblock_bc(cr,nr,atomtypes->surftens);
672 nblock_bc(cr,nr,atomtypes->gb_radius);
673 nblock_bc(cr,nr,atomtypes->S_hct);
677 void bcast_ir_mtop(const t_commrec *cr,t_inputrec *inputrec,gmx_mtop_t *mtop)
680 if (debug) fprintf(debug,"in bc_data\n");
681 bc_inputrec(cr,inputrec);
682 if (debug) fprintf(debug,"after bc_inputrec\n");
683 bc_symtab(cr,&mtop->symtab);
684 if (debug) fprintf(debug,"after bc_symtab\n");
685 bc_string(cr,&mtop->symtab,&mtop->name);
686 if (debug) fprintf(debug,"after bc_name\n");
688 bc_ffparams(cr,&mtop->ffparams);
690 block_bc(cr,mtop->nmoltype);
691 snew_bc(cr,mtop->moltype,mtop->nmoltype);
692 for(i=0; i<mtop->nmoltype; i++) {
693 bc_moltype(cr,&mtop->symtab,&mtop->moltype[i]);
696 block_bc(cr,mtop->nmolblock);
697 snew_bc(cr,mtop->molblock,mtop->nmolblock);
698 for(i=0; i<mtop->nmolblock; i++) {
699 bc_molblock(cr,&mtop->molblock[i]);
702 block_bc(cr,mtop->natoms);
704 bc_atomtypes(cr,&mtop->atomtypes);
706 bc_block(cr,&mtop->mols);
707 bc_groups(cr,&mtop->symtab,mtop->natoms,&mtop->groups);