Commit 14251948 authored by dilkins's avatar dilkins
Browse files

LAMMPS coding conventions

parent 799ffc58

src/USER-MISC/fix_ffl.cpp

+303 −353
Original line number Diff line number Diff line
@@ -62,8 +62,7 @@ enum {CONSTANT,EQUAL,ATOM}; 




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

    Fix(lmp, narg, arg)

{

  Fix(lmp, narg, arg) {





  if (narg < 7)
@@ -92,24 +91,21 @@ FixFFL::FixFFL(LAMMPS *lmp, int narg, char **arg) : 


  // Flip type used, uses rescale if no flip is given

  if (narg == 8) {

        if (strcmp(arg[7],"no_flip") == 0) {flip_int = 0;}

	else if ((strcmp(arg[7],"rescale") == 0) {flip_int = 1;}

	else if ((strcmp(arg[7],"hard") == 0) {flip_int = 2;}

	else if ((strcmp(arg[7],"soft") == 0) {flip_int = 3;}

	else {

    if (strcmp(arg[7],"no_flip") == 0) {

      flip_int = 0;

    } else if (strcmp(arg[7],"rescale") == 0) {

      flip_int = 1;

    } else if (strcmp(arg[7],"hard") == 0) {

      flip_int = 2;

    } else if (strcmp(arg[7],"soft") == 0) {

      flip_int = 3;

    } else {

      error->all(FLERR,"Illegal fix ffl flip type, only accepts : rescale - hard - soft - no_flip");

    }

  } else {

    flip_int = 1;

  }







//    if ( strcmp(flip_type,"no_flip") == 0 ) flip_int = 0;

 //   if ( strcmp(flip_type,"rescale") == 0 ) flip_int = 1;

  //  if ( strcmp(flip_type,"hard") == 0 ) flip_int = 2;

  //  if ( strcmp(flip_type,"soft") == 0 ) flip_int = 3;



  t_target=t_start;

  const double kT = t_target * force->boltz / force->mvv2e;
@@ -138,8 +134,7 @@ FixFFL::FixFFL(LAMMPS *lmp, int narg, char **arg) : 


/* --- Frees up memory used by temporaries and buffers ------------------ */



FixFFL::~FixFFL()

{

FixFFL::~FixFFL() {

  delete random;



  memory->destroy(sqrt_m);
@@ -149,8 +144,7 @@ FixFFL::~FixFFL() 


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



int FixFFL::setmask()

{

int FixFFL::setmask() {

  int mask = 0;



  mask |= INITIAL_INTEGRATE;
@@ -165,23 +159,19 @@ int FixFFL::setmask() 


/* ------- Initializes one-time quantities for FFL ---------------------- */



void FixFFL::init()

{

void FixFFL::init() {

  doffl = 1;

  dtv = update->dt;

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



  // set force prefactors

    if (!atom->rmass)

    {

        for (int i = 1; i <= atom->ntypes; i++)

        {

  if (!atom->rmass) {

    for (int i = 1; i <= atom->ntypes; i++) {

      sqrt_m[i] = sqrt(atom->mass[i]);

    }

  }



    if (strstr(update->integrate_style,"respa"))

    {

  if (strstr(update->integrate_style,"respa")) {

    nlevels_respa = ((Respa *) update->integrate)->nlevels;

    step_respa = ((Respa *) update->integrate)->step;

  }
@@ -191,8 +181,7 @@ void FixFFL::init() 


/* ------- Initializes constants for FFL (change with T and dt) ------- */



void FixFFL::init_ffl()

{

void FixFFL::init_ffl() {

  const double kT = t_target * force->boltz / force->mvv2e;



  // compute constants for FFL
@@ -207,20 +196,17 @@ void FixFFL::init_ffl() 


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



void FixFFL::setup(int vflag)

{

void FixFFL::setup(int vflag) {

  if (strstr(update->integrate_style,"verlet"))

    post_force(vflag);

    else

    {

  else {

    ((Respa *) update->integrate)->copy_flevel_f(nlevels_respa-1);

    post_force_respa(vflag,nlevels_respa-1,0);

    ((Respa *) update->integrate)->copy_f_flevel(nlevels_respa-1);

  }

}



void FixFFL::ffl_integrate()

{

void FixFFL::ffl_integrate() {

  double **v = atom->v;

  double *rmass = atom->rmass, smi, ismi;

  double factor;
@@ -232,15 +218,12 @@ void FixFFL::ffl_integrate() 
  // loads momentum data (mass-scaled) into the temporary vectors for the propagation

  int nk=0;

  double deltae=0.0;

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

    {

        if (mask[i] & groupbit)

        {

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

    if (mask[i] & groupbit) {

      if (rmass) smi = sqrt(rmass[i]);

      else smi = sqrt_m[type[i]];



            for (int k = 0; k<3; k++)

            {

      for (int k = 0; k<3; k++) {

        // first loads velocities and accumulates conserved quantity

        ffl_tmp2[nk] = v[i][k] * smi;

        deltae += ffl_tmp2[nk] * ffl_tmp2[nk];
@@ -255,21 +238,18 @@ void FixFFL::ffl_integrate() 


  // unloads momentum data (mass-scaled) from the temporary vectors

  nk=0;

    for (int i = 0; i < nlocal; i++) if (mask[i] & groupbit)

        {

  for (int i = 0; i < nlocal; i++) if (mask[i] & groupbit) {

      if (rmass) ismi = 1.0 / sqrt(rmass[i]);

      else ismi = 1.0/ sqrt_m[type[i]];



            for (int k = 0; k<3; k++)

            {

      for (int k = 0; k<3; k++) {

        // fetches new velocities and completes computation of the conserved quantity change

        v[i][k]= c1*v[i][k] + c2*ffl_tmp1[nk]*ismi;



        deltae-= v[i][k]*v[i][k] /ismi /ismi;



        //flips the sign of the momentum (HARD FLIP)

                if ( flip_int == 2)

                {

        if ( flip_int == 2) {

          if (v[i][k]*ffl_tmp2[nk] < 0.0) v[i][k] = -v[i][k];

        }
@@ -278,17 +258,14 @@ void FixFFL::ffl_integrate() 
    }



  //rescale operation (RESCALE FLIP)

    if (flip_int == 1)

    {

  if (flip_int == 1) {

    nk=0;

        for (int i = 0; i < nlocal; i++) if (mask[i] & groupbit)

            {

    for (int i = 0; i < nlocal; i++) if (mask[i] & groupbit) {

      factor = sqrt ((v[i][0]*v[i][0] + v[i][1]*v[i][1] + v[i][2]*v[i][2]) /

                       (ffl_tmp2[nk]*ffl_tmp2[nk] + ffl_tmp2[nk+1]*ffl_tmp2[nk+1]

                        + ffl_tmp2[nk+2]*ffl_tmp2[nk+2]));



                for (int k = 0; k<3; k++)

                {

      for (int k = 0; k<3; k++) {

        v[i][k]= factor * ffl_tmp2[nk];

        nk++;

      }
@@ -297,34 +274,30 @@ void FixFFL::ffl_integrate() 




  //soft flip operation (SOFT FLIP)

    if (flip_int == 3)

    {

  if (flip_int == 3) {

    nk=0;

        for (int i = 0; i < nlocal; i++) if (mask[i] & groupbit)

            {

    for (int i = 0; i < nlocal; i++) if (mask[i] & groupbit) {

      factor = v[i][0]*ffl_tmp2[nk] + v[i][1]*ffl_tmp2[nk+1] + v[i][2]*ffl_tmp2[nk+2];

                if (factor < 0)

                {

      if (factor < 0) {

        factor =  factor / (ffl_tmp2[nk]*ffl_tmp2[nk] + ffl_tmp2[nk+1]*ffl_tmp2[nk+1]

                            + ffl_tmp2[nk+2]*ffl_tmp2[nk+2]);



                    for (int k = 0; k<3; k++)

                    {

        for (int k = 0; k<3; k++) {

          v[i][k] -= 2.0 * factor * ffl_tmp2[nk];

          nk++;

        }

                }

                else

      } else {

        nk += 3;

      }

    }



  }



  energy += deltae*0.5*force->mvv2e;



}



void FixFFL::initial_integrate(int vflag)

{

void FixFFL::initial_integrate(int vflag) {

  double dtfm;



  // update v and x of atoms in group
@@ -341,11 +314,9 @@ void FixFFL::initial_integrate(int vflag) 
  ffl_step--;

  if (doffl && ffl_step<1) ffl_integrate();



    if (rmass)

    {

  if (rmass) {

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

            if (mask[i] & groupbit)

            {

      if (mask[i] & groupbit) {

        dtfm = dtf / rmass[i];

        v[i][0] += dtfm * f[i][0];

        v[i][1] += dtfm * f[i][1];
@@ -355,12 +326,9 @@ void FixFFL::initial_integrate(int vflag) 
        x[i][2] += dtv * v[i][2];

      }



    }

    else

    {

  } else {

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

            if (mask[i] & groupbit)

            {

      if (mask[i] & groupbit) {

        dtfm = dtf / mass[type[i]];

        v[i][0] += dtfm * f[i][0];

        v[i][1] += dtfm * f[i][1];
@@ -372,8 +340,7 @@ void FixFFL::initial_integrate(int vflag) 
  }

}



void FixFFL::final_integrate()

{

void FixFFL::final_integrate() {

  double dtfm;



  // update v of atoms in group
@@ -387,23 +354,18 @@ void FixFFL::final_integrate() 
  int nlocal = atom->nlocal;

  if (igroup == atom->firstgroup) nlocal = atom->nfirst;



    if (rmass)

    {

  if (rmass) {

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

            if (mask[i] & groupbit)

            {

      if (mask[i] & groupbit) {

        dtfm = dtf / rmass[i];

        v[i][0] += dtfm * f[i][0];

        v[i][1] += dtfm * f[i][1];

        v[i][2] += dtfm * f[i][2];

      }



    }

    else

    {

  } else {

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

            if (mask[i] & groupbit)

            {

      if (mask[i] & groupbit) {

        dtfm = dtf / mass[type[i]];

        v[i][0] += dtfm * f[i][0];

        v[i][1] += dtfm * f[i][1];
@@ -411,8 +373,7 @@ void FixFFL::final_integrate() 
      }

  }



    if (doffl && ffl_step<1)

    {

  if (doffl && ffl_step<1) {

    ffl_integrate();

    ffl_step = ffl_every;

  }
@@ -421,8 +382,7 @@ void FixFFL::final_integrate() 
  double delta = update->ntimestep - update->beginstep;

  delta /= update->endstep - update->beginstep;

  t_target = t_start + delta * (t_stop - t_start);

    if (t_stop != t_start)

    {

  if (t_stop != t_start) {

    // only updates if it is really necessary

    init_ffl();

  }
@@ -430,8 +390,7 @@ void FixFFL::final_integrate() 
}

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



void FixFFL::initial_integrate_respa(int vflag, int ilevel, int iloop)

{

void FixFFL::initial_integrate_respa(int vflag, int ilevel, int iloop) {

  dtv = step_respa[ilevel];

  dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
@@ -441,14 +400,12 @@ void FixFFL::initial_integrate_respa(int vflag, int ilevel, int iloop) 
  if (ilevel==nlevels_respa-1) ffl_integrate();

  doffl=0;

  if (ilevel == 0) initial_integrate(vflag);

    else

    {

  else {

    final_integrate();

  }

}



void FixFFL::final_integrate_respa(int ilevel, int iloop)

{

void FixFFL::final_integrate_respa(int ilevel, int iloop) {



  dtv = step_respa[ilevel];

  dtf = 0.5 * step_respa[ilevel] * force->ftm2v;
@@ -458,8 +415,7 @@ void FixFFL::final_integrate_respa(int ilevel, int iloop) 
}





double FixFFL::compute_scalar()

{

double FixFFL::compute_scalar() {



  double energy_me = energy;

  double energy_all;
@@ -472,11 +428,9 @@ double FixFFL::compute_scalar() 
   extract thermostat properties

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



void *FixFFL::extract(const char *str, int &dim)

{

void *FixFFL::extract(const char *str, int &dim) {

  dim = 0;

    if (strcmp(str,"t_target") == 0)

    {

  if (strcmp(str,"t_target") == 0) {

    return &t_target;

  }

  return NULL;
@@ -487,8 +441,7 @@ void *FixFFL::extract(const char *str, int &dim) 
   Called when a change to the target temperature is requested mid-run

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



void FixFFL::reset_target(double t_new)

{

void FixFFL::reset_target(double t_new) {



  t_target = t_start = t_stop = t_new;

}
@@ -497,8 +450,7 @@ void FixFFL::reset_target(double t_new) 
   Called when a change to the timestep is requested mid-run

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



void FixFFL::reset_dt()

{

void FixFFL::reset_dt() {

  // set the time integration constants

  dtv = update->dt;

  dtf = 0.5 * update->dt * (force->ftm2v);
@@ -509,8 +461,7 @@ void FixFFL::reset_dt() 
   memory usage of local atom-based arrays

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



double FixFFL::memory_usage()

{

double FixFFL::memory_usage() {

  double bytes = atom->nmax*(3*2)*sizeof(double);

  return bytes;

}
@@ -520,8 +471,7 @@ double FixFFL::memory_usage() 
   allocate local atom-based arrays

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



void FixFFL::grow_arrays(int nmax)

{

void FixFFL::grow_arrays(int nmax) {

  memory->grow(ffl_tmp1, nmax*3,"ffl:tmp1");

  memory->grow(ffl_tmp2, nmax*3,"ffl:tmp2");

  //zeroes out temporary buffers

CRA Git | Maintained and supported by SUSTech CRA and CCSE