remove unused custom constructor

  if (lmp->citeme) lmp->citeme->add(cite_neb_spin);

}

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

   internal NEBSpin constructor, called from TAD

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

NEBSpin::NEBSpin(LAMMPS *lmp, double etol_in, double ftol_in, int n1steps_in,

         int n2steps_in, int nevery_in, double *buf_init, double *buf_final)

  : Pointers(lmp)

{

  etol = etol_in;

  ttol = ftol_in;

  n1steps = n1steps_in;

  n2steps = n2steps_in;

  nevery = nevery_in;

  // replica info

  nreplica = universe->nworlds;

  ireplica = universe->iworld;

  me_universe = universe->me;

  uworld = universe->uworld;

  MPI_Comm_rank(world,&me);

  // fraction to interpolate intermediate replica

  double fraction = ireplica/(nreplica-1.0);

  double **sp = atom->sp;

  int nlocal = atom->nlocal;

  int temp_flag,rot_flag;

  temp_flag = rot_flag = 0;

  int ii = 0;

  double spinit[3],spfinal[3];

  for (int i = 0; i < nlocal; i++) {

    spinit[0] = buf_init[ii];

    spinit[1] = buf_init[ii+1];

    spinit[2] = buf_init[ii+2];

    spfinal[0] = buf_final[ii];

    spfinal[1] = buf_final[ii+1];

    spfinal[2] = buf_final[ii+2];

    // interpolate intermediate spin states

    if (fraction == 0.0) {

      sp[i][0] = spinit[0];

      sp[i][1] = spinit[1];

      sp[i][2] = spinit[2];

    } else if (fraction == 1.0) {

      sp[i][0] = spfinal[0];

      sp[i][1] = spfinal[1];

      sp[i][2] = spfinal[2];

    } else {

      temp_flag = initial_rotation(spinit,spfinal,fraction);

      rot_flag = MAX(temp_flag,rot_flag);

      sp[i][0] = spfinal[0];

      sp[i][1] = spfinal[1];

      sp[i][2] = spfinal[2];

    }

    ii += 3;

  }

  // warning message if one or more couples (spi,spf) were aligned

  // this breaks Rodrigues' formula, and an arbitrary rotation

  // vector has to be chosen

  if ((rot_flag > 0) && (comm->me == 0))

    error->warning(FLERR,"arbitrary initial rotation of one or more spin(s)");

}

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

NEBSpin::~NEBSpin()

class NEBSpin : protected Pointers {

 public:

  NEBSpin(class LAMMPS *);

  NEBSpin(class LAMMPS *, double, double, int, int, int, double *, double *);

  ~NEBSpin();

  void command(int, char **);  // process neb/spin command

  void run();                  // run NEBSpin