sync with Git

git-svn-id: svn://svn.icms.temple.edu/lammps-ro/trunk@15520 f3b2605a-c512-4ea7-a41b-209d697bcdaa

src/MANYBODY/fix_qeq_comb.cpp

@@ -38,7 +38,8 @@ using namespace FixConst;
 
 /* ---------------------------------------------------------------------- */
 
-FixQEQComb::FixQEQComb(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
+FixQEQComb::FixQEQComb(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg),
+fp(NULL), qf(NULL), q1(NULL), q2(NULL)
 {
   if (narg < 5) error->all(FLERR,"Illegal fix qeq/comb command");
 
@@ -58,8 +59,6 @@ FixQEQComb::FixQEQComb(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
 
   // optional args
 
-  fp = NULL;
-
   int iarg = 5;
   while (iarg < narg) {
     if (strcmp(arg[iarg],"file") == 0) {

src/MC/fix_atom_swap.cpp

@@ -56,7 +56,8 @@ using namespace MathConst;
 /* ---------------------------------------------------------------------- */
 
 FixAtomSwap::FixAtomSwap(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  idregion(NULL), type_list(NULL), mu(NULL), qtype(NULL), sqrt_mass_ratio(NULL), random_equal(NULL), random_unequal(NULL)
 {
   if (narg < 10) error->all(FLERR,"Illegal fix atom/swap command");
 
@@ -68,8 +69,6 @@ FixAtomSwap::FixAtomSwap(LAMMPS *lmp, int narg, char **arg) :
   extvector = 0;
   restart_global = 1;
   time_depend = 1;
-  type_list = NULL;
-  qtype = NULL;
   
   // required args
 

src/MC/fix_bond_break.cpp

@@ -36,7 +36,8 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixBondBreak::FixBondBreak(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  partner(NULL), finalpartner(NULL), distsq(NULL), broken(NULL), copy(NULL), random(NULL)
 {
   if (narg < 6) error->all(FLERR,"Illegal fix bond/break command");
 
@@ -98,11 +99,8 @@ FixBondBreak::FixBondBreak(LAMMPS *lmp, int narg, char **arg) :
   // allocate arrays local to this fix
 
   nmax = 0;
-  partner = finalpartner = NULL;
-  distsq = NULL;
 
   maxbreak = 0;
-  broken = NULL;
 
   // copy = special list for one atom
   // size = ms^2 + ms is sufficient

src/MC/fix_bond_create.cpp

@@ -39,7 +39,8 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixBondCreate::FixBondCreate(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  bondcount(NULL), partner(NULL), finalpartner(NULL), distsq(NULL), created(NULL), copy(NULL), random(NULL)
 {
   if (narg < 8) error->all(FLERR,"Illegal fix bond/create command");
 

src/MC/fix_bond_swap.cpp

@@ -52,7 +52,8 @@ static const char cite_fix_bond_swap[] =
 /* ---------------------------------------------------------------------- */
 
 FixBondSwap::FixBondSwap(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  tflag(0), alist(NULL), id_temp(NULL)
 {
   if (lmp->citeme) lmp->citeme->add(cite_fix_bond_swap);
 

src/MC/fix_gcmc.cpp

@@ -58,7 +58,10 @@ enum{ATOM,MOLECULE};
 /* ---------------------------------------------------------------------- */
 
 FixGCMC::FixGCMC(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  idregion(NULL), full_flag(0), ngroups(0), groupstrings(NULL), ngrouptypes(0), grouptypestrings(NULL),
+  grouptypebits(NULL), grouptypes(NULL), local_gas_list(NULL), atom_coord(NULL), random_equal(NULL), random_unequal(NULL), 
+  coords(NULL), imageflags(NULL), idshake(NULL)
 {
   if (narg < 11) error->all(FLERR,"Illegal fix gcmc command");
 

src/MC/fix_tfmc.cpp

@@ -37,7 +37,8 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixTFMC::FixTFMC(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  xd(NULL), rotflag(0)
 {
   if (narg < 6) error->all(FLERR,"Illegal fix tfmc command");
 

src/fix.cpp

@@ -31,7 +31,8 @@ int Fix::instance_total = 0;
 
 /* ---------------------------------------------------------------------- */
 
-Fix::Fix(LAMMPS *lmp, int narg, char **arg) : Pointers(lmp)
+Fix::Fix(LAMMPS *lmp, int narg, char **arg) : Pointers(lmp),
+id(NULL), style(NULL), eatom(NULL), vatom(NULL)
 {
   instance_me = instance_total++;
 
@@ -92,8 +93,6 @@ Fix::Fix(LAMMPS *lmp, int narg, char **arg) : Pointers(lmp)
   //   which may occur outside of timestepping
 
   maxeatom = maxvatom = 0;
-  eatom = NULL;
-  vatom = NULL;
   vflag_atom = 0;
 
   // CUDA and KOKKOS per-fix data masks

src/fix_adapt.cpp

@@ -40,7 +40,8 @@ enum{DIAMETER,CHARGE};
 
 /* ---------------------------------------------------------------------- */
 
-FixAdapt::FixAdapt(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
+FixAdapt::FixAdapt(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg),
+nadapt(0), id_fix_diam(NULL), id_fix_chg(NULL), adapt(NULL)
 {
   if (narg < 5) error->all(FLERR,"Illegal fix adapt command");
   nevery = force->inumeric(FLERR,arg[3]);
@@ -159,8 +160,6 @@ FixAdapt::FixAdapt(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
   for (int m = 0; m < nadapt; m++)
     if (adapt[m].which == PAIR)
       memory->create(adapt[m].array_orig,n+1,n+1,"adapt:array_orig");
-
-  id_fix_diam = id_fix_chg = NULL;
 }
 
 /* ---------------------------------------------------------------------- */

src/fix_addforce.cpp

@@ -36,7 +36,9 @@ enum{NONE,CONSTANT,EQUAL,ATOM};
 /* ---------------------------------------------------------------------- */
 
 FixAddForce::FixAddForce(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  xstr(NULL), ystr(NULL), zstr(NULL), estr(NULL), idregion(NULL), sforce(NULL)
+
 {
   if (narg < 6) error->all(FLERR,"Illegal fix addforce command");
 
@@ -81,8 +83,6 @@ FixAddForce::FixAddForce(LAMMPS *lmp, int narg, char **arg) :
 
   nevery = 1;
   iregion = -1;
-  idregion = NULL;
-  estr = NULL;
 
   int iarg = 6;
   while (iarg < narg) {

src/fix_ave_atom.cpp

@@ -35,7 +35,8 @@ enum{X,V,F,COMPUTE,FIX,VARIABLE};
 /* ---------------------------------------------------------------------- */
 
 FixAveAtom::FixAveAtom(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  nvalues(0), which(NULL), argindex(NULL), value2index(NULL), ids(NULL), array(NULL)
 {
   if (narg < 7) error->all(FLERR,"Illegal fix ave/atom command");
 
@@ -192,7 +193,6 @@ FixAveAtom::FixAveAtom(LAMMPS *lmp, int narg, char **arg) :
   // perform initial allocation of atom-based array
   // register with Atom class
 
-  array = NULL;
   grow_arrays(atom->nmax);
   atom->add_callback(0);
 

src/fix_ave_correlate.cpp

@@ -44,7 +44,9 @@ enum{AUTO,UPPER,LOWER,AUTOUPPER,AUTOLOWER,FULL};
 /* ---------------------------------------------------------------------- */
 
 FixAveCorrelate::FixAveCorrelate(LAMMPS * lmp, int narg, char **arg):
-  Fix (lmp, narg, arg)
+  Fix (lmp, narg, arg),
+  nvalues(0), which(NULL), argindex(NULL), value2index(NULL), ids(NULL), fp(NULL),
+  count(NULL), values(NULL), corr(NULL), save_count(NULL), save_corr(NULL)
 {
   if (narg < 7) error->all(FLERR,"Illegal fix ave/correlate command");
 

src/fix_ave_histo.cpp

@@ -45,7 +45,9 @@ enum{IGNORE,END,EXTRA};
 /* ---------------------------------------------------------------------- */
 
 FixAveHisto::FixAveHisto(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  nvalues(0), which(NULL), argindex(NULL), value2index(NULL), ids(NULL), fp(NULL), stats_list(NULL), 
+  bin(NULL), bin_total(NULL), bin_all(NULL), bin_list(NULL), coord(NULL), vector(NULL)
 {
   if (narg < 10) error->all(FLERR,"Illegal fix ave/histo command");
 

src/fix_ave_time.cpp

@@ -42,7 +42,10 @@ enum{SCALAR,VECTOR};
 /* ---------------------------------------------------------------------- */
 
 FixAveTime::FixAveTime(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  nvalues(0), which(NULL), argindex(NULL), value2index(NULL), offcol(NULL), varlen(NULL), ids(NULL),
+  fp(NULL), offlist(NULL), format(NULL), format_user(NULL), vector(NULL), vector_total(NULL), vector_list(NULL),
+  column(NULL), array(NULL), array_total(NULL), array_list(NULL)
 {
   if (narg < 7) error->all(FLERR,"Illegal fix ave/time command");
 

src/fix_aveforce.cpp

@@ -34,7 +34,8 @@ enum{NONE,CONSTANT,EQUAL};
 /* ---------------------------------------------------------------------- */
 
 FixAveForce::FixAveForce(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  xstr(NULL), ystr(NULL), zstr(NULL), idregion(NULL)
 {
   if (narg < 6) error->all(FLERR,"Illegal fix aveforce command");
 

src/fix_balance.cpp

@@ -35,7 +35,8 @@ enum{LAYOUT_UNIFORM,LAYOUT_NONUNIFORM,LAYOUT_TILED};    // several files
 /* ---------------------------------------------------------------------- */
 
 FixBalance::FixBalance(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  fp(NULL), nimbalance(0), imbalance(NULL), imb_fix(NULL), balance(NULL), irregular(NULL)
 {
   if (narg < 6) error->all(FLERR,"Illegal fix balance command");
 

src/fix_box_relax.cpp

@@ -41,7 +41,8 @@ enum{ISO,ANISO,TRICLINIC};
 /* ---------------------------------------------------------------------- */
 
 FixBoxRelax::FixBoxRelax(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  id_temp(NULL), id_press(NULL), tflag(0), pflag(0)
 {
   if (narg < 5) error->all(FLERR,"Illegal fix box/relax command");
 

src/fix_controller.cpp

@@ -33,7 +33,8 @@ enum{COMPUTE,FIX,VARIABLE};
 /* ---------------------------------------------------------------------- */
 
 FixController::FixController(LAMMPS *lmp, int narg, char **arg) : 
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  pvID(NULL), cvID(NULL)
 {
   if (narg != 11) error->all(FLERR,"Illegal fix controller command");
 
@@ -50,8 +51,6 @@ FixController::FixController(LAMMPS *lmp, int narg, char **arg) :
   ki = force->numeric(FLERR,arg[6]);
   kd = force->numeric(FLERR,arg[7]);
 
-  pvID = cvID = NULL;
-
   // process variable arg
 
   int iarg = 8;

src/fix_deform.cpp

@@ -46,7 +46,8 @@ enum{NO_REMAP,X_REMAP,V_REMAP};
 
 /* ---------------------------------------------------------------------- */
 
-FixDeform::FixDeform(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
+FixDeform::FixDeform(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg),
+rfix(NULL), irregular(NULL), set(NULL)
 {
   if (narg < 4) error->all(FLERR,"Illegal fix deform command");
 
@@ -355,7 +356,6 @@ FixDeform::FixDeform(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
   next_reneighbor = -1;
 
   nrigid = 0;
-  rfix = NULL;
   flip = 0;
 
   if (force_reneighbor) irregular = new Irregular(lmp);
@@ -368,10 +368,12 @@ FixDeform::FixDeform(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
 
 FixDeform::~FixDeform()
 {
+  if(set) {
     for (int i = 0; i < 6; i++) {
       delete [] set[i].hstr;
       delete [] set[i].hratestr;
     }
+  }
   delete [] set;
   delete [] rfix;
 

src/fix_enforce2d.cpp

@@ -26,12 +26,12 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixEnforce2D::FixEnforce2D(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  flist(NULL)
 {
   if (narg != 3) error->all(FLERR,"Illegal fix enforce2d command");
 
   nfixlist = 0;
-  flist = NULL;
 }
 
 /* ---------------------------------------------------------------------- */

src/fix_external.cpp

@@ -29,7 +29,8 @@ enum{PF_CALLBACK,PF_ARRAY};
 /* ---------------------------------------------------------------------- */
 
 FixExternal::FixExternal(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  fexternal(NULL)
 {
   if (narg < 4) error->all(FLERR,"Illegal fix external command");
 
@@ -56,7 +57,6 @@ FixExternal::FixExternal(LAMMPS *lmp, int narg, char **arg) :
   // perform initial allocation of atom-based array
   // register with Atom class
 
-  fexternal = NULL;
   grow_arrays(atom->nmax);
   atom->add_callback(0);
 

src/fix_gravity.cpp

@@ -37,7 +37,8 @@ enum{CONSTANT,EQUAL};
 /* ---------------------------------------------------------------------- */
 
 FixGravity::FixGravity(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  mstr(NULL), vstr(NULL), pstr(NULL), tstr(NULL), xstr(NULL), ystr(NULL), zstr(NULL)
 {
   if (narg < 5) error->all(FLERR,"Illegal fix gravity command");
 

src/fix_group.cpp

@@ -31,7 +31,8 @@ using namespace FixConst;
 
 /* ---------------------------------------------------------------------- */
 
-FixGroup::FixGroup(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
+FixGroup::FixGroup(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg),
+idregion(NULL), idvar(NULL)
 {
   // dgroupbit = bitmask of dynamic group
   // group ID is last part of fix ID
@@ -46,9 +47,7 @@ FixGroup::FixGroup(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
   // process optional args
 
   regionflag = 0;
-  idregion = NULL;
   varflag = 0;
-  idvar = NULL;
   nevery = 1;
 
   int iarg = 3;

src/fix_heat.cpp

@@ -38,7 +38,8 @@ enum{CONSTANT,EQUAL,ATOM};
 
 /* ---------------------------------------------------------------------- */
 
-FixHeat::FixHeat(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
+FixHeat::FixHeat(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg),
+idregion(NULL), hstr(NULL), vheat(NULL), vscale(NULL)
 {
   if (narg < 4) error->all(FLERR,"Illegal fix heat command");
 
@@ -63,7 +64,6 @@ FixHeat::FixHeat(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
   // optional args
 
   iregion = -1;
-  idregion = NULL;
   
   int iarg = 5;
   while (iarg < narg) {
@@ -82,8 +82,6 @@ FixHeat::FixHeat(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
   scale = 1.0;
 
   maxatom = 0;
-  vheat = NULL;
-  vscale = NULL;
 }
 
 /* ---------------------------------------------------------------------- */

src/fix_indent.cpp

@@ -40,7 +40,8 @@ enum{INSIDE,OUTSIDE};
 /* ---------------------------------------------------------------------- */
 
 FixIndent::FixIndent(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  xstr(NULL), ystr(NULL), zstr(NULL), rstr(NULL), pstr(NULL)
 {
   if (narg < 4) error->all(FLERR,"Illegal fix indent command");
 

src/fix_langevin.cpp

@@ -51,7 +51,9 @@ enum{CONSTANT,EQUAL,ATOM};
 /* ---------------------------------------------------------------------- */
 
 FixLangevin::FixLangevin(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  gjfflag(0), gfactor1(NULL), gfactor2(NULL), ratio(NULL), tstr(NULL),
+  flangevin(NULL), tforce(NULL), franprev(NULL), id_temp(NULL), random(NULL)
 {
   if (narg < 7) error->all(FLERR,"Illegal fix langevin command");
 
@@ -61,7 +63,6 @@ FixLangevin::FixLangevin(LAMMPS *lmp, int narg, char **arg) :
   extscalar = 1;
   nevery = 1;
 
-  tstr = NULL;
   if (strstr(arg[3],"v_") == arg[3]) {
     int n = strlen(&arg[3][2]) + 1;
     tstr = new char[n];

src/fix_minimize.cpp

@@ -24,12 +24,9 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixMinimize::FixMinimize(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  nvector(0), peratom(NULL), vectors(NULL)
 {
-  nvector = 0;
-  peratom = NULL;
-  vectors = NULL;
-
   // register callback to this fix from Atom class
   // don't perform initial allocation here, must wait until add_vector()
 

src/fix_move.cpp

@@ -47,7 +47,9 @@ enum{EQUAL,ATOM};
 /* ---------------------------------------------------------------------- */
 
 FixMove::FixMove(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  xvarstr(NULL), yvarstr(NULL), zvarstr(NULL), vxvarstr(NULL), vyvarstr(NULL), vzvarstr(NULL),
+  xoriginal(NULL), toriginal(NULL), qoriginal(NULL), displace(NULL), velocity(NULL)
 {
   if (narg < 4) error->all(FLERR,"Illegal fix move command");
 
@@ -65,8 +67,6 @@ FixMove::FixMove(LAMMPS *lmp, int narg, char **arg) :
   // parse args
 
   int iarg;
-  xvarstr = yvarstr = zvarstr = NULL;
-  vxvarstr = vyvarstr = vzvarstr = NULL;
   
   if (strcmp(arg[3],"linear") == 0) {
     if (narg < 7) error->all(FLERR,"Illegal fix move command");
@@ -255,9 +255,6 @@ FixMove::FixMove(LAMMPS *lmp, int narg, char **arg) :
   // perform initial allocation of atom-based array
   // register with Atom class
 
-  xoriginal = NULL;
-  toriginal = NULL;
-  qoriginal = NULL;
   grow_arrays(atom->nmax);
   atom->add_callback(0);
   atom->add_callback(1);

src/fix_nh.cpp

@@ -50,7 +50,11 @@ enum{ISO,ANISO,TRICLINIC};
    NVT,NPH,NPT integrators for improved Nose-Hoover equations of motion
  ---------------------------------------------------------------------- */
 
-FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
+FixNH::FixNH(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg),
+tstat_flag(0), pstat_flag(0),
+rfix(NULL), id_dilate(NULL), irregular(NULL), id_temp(NULL), id_press(NULL),
+tcomputeflag(0), pcomputeflag(0), eta(NULL), eta_dot(NULL), eta_dotdot(NULL),
+eta_mass(NULL), etap(NULL), etap_dot(NULL), etap_dotdot(NULL), etap_mass(NULL), mpchain(0)
 {
   if (narg < 4) error->all(FLERR,"Illegal fix nvt/npt/nph command");
 

src/fix_press_berendsen.cpp

@@ -37,7 +37,8 @@ enum{ISO,ANISO};
 /* ---------------------------------------------------------------------- */
 
 FixPressBerendsen::FixPressBerendsen(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  id_temp(NULL), id_press(NULL), tflag(0), pflag(0)
 {
   if (narg < 5) error->all(FLERR,"Illegal fix press/berendsen command");
 

src/fix_print.cpp

@@ -28,7 +28,8 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixPrint::FixPrint(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  fp(NULL), string(NULL), copy(NULL), work(NULL)
 {
   if (narg < 5) error->all(FLERR,"Illegal fix print command");
   nevery = force->inumeric(FLERR,arg[3]);

src/fix_property_atom.cpp

@@ -29,7 +29,8 @@ enum{MOLECULE,CHARGE,RMASS,INTEGER,DOUBLE};
 /* ---------------------------------------------------------------------- */
 
 FixPropertyAtom::FixPropertyAtom(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  nvalue(0), style(NULL), index(NULL), astyle(NULL)
 {
   if (narg < 4) error->all(FLERR,"Illegal fix property/atom command");
 

src/fix_read_restart.cpp

@@ -23,7 +23,8 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixReadRestart::FixReadRestart(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  count(NULL), extra(NULL)
 {
   nextra = force->inumeric(FLERR,arg[3]);
   int nfix = force->inumeric(FLERR,arg[4]);
@@ -31,8 +32,6 @@ FixReadRestart::FixReadRestart(LAMMPS *lmp, int narg, char **arg) :
   // perform initial allocation of atom-based array
   // register with Atom class
 
-  count = NULL;
-  extra = NULL;
   grow_arrays(atom->nmax);
   atom->add_callback(0);
 

src/fix_respa.cpp

@@ -24,7 +24,8 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixRespa::FixRespa(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  store_torque(0), f_level(NULL), t_level(NULL)
 {
   // nlevels = # of rRESPA levels
 

src/fix_restrain.cpp

@@ -44,7 +44,8 @@ enum{BOND,ANGLE,DIHEDRAL};
 /* ---------------------------------------------------------------------- */
 
 FixRestrain::FixRestrain(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  rstyle(NULL), ids(NULL), kstart(NULL), kstop(NULL), target(NULL), cos_target(NULL), sin_target(NULL)
 {
   if (narg < 4) error->all(FLERR,"Illegal fix restrain command");
 
@@ -57,10 +58,6 @@ FixRestrain::FixRestrain(LAMMPS *lmp, int narg, char **arg) :
   // parse args
 
   nrestrain = maxrestrain = 0;
-  rstyle = NULL;
-  ids = NULL;
-  kstart = kstop = NULL;
-  target = cos_target = sin_target = NULL;
   
   int iarg = 3;
   while (iarg < narg) {

src/fix_setforce.cpp

@@ -34,7 +34,8 @@ enum{NONE,CONSTANT,EQUAL,ATOM};
 /* ---------------------------------------------------------------------- */
 
 FixSetForce::FixSetForce(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  xstr(NULL), ystr(NULL), zstr(NULL), idregion(NULL), sforce(NULL)
 {
   if (narg < 6) error->all(FLERR,"Illegal fix setforce command");
 

src/fix_shear_history.cpp

@@ -34,7 +34,8 @@ enum{NPARTNER,PERPARTNER};
 /* ---------------------------------------------------------------------- */
 
 FixShearHistory::FixShearHistory(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  npartner(NULL), partner(NULL), shearpartner(NULL), ipage(NULL), dpage(NULL)
 {
   if (narg != 4) error->all(FLERR,"Illegal fix SHEAR_HISTORY commmand");
 
@@ -57,15 +58,10 @@ FixShearHistory::FixShearHistory(LAMMPS *lmp, int narg, char **arg) :
   // perform initial allocation of atom-based arrays
   // register with atom class
 
-  npartner = NULL;
-  partner = NULL;
-  shearpartner = NULL;
   grow_arrays(atom->nmax);
   atom->add_callback(0);
   atom->add_callback(1);
 
-  ipage = NULL;
-  dpage = NULL;
   pgsize = oneatom = 0;
 
   // initialize npartner to 0 so neighbor list creation is OK the 1st time

src/fix_spring.cpp

@@ -37,7 +37,8 @@ enum{TETHER,COUPLE};
 /* ---------------------------------------------------------------------- */
 
 FixSpring::FixSpring(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  group2(NULL)
 {
   if (narg < 9) error->all(FLERR,"Illegal fix spring command");
 
@@ -51,8 +52,6 @@ FixSpring::FixSpring(LAMMPS *lmp, int narg, char **arg) :
   respa_level_support = 1;
   ilevel_respa = 0;
 
-  group2 = NULL;
-
   if (strcmp(arg[3],"tether") == 0) {
     if (narg != 9) error->all(FLERR,"Illegal fix spring command");
     styleflag = TETHER;

src/fix_spring_chunk.cpp

@@ -34,7 +34,8 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixSpringChunk::FixSpringChunk(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  idchunk(NULL), idcom(NULL), com0(NULL), fcom(NULL)
 {
   if (narg != 6) error->all(FLERR,"Illegal fix spring/chunk command");
 
@@ -55,7 +56,6 @@ FixSpringChunk::FixSpringChunk(LAMMPS *lmp, int narg, char **arg) :
   strcpy(idcom,arg[5]);
 
   esprings = 0.0;
-  com0 = fcom = NULL;
   nchunk = 0;
 }
 

src/fix_spring_self.cpp

@@ -32,7 +32,8 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixSpringSelf::FixSpringSelf(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  xoriginal(NULL)
 {
   if ((narg < 4) || (narg > 5))
     error->all(FLERR,"Illegal fix spring/self command");

src/fix_store.cpp

@@ -27,7 +27,8 @@ enum{UNKNOWN,GLOBAL,PERATOM};
 
 /* ---------------------------------------------------------------------- */
 
-FixStore::FixStore(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
+FixStore::FixStore(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg),
+vstore(NULL), astore(NULL), rbuf(NULL)
 {
   if (narg != 6) error->all(FLERR,"Illegal fix store command");
 

src/fix_store_force.cpp

@@ -26,7 +26,8 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixStoreForce::FixStoreForce(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  foriginal(NULL)
 {
   if (narg < 3) error->all(FLERR,"Illegal fix store/coord command");
 

src/fix_store_state.cpp

@@ -37,7 +37,9 @@ enum{KEYWORD,COMPUTE,FIX,VARIABLE,DNAME,INAME};
 /* ---------------------------------------------------------------------- */
 
 FixStoreState::FixStoreState(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  nvalues(0), which(NULL), argindex(NULL), value2index(NULL), ids(NULL), values(NULL),
+  vbuf(NULL), pack_choice(NULL)
 {
   if (narg < 5) error->all(FLERR,"Illegal fix store/state command");
 

src/fix_temp_berendsen.cpp

@@ -35,7 +35,8 @@ enum{CONSTANT,EQUAL};
 /* ---------------------------------------------------------------------- */
 
 FixTempBerendsen::FixTempBerendsen(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  tstr(NULL), id_temp(NULL), tflag(0)
 {
   if (narg != 6) error->all(FLERR,"Illegal fix temp/berendsen command");
 

src/fix_temp_csld.cpp

@@ -41,7 +41,8 @@ enum{CONSTANT,EQUAL};
 /* ---------------------------------------------------------------------- */
 
 FixTempCSLD::FixTempCSLD(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  vhold(NULL), tstr(NULL), id_temp(NULL), random(NULL)
 {
   if (narg != 7) error->all(FLERR,"Illegal fix temp/csld command");
 

src/fix_temp_csvr.cpp

@@ -113,7 +113,8 @@ double FixTempCSVR::resamplekin(double ekin_old, double ekin_new){
 /* ---------------------------------------------------------------------- */
 
 FixTempCSVR::FixTempCSVR(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  tstr(NULL), id_temp(NULL), random(NULL)
 {
   if (narg != 7) error->all(FLERR,"Illegal fix temp/csvr command");
 

src/fix_temp_rescale.cpp

@@ -37,7 +37,8 @@ enum{CONSTANT,EQUAL};
 /* ---------------------------------------------------------------------- */
 
 FixTempRescale::FixTempRescale(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  tstr(NULL), id_temp(NULL), tflag(0)
 {
   if (narg < 8) error->all(FLERR,"Illegal fix temp/rescale command");
 

src/fix_tmd.cpp

@@ -39,7 +39,8 @@ using namespace FixConst;
 
 /* ---------------------------------------------------------------------- */
 
-FixTMD::FixTMD(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
+FixTMD::FixTMD(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg),
+nfileevery(0), fp(NULL), xf(NULL), xold(NULL)
 {
   if (narg < 6) error->all(FLERR,"Illegal fix tmd command");
 
@@ -54,8 +55,6 @@ FixTMD::FixTMD(LAMMPS *lmp, int narg, char **arg) : Fix(lmp, narg, arg)
   // perform initial allocation of atom-based arrays
   // register with Atom class
 
-  xf = NULL;
-  xold = NULL;
   grow_arrays(atom->nmax);
   atom->add_callback(0);
 

src/fix_vector.cpp

@@ -37,7 +37,8 @@ enum{SCALAR,VECTOR};
 /* ---------------------------------------------------------------------- */
 
 FixVector::FixVector(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  nvalues(0), which(NULL), argindex(NULL), value2index(NULL), ids(NULL), vector(NULL), array(NULL)
 {
   if (narg < 5) error->all(FLERR,"Illegal fix vector command");
 
@@ -294,7 +295,7 @@ void FixVector::end_of_step()
 
     // evaluate equal-style or vector-style variable
 
-    } else if (which[i] == VARIABLE)
+    } else if (which[i] == VARIABLE) {
       if (argindex[i] == 0) 
         result[i] = input->variable->compute_equal(m);
       else {
@@ -305,6 +306,7 @@ void FixVector::end_of_step()
         else result[i] = varvec[index-1];
       }
     }
+  }
 
   // trigger computes on next needed step
 

src/fix_viscous.cpp

@@ -27,7 +27,8 @@ using namespace FixConst;
 /* ---------------------------------------------------------------------- */
 
 FixViscous::FixViscous(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  gamma(NULL)
 {
   if (narg < 4) error->all(FLERR,"Illegal fix viscous command");
 

src/fix_wall.cpp

@@ -35,7 +35,8 @@ enum{NONE=0,EDGE,CONSTANT,VARIABLE};
 /* ---------------------------------------------------------------------- */
 
 FixWall::FixWall(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  nwall(0)
 {
   scalar_flag = 1;
   vector_flag = 1;
@@ -47,7 +48,6 @@ FixWall::FixWall(LAMMPS *lmp, int narg, char **arg) :
 
   // parse args
 
-  nwall = 0;
   int scaleflag = 1;
   fldflag = 0;
   int pbcflag = 0;

src/fix_wall_reflect.cpp

@@ -34,7 +34,8 @@ enum{NONE=0,EDGE,CONSTANT,VARIABLE};
 /* ---------------------------------------------------------------------- */
 
 FixWallReflect::FixWallReflect(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  nwall(0)
 {
   if (narg < 4) error->all(FLERR,"Illegal fix wall/reflect command");
 

src/fix_wall_region.cpp

@@ -34,7 +34,8 @@ enum{LJ93,LJ126,COLLOID,HARMONIC};
 /* ---------------------------------------------------------------------- */
 
 FixWallRegion::FixWallRegion(LAMMPS *lmp, int narg, char **arg) :
-  Fix(lmp, narg, arg)
+  Fix(lmp, narg, arg),
+  idregion(NULL)
 {
   if (narg != 8) error->all(FLERR,"Illegal fix wall/region command");