removed fix_latte from src folder

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

   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator

   http://lammps.sandia.gov, Sandia National Laboratories

   Steve Plimpton, sjplimp@sandia.gov

   Copyright (2003) Sandia Corporation.  Under the terms of Contract

   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains

   certain rights in this software.  This software is distributed under

   the GNU General Public License.

   See the README file in the top-level LAMMPS directory.

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

// NOTES on possible future issues:

// LATTE compute and return 6-value virial tensor

// can LATTE compute per-atom energy and per-atom virial

// for minimize, what about charge DOFs

// implement charge DOF integration

// pass neighbor list to LATTE: half or full

// will we ever auto-adjust the timestep in reset_dt()

// could pass an input file to LATTE, specified in LAMMPS input script

// what units options can LAMMPS be using

// should LATTE take triclinic box from LAMMPS

// does Coulomb potential = pe[i]/q[i], is it 0 when q = 0

// how will this work for serial/parallel LAMMPS with serial/parallel LATTE

#include <stdio.h>

#include <string.h>

#include "fix_latte.h"

#include "atom.h"

#include "comm.h"

#include "update.h"

#include "neighbor.h"

#include "domain.h"

#include "force.h"

#include "neigh_request.h"

#include "neigh_list.h"

#include "modify.h"

#include "compute.h"

#include "memory.h"

#include "error.h"

using namespace LAMMPS_NS;

using namespace FixConst;

extern "C" {

  void latte(int *, int *, double *, int *, int *, 

             double *, double *, double *, double *, int*, double *, double *, double*);

}

#define INVOKED_PERATOM 8

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

FixLatte::FixLatte(LAMMPS *lmp, int narg, char **arg) :

  Fix(lmp, narg, arg)

{

  if (narg != 4) error->all(FLERR,"Illegal fix latte command");

  if (comm->nprocs != 1)

    error->all(FLERR,"Fix latte currently runs only in serial");

  scalar_flag = 1;

  global_freq = 1;

  extscalar = 1;

  virial_flag = 1;

  // store ID of compute pe/atom used to generate Coulomb potential for LATTE

  // NULL means LATTE will compute Coulombic potential

  coulomb = 0;

  id_pe = NULL;

  if (strcmp(arg[3],"NULL") != 0) {

    coulomb = 1;

    int n = strlen(arg[3]) + 1;

    id_pe = new char[n];

    strcpy(id_pe,arg[3]);

    int ipe = modify->find_compute(id_pe);

    if (ipe < 0) error->all(FLERR,"Could not find fix latte compute ID");

    if (modify->compute[ipe]->peatomflag == 0)

      error->all(FLERR,"Fix latte compute ID does not compute pe/atom");

  }

  // initializations

  nmax = 0;

  qpotential = NULL;

  flatte = NULL;

  latte_energy = 0.0;

}

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

FixLatte::~FixLatte()

{

  delete [] id_pe;

  memory->destroy(qpotential);

  memory->destroy(flatte);

}

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

int FixLatte::setmask()

{

  int mask = 0;

  //mask |= INITIAL_INTEGRATE;

  //mask |= FINAL_INTEGRATE;

  mask |= PRE_REVERSE;

  mask |= POST_FORCE;

  mask |= MIN_POST_FORCE;

  mask |= THERMO_ENERGY;

  return mask;

}

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

void FixLatte::init()

{

  // error checks

  if (domain->dimension == 2) 

    error->all(FLERR,"Fix latte requires 3d problem");

  if (coulomb) {

    if (atom->q_flag == 0 || force->pair == NULL || force->kspace == NULL)

      error->all(FLERR,"Fix latte cannot compute Coulombic potential");

    int ipe = modify->find_compute(id_pe);

    if (ipe < 0) error->all(FLERR,"Could not find fix latte compute ID");

    c_pe = modify->compute[ipe];

  }

  // must be fully periodic or fully non-periodic

  if (domain->nonperiodic == 0) pbcflag = 1;

  else if (!domain->xperiodic && !domain->yperiodic && !domain->zperiodic)

    pbcflag = 0;

  else error->all(FLERR,"Fix latte requires 3d simulation");

  // create qpotential & flatte if needed

  // for now, assume nlocal will never change

  if (coulomb && qpotential == NULL) {

    memory->create(qpotential,atom->nlocal,"latte:qpotential");

    memory->create(flatte,atom->nlocal,3,"latte:flatte");

  }

  /*

  // warn if any integrate fix comes after this one

  // is it actually necessary for q(n) update to come after x,v update ??

  int after = 0;

  int flag = 0;

  for (int i = 0; i < modify->nfix; i++) {

    if (strcmp(id,modify->fix[i]->id) == 0) after = 1;

    else if ((modify->fmask[i] & INITIAL_INTEGRATE) && after) flag = 1;

  }

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

    error->warning(FLERR,"Fix latte should come after all other "

                   "integration fixes");

  */

  /*

  // need a full neighbor list

  // could we use a half list?

  // perpetual list, built whenever re-neighboring occurs

  int irequest = neighbor->request(this,instance_me);

  neighbor->requests[irequest]->pair = 0;

  neighbor->requests[irequest]->fix = 1;

  neighbor->requests[irequest]->half = 0;

  neighbor->requests[irequest]->full = 1;

  */

}

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

