src/gmxlib/mvdata.c

   1 /*
   2  * $Id$
   3  *
   4  *       This source code is part of
   5  *
   6  *        G   R   O   M   A   C   S
   7  *
   8  * GROningen MAchine for Chemical Simulations
   9  *
  10  *               VERSION 2.0
  11  *
  12  * Copyright (c) 1991-1999
  13  * BIOSON Research Institute, Dept. of Biophysical Chemistry
  14  * University of Groningen, The Netherlands
  15  *
  16  * Please refer to:
  17  * GROMACS: A message-passing parallel molecular dynamics implementation
  18  * H.J.C. Berendsen, D. van der Spoel and R. van Drunen
  19  * Comp. Phys. Comm. 91, 43-56 (1995)
  20  *
  21  * Also check out our WWW page:
  22  * http://md.chem.rug.nl/~gmx
  23  * or e-mail to:
  24  * gromacs@chem.rug.nl
  25  *
  26  * And Hey:
  27  * Green Red Orange Magenta Azure Cyan Skyblue
  28  */
  29 static char *SRCID_mvdata_c = "$Id$";
  30
  31 #include <sysstuff.h>
  32 #include <string.h>
  33 #include "typedefs.h"
  34 #include "main.h"
  35 #include "assert.h"
  36 #include "mvdata.h"
  37 #include "network.h"
  38 #include "smalloc.h"
  39 #include "fatal.h"
  40 #include "symtab.h"
  41 #include "vec.h"
  42 #include "tgroup.h"
  43 #include "block_tx.h"
  44
  45 static void ld_nsb(int src,t_nsborder *nsb)
  46 {
  47   blockrx(src,nsb->nprocs);
  48   blockrx(src,nsb->shift);
  49   blockrx(src,nsb->bshift);
  50   blockrx(src,nsb->nstDlb);
  51   blockrx(src,nsb->cgtotal);
  52   blockrx(src,nsb->natoms);
  53   nblockrx(src,MAXPROC,nsb->homenr);
  54   nblockrx(src,MAXPROC,nsb->index);
  55   nblockrx(src,MAXPROC,nsb->cgload);
  56   nblockrx(src,MAXPROC,nsb->workload);
  57 }
  58
  59 static char **ld_string(int src,t_symtab *symtab)
  60 {
  61   int name;
  62
  63   blockrx(src,name);
  64   return get_symtab_handle(symtab,name);
  65 }
  66
  67 static int ld_strings(int src,t_symtab *symtab,char ****nm)
  68 {
  69   int  i,nr;
  70   int  *handle;
  71   char ***NM;
  72
  73   blockrx(src,nr);
  74   snew(handle,nr);
  75   nblockrx(src,nr,handle);
  76
  77   snew(*nm,nr);
  78   NM=*nm;
  79   for (i=0; (i<nr); i++)
  80     NM[i]=get_symtab_handle(symtab,handle[i]);
  81   sfree(handle);
  82
  83   return nr;
  84 }
  85
  86 static void ld_symtab(int src,t_symtab *symtab)
  87 {
  88   int i,nr,len;
  89
  90   blockrx(src,symtab->nr);
  91   nr=symtab->nr;
  92   snew(symtab->symbuf,1);
  93   symtab->symbuf->bufsize=nr;
  94   snew(symtab->symbuf->buf,nr);
  95   for (i=0; i<nr; i++)
  96     {
  97       blockrx(src,len);
  98       snew(symtab->symbuf->buf[i],len);
  99       nblockrx(src,len,symtab->symbuf->buf[i]);
 100     }
 101 }
 102
 103 static void ld_grps(int src,t_grps grps[])
 104 {
 105   int i;
 106
 107   for(i=0; (i<egcNR); i++) {
 108     blockrx(src,grps[i].nr);
 109     snew(grps[i].nm_ind,grps[i].nr);
 110     nblockrx(src,grps[i].nr,grps[i].nm_ind);
 111   }
 112   for( ; (i<egcNR); i++) {
 113     grps[i].nr=0;
 114     grps[i].nm_ind=NULL;
 115   }
 116 }
 117
 118 static void ld_atoms(int src,t_symtab *symtab,t_atoms *atoms)
 119 {
 120   int atomnr;
 121
 122   blockrx(src,atoms->nr);
 123   snew(atoms->atom,atoms->nr);
 124   nblockrx(src,atoms->nr,atoms->atom);
 125   atomnr=ld_strings(src,symtab,&atoms->atomname);
 126   assert(atomnr==atoms->nr);
 127   atoms->nres=ld_strings(src,symtab,&atoms->resname);
 128   atoms->ngrpname=ld_strings(src,symtab,&atoms->grpname);
 129   ld_grps(src,atoms->grps);
 130   ld_block(src,&atoms->excl);
 131 }
 132
 133 static void ld_vectors(int src,rvec x[],rvec v[])
 134 {
 135   int natoms;
 136
 137   blockrx(src,natoms);
 138   nblockrx(src,natoms,x);
 139   nblockrx(src,natoms,v);
 140 }
 141
 142 static void ld_ilist(int src,t_ilist *ilist)
 143 {
 144   blockrx(src,ilist->nr);
 145   nblockrx(src,MAXPROC,ilist->multinr);
 146   snew(ilist->iatoms,ilist->nr);
 147   nblockrx(src,ilist->nr,ilist->iatoms);
 148 }
 149
 150 static void ld_idef(int src,t_idef *idef)
 151 {
 152   int i;
 153
 154   blockrx(src,idef->ntypes);
 155   blockrx(src,idef->atnr);
 156   snew(idef->functype,idef->ntypes);
 157   snew(idef->iparams,idef->ntypes);
 158   nblockrx(src,idef->ntypes,idef->functype);
 159   nblockrx(src,idef->ntypes,idef->iparams);
 160   for(i=0; (i<F_NRE); i++)
 161     ld_ilist(src,&idef->il[i]);
 162 }
 163
 164 static void ld_grpopts(int src,t_grpopts *g)
 165 {
 166   blockrx(src,g->ngtc);
 167   blockrx(src,g->ngacc);
 168   blockrx(src,g->ngfrz);
 169   snew(g->nrdf,g->ngtc);
 170   snew(g->tau_t,g->ngtc);
 171   snew(g->ref_t,g->ngtc);
 172   snew(g->acc,g->ngacc);
 173   snew(g->nFreeze,g->ngfrz);
 174   nblockrx(src,g->ngtc,g->nrdf);
 175   nblockrx(src,g->ngtc,g->tau_t);
 176   nblockrx(src,g->ngtc,g->ref_t);
 177   nblockrx(src,g->ngacc,g->acc);
 178   nblockrx(src,g->ngfrz,g->nFreeze);
 179 }
 180
 181 static void ld_cosines(int src,t_cosines *cs)
 182 {
 183   blockrx(src,cs->n);
 184   snew(cs->a,cs->n);
 185   snew(cs->phi,cs->n);
 186   if (cs->n > 0) {
 187     nblockrx(src,cs->n,cs->a);
 188     nblockrx(src,cs->n,cs->phi);
 189   }
 190 }
 191
 192 static void ld_parm(int src,t_parm *parm)
 193 {
 194   int i;
 195
 196   blockrx(src,*parm);
 197   ld_grpopts(src,&(parm->ir.opts));
 198   for(i=0; (i<DIM); i++) {
 199     ld_cosines(src,&(parm->ir.ex[i]));
 200     ld_cosines(src,&(parm->ir.et[i]));
 201   }
 202 }
 203
 204 void ld_data(int left,int right,t_parm *parm,t_nsborder *nsb,
 205              t_topology *top,rvec **x,rvec **v)
 206 {
 207   int i;
 208
 209   ld_parm(left,parm);
 210   if (debug) fprintf(stdlog,"after ld_parm");
 211   ld_nsb(left,nsb);
 212   if (debug) fprintf(stdlog,"after ld_nsb");
 213   ld_symtab(left,&top->symtab);
 214   if (debug) fprintf(stdlog,"after ld_symtab");
 215   top->name=ld_string(left,&top->symtab);
 216   if (debug) fprintf(stdlog,"after ld_name");
 217   ld_atoms(left,&top->symtab,&top->atoms);
 218   if (debug) fprintf(stdlog,"after ld_atoms");
 219   ld_idef(left,&top->idef);
 220   if (debug) fprintf(stdlog,"after ld_idef");
 221   for (i=0; (i<ebNR); i++)
 222     ld_block(left,&top->blocks[i]);
 223   if (debug) fprintf(stdlog,"after ld_block");
 224   snew(*x,top->atoms.nr);
 225   snew(*v,top->atoms.nr);
 226   ld_vectors(left,*x,*v);
 227   if (debug) fprintf(stdlog,"after ld_vectors");
 228 }
 229
 230 static void mv_grpopts(int dest,t_grpopts *g)
 231 {
 232   blocktx(dest,g->ngtc);
 233   blocktx(dest,g->ngacc);
 234   blocktx(dest,g->ngfrz);
 235   nblocktx(dest,g->ngtc,g->nrdf);
 236   nblocktx(dest,g->ngtc,g->tau_t);
 237   nblocktx(dest,g->ngtc,g->ref_t);
 238   nblocktx(dest,g->ngacc,g->acc);
 239   nblocktx(dest,g->ngfrz,g->nFreeze);
 240 }
 241
 242 static void mv_cosines(int dest,t_cosines *cs)
 243 {
 244   blocktx(dest,cs->n);
 245   if (cs->n > 0) {
 246     nblocktx(dest,cs->n,cs->a);
 247     nblocktx(dest,cs->n,cs->phi);
 248   }
 249 }
 250
 251 static void mv_parm(int dest,t_parm *parm)
 252 {
 253   int i;
 254
 255   blocktx(dest,*parm);
 256   mv_grpopts(dest,&(parm->ir.opts));
 257   for(i=0; (i<DIM); i++) {
 258     mv_cosines(dest,&(parm->ir.ex[i]));
 259     mv_cosines(dest,&(parm->ir.et[i]));
 260   }
 261 }
 262
 263 static void mv_nsb(int dest,t_nsborder *nsb)
 264 {
 265   blocktx(dest,nsb->nprocs);
 266   blocktx(dest,nsb->shift);
 267   blocktx(dest,nsb->bshift);
 268   blocktx(dest,nsb->nstDlb);
 269   blocktx(dest,nsb->cgtotal);
 270   blocktx(dest,nsb->natoms);
 271   nblocktx(dest,MAXPROC,nsb->homenr);
 272   nblocktx(dest,MAXPROC,nsb->index);
 273   nblocktx(dest,MAXPROC,nsb->cgload);
 274   nblocktx(dest,MAXPROC,nsb->workload);
 275 }
 276
 277 static void mv_string(int dest,t_symtab *symtab,char **s)
 278 {
 279   int handle;
 280
 281   handle=lookup_symtab(symtab,s);
 282   blocktx(dest,handle);
 283 }
 284
 285 static void mv_strings(int dest,t_symtab *symtab,int nr,
 286                        char ***nm)
 287 {
 288   int i;
 289   int *handle;
 290
 291   snew(handle,nr);
 292   for(i=0; (i<nr); i++)
 293     handle[i]=lookup_symtab(symtab,nm[i]);
 294   blocktx(dest,nr);
 295   nblocktx(dest,nr,handle);
 296   sfree(handle);
 297 }
 298
 299 static void mv_symtab(int dest,t_symtab *symtab)
 300 {
 301   int i,nr,len;
 302   struct symbuf *symbuf;
 303
 304   blocktx(dest,symtab->nr);
 305   nr=symtab->nr;
 306   symbuf=symtab->symbuf;
 307   while (symbuf!=NULL)
 308     {
 309       for (i=0; (i<symbuf->bufsize)&&(i<nr); i++)
 310         {
 311           len=strlen(symbuf->buf[i])+1;
 312           blocktx(dest,len);
 313           nblocktx(dest,len,symbuf->buf[i]);
 314         }
 315       nr-=i;
 316       symbuf=symbuf->next;
 317     }
 318   assert(nr==0);
 319 }
 320
 321 static void mv_grps(int dest,t_grps grps[])
 322 {
 323   int i;
 324
 325   for(i=0; (i<egcNR); i++) {
 326     blocktx(dest,grps[i].nr);
 327     nblocktx(dest,grps[i].nr,grps[i].nm_ind);
 328   }
 329 }
 330
 331
 332 static void mv_atoms(int dest,t_symtab *symtab,t_atoms *atoms)
 333 {
 334   int nr;
 335
 336   nr=atoms->nr;
 337   blocktx(dest,nr);
 338   nblocktx(dest,nr,atoms->atom);
 339   mv_strings(dest,symtab,atoms->nr,atoms->atomname);
 340   mv_strings(dest,symtab,atoms->nres,atoms->resname);
 341   mv_strings(dest,symtab,atoms->ngrpname,atoms->grpname);
 342   mv_grps(dest,atoms->grps);
 343   mv_block(dest,&atoms->excl);
 344 }
 345
 346 static void mv_vectors(int dest,int natoms,rvec x[],rvec v[])
 347 {
 348   blocktx(dest,natoms);
 349   nblocktx(dest,natoms,x);
 350   nblocktx(dest,natoms,v);
 351 }
 352
 353 static void mv_ilist(int dest,t_ilist *ilist)
 354 {
 355   blocktx(dest,ilist->nr);
 356   nblocktx(dest,MAXPROC,ilist->multinr);
 357   nblocktx(dest,ilist->nr,ilist->iatoms);
 358 }
 359
 360 static void mv_idef(int dest,t_idef *idef)
 361 {
 362   int i;
 363
 364   blocktx(dest,idef->ntypes);
 365   blocktx(dest,idef->atnr);
 366   nblocktx(dest,idef->ntypes,idef->functype);
 367   nblocktx(dest,idef->ntypes,idef->iparams);
 368   for(i=0; (i<F_NRE); i++)
 369     mv_ilist(dest,&idef->il[i]);
 370 }
 371
 372 void mv_data(int left,int right,t_parm *parm,t_nsborder *nsb,
 373              t_topology *top,rvec x[],rvec v[])
 374 {
 375   int i;
 376
 377   mv_parm(right,parm);
 378   mv_nsb(right,nsb);
 379   mv_symtab(right,&top->symtab);
 380   mv_string(right,&top->symtab,top->name);
 381   mv_atoms(right,&top->symtab,&top->atoms);
 382   mv_idef(right,&top->idef);
 383   for (i=0; (i<ebNR); i++)
 384     mv_block(right,&top->blocks[i]);
 385   mv_vectors(right,top->atoms.nr,x,v);
 386 }
 387