convert weight array from class member to local pointer to temporary storage

  nimbalance = 0;

  imbalance = NULL;

  weight = NULL;

}

/* ---------------------------------------------------------------------- */

  for (int i; i < nimbalance; ++i)

    delete imbalance[i];

  delete [] imbalance;

  delete [] weight;

  if (fp) fclose(fp);

}

  nimbalance = 0;

  for (int i=iarg; i < narg; ++i)

    if (strcmp(arg[iarg],"weight") == 0) ++nimbalance;

  imbalance = new Imbalance*[nimbalance];

  if (nimbalance) imbalance = new Imbalance*[nimbalance];

  nimbalance = outflag = 0;

  while (iarg < narg) {

  if (domain->triclinic) domain->lamda2x(atom->nlocal);

  // compute and apply imbalance weights for local atoms

  double *weight = NULL;

  if (nimbalance > 0) {

    int i;

    const int nlocal = atom->nlocal;

      weight[i] = 1.0;

    for (i = 0; i < nimbalance; ++i)

      imbalance[i]->compute(weight);

  } else weight = NULL;

  }

  // imbinit = initial imbalance

  int maxinit;

  double imbinit = imbalance_nlocal(maxinit);

  double imbinit = imbalance_nlocal(maxinit,weight);

  // no load-balance if imbalance doesn't exceed threshhold

  // unless switching from tiled to non tiled layout, then force rebalance

  if (style == SHIFT) {

    comm->layout = LAYOUT_NONUNIFORM;

    shift_setup_static(bstr);

    niter = shift();

    niter = shift(weight);

  }

  // style BISECTION = recursive coordinate bisectioning

  if (style == BISECTION) {

    comm->layout = LAYOUT_TILED;

    bisection(1);

    bisection(weight,1);

  }

  // reset proc sub-domains

      weight[i] = 1.0;

    for (i = 0; i < nimbalance; ++i)

      imbalance[i]->compute(weight);

  } else weight = NULL;

  }

  // imbfinal = final imbalance based on final (weighted) nlocal

  int maxfinal;

  double imbfinal = imbalance_nlocal(maxfinal);

  double imbfinal = imbalance_nlocal(maxfinal,weight);

  delete[] weight;

  if (me == 0) {

    double stop_time = MPI_Wtime();

   return imbalance factor = max atom per proc / ave atom per proc

------------------------------------------------------------------------- */

double Balance::imbalance_nlocal(int &maxcost)

double Balance::imbalance_nlocal(int &maxcost, double *weight)

{

  // Compute the cost function of local atoms

   return imbalance factor = max atom per proc / ave atom per proc

------------------------------------------------------------------------- */

double Balance::imbalance_splits(int &max)

double Balance::imbalance_splits(int &max, double *weight)

{

  double *xsplit = comm->xsplit;

  double *ysplit = comm->ysplit;

   sortflag = flag for sorting order of received messages by proc ID

------------------------------------------------------------------------- */

int *Balance::bisection(int sortflag)

int *Balance::bisection(double *weight, int sortflag)

{

  if (!rcb) rcb = new RCB(lmp);

   return niter = iteration count

------------------------------------------------------------------------- */

int Balance::shift()

int Balance::shift(double *weight)

{

  int i,j,k,m,np,max;

  double *split;

    // intial count and sum

    np = procgrid[bdim[idim]];

    tally(bdim[idim],np,split);

    tally(bdim[idim],np,split,weight);

    double cost = 0.0;

    if (weight == NULL) {

    int change = 1;

    for (m = 0; m < nitermax; m++) {

      change = adjust(np,split);

      tally(bdim[idim],np,split);

      tally(bdim[idim],np,split,weight);

      niter++;

#ifdef BALANCE_DEBUG

    // stop at this point in bstr if imbalance factor < threshhold

    // this is a true 3d test of particle count per processor

    double imbfactor = imbalance_splits(max);

    double imbfactor = imbalance_splits(max,weight);

    if (imbfactor <= stopthresh) break;

  }

   use binary search to find which slice each atom is in

------------------------------------------------------------------------- */

void Balance::tally(int dim, int n, double *split)

void Balance::tally(int dim, int n, double *split, double *weight)

{

  double *onecost = new double[n];

  for (int i = 0; i < n; i++) onecost[i] = 0.0;

  ~Balance();

  void command(int, char **);

  void shift_setup(char *, int, double);

  int shift();

  int *bisection(int sortflag = 0);

  double imbalance_nlocal(int &);

  int shift(double *);

  int *bisection(double *, int sortflag = 0);

  double imbalance_nlocal(int &, double *);

  void dumpout(bigint, FILE *);

 private:

  int rho;                      // 0 for geometric recursion

                                // 1 for density weighted recursion

  int *proccount;            // particle count per processor

  int *proccount;               // (weighted) particle count per processor

  int *allproccount;

  int nimbalance;

  int nimbalance;               // number of imbalance weight computes

  class Imbalance **imbalance;  // list of imbalance compute classes

  double *weight;            // per (local) atom weight factor or NULL

  int outflag;                  // for output of balance results to file

  FILE *fp;

  int firststep;

  double imbalance_splits(int &);

  double imbalance_splits(int &, double *);

  void shift_setup_static(char *);

  void tally(int, int, double *);

  void tally(int, int, double *, double *);

  int adjust(int, double *);

  int binary(double, int, double *);

#ifdef BALANCE_DEBUG