void FixLatte::init_list(int id, NeighList *ptr)

{

  // list = ptr;

}

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

void FixLatte::setup(int vflag)

{

  post_force(vflag);

}

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

void FixLatte::min_setup(int vflag)

{

  post_force(vflag);

}

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

   integrate electronic degrees of freedom

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

void FixLatte::initial_integrate(int vflag) {}

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

   store eflag, so can use it in post_force to tally per-atom energies

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

void FixLatte::pre_reverse(int eflag, int vflag)

{

  eflag_caller = eflag;

}

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

void FixLatte::post_force(int vflag)

{

  int eflag = eflag_caller;

  if (eflag || vflag) ev_setup(eflag,vflag);

  else evflag = 0;

  // compute Coulombic potential = pe[i]/q[i]

  // invoke compute pe/atom

  // wrap with clear/add and trigger pe/atom calculation every step

  if (coulomb) {

    modify->clearstep_compute();

    if (!(c_pe->invoked_flag & INVOKED_PERATOM)) {

      c_pe->compute_peratom();

      c_pe->invoked_flag |= INVOKED_PERATOM;

    }

    modify->addstep_compute(update->ntimestep+1);

    double *pe = c_pe->vector_atom;

    double *q = atom->q;

    int nlocal = atom->nlocal;

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

      if (q[i]) qpotential[i] = pe[i]/q[i];

      else qpotential[i] = 0.0;

  }

  // hardwire these unsupported flags for now

  int coulombflag = 0;

  pe_peratom = 0;

  virial_global = 0;              // set via vflag_global at some point

  virial_peratom = 0;

  neighflag = 0;

  // set flags used by LATTE

  int flags[6];

  flags[0] = pbcflag;         // 1 for fully periodic, 0 for fully non-periodic

  flags[1] = coulombflag;     // 1 for LAMMPS computes Coulombics, 0 for LATTE

  flags[2] = pe_peratom;      // 1 to return per-atom energies, 0 for no

  flags[3] = virial_global;   // 1 to return global virial 0 for no

  flags[4] = virial_peratom;  // 1 to return per-atom virial, 0 for no

  flags[5] = neighflag;       // 1 to pass neighbor list to LATTE, 0 for no

  // setup LATTE arguments

  int natoms = atom->nlocal;

  double *coords = &atom->x[0][0];

  int *type = atom->type;

  int ntypes = atom->ntypes;

  double *mass = &atom->mass[1];

  double *boxlo = domain->boxlo;

  double *boxhi = domain->boxhi;

  double *forces;

  if (coulomb) forces = &flatte[0][0];

  else forces = &atom->f[0][0];

  // invoke LATTE

  int maxiter = -1;

  double *dt_latte = &update->dt;  

  double dt_latte_ang = *dt_latte * 1000.0; // Units of DT must be in Angstroms     

//   latte(flags,&natoms,coords,type,&ntypes,mass,boxlo,boxhi,

//         forces,&maxiter, &latte_energy, &atom->v[0][0],&update->dt);  

  latte(flags,&natoms,coords,type,&ntypes,mass,boxlo,boxhi,

        forces,&maxiter, &latte_energy, &atom->v[0][0], &dt_latte_ang);  

  // sum LATTE forces to LAMMPS (Coulombic) forces

  if (coulomb) {

    double **f = atom->f;

    int nlocal = atom->nlocal;

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

      f[i][0] += flatte[i][0];

      f[i][1] += flatte[i][1];

      f[i][2] += flatte[i][2];

    }

  }

}

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

   integrate electronic degrees of freedom

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

void FixLatte::final_integrate() {}

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

void FixLatte::reset_dt()

{

  //dtv = update->dt;

  //dtf = 0.5 * update->dt * force->ftm2v;

}

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

   DFTB energy from LATTE

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

double FixLatte::compute_scalar()

{

  return latte_energy;

}

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

   memory usage of local arrays

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

double FixLatte::memory_usage()

{

  double bytes = 0.0;

  if (coulomb) bytes += nmax * sizeof(double);

  if (coulomb) bytes += nmax*3 * sizeof(double);

  return bytes;

}