diff --git a/.astyle.options b/.astyle.options
index 0a17526e3b..5b9545ac1f 100644
--- a/.astyle.options
+++ b/.astyle.options
@@ -1 +1,13 @@
--n --indent=spaces=2 --keep-one-line-statements --keep-one-line-blocks
+# long options can be written without the preceding '--'
+suffix=none #equivalent to "-n"
+style=attach
+add-braces
+indent=spaces=2
+break-one-line-headers
+
+# old options
+#suffix=none
+#indent=spaces=2
+#keep-one-line-statements
+#keep-one-line-blocks
+# end old options
diff --git a/src/adjmat/AdjacencyMatrixBase.cpp b/src/adjmat/AdjacencyMatrixBase.cpp
index 61d52a2fd0..1b3a953a7f 100644
--- a/src/adjmat/AdjacencyMatrixBase.cpp
+++ b/src/adjmat/AdjacencyMatrixBase.cpp
@@ -28,7 +28,8 @@ namespace PLMD {
 namespace adjmat {
 
 void AdjacencyMatrixBase::registerKeywords( Keywords& keys ) {
-  ActionWithMatrix::registerKeywords( keys ); keys.remove("ARG");
+  ActionWithMatrix::registerKeywords( keys );
+  keys.remove("ARG");
   keys.add("atoms","GROUP","the atoms for which you would like to calculate the adjacency matrix");
   keys.add("atoms","GROUPA","");
   keys.add("atoms","GROUPB","");
@@ -53,68 +54,126 @@ AdjacencyMatrixBase::AdjacencyMatrixBase(const ActionOptions& ao):
   linkcells(comm),
   threecells(comm),
   maxcol(0),
-  natoms_per_list(0)
-{
-  std::vector<unsigned> shape(2); std::vector<AtomNumber> t; parseAtomList("GROUP", t );
+  natoms_per_list(0) {
+  std::vector<unsigned> shape(2);
+  std::vector<AtomNumber> t;
+  parseAtomList("GROUP", t );
   if( t.size()==0 ) {
     parseAtomList("ATOMS", t);
-    if( t.size()>0 ) warning("using depracated syntax for contact matrix.  You are strongly recommended to use GROUP instead of ATOMS");
+    if( t.size()>0 ) {
+      warning("using depracated syntax for contact matrix.  You are strongly recommended to use GROUP instead of ATOMS");
+    }
   }
 
   if( t.size()==0 ) {
-    std::vector<AtomNumber> ta; parseAtomList("GROUPA",ta);
-    if( ta.size()==0 && getName()=="HBOND_MATRIX") parseAtomList("DONORS",ta);
-    std::vector<AtomNumber> tb; parseAtomList("GROUPB",tb);
-    if( tb.size()==0 && getName()=="HBOND_MATRIX") parseAtomList("ACCEPTORS",tb);
-    if( ta.size()==0 || tb.size()==0 ) error("no atoms have been specified in input");
+    std::vector<AtomNumber> ta;
+    parseAtomList("GROUPA",ta);
+    if( ta.size()==0 && getName()=="HBOND_MATRIX") {
+      parseAtomList("DONORS",ta);
+    }
+    std::vector<AtomNumber> tb;
+    parseAtomList("GROUPB",tb);
+    if( tb.size()==0 && getName()=="HBOND_MATRIX") {
+      parseAtomList("ACCEPTORS",tb);
+    }
+    if( ta.size()==0 || tb.size()==0 ) {
+      error("no atoms have been specified in input");
+    }
 
     // Create list of tasks
     log.printf("  atoms in GROUPA ");
-    for(unsigned i=0; i<ta.size(); ++i) { log.printf("%d ", ta[i].serial()); t.push_back(ta[i]); }
+    for(unsigned i=0; i<ta.size(); ++i) {
+      log.printf("%d ", ta[i].serial());
+      t.push_back(ta[i]);
+    }
     log.printf("\n");
-    log.printf("  atoms in GROUPB "); ablocks.resize( tb.size() ); unsigned n=0;
+    log.printf("  atoms in GROUPB ");
+    ablocks.resize( tb.size() );
+    unsigned n=0;
     for(unsigned i=0; i<tb.size(); ++i) {
       log.printf("%d ", tb[i].serial());
-      ablocks[i]=ta.size()+n; t.push_back(tb[i]); n++;
+      ablocks[i]=ta.size()+n;
+      t.push_back(tb[i]);
+      n++;
     }
-    log.printf("\n"); shape[0]=ta.size(); shape[1]=tb.size();
+    log.printf("\n");
+    shape[0]=ta.size();
+    shape[1]=tb.size();
   } else {
     // Create list of tasks
-    log.printf("  atoms in GROUP "); ablocks.resize( t.size() );
-    for(unsigned i=0; i<t.size(); ++i) { log.printf("%d ", t[i].serial()); ablocks[i]=i; }
-    log.printf("\n"); shape[0]=shape[1]=t.size(); read_one_group=true;
+    log.printf("  atoms in GROUP ");
+    ablocks.resize( t.size() );
+    for(unsigned i=0; i<t.size(); ++i) {
+      log.printf("%d ", t[i].serial());
+      ablocks[i]=i;
+    }
+    log.printf("\n");
+    shape[0]=shape[1]=t.size();
+    read_one_group=true;
   }
   if( keywords.exists("GROUPC") ) {
-    std::vector<AtomNumber> tc; parseAtomList("GROUPC",tc);
-    if( tc.size()==0 ) error("no atoms in GROUPC specified");
-    log.printf("  atoms in GROUPC "); setupThirdAtomBlock( tc, t );
+    std::vector<AtomNumber> tc;
+    parseAtomList("GROUPC",tc);
+    if( tc.size()==0 ) {
+      error("no atoms in GROUPC specified");
+    }
+    log.printf("  atoms in GROUPC ");
+    setupThirdAtomBlock( tc, t );
   } else if( keywords.exists("BRIDGING_ATOMS") ) {
-    std::vector<AtomNumber> tc; parseAtomList("BRIDGING_ATOMS",tc);
-    if( tc.size()==0 ) error("no BRIDGING_ATOMS specified");
-    log.printf("  bridging atoms are "); setupThirdAtomBlock( tc, t );
+    std::vector<AtomNumber> tc;
+    parseAtomList("BRIDGING_ATOMS",tc);
+    if( tc.size()==0 ) {
+      error("no BRIDGING_ATOMS specified");
+    }
+    log.printf("  bridging atoms are ");
+    setupThirdAtomBlock( tc, t );
   } else if( keywords.exists("HYDROGENS") ) {
-    std::vector<AtomNumber> tc; parseAtomList("HYDROGENS",tc);
-    if( tc.size()==0 ) error("no HYDROGEN atoms specified");
-    log.printf("  hydrogen atoms are "); setupThirdAtomBlock( tc, t );
+    std::vector<AtomNumber> tc;
+    parseAtomList("HYDROGENS",tc);
+    if( tc.size()==0 ) {
+      error("no HYDROGEN atoms specified");
+    }
+    log.printf("  hydrogen atoms are ");
+    setupThirdAtomBlock( tc, t );
   } else if( keywords.exists("BACKGROUND_ATOMS") ) {
-    std::vector<AtomNumber> tc; parseAtomList("BACKGROUND_ATOMS",tc);
-    if( tc.size()==0 ) error("no ATOMS atoms specified");
-    log.printf("  atoms for background density are "); setupThirdAtomBlock( tc, t );
+    std::vector<AtomNumber> tc;
+    parseAtomList("BACKGROUND_ATOMS",tc);
+    if( tc.size()==0 ) {
+      error("no ATOMS atoms specified");
+    }
+    log.printf("  atoms for background density are ");
+    setupThirdAtomBlock( tc, t );
   }
   // Request the atoms from the ActionAtomistic
-  requestAtoms( t ); parseFlag("COMPONENTS",components); parseFlag("NOPBC",nopbc);
-  if( !components ) { addValue( shape ); setNotPeriodic(); }
-  else { addComponent( "w", shape ); componentIsNotPeriodic("w"); }
+  requestAtoms( t );
+  parseFlag("COMPONENTS",components);
+  parseFlag("NOPBC",nopbc);
+  if( !components ) {
+    addValue( shape );
+    setNotPeriodic();
+  } else {
+    addComponent( "w", shape );
+    componentIsNotPeriodic("w");
+  }
   getPntrToComponent(0)->setDerivativeIsZeroWhenValueIsZero();
   // Stuff for neighbor list
-  parse("NL_CUTOFF",nl_cut); nl_cut2=nl_cut*nl_cut; parse("NL_STRIDE",nl_stride);
-  if( nl_cut==0 && nl_stride>1 ) error("NL_CUTOFF must be set if NL_STRIDE is set greater than 1");
-  if( nl_cut>0 ) log.printf("  using neighbor list with cutoff %f.  List is updated every %u steps.\n",nl_cut,nl_stride);
+  parse("NL_CUTOFF",nl_cut);
+  nl_cut2=nl_cut*nl_cut;
+  parse("NL_STRIDE",nl_stride);
+  if( nl_cut==0 && nl_stride>1 ) {
+    error("NL_CUTOFF must be set if NL_STRIDE is set greater than 1");
+  }
+  if( nl_cut>0 ) {
+    log.printf("  using neighbor list with cutoff %f.  List is updated every %u steps.\n",nl_cut,nl_stride);
+  }
 
   if( components ) {
-    addComponent( "x", shape ); componentIsNotPeriodic("x");
-    addComponent( "y", shape ); componentIsNotPeriodic("y");
-    addComponent( "z", shape ); componentIsNotPeriodic("z");
+    addComponent( "x", shape );
+    componentIsNotPeriodic("x");
+    addComponent( "y", shape );
+    componentIsNotPeriodic("y");
+    addComponent( "z", shape );
+    componentIsNotPeriodic("z");
   }
   log<<"  Bibliography "<<plumed.cite("Tribello, Giberti, Sosso, Salvalaglio and Parrinello, J. Chem. Theory Comput. 13, 1317 (2017)")<<"\n";
 }
@@ -124,23 +183,41 @@ unsigned AdjacencyMatrixBase::getNumberOfDerivatives() {
 }
 
 void AdjacencyMatrixBase::setupThirdAtomBlock( const std::vector<AtomNumber>& tc, std::vector<AtomNumber>& t ) {
-  threeblocks.resize( tc.size() ); unsigned base=t.size();
-  for(unsigned i=0; i<tc.size(); ++i) { log.printf("%d ", tc[i].serial()); t.push_back(tc[i]); threeblocks[i]=base+i; }
+  threeblocks.resize( tc.size() );
+  unsigned base=t.size();
+  for(unsigned i=0; i<tc.size(); ++i) {
+    log.printf("%d ", tc[i].serial());
+    t.push_back(tc[i]);
+    threeblocks[i]=base+i;
+  }
   log.printf("\n");
 }
 
 void AdjacencyMatrixBase::setLinkCellCutoff( const bool& symmetric, const double& lcut, double tcut ) {
-  if( read_one_group && symmetric ) getPntrToComponent(0)->setSymmetric( true );
-  if( nl_cut>0 && lcut>nl_cut ) error("D_MAX for switching functions should be shorter than neighbor list cutoff");
+  if( read_one_group && symmetric ) {
+    getPntrToComponent(0)->setSymmetric( true );
+  }
+  if( nl_cut>0 && lcut>nl_cut ) {
+    error("D_MAX for switching functions should be shorter than neighbor list cutoff");
+  }
 
-  if( tcut<0 ) tcut=lcut;
-  if( nl_cut>0 ) linkcells.setCutoff( nl_cut ); else linkcells.setCutoff( lcut );
-  if( linkcells.getCutoff()<std::numeric_limits<double>::max() ) log.printf("  set link cell cutoff to %f \n", linkcells.getCutoff() );
+  if( tcut<0 ) {
+    tcut=lcut;
+  }
+  if( nl_cut>0 ) {
+    linkcells.setCutoff( nl_cut );
+  } else {
+    linkcells.setCutoff( lcut );
+  }
+  if( linkcells.getCutoff()<std::numeric_limits<double>::max() ) {
+    log.printf("  set link cell cutoff to %f \n", linkcells.getCutoff() );
+  }
   threecells.setCutoff( tcut );
 }
 
 void AdjacencyMatrixBase::prepare() {
-  ActionWithVector::prepare(); neighbour_list_updated=false;
+  ActionWithVector::prepare();
+  neighbour_list_updated=false;
 }
 
 void AdjacencyMatrixBase::updateNeighbourList() {
@@ -149,7 +226,9 @@ void AdjacencyMatrixBase::updateNeighbourList() {
   if( getStep()%nl_stride==0 ) {
     // Build the link cells
     std::vector<Vector> ltmp_pos( ablocks.size() );
-    for(unsigned i=0; i<ablocks.size(); ++i) ltmp_pos[i]=ActionAtomistic::getPosition( ablocks[i] );
+    for(unsigned i=0; i<ablocks.size(); ++i) {
+      ltmp_pos[i]=ActionAtomistic::getPosition( ablocks[i] );
+    }
     linkcells.buildCellLists( ltmp_pos, ablocks, getPbc() );
     // This ensures the link cell does not get too big.  We find the cell that contains the maximum number of atoms and multiply this by 27.
     // In this way we ensure that the neighbour list doesn't get too big.  Also this number should always be large enough
@@ -158,11 +237,19 @@ void AdjacencyMatrixBase::updateNeighbourList() {
     // Set the number of neighbors to zero for all ranks
     nlist.assign(nlist.size(),0);
     // Now get stuff to do parallel implementation
-    unsigned stride=comm.Get_size(); unsigned rank=comm.Get_rank();
-    if( runInSerial() ) { stride=1; rank=0; }
+    unsigned stride=comm.Get_size();
+    unsigned rank=comm.Get_rank();
+    if( runInSerial() ) {
+      stride=1;
+      rank=0;
+    }
     unsigned nt=OpenMP::getNumThreads();
-    if( nt*stride*10>getConstPntrToComponent(0)->getShape()[0] ) nt=getConstPntrToComponent(0)->getShape()[0]/stride/10;
-    if( nt==0 ) nt=1;
+    if( nt*stride*10>getConstPntrToComponent(0)->getShape()[0] ) {
+      nt=getConstPntrToComponent(0)->getShape()[0]/stride/10;
+    }
+    if( nt==0 ) {
+      nt=1;
+    }
     // Create a vector from the input set of tasks
     std::vector<unsigned> & pTaskList( getListOfActiveTasks(this) );
 
@@ -170,10 +257,14 @@ void AdjacencyMatrixBase::updateNeighbourList() {
     {
       // Get the number of tasks we have to deal with
       unsigned ntasks=getConstPntrToComponent(0)->getShape()[0];
-      if( nl_stride==1 ) ntasks=pTaskList.size();
+      if( nl_stride==1 ) {
+        ntasks=pTaskList.size();
+      }
       // Build a tempory nlist so we can do omp parallelism
       std::vector<unsigned> omp_nlist;
-      if( nt>1 ) omp_nlist.resize( nlist.size(), 0 );
+      if( nt>1 ) {
+        omp_nlist.resize( nlist.size(), 0 );
+      }
       // Now run over all atoms and construct the link cells
       std::vector<Vector> t_atoms( 1+ablocks.size() );
       std::vector<unsigned> indices( 1+ablocks.size() ), cells_required( linkcells.getNumberOfCells() );
@@ -183,29 +274,52 @@ void AdjacencyMatrixBase::updateNeighbourList() {
         unsigned ncells_required=0;
         linkcells.addRequiredCells( linkcells.findMyCell( ActionAtomistic::getPosition(pTaskList[i]) ), ncells_required, cells_required );
         // Now get the indices of the atoms in the link cells positions
-        unsigned natoms=1; indices[0]=pTaskList[i];
+        unsigned natoms=1;
+        indices[0]=pTaskList[i];
         linkcells.retrieveAtomsInCells( ncells_required, cells_required, natoms, indices );
         if( nl_stride==1 ) {
-          if( nt>1 ) omp_nlist[indices[0]]=0; else nlist[indices[0]] = 0;
+          if( nt>1 ) {
+            omp_nlist[indices[0]]=0;
+          } else {
+            nlist[indices[0]] = 0;
+          }
           unsigned lstart = getConstPntrToComponent(0)->getShape()[0] + indices[0]*(1+natoms_per_list);
           for(unsigned j=0; j<natoms; ++j) {
-            if( nt>1 ) { omp_nlist[ lstart + omp_nlist[indices[0]] ] = indices[j]; omp_nlist[indices[0]]++; }
-            else { nlist[ lstart + nlist[indices[0]] ] = indices[j]; nlist[indices[0]]++; }
+            if( nt>1 ) {
+              omp_nlist[ lstart + omp_nlist[indices[0]] ] = indices[j];
+              omp_nlist[indices[0]]++;
+            } else {
+              nlist[ lstart + nlist[indices[0]] ] = indices[j];
+              nlist[indices[0]]++;
+            }
           }
         } else {
           // Get the positions of all the atoms in the link cells relative to the central atom
-          for(unsigned j=0; j<natoms; ++j) t_atoms[j] = ActionAtomistic::getPosition(indices[j]) - ActionAtomistic::getPosition(indices[0]);
-          if( !nopbc ) pbcApply( t_atoms, natoms );
+          for(unsigned j=0; j<natoms; ++j) {
+            t_atoms[j] = ActionAtomistic::getPosition(indices[j]) - ActionAtomistic::getPosition(indices[0]);
+          }
+          if( !nopbc ) {
+            pbcApply( t_atoms, natoms );
+          }
           // Now construct the neighbor list
-          if( nt>1 ) omp_nlist[indices[0]] = 0; else nlist[indices[0]] = 0;
+          if( nt>1 ) {
+            omp_nlist[indices[0]] = 0;
+          } else {
+            nlist[indices[0]] = 0;
+          }
           unsigned lstart = getConstPntrToComponent(0)->getShape()[0] + indices[0]*(1+natoms_per_list);
           for(unsigned j=0; j<natoms; ++j) {
             double d2;
             if ( (d2=t_atoms[j][0]*t_atoms[j][0])<nl_cut2 &&
                  (d2+=t_atoms[j][1]*t_atoms[j][1])<nl_cut2 &&
                  (d2+=t_atoms[j][2]*t_atoms[j][2])<nl_cut2 ) {
-              if( nt>1 ) { omp_nlist[ lstart + omp_nlist[indices[0]] ] = indices[j]; omp_nlist[indices[0]]++; }
-              else { nlist[ lstart + nlist[indices[0]] ] = indices[j]; nlist[indices[0]]++; }
+              if( nt>1 ) {
+                omp_nlist[ lstart + omp_nlist[indices[0]] ] = indices[j];
+                omp_nlist[indices[0]]++;
+              } else {
+                nlist[ lstart + nlist[indices[0]] ] = indices[j];
+                nlist[indices[0]]++;
+              }
             }
           }
 
@@ -214,15 +328,21 @@ void AdjacencyMatrixBase::updateNeighbourList() {
       // Gather OMP stuff
       #pragma omp critical
       if(nt>1) {
-        for(unsigned i=0; i<ntasks; ++i) nlist[pTaskList[i]]+=omp_nlist[pTaskList[i]];
+        for(unsigned i=0; i<ntasks; ++i) {
+          nlist[pTaskList[i]]+=omp_nlist[pTaskList[i]];
+        }
         for(unsigned i=0; i<ntasks; ++i) {
           unsigned lstart = getConstPntrToComponent(0)->getShape()[0] + pTaskList[i]*(1+natoms_per_list);
-          for(unsigned j=0; j<omp_nlist[pTaskList[i]]; ++j) nlist[ lstart + j ] += omp_nlist[ lstart + j ];
+          for(unsigned j=0; j<omp_nlist[pTaskList[i]]; ++j) {
+            nlist[ lstart + j ] += omp_nlist[ lstart + j ];
+          }
         }
       }
     }
     // MPI gather
-    if( !runInSerial() ) comm.Sum( nlist );
+    if( !runInSerial() ) {
+      comm.Sum( nlist );
+    }
   }
   if( threeblocks.size()>0 ) {
     std::vector<Vector> ltmp_pos2( threeblocks.size() );
@@ -234,12 +354,16 @@ void AdjacencyMatrixBase::updateNeighbourList() {
   // And finally work out maximum number of columns to use
   maxcol = nlist[0];
   for(unsigned i=1; i<getConstPntrToComponent(0)->getShape()[0]; ++i) {
-    if( nlist[i]>maxcol ) maxcol = nlist[i];
+    if( nlist[i]>maxcol ) {
+      maxcol = nlist[i];
+    }
   }
 }
 
 void AdjacencyMatrixBase::getAdditionalTasksRequired( ActionWithVector* action, std::vector<unsigned>& atasks ) {
-  if( action==this ) return;
+  if( action==this ) {
+    return;
+  }
   // Update the neighbour list
   updateNeighbourList();
 
@@ -250,69 +374,112 @@ void AdjacencyMatrixBase::getAdditionalTasksRequired( ActionWithVector* action,
     for(unsigned j=0; j<num; ++j) {
       bool found=false;
       for(unsigned k=0; k<atasks.size(); ++k ) {
-        if( indlist[j]==atasks[k] ) { found=true; break; }
+        if( indlist[j]==atasks[k] ) {
+          found=true;
+          break;
+        }
+      }
+      if( !found ) {
+        atasks.push_back( indlist[j] );
       }
-      if( !found ) atasks.push_back( indlist[j] );
     }
   }
 }
 
 unsigned AdjacencyMatrixBase::retrieveNeighbours( const unsigned& current, std::vector<unsigned> & indices ) const {
-  unsigned natoms=nlist[current]; indices[0]=current;
-  unsigned lstart = getConstPntrToComponent(0)->getShape()[0] + current*(1+natoms_per_list); plumed_dbg_assert( nlist[lstart]==current );
-  for(unsigned i=1; i<nlist[current]; ++i) { indices[i] = nlist[ lstart + i ]; }
+  unsigned natoms=nlist[current];
+  indices[0]=current;
+  unsigned lstart = getConstPntrToComponent(0)->getShape()[0] + current*(1+natoms_per_list);
+  plumed_dbg_assert( nlist[lstart]==current );
+  for(unsigned i=1; i<nlist[current]; ++i) {
+    indices[i] = nlist[ lstart + i ];
+  }
   return natoms;
 }
 
 void AdjacencyMatrixBase::setupForTask( const unsigned& current, std::vector<unsigned> & indices, MultiValue& myvals ) const {
   // Now retrieve bookeeping arrays
-  if( indices.size()!=(1+ablocks.size()+threeblocks.size()) ) indices.resize( 1+ablocks.size()+threeblocks.size() );
+  if( indices.size()!=(1+ablocks.size()+threeblocks.size()) ) {
+    indices.resize( 1+ablocks.size()+threeblocks.size() );
+  }
 
   // Now get the positions
   unsigned natoms=retrieveNeighbours( current, indices );
-  unsigned ntwo_atoms=natoms; myvals.setSplitIndex( ntwo_atoms );
+  unsigned ntwo_atoms=natoms;
+  myvals.setSplitIndex( ntwo_atoms );
 
   // Now retrieve everything for the third atoms
   if( threeblocks.size()>0 ) {
-    unsigned ncells_required=0; std::vector<unsigned> cells_required( threecells.getNumberOfCells() );
+    unsigned ncells_required=0;
+    std::vector<unsigned> cells_required( threecells.getNumberOfCells() );
     threecells.addRequiredCells( threecells.findMyCell( ActionAtomistic::getPosition(current) ), ncells_required, cells_required );
     threecells.retrieveAtomsInCells( ncells_required, cells_required, natoms, indices );
   }
   myvals.setNumberOfIndices( natoms );
 
 // Apply periodic boundary conditions to atom positions
-  std::vector<std::vector<Vector> > & t_atoms( myvals.getFirstAtomDerivativeVector() ); if( t_atoms.size()!=1 ) t_atoms.resize(1);
-  if( t_atoms[0].size()<getNumberOfAtoms() ) t_atoms[0].resize( getNumberOfAtoms() );
-  for(unsigned i=0; i<natoms; ++i) t_atoms[0][i] = ActionAtomistic::getPosition(indices[i]) - ActionAtomistic::getPosition(current);
-  if( !nopbc ) pbcApply( t_atoms[0], natoms );
+  std::vector<std::vector<Vector> > & t_atoms( myvals.getFirstAtomDerivativeVector() );
+  if( t_atoms.size()!=1 ) {
+    t_atoms.resize(1);
+  }
+  if( t_atoms[0].size()<getNumberOfAtoms() ) {
+    t_atoms[0].resize( getNumberOfAtoms() );
+  }
+  for(unsigned i=0; i<natoms; ++i) {
+    t_atoms[0][i] = ActionAtomistic::getPosition(indices[i]) - ActionAtomistic::getPosition(current);
+  }
+  if( !nopbc ) {
+    pbcApply( t_atoms[0], natoms );
+  }
   // And collect atom position data
   std::vector<Vector> & atoms( myvals.getAtomVector() );
-  if( atoms.size()<getNumberOfAtoms() ) atoms.resize( getNumberOfAtoms() );
-  for(unsigned i=0; i<natoms; ++i) atoms[ indices[i] ] = t_atoms[0][i];
+  if( atoms.size()<getNumberOfAtoms() ) {
+    atoms.resize( getNumberOfAtoms() );
+  }
+  for(unsigned i=0; i<natoms; ++i) {
+    atoms[ indices[i] ] = t_atoms[0][i];
+  }
 }
 
 void AdjacencyMatrixBase::performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const {
-  Vector zero; zero.zero(); plumed_dbg_assert( index2<myvals.getAtomVector().size() );
+  Vector zero;
+  zero.zero();
+  plumed_dbg_assert( index2<myvals.getAtomVector().size() );
   double weight = calculateWeight( zero, myvals.getAtomVector()[index2], myvals.getNumberOfIndices()-myvals.getSplitIndex(), myvals );
-  unsigned w_ind = getConstPntrToComponent(0)->getPositionInStream(); myvals.setValue( w_ind, weight );
-  if( fabs(weight)<epsilon ) { myvals.setValue( w_ind, 0 ); return; }
+  unsigned w_ind = getConstPntrToComponent(0)->getPositionInStream();
+  myvals.setValue( w_ind, weight );
+  if( fabs(weight)<epsilon ) {
+    myvals.setValue( w_ind, 0 );
+    return;
+  }
 
   if( !doNotCalculateDerivatives() ) {
     // Update dynamic list indices for central atom
-    myvals.updateIndex( w_ind, 3*index1+0 ); myvals.updateIndex( w_ind, 3*index1+1 ); myvals.updateIndex( w_ind, 3*index1+2 );
+    myvals.updateIndex( w_ind, 3*index1+0 );
+    myvals.updateIndex( w_ind, 3*index1+1 );
+    myvals.updateIndex( w_ind, 3*index1+2 );
     // Update dynamic list indices for atom forming this bond
-    myvals.updateIndex( w_ind, 3*index2+0 ); myvals.updateIndex( w_ind, 3*index2+1 ); myvals.updateIndex( w_ind, 3*index2+2 );
+    myvals.updateIndex( w_ind, 3*index2+0 );
+    myvals.updateIndex( w_ind, 3*index2+1 );
+    myvals.updateIndex( w_ind, 3*index2+2 );
     // Now look after all the atoms in the third block
     std::vector<unsigned> & indices( myvals.getIndices() );
     for(unsigned i=myvals.getSplitIndex(); i<myvals.getNumberOfIndices(); ++i) {
-      myvals.updateIndex( w_ind, 3*indices[i]+0 ); myvals.updateIndex( w_ind, 3*indices[i]+1 ); myvals.updateIndex( w_ind, 3*indices[i]+2 );
+      myvals.updateIndex( w_ind, 3*indices[i]+0 );
+      myvals.updateIndex( w_ind, 3*indices[i]+1 );
+      myvals.updateIndex( w_ind, 3*indices[i]+2 );
     }
     // Update dynamic list indices for virial
-    unsigned base = 3*getNumberOfAtoms(); for(unsigned j=0; j<9; ++j) myvals.updateIndex( w_ind, base+j );
+    unsigned base = 3*getNumberOfAtoms();
+    for(unsigned j=0; j<9; ++j) {
+      myvals.updateIndex( w_ind, base+j );
+    }
     // And the indices for the derivatives of the row of the matrix
     unsigned nmat = getConstPntrToComponent(0)->getPositionInMatrixStash(), nmat_ind = myvals.getNumberOfMatrixRowDerivatives( nmat );
     std::vector<unsigned>& matrix_indices( myvals.getMatrixRowDerivativeIndices( nmat ) );
-    matrix_indices[nmat_ind+0]=3*index2+0; matrix_indices[nmat_ind+1]=3*index2+1; matrix_indices[nmat_ind+2]=3*index2+2;
+    matrix_indices[nmat_ind+0]=3*index2+0;
+    matrix_indices[nmat_ind+1]=3*index2+1;
+    matrix_indices[nmat_ind+2]=3*index2+2;
     myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind+3 );
   }
 
@@ -322,42 +489,81 @@ void AdjacencyMatrixBase::performTask( const std::string& controller, const unsi
     unsigned y_index = getConstPntrToComponent(2)->getPositionInStream();
     unsigned z_index = getConstPntrToComponent(3)->getPositionInStream();
     Vector atom = myvals.getAtomVector()[index2];
-    myvals.setValue( x_index, atom[0] ); myvals.setValue( y_index, atom[1] ); myvals.setValue( z_index, atom[2] );
+    myvals.setValue( x_index, atom[0] );
+    myvals.setValue( y_index, atom[1] );
+    myvals.setValue( z_index, atom[2] );
     if( !doNotCalculateDerivatives() ) {
-      myvals.addDerivative( x_index, 3*index1+0, -1 ); myvals.addDerivative( x_index, 3*index2+0, +1 );
-      myvals.addDerivative( x_index, 3*index1+1, 0 ); myvals.addDerivative( x_index, 3*index2+1, 0 );
-      myvals.addDerivative( x_index, 3*index1+2, 0 ); myvals.addDerivative( x_index, 3*index2+2, 0 );
-      myvals.addDerivative( y_index, 3*index1+0, 0 ); myvals.addDerivative( y_index, 3*index2+0, 0 );
-      myvals.addDerivative( y_index, 3*index1+1, -1 ); myvals.addDerivative( y_index, 3*index2+1, +1 );
-      myvals.addDerivative( y_index, 3*index1+2, 0 ); myvals.addDerivative( y_index, 3*index2+2, 0 );
-      myvals.addDerivative( z_index, 3*index1+0, 0 ); myvals.addDerivative( z_index, 3*index2+0, 0 );
-      myvals.addDerivative( z_index, 3*index1+1, 0 ); myvals.addDerivative( z_index, 3*index2+1, 0 );
-      myvals.addDerivative( z_index, 3*index1+2, -1 ); myvals.addDerivative( z_index, 3*index2+2, +1 );
+      myvals.addDerivative( x_index, 3*index1+0, -1 );
+      myvals.addDerivative( x_index, 3*index2+0, +1 );
+      myvals.addDerivative( x_index, 3*index1+1, 0 );
+      myvals.addDerivative( x_index, 3*index2+1, 0 );
+      myvals.addDerivative( x_index, 3*index1+2, 0 );
+      myvals.addDerivative( x_index, 3*index2+2, 0 );
+      myvals.addDerivative( y_index, 3*index1+0, 0 );
+      myvals.addDerivative( y_index, 3*index2+0, 0 );
+      myvals.addDerivative( y_index, 3*index1+1, -1 );
+      myvals.addDerivative( y_index, 3*index2+1, +1 );
+      myvals.addDerivative( y_index, 3*index1+2, 0 );
+      myvals.addDerivative( y_index, 3*index2+2, 0 );
+      myvals.addDerivative( z_index, 3*index1+0, 0 );
+      myvals.addDerivative( z_index, 3*index2+0, 0 );
+      myvals.addDerivative( z_index, 3*index1+1, 0 );
+      myvals.addDerivative( z_index, 3*index2+1, 0 );
+      myvals.addDerivative( z_index, 3*index1+2, -1 );
+      myvals.addDerivative( z_index, 3*index2+2, +1 );
       for(unsigned k=0; k<3; ++k) {
         // Update dynamic lists for central atom
-        myvals.updateIndex( x_index, 3*index1+k ); myvals.updateIndex( y_index, 3*index1+k ); myvals.updateIndex( z_index, 3*index1+k );
+        myvals.updateIndex( x_index, 3*index1+k );
+        myvals.updateIndex( y_index, 3*index1+k );
+        myvals.updateIndex( z_index, 3*index1+k );
         // Update dynamic lists for bonded atom
-        myvals.updateIndex( x_index, 3*index2+k ); myvals.updateIndex( y_index, 3*index2+k ); myvals.updateIndex( z_index, 3*index2+k );
+        myvals.updateIndex( x_index, 3*index2+k );
+        myvals.updateIndex( y_index, 3*index2+k );
+        myvals.updateIndex( z_index, 3*index2+k );
       }
       // Add derivatives of virial
       unsigned base = 3*getNumberOfAtoms();
       // Virial for x
-      myvals.addDerivative( x_index, base+0, -atom[0] ); myvals.addDerivative( x_index, base+3, -atom[1] ); myvals.addDerivative( x_index, base+6, -atom[2] );
-      myvals.addDerivative( x_index, base+1, 0 ); myvals.addDerivative( x_index, base+4, 0 ); myvals.addDerivative( x_index, base+7, 0 );
-      myvals.addDerivative( x_index, base+2, 0 ); myvals.addDerivative( x_index, base+5, 0 ); myvals.addDerivative( x_index, base+8, 0 );
+      myvals.addDerivative( x_index, base+0, -atom[0] );
+      myvals.addDerivative( x_index, base+3, -atom[1] );
+      myvals.addDerivative( x_index, base+6, -atom[2] );
+      myvals.addDerivative( x_index, base+1, 0 );
+      myvals.addDerivative( x_index, base+4, 0 );
+      myvals.addDerivative( x_index, base+7, 0 );
+      myvals.addDerivative( x_index, base+2, 0 );
+      myvals.addDerivative( x_index, base+5, 0 );
+      myvals.addDerivative( x_index, base+8, 0 );
       // Virial for y
-      myvals.addDerivative( y_index, base+0, 0 ); myvals.addDerivative( y_index, base+3, 0 ); myvals.addDerivative( y_index, base+6, 0 );
-      myvals.addDerivative( y_index, base+1, -atom[0] ); myvals.addDerivative( y_index, base+4, -atom[1] ); myvals.addDerivative( y_index, base+7, -atom[2] );
-      myvals.addDerivative( y_index, base+2, 0 ); myvals.addDerivative( y_index, base+5, 0 ); myvals.addDerivative( y_index, base+8, 0 );
+      myvals.addDerivative( y_index, base+0, 0 );
+      myvals.addDerivative( y_index, base+3, 0 );
+      myvals.addDerivative( y_index, base+6, 0 );
+      myvals.addDerivative( y_index, base+1, -atom[0] );
+      myvals.addDerivative( y_index, base+4, -atom[1] );
+      myvals.addDerivative( y_index, base+7, -atom[2] );
+      myvals.addDerivative( y_index, base+2, 0 );
+      myvals.addDerivative( y_index, base+5, 0 );
+      myvals.addDerivative( y_index, base+8, 0 );
       // Virial for z
-      myvals.addDerivative( z_index, base+0, 0 ); myvals.addDerivative( z_index, base+3, 0 ); myvals.addDerivative( z_index, base+6, 0 );
-      myvals.addDerivative( z_index, base+1, 0 ); myvals.addDerivative( z_index, base+4, 0 ); myvals.addDerivative( z_index, base+7, 0 );
-      myvals.addDerivative( z_index, base+2, -atom[0] ); myvals.addDerivative( z_index, base+5, -atom[1] ); myvals.addDerivative( z_index, base+8, -atom[2] );
-      for(unsigned k=0; k<9; ++k) { myvals.updateIndex( x_index, base+k ); myvals.updateIndex( y_index, base+k ); myvals.updateIndex( z_index, base+k ); }
+      myvals.addDerivative( z_index, base+0, 0 );
+      myvals.addDerivative( z_index, base+3, 0 );
+      myvals.addDerivative( z_index, base+6, 0 );
+      myvals.addDerivative( z_index, base+1, 0 );
+      myvals.addDerivative( z_index, base+4, 0 );
+      myvals.addDerivative( z_index, base+7, 0 );
+      myvals.addDerivative( z_index, base+2, -atom[0] );
+      myvals.addDerivative( z_index, base+5, -atom[1] );
+      myvals.addDerivative( z_index, base+8, -atom[2] );
+      for(unsigned k=0; k<9; ++k) {
+        myvals.updateIndex( x_index, base+k );
+        myvals.updateIndex( y_index, base+k );
+        myvals.updateIndex( z_index, base+k );
+      }
       for(unsigned k=1; k<4; ++k) {
         unsigned nmat = getConstPntrToComponent(k)->getPositionInMatrixStash(), nmat_ind = myvals.getNumberOfMatrixRowDerivatives( nmat );
         std::vector<unsigned>& matrix_indices( myvals.getMatrixRowDerivativeIndices( nmat ) );
-        matrix_indices[nmat_ind+0]=3*index2+0; matrix_indices[nmat_ind+1]=3*index2+1; matrix_indices[nmat_ind+2]=3*index2+2;
+        matrix_indices[nmat_ind+0]=3*index2+0;
+        matrix_indices[nmat_ind+1]=3*index2+1;
+        matrix_indices[nmat_ind+2]=3*index2+2;
         myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind+3 );
       }
     }
@@ -365,7 +571,9 @@ void AdjacencyMatrixBase::performTask( const std::string& controller, const unsi
 }
 
 void AdjacencyMatrixBase::runEndOfRowJobs( const unsigned& ind, const std::vector<unsigned> & indices, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
 
   for(int k=0; k<getNumberOfComponents(); ++k) {
     unsigned nmat = getConstPntrToComponent(k)->getPositionInMatrixStash(), nmat_ind = myvals.getNumberOfMatrixRowDerivatives( nmat );
@@ -382,8 +590,11 @@ void AdjacencyMatrixBase::runEndOfRowJobs( const unsigned& ind, const std::vecto
       nmat_ind+=3;
     }
     unsigned virbase = 3*getNumberOfAtoms();
-    for(unsigned i=0; i<9; ++i) matrix_indices[nmat_ind+i]=virbase+i;
-    nmat_ind+=9; plumed_dbg_massert( nmat_ind<=3*getNumberOfAtoms() + 9, "found too many derivatives in " + getLabel() );
+    for(unsigned i=0; i<9; ++i) {
+      matrix_indices[nmat_ind+i]=virbase+i;
+    }
+    nmat_ind+=9;
+    plumed_dbg_massert( nmat_ind<=3*getNumberOfAtoms() + 9, "found too many derivatives in " + getLabel() );
     myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind );
   }
 }
diff --git a/src/adjmat/AdjacencyMatrixBase.h b/src/adjmat/AdjacencyMatrixBase.h
index e529688d8d..167ec34cc8 100644
--- a/src/adjmat/AdjacencyMatrixBase.h
+++ b/src/adjmat/AdjacencyMatrixBase.h
@@ -50,7 +50,9 @@ class AdjacencyMatrixBase : public ActionWithMatrix {
 public:
   static void registerKeywords( Keywords& keys );
   explicit AdjacencyMatrixBase(const ActionOptions&);
-  bool isAdjacencyMatrix() const override { return true; }
+  bool isAdjacencyMatrix() const override {
+    return true;
+  }
   unsigned getNumberOfDerivatives() override ;
   unsigned getNumberOfColumns() const override;
   void prepare() override;
@@ -72,9 +74,14 @@ Vector AdjacencyMatrixBase::getPosition( const unsigned& indno, MultiValue& myva
 
 inline
 void AdjacencyMatrixBase::addAtomDerivatives( const unsigned& indno, const Vector& der, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() ) return;
-  plumed_dbg_assert( indno<2 ); unsigned index = myvals.getTaskIndex();
-  if( indno==1 ) index = myvals.getSecondTaskIndex();
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
+  plumed_dbg_assert( indno<2 );
+  unsigned index = myvals.getTaskIndex();
+  if( indno==1 ) {
+    index = myvals.getSecondTaskIndex();
+  }
   unsigned w_index = getConstPntrToComponent(0)->getPositionInStream();
   myvals.addDerivative( w_index, 3*index+0, der[0] );
   myvals.addDerivative( w_index, 3*index+1, der[1] );
@@ -83,7 +90,9 @@ void AdjacencyMatrixBase::addAtomDerivatives( const unsigned& indno, const Vecto
 
 inline
 void AdjacencyMatrixBase::addThirdAtomDerivatives( const unsigned& indno, const Vector& der, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
   unsigned index = myvals.getIndices()[ indno + myvals.getSplitIndex() ];
   unsigned w_index = getConstPntrToComponent(0)->getPositionInStream();
   myvals.addDerivative( w_index, 3*index+0, der[0] );
@@ -93,7 +102,9 @@ void AdjacencyMatrixBase::addThirdAtomDerivatives( const unsigned& indno, const
 
 inline
 void AdjacencyMatrixBase::addBoxDerivatives( const Tensor& vir, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
   unsigned nbase = 3*getNumberOfAtoms();
   unsigned w_index = getConstPntrToComponent(0)->getPositionInStream();
   myvals.addDerivative( w_index, nbase+0, vir(0,0) );
diff --git a/src/adjmat/Bridge.cpp b/src/adjmat/Bridge.cpp
index d018fb07b2..63b8540c1f 100644
--- a/src/adjmat/Bridge.cpp
+++ b/src/adjmat/Bridge.cpp
@@ -54,18 +54,30 @@ void Bridge::registerKeywords(Keywords& keys) {
            "group A");
   keys.add("optional","SWITCHB","The switchingfunction on the distance between the bridging atoms and the atoms in "
            "group B");
-  keys.needsAction("BRIDGE_MATRIX"); keys.needsAction("SUM");
+  keys.needsAction("BRIDGE_MATRIX");
+  keys.needsAction("SUM");
   keys.setValueDescription("the number of bridging atoms between the two groups");
 }
 
 Bridge::Bridge(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Need to read in switch
-  std::string s_inp, sfinput; parse("SWITCH",sfinput); if( sfinput.length()>0 ) s_inp += "SWITCH={" + sfinput +"} ";
-  std::string sfinputa; parse("SWITCHA",sfinputa); if( sfinputa.length()>0 ) s_inp += "SWITCHA={" + sfinputa +"} ";
-  std::string sfinputb; parse("SWITCHB",sfinputb); if( sfinputb.length()>0 ) s_inp += "SWITCHB={" + sfinputb +"} ";
+  std::string s_inp, sfinput;
+  parse("SWITCH",sfinput);
+  if( sfinput.length()>0 ) {
+    s_inp += "SWITCH={" + sfinput +"} ";
+  }
+  std::string sfinputa;
+  parse("SWITCHA",sfinputa);
+  if( sfinputa.length()>0 ) {
+    s_inp += "SWITCHA={" + sfinputa +"} ";
+  }
+  std::string sfinputb;
+  parse("SWITCHB",sfinputb);
+  if( sfinputb.length()>0 ) {
+    s_inp += "SWITCHB={" + sfinputb +"} ";
+  }
   // Create the matrix object
   readInputLine( getShortcutLabel() + "_mat: BRIDGE_MATRIX " + s_inp + convertInputLineToString() );
   // Add all the elements of the matrix together
diff --git a/src/adjmat/BridgeMatrix.cpp b/src/adjmat/BridgeMatrix.cpp
index 7d049a8874..9d98b3e2c8 100644
--- a/src/adjmat/BridgeMatrix.cpp
+++ b/src/adjmat/BridgeMatrix.cpp
@@ -83,23 +83,37 @@ void BridgeMatrix::registerKeywords( Keywords& keys ) {
 
 BridgeMatrix::BridgeMatrix(const ActionOptions&ao):
   Action(ao),
-  AdjacencyMatrixBase(ao)
-{
-  bool oneswitch; std::string sfinput,errors; parse("SWITCH",sfinput);
+  AdjacencyMatrixBase(ao) {
+  bool oneswitch;
+  std::string sfinput,errors;
+  parse("SWITCH",sfinput);
   if( sfinput.length()>0 ) {
-    sf1.set(sfinput,errors); oneswitch=true;
-    if( errors.length()!=0 ) error("problem reading SWITCH keyword : " + errors );
+    sf1.set(sfinput,errors);
+    oneswitch=true;
+    if( errors.length()!=0 ) {
+      error("problem reading SWITCH keyword : " + errors );
+    }
     sf2.set(sfinput,errors);
-    if( errors.length()!=0 ) error("problem reading SWITCH keyword : " + errors );
+    if( errors.length()!=0 ) {
+      error("problem reading SWITCH keyword : " + errors );
+    }
   } else {
     parse("SWITCHA",sfinput);
     if(sfinput.length()>0) {
-      sf1.set(sfinput,errors); oneswitch=false;
-      if( errors.length()!=0 ) error("problem reading SWITCHA keyword : " + errors );
-      sfinput.clear(); parse("SWITCHB",sfinput);
-      if(sfinput.length()==0) error("found SWITCHA keyword without SWITCHB");
+      sf1.set(sfinput,errors);
+      oneswitch=false;
+      if( errors.length()!=0 ) {
+        error("problem reading SWITCHA keyword : " + errors );
+      }
+      sfinput.clear();
+      parse("SWITCHB",sfinput);
+      if(sfinput.length()==0) {
+        error("found SWITCHA keyword without SWITCHB");
+      }
       sf2.set(sfinput,errors);
-      if( errors.length()!=0 ) error("problem reading SWITCHB keyword : " + errors );
+      if( errors.length()!=0 ) {
+        error("problem reading SWITCHB keyword : " + errors );
+      }
     } else {
       error("missing definition of switching functions");
     }
@@ -115,12 +129,25 @@ BridgeMatrix::BridgeMatrix(const ActionOptions&ao):
 }
 
 double BridgeMatrix::calculateWeight( const Vector& pos1, const Vector& pos2, const unsigned& natoms, MultiValue& myvals ) const {
-  double tot=0; if( pos2.modulo2()<epsilon ) return 0.0;
+  double tot=0;
+  if( pos2.modulo2()<epsilon ) {
+    return 0.0;
+  }
   for(unsigned i=0; i<natoms; ++i) {
-    Vector dij= getPosition(i,myvals); double dijm = dij.modulo2();
-    double dw1, w1=sf1.calculateSqr( dijm, dw1 ); if( dijm<epsilon ) { w1=0.0; dw1=0.0; }
-    Vector dik=pbcDistance( getPosition(i,myvals), pos2 ); double dikm=dik.modulo2();
-    double dw2, w2=sf2.calculateSqr( dikm, dw2 ); if( dikm<epsilon ) { w2=0.0; dw2=0.0; }
+    Vector dij= getPosition(i,myvals);
+    double dijm = dij.modulo2();
+    double dw1, w1=sf1.calculateSqr( dijm, dw1 );
+    if( dijm<epsilon ) {
+      w1=0.0;
+      dw1=0.0;
+    }
+    Vector dik=pbcDistance( getPosition(i,myvals), pos2 );
+    double dikm=dik.modulo2();
+    double dw2, w2=sf2.calculateSqr( dikm, dw2 );
+    if( dikm<epsilon ) {
+      w2=0.0;
+      dw2=0.0;
+    }
 
     tot += w1*w2;
     // And finish the calculation
diff --git a/src/adjmat/ContactMatrix.cpp b/src/adjmat/ContactMatrix.cpp
index 1f6b8c0df3..91de71ef96 100644
--- a/src/adjmat/ContactMatrix.cpp
+++ b/src/adjmat/ContactMatrix.cpp
@@ -72,13 +72,16 @@ class ContactMatrix : public AdjacencyMatrixBase {
 /// This does nothing
   double calculateWeight( const Vector& pos1, const Vector& pos2, const unsigned& natoms, MultiValue& myvals ) const override;
 /// Override this so we write the graph properly
-  std::string writeInGraph() const override { return "CONTACT_MATRIX"; }
+  std::string writeInGraph() const override {
+    return "CONTACT_MATRIX";
+  }
 };
 
 PLUMED_REGISTER_ACTION(ContactMatrix,"CONTACT_MATRIX_PROPER")
 
 void ContactMatrix::registerKeywords( Keywords& keys ) {
-  AdjacencyMatrixBase::registerKeywords( keys ); keys.setDisplayName("CONTACT_MATRIX");
+  AdjacencyMatrixBase::registerKeywords( keys );
+  keys.setDisplayName("CONTACT_MATRIX");
   keys.add("compulsory","NN","6","The n parameter of the switching function ");
   keys.add("compulsory","MM","0","The m parameter of the switching function; 0 implies 2*NN");
   keys.add("compulsory","D_0","0.0","The d_0 parameter of the switching function");
@@ -90,17 +93,24 @@ void ContactMatrix::registerKeywords( Keywords& keys ) {
 
 ContactMatrix::ContactMatrix( const ActionOptions& ao ):
   Action(ao),
-  AdjacencyMatrixBase(ao)
-{
-  std::string errors, input; parse("SWITCH",input);
+  AdjacencyMatrixBase(ao) {
+  std::string errors, input;
+  parse("SWITCH",input);
   if( input.length()>0 ) {
     switchingFunction.set( input, errors );
-    if( errors.length()!=0 ) error("problem reading switching function description " + errors);
+    if( errors.length()!=0 ) {
+      error("problem reading switching function description " + errors);
+    }
   } else {
-    double r_0=-1.0, d_0; int nn, mm;
-    parse("NN",nn); parse("MM",mm);
-    parse("R_0",r_0); parse("D_0",d_0);
-    if( r_0<0.0 ) error("you must set a value for R_0");
+    double r_0=-1.0, d_0;
+    int nn, mm;
+    parse("NN",nn);
+    parse("MM",mm);
+    parse("R_0",r_0);
+    parse("D_0",d_0);
+    if( r_0<0.0 ) {
+      error("you must set a value for R_0");
+    }
     switchingFunction.set(nn,mm,r_0,d_0);
   }
   // And set the link cell cutoff
@@ -109,11 +119,18 @@ ContactMatrix::ContactMatrix( const ActionOptions& ao ):
 }
 
 double ContactMatrix::calculateWeight( const Vector& pos1, const Vector& pos2, const unsigned& natoms, MultiValue& myvals ) const {
-  Vector distance = pos2; double mod2 = distance.modulo2();
-  if( mod2<epsilon ) return 0.0;  // Atoms can't be bonded to themselves
+  Vector distance = pos2;
+  double mod2 = distance.modulo2();
+  if( mod2<epsilon ) {
+    return 0.0;  // Atoms can't be bonded to themselves
+  }
   double dfunc, val = switchingFunction.calculateSqr( mod2, dfunc );
-  if( val<epsilon ) return 0.0;
-  if( doNotCalculateDerivatives() ) return val;
+  if( val<epsilon ) {
+    return 0.0;
+  }
+  if( doNotCalculateDerivatives() ) {
+    return val;
+  }
   addAtomDerivatives( 0, (-dfunc)*distance, myvals );
   addAtomDerivatives( 1, (+dfunc)*distance, myvals );
   addBoxDerivatives( (-dfunc)*Tensor(distance,distance), myvals );
diff --git a/src/adjmat/ContactMatrixShortcut.cpp b/src/adjmat/ContactMatrixShortcut.cpp
index 70682bdb68..9431c8a699 100644
--- a/src/adjmat/ContactMatrixShortcut.cpp
+++ b/src/adjmat/ContactMatrixShortcut.cpp
@@ -71,58 +71,87 @@ PLUMED_REGISTER_ACTION(ContactMatrixShortcut,"CONTACT_MATRIX")
 
 void ContactMatrixShortcut::registerKeywords(Keywords& keys) {
   AdjacencyMatrixBase::registerKeywords( keys );
-  keys.remove("GROUP"); keys.add("numbered","GROUP","specifies the list of atoms that should be assumed indistinguishable");
+  keys.remove("GROUP");
+  keys.add("numbered","GROUP","specifies the list of atoms that should be assumed indistinguishable");
   keys.add("compulsory","NN","6","The n parameter of the switching function ");
   keys.add("compulsory","MM","0","The m parameter of the switching function; 0 implies 2*NN");
   keys.add("compulsory","D_0","0.0","The d_0 parameter of the switching function");
   keys.add("compulsory","R_0","The r_0 parameter of the switching function");
   keys.add("numbered","SWITCH","specify the switching function to use between two sets of indistinguishable atoms");
-  keys.addActionNameSuffix("_PROPER"); keys.needsAction("TRANSPOSE"); keys.needsAction("CONCATENATE");
+  keys.addActionNameSuffix("_PROPER");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("CONCATENATE");
 }
 
 ContactMatrixShortcut::ContactMatrixShortcut(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::vector<std::string> grp_str; std::string atomsstr="";
-  std::vector<std::string> atomsvec; parseVector("ATOMS",atomsvec);
+  ActionShortcut(ao) {
+  std::vector<std::string> grp_str;
+  std::string atomsstr="";
+  std::vector<std::string> atomsvec;
+  parseVector("ATOMS",atomsvec);
   if( atomsvec.size()>0 )  {
     for(unsigned i=0; i<atomsvec.size(); ++i) {
       Group* gg = plumed.getActionSet().selectWithLabel<Group*>( atomsvec[i] );
-      if( gg ) grp_str.push_back( atomsvec[i] );
+      if( gg ) {
+        grp_str.push_back( atomsvec[i] );
+      }
     }
     if( grp_str.size()!=atomsvec.size() ) {
       grp_str.resize(0);
-      atomsstr = " ATOMS=" + atomsvec[0]; for(unsigned i=1; i<atomsvec.size(); ++i) atomsstr += "," + atomsvec[i];
+      atomsstr = " ATOMS=" + atomsvec[0];
+      for(unsigned i=1; i<atomsvec.size(); ++i) {
+        atomsstr += "," + atomsvec[i];
+      }
     }
   } else {
     std::string grp_inpt;
     for(unsigned i=1;; ++i) {
-      if( !parseNumbered("GROUP",i,grp_inpt) ) break;
+      if( !parseNumbered("GROUP",i,grp_inpt) ) {
+        break;
+      }
       grp_str.push_back( grp_inpt );
     }
   }
-  if( grp_str.size()>9 ) error("cannot handle more than 9 groups");
-  if( grp_str.size()==0 )  { readInputLine( getShortcutLabel() + ": CONTACT_MATRIX_PROPER " + atomsstr + " " + convertInputLineToString() ); return; }
+  if( grp_str.size()>9 ) {
+    error("cannot handle more than 9 groups");
+  }
+  if( grp_str.size()==0 )  {
+    readInputLine( getShortcutLabel() + ": CONTACT_MATRIX_PROPER " + atomsstr + " " + convertInputLineToString() );
+    return;
+  }
 
   for(unsigned i=0; i<grp_str.size(); ++i) {
-    std::string sw_str, num; Tools::convert( i+1, num ); parseNumbered("SWITCH", (i+1)*10 + 1 + i,  sw_str );
-    if( sw_str.length()==0 ) error("missing SWITCH" + num + num + " keyword");
+    std::string sw_str, num;
+    Tools::convert( i+1, num );
+    parseNumbered("SWITCH", (i+1)*10 + 1 + i,  sw_str );
+    if( sw_str.length()==0 ) {
+      error("missing SWITCH" + num + num + " keyword");
+    }
     readInputLine( getShortcutLabel() + num +  num + ": CONTACT_MATRIX_PROPER GROUP=" + grp_str[i] + " SWITCH={" + sw_str + "}" );
     for(unsigned j=0; j<i; ++j) {
-      std::string sw_str2, jnum; Tools::convert( j+1, jnum ); parseNumbered("SWITCH", (j+1)*10 + 1 + i, sw_str2);
-      if( sw_str2.length()==0 ) error("missing SWITCH" + jnum + num + " keyword");
+      std::string sw_str2, jnum;
+      Tools::convert( j+1, jnum );
+      parseNumbered("SWITCH", (j+1)*10 + 1 + i, sw_str2);
+      if( sw_str2.length()==0 ) {
+        error("missing SWITCH" + jnum + num + " keyword");
+      }
       readInputLine( getShortcutLabel() + jnum + num + ": CONTACT_MATRIX_PROPER GROUPA=" + grp_str[j] + " GROUPB=" + grp_str[i] + " SWITCH={" + sw_str2 +"}");
       readInputLine( getShortcutLabel() + num +  jnum + ": TRANSPOSE ARG=" + getShortcutLabel() + jnum + num );
     }
   }
   std::string join_matrices = getShortcutLabel() + ": CONCATENATE";
   for(unsigned i=0; i<grp_str.size(); ++i) {
-    std::string inum; Tools::convert(i+1,inum);
+    std::string inum;
+    Tools::convert(i+1,inum);
     for(unsigned j=0; j<grp_str.size(); ++j) {
-      std::string jnum; Tools::convert(j+1,jnum);
-      if( i>j ) join_matrices += " MATRIX" + inum + jnum + "=" + getShortcutLabel() + inum +  jnum;
-      else join_matrices += " MATRIX" + inum + jnum + "=" + getShortcutLabel() + inum +  jnum;
+      std::string jnum;
+      Tools::convert(j+1,jnum);
+      if( i>j ) {
+        join_matrices += " MATRIX" + inum + jnum + "=" + getShortcutLabel() + inum +  jnum;
+      } else {
+        join_matrices += " MATRIX" + inum + jnum + "=" + getShortcutLabel() + inum +  jnum;
+      }
     }
   }
   readInputLine( join_matrices );
diff --git a/src/adjmat/DistanceMatrix.cpp b/src/adjmat/DistanceMatrix.cpp
index e224f2ee84..3d097bb347 100644
--- a/src/adjmat/DistanceMatrix.cpp
+++ b/src/adjmat/DistanceMatrix.cpp
@@ -58,8 +58,7 @@ void DistanceMatrix::registerKeywords( Keywords& keys ) {
 
 DistanceMatrix::DistanceMatrix( const ActionOptions& ao ):
   Action(ao),
-  AdjacencyMatrixBase(ao)
-{
+  AdjacencyMatrixBase(ao) {
   // And set the link cell cutoff
   log.printf("  weight is distance between atoms \n");
   parse("CUTOFF",cutoff);
@@ -72,7 +71,8 @@ DistanceMatrix::DistanceMatrix( const ActionOptions& ao ):
 }
 
 double DistanceMatrix::calculateWeight( const Vector& pos1, const Vector& pos2, const unsigned& natoms, MultiValue& myvals ) const {
-  Vector distance = pos2; double mod = distance.modulo();
+  Vector distance = pos2;
+  double mod = distance.modulo();
   if( cutoff<0 || mod<cutoff ) {
     double invd = 1.0/mod;
     addAtomDerivatives( 0, (-invd)*distance, myvals );
diff --git a/src/adjmat/HbondMatrix.cpp b/src/adjmat/HbondMatrix.cpp
index acb779720a..b799c3e1b4 100644
--- a/src/adjmat/HbondMatrix.cpp
+++ b/src/adjmat/HbondMatrix.cpp
@@ -109,22 +109,36 @@ void HbondMatrix::registerKeywords( Keywords& keys ) {
 
 HbondMatrix::HbondMatrix(const ActionOptions&ao):
   Action(ao),
-  AdjacencyMatrixBase(ao)
-{
-  std::string sfinput,errors; parse("SWITCH",sfinput);
-  if( sfinput.length()==0 ) error("could not find SWITCH keyword");
+  AdjacencyMatrixBase(ao) {
+  std::string sfinput,errors;
+  parse("SWITCH",sfinput);
+  if( sfinput.length()==0 ) {
+    error("could not find SWITCH keyword");
+  }
   distanceOOSwitch.set(sfinput,errors);
-  if( errors.length()!=0 ) error("problem reading SWITCH keyword : " + errors );
+  if( errors.length()!=0 ) {
+    error("problem reading SWITCH keyword : " + errors );
+  }
 
-  std::string hsfinput; parse("HSWITCH",hsfinput);
-  if( hsfinput.length()==0 ) error("could not find HSWITCH keyword");
+  std::string hsfinput;
+  parse("HSWITCH",hsfinput);
+  if( hsfinput.length()==0 ) {
+    error("could not find HSWITCH keyword");
+  }
   distanceOHSwitch.set(hsfinput,errors);
-  if( errors.length()!=0 ) error("problem reading HSWITCH keyword : " + errors );
+  if( errors.length()!=0 ) {
+    error("problem reading HSWITCH keyword : " + errors );
+  }
 
-  std::string asfinput; parse("ASWITCH",asfinput);
-  if( asfinput.length()==0 ) error("could not find SWITCH keyword");
+  std::string asfinput;
+  parse("ASWITCH",asfinput);
+  if( asfinput.length()==0 ) {
+    error("could not find SWITCH keyword");
+  }
   angleSwitch.set(asfinput,errors);
-  if( errors.length()!=0 ) error("problem reading SWITCH keyword : " + errors );
+  if( errors.length()!=0 ) {
+    error("problem reading SWITCH keyword : " + errors );
+  }
 
   // Setup link cells
   setLinkCellCutoff( false, distanceOOSwitch.get_dmax() );
@@ -134,16 +148,22 @@ HbondMatrix::HbondMatrix(const ActionOptions&ao):
 }
 
 double HbondMatrix::calculateWeight( const Vector& pos1, const Vector& pos2, const unsigned& natoms, MultiValue& myvals ) const {
-  Vector ood = pos2; double ood_l = ood.modulo2(); // acceptor - donor
-  if( ood_l<epsilon) return 0;
+  Vector ood = pos2;
+  double ood_l = ood.modulo2(); // acceptor - donor
+  if( ood_l<epsilon) {
+    return 0;
+  }
   double ood_df, ood_sw=distanceOOSwitch.calculateSqr( ood_l, ood_df );
 
   double value=0;
   for(unsigned i=0; i<natoms; ++i) {
-    Vector ohd=getPosition(i,myvals); double ohd_l=ohd.modulo2();
+    Vector ohd=getPosition(i,myvals);
+    double ohd_l=ohd.modulo2();
     double ohd_df, ohd_sw=distanceOHSwitch.calculateSqr( ohd_l, ohd_df );
 
-    Angle a; Vector ood_adf, ohd_adf; double angle=a.compute( ood, ohd, ood_adf, ohd_adf );
+    Angle a;
+    Vector ood_adf, ohd_adf;
+    double angle=a.compute( ood, ohd, ood_adf, ohd_adf );
     double angle_df, angle_sw=angleSwitch.calculate( angle, angle_df );
     value += ood_sw*ohd_sw*angle_sw;
 
diff --git a/src/adjmat/Neighbors.cpp b/src/adjmat/Neighbors.cpp
index 58f4b4b978..e214f067c5 100644
--- a/src/adjmat/Neighbors.cpp
+++ b/src/adjmat/Neighbors.cpp
@@ -41,8 +41,12 @@ class Neighbors : public ActionWithMatrix {
   static void registerKeywords( Keywords& keys );
   explicit Neighbors(const ActionOptions&);
   unsigned getNumberOfDerivatives() override;
-  unsigned getNumberOfColumns() const override { return number; }
-  bool canBeAfterInChain( ActionWithVector* av ) { return av->getLabel()!=(getPntrToArgument(0)->getPntrToAction())->getLabel(); }
+  unsigned getNumberOfColumns() const override {
+    return number;
+  }
+  bool canBeAfterInChain( ActionWithVector* av ) {
+    return av->getLabel()!=(getPntrToArgument(0)->getPntrToAction())->getLabel();
+  }
   void setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const ;
   void performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const override;
   void runEndOfRowJobs( const unsigned& ival, const std::vector<unsigned> & indices, MultiValue& myvals ) const override {}
@@ -52,7 +56,8 @@ class Neighbors : public ActionWithMatrix {
 PLUMED_REGISTER_ACTION(Neighbors,"NEIGHBORS")
 
 void Neighbors::registerKeywords( Keywords& keys ) {
-  ActionWithMatrix::registerKeywords( keys ); keys.use("ARG");
+  ActionWithMatrix::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("compulsory","NLOWEST","0","in each row of the output matrix set the elements that correspond to the n lowest elements in each row of the input matrix equal to one");
   keys.add("compulsory","NHIGHEST","0","in each row of the output matrix set the elements that correspond to the n highest elements in each row of the input matrix equal to one");
   keys.setValueDescription("a matrix in which the ij element is one if the ij-element of the input matrix is one of the NLOWEST/NHIGHEST elements on that row of the input matrix and zero otherwise");
@@ -60,28 +65,40 @@ void Neighbors::registerKeywords( Keywords& keys ) {
 
 Neighbors::Neighbors(const ActionOptions&ao):
   Action(ao),
-  ActionWithMatrix(ao)
-{
-  if( getNumberOfArguments()!=1 ) error("found wrong number of arguments in input");
-  if( getPntrToArgument(0)->getRank()!=2 ) error("input argument should be a matrix");
+  ActionWithMatrix(ao) {
+  if( getNumberOfArguments()!=1 ) {
+    error("found wrong number of arguments in input");
+  }
+  if( getPntrToArgument(0)->getRank()!=2 ) {
+    error("input argument should be a matrix");
+  }
   getPntrToArgument(0)->buildDataStore();
 
-  unsigned nlow; parse("NLOWEST",nlow);
-  unsigned nhigh; parse("NHIGHEST",nhigh);
-  if( nlow==0 && nhigh==0 ) error("missing NLOWEST or NHIGHEST keyword one of these two keywords must be set in input");
-  if( nlow>0 && nhigh>0 ) error("should only be one of NLOWEST or NHIGHEST set in input");
+  unsigned nlow;
+  parse("NLOWEST",nlow);
+  unsigned nhigh;
+  parse("NHIGHEST",nhigh);
+  if( nlow==0 && nhigh==0 ) {
+    error("missing NLOWEST or NHIGHEST keyword one of these two keywords must be set in input");
+  }
+  if( nlow>0 && nhigh>0 ) {
+    error("should only be one of NLOWEST or NHIGHEST set in input");
+  }
   if( nlow>0 ) {
-    number=nlow; lowest=true;
+    number=nlow;
+    lowest=true;
     log.printf("  output matrix will have non-zero values for elements that correpsond to the %d lowest elements in each row of the input matrix\n",number);
   }
   if( nhigh>0 ) {
-    number=nhigh; lowest=false;
+    number=nhigh;
+    lowest=false;
     log.printf("  output matrix will have non-zero values for elements that correpsond to the %d highest elements in each row of the input matrix\n",number);
   }
 
   // And get the shape
   std::vector<unsigned> shape( getPntrToArgument(0)->getShape() );
-  addValue( shape ); setNotPeriodic();
+  addValue( shape );
+  setNotPeriodic();
   checkRead();
 }
 
@@ -95,27 +112,39 @@ unsigned Neighbors::getNumberOfDerivatives() {
 }
 
 void Neighbors::setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const {
-  const Value* wval = getPntrToArgument(0); unsigned nbonds = wval->getRowLength( task_index ), ncols = wval->getShape()[1];
-  if( indices.size()!=1+number ) indices.resize( 1 + number );
+  const Value* wval = getPntrToArgument(0);
+  unsigned nbonds = wval->getRowLength( task_index ), ncols = wval->getShape()[1];
+  if( indices.size()!=1+number ) {
+    indices.resize( 1 + number );
+  }
   myvals.setSplitIndex(1+number);
 
   unsigned nind=0;
   for(unsigned i=0; i<nbonds; ++i) {
     unsigned ipos = ncols*task_index + wval->getRowIndex( task_index, i );
     double weighti = wval->get( ipos );
-    if( weighti<epsilon ) continue ;
+    if( weighti<epsilon ) {
+      continue ;
+    }
     nind++;
   }
-  if( number>nind ) plumed_merror("not enough matrix elements were stored");
+  if( number>nind ) {
+    plumed_merror("not enough matrix elements were stored");
+  }
 
   // Now build vectors for doing sorting
-  std::vector<std::pair<double,unsigned> > rows( nind ); unsigned n=0;
+  std::vector<std::pair<double,unsigned> > rows( nind );
+  unsigned n=0;
   for(unsigned i=0; i<nbonds; ++i) {
     unsigned iind = wval->getRowIndex( task_index, i );
     unsigned ipos = ncols*task_index + iind;
     double weighti = wval->get( ipos );
-    if( weighti<epsilon ) continue ;
-    rows[n].first=weighti; rows[n].second=iind; n++;
+    if( weighti<epsilon ) {
+      continue ;
+    }
+    rows[n].first=weighti;
+    rows[n].second=iind;
+    n++;
   }
 
   // Now do the sort and clear all the stored values ready for recompute
@@ -125,7 +154,9 @@ void Neighbors::setupForTask( const unsigned& task_index, std::vector<unsigned>&
   // And setup the lowest indices, which are the ones we need to calculate
   for(unsigned i=0; i<number; ++i) {
     indices[i+1] = start_n + rows[nind-1-i].second;
-    if( lowest ) indices[i+1] = start_n + rows[i].second;
+    if( lowest ) {
+      indices[i+1] = start_n + rows[i].second;
+    }
   }
 }
 
diff --git a/src/adjmat/TopologyMatrix.cpp b/src/adjmat/TopologyMatrix.cpp
index 4234c24ddb..7816236fd7 100644
--- a/src/adjmat/TopologyMatrix.cpp
+++ b/src/adjmat/TopologyMatrix.cpp
@@ -82,29 +82,50 @@ void TopologyMatrix::registerKeywords( Keywords& keys ) {
 
 TopologyMatrix::TopologyMatrix(const ActionOptions&ao):
   Action(ao),
-  AdjacencyMatrixBase(ao)
-{
-  std::string sfinput,errors; parse("SWITCH",sfinput);
-  if( sfinput.length()==0 ) error("could not find SWITCH keyword");
+  AdjacencyMatrixBase(ao) {
+  std::string sfinput,errors;
+  parse("SWITCH",sfinput);
+  if( sfinput.length()==0 ) {
+    error("could not find SWITCH keyword");
+  }
   switchingFunction.set(sfinput,errors);
-  if( errors.length()!=0 ) error("problem reading SWITCH keyword : " + errors );
+  if( errors.length()!=0 ) {
+    error("problem reading SWITCH keyword : " + errors );
+  }
 
-  std::string hsfinput; parse("CYLINDER_SWITCH",hsfinput);
-  if( hsfinput.length()==0 ) error("could not find CYLINDER_SWITCH keyword");
+  std::string hsfinput;
+  parse("CYLINDER_SWITCH",hsfinput);
+  if( hsfinput.length()==0 ) {
+    error("could not find CYLINDER_SWITCH keyword");
+  }
   low_sf.set(hsfinput,errors);
-  if( errors.length()!=0 ) error("problem reading CYLINDER_SWITCH keyword : " + errors );
+  if( errors.length()!=0 ) {
+    error("problem reading CYLINDER_SWITCH keyword : " + errors );
+  }
 
-  std::string asfinput; parse("RADIUS",asfinput);
-  if( asfinput.length()==0 ) error("could not find RADIUS keyword");
+  std::string asfinput;
+  parse("RADIUS",asfinput);
+  if( asfinput.length()==0 ) {
+    error("could not find RADIUS keyword");
+  }
   cylinder_sw.set(asfinput,errors);
-  if( errors.length()!=0 ) error("problem reading RADIUS keyword : " + errors );
+  if( errors.length()!=0 ) {
+    error("problem reading RADIUS keyword : " + errors );
+  }
 
-  std::string tsfinput; parse("DENSITY_THRESHOLD",tsfinput);
-  if( tsfinput.length()==0 ) error("could not find DENSITY_THRESHOLD keyword");
+  std::string tsfinput;
+  parse("DENSITY_THRESHOLD",tsfinput);
+  if( tsfinput.length()==0 ) {
+    error("could not find DENSITY_THRESHOLD keyword");
+  }
   threshold_switch.set(tsfinput,errors);
-  if( errors.length()!=0 ) error("problem reading DENSITY_THRESHOLD keyword : " + errors );
+  if( errors.length()!=0 ) {
+    error("problem reading DENSITY_THRESHOLD keyword : " + errors );
+  }
   // Read in stuff for grid
-  parse("SIGMA",sigma); parse("KERNEL",kerneltype); parse("BIN_SIZE",binw_mat);
+  parse("SIGMA",sigma);
+  parse("KERNEL",kerneltype);
+  parse("BIN_SIZE",binw_mat);
 
   // Set the link cell cutoff
   setLinkCellCutoff( true, switchingFunction.get_dmax(), std::numeric_limits<double>::max() );
@@ -120,13 +141,20 @@ TopologyMatrix::TopologyMatrix(const ActionOptions&ao):
 
 double TopologyMatrix::calculateWeight( const Vector& pos1, const Vector& pos2, const unsigned& natoms, MultiValue& myvals ) const {
   // Compute switching function on distance between atoms
-  Vector distance = pbcDistance( pos1, pos2 ); double len2 = distance.modulo2();
-  if( len2>switchingFunction.get_dmax2() ) return 0.0;
+  Vector distance = pbcDistance( pos1, pos2 );
+  double len2 = distance.modulo2();
+  if( len2>switchingFunction.get_dmax2() ) {
+    return 0.0;
+  }
   double dfuncl, sw = switchingFunction.calculateSqr( len2, dfuncl );
 
   // Now run through all sea atoms
-  HistogramBead bead; bead.isNotPeriodic(); bead.setKernelType( kerneltype );
-  Vector g1derivf,g2derivf,lderivf; Tensor vir; double binlength = maxbins * binw_mat;
+  HistogramBead bead;
+  bead.isNotPeriodic();
+  bead.setKernelType( kerneltype );
+  Vector g1derivf,g2derivf,lderivf;
+  Tensor vir;
+  double binlength = maxbins * binw_mat;
   MultiValue tvals( maxbins, myvals.getNumberOfDerivatives() );
   for(unsigned i=0; i<natoms; ++i) {
     // Position of sea atom (this will be the origin)
@@ -136,11 +164,16 @@ double TopologyMatrix::calculateWeight( const Vector& pos1, const Vector& pos2,
     // Vector connecting sea atom and second in bond taking pbc into account
     Vector d21 = pbcDistance( d2, pos2 );
     // Now length of bond modulus and so on -- no pbc here as we want sea atom in middle
-    Vector d1 = delta( d20, d21 ); double d1_len = d1.modulo(); d1 = d1 / d1_len;
+    Vector d1 = delta( d20, d21 );
+    double d1_len = d1.modulo();
+    d1 = d1 / d1_len;
     // Switching function on distance between nodes
-    if( d1_len>switchingFunction.get_dmax() ) continue ;
+    if( d1_len>switchingFunction.get_dmax() ) {
+      continue ;
+    }
     // Ensure that the center of the bins are on the center of the bond connecting the two atoms
-    double start2atom = 0.5*(binlength-d1_len); Vector dstart = d20 - start2atom*d1;
+    double start2atom = 0.5*(binlength-d1_len);
+    Vector dstart = d20 - start2atom*d1;
     // Now calculate projection of axis of cylinder
     double proj=dotProduct(-dstart,d1);
     // Calculate length of vector connecting start of cylinder to first atom
@@ -149,7 +182,9 @@ double TopologyMatrix::calculateWeight( const Vector& pos1, const Vector& pos2,
     // This tells us if we are outside the end of the cylinder
     double excess = proj_between - d1_len;
     // Return if we are outside of the cylinder as calculated based on excess
-    if( excess>low_sf.get_dmax() || -proj_between>low_sf.get_dmax() ) continue;
+    if( excess>low_sf.get_dmax() || -proj_between>low_sf.get_dmax() ) {
+      continue;
+    }
     // Calculate the excess swiching functions
     double edf1, eval1 = low_sf.calculate( excess, edf1 );
     double edf2, eval2 = low_sf.calculate( -proj_between, edf2 );
@@ -191,8 +226,11 @@ double TopologyMatrix::calculateWeight( const Vector& pos1, const Vector& pos2,
       }
       for(unsigned bin=0; bin<maxbins; ++bin) {
         bead.set( bin*binw_mat, (bin+1)*binw_mat, sigma );
-        if( proj<(bin*binw_mat-bead.getCutoff()) || proj>binw_mat*(bin+1)+bead.getCutoff() ) continue;
-        double der, contr=bead.calculateWithCutoff( proj, der ) / cell_volume; der /= cell_volume;
+        if( proj<(bin*binw_mat-bead.getCutoff()) || proj>binw_mat*(bin+1)+bead.getCutoff() ) {
+          continue;
+        }
+        double der, contr=bead.calculateWithCutoff( proj, der ) / cell_volume;
+        der /= cell_volume;
         tvals.addValue( bin, contr*val*eval1*eval2 );
 
         if( !doNotCalculateDerivatives() ) {
@@ -226,16 +264,24 @@ double TopologyMatrix::calculateWeight( const Vector& pos1, const Vector& pos2,
     }
   }
   // Find maximum density
-  double max = tvals.get(0); unsigned vout = 0;
+  double max = tvals.get(0);
+  unsigned vout = 0;
   for(unsigned i=1; i<maxbins; ++i) {
-    if( tvals.get(i)>max ) { max=tvals.get(i); vout=i; }
+    if( tvals.get(i)>max ) {
+      max=tvals.get(i);
+      vout=i;
+    }
   }
   // Transform the density
   double df, tsw = threshold_switch.calculate( max, df );
-  if( fabs(sw*tsw)<epsilon ) return 0;
+  if( fabs(sw*tsw)<epsilon ) {
+    return 0;
+  }
 
   if( !doNotCalculateDerivatives() ) {
-    Vector ader; Tensor vir; Vector ddd = tsw*dfuncl*distance;
+    Vector ader;
+    Tensor vir;
+    Vector ddd = tsw*dfuncl*distance;
     ader[0] = tvals.getDerivative( vout, 3*myvals.getTaskIndex()+0 );
     ader[1] = tvals.getDerivative( vout, 3*myvals.getTaskIndex()+1 );
     ader[2] = tvals.getDerivative( vout, 3*myvals.getTaskIndex()+2 );
@@ -251,7 +297,8 @@ double TopologyMatrix::calculateWeight( const Vector& pos1, const Vector& pos2,
       ader[2] = tvals.getDerivative( vout, 3*tindex+2 );
       addThirdAtomDerivatives( i, sw*df*max*ader, myvals );
     }
-    unsigned nbase = 3*getNumberOfAtoms(); Tensor vird(ddd,distance);
+    unsigned nbase = 3*getNumberOfAtoms();
+    Tensor vird(ddd,distance);
     vir(0,0) = sw*df*max*tvals.getDerivative( vout, nbase+0 ) - vird(0,0);
     vir(0,1) = sw*df*max*tvals.getDerivative( vout, nbase+1 ) - vird(0,1);
     vir(0,2) = sw*df*max*tvals.getDerivative( vout, nbase+2 ) - vird(0,2);
diff --git a/src/adjmat/TorsionsMatrix.cpp b/src/adjmat/TorsionsMatrix.cpp
index 3a0d112aa4..270d4c748c 100644
--- a/src/adjmat/TorsionsMatrix.cpp
+++ b/src/adjmat/TorsionsMatrix.cpp
@@ -43,7 +43,9 @@ class TorsionsMatrix : public ActionWithMatrix {
   static void registerKeywords( Keywords& keys );
   explicit TorsionsMatrix(const ActionOptions&);
   unsigned getNumberOfDerivatives();
-  unsigned getNumberOfColumns() const override { return getConstPntrToComponent(0)->getShape()[1]; }
+  unsigned getNumberOfColumns() const override {
+    return getConstPntrToComponent(0)->getShape()[1];
+  }
   void setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const ;
   void performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const override;
   void runEndOfRowJobs( const unsigned& ival, const std::vector<unsigned> & indices, MultiValue& myvals ) const override ;
@@ -52,7 +54,8 @@ class TorsionsMatrix : public ActionWithMatrix {
 PLUMED_REGISTER_ACTION(TorsionsMatrix,"TORSIONS_MATRIX")
 
 void TorsionsMatrix::registerKeywords( Keywords& keys ) {
-  ActionWithMatrix::registerKeywords(keys); keys.use("ARG");
+  ActionWithMatrix::registerKeywords(keys);
+  keys.use("ARG");
   keys.add("atoms","POSITIONS1","the positions to use for the molecules specified using the first argument");
   keys.add("atoms","POSITIONS2","the positions to use for the molecules specified using the second argument");
   keys.setValueDescription("the matrix of torsions between the two vectors of input directors");
@@ -60,31 +63,55 @@ void TorsionsMatrix::registerKeywords( Keywords& keys ) {
 
 TorsionsMatrix::TorsionsMatrix(const ActionOptions&ao):
   Action(ao),
-  ActionWithMatrix(ao)
-{
-  if( getNumberOfArguments()!=2 ) error("should be two arguments to this action, a matrix and a vector");
-  if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) error("first argument to this action should be a matrix");
-  if( getPntrToArgument(1)->getRank()!=2 || getPntrToArgument(1)->hasDerivatives() ) error("second argument to this action should be a matrix");
-  if( getPntrToArgument(0)->getShape()[1]!=3 || getPntrToArgument(1)->getShape()[0]!=3 ) error("number of columns in first matrix and number of rows in second matrix should equal 3");
-
-  std::vector<AtomNumber> atoms_a; parseAtomList("POSITIONS1", atoms_a );
-  if( atoms_a.size()!=getPntrToArgument(0)->getShape()[0] ) error("mismatch between number of atoms specified using POSITIONS1 and number of arguments in vector input");
+  ActionWithMatrix(ao) {
+  if( getNumberOfArguments()!=2 ) {
+    error("should be two arguments to this action, a matrix and a vector");
+  }
+  if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) {
+    error("first argument to this action should be a matrix");
+  }
+  if( getPntrToArgument(1)->getRank()!=2 || getPntrToArgument(1)->hasDerivatives() ) {
+    error("second argument to this action should be a matrix");
+  }
+  if( getPntrToArgument(0)->getShape()[1]!=3 || getPntrToArgument(1)->getShape()[0]!=3 ) {
+    error("number of columns in first matrix and number of rows in second matrix should equal 3");
+  }
+
+  std::vector<AtomNumber> atoms_a;
+  parseAtomList("POSITIONS1", atoms_a );
+  if( atoms_a.size()!=getPntrToArgument(0)->getShape()[0] ) {
+    error("mismatch between number of atoms specified using POSITIONS1 and number of arguments in vector input");
+  }
   log.printf("  using positions of these atoms for vectors in first matrix \n");
   for(unsigned int i=0; i<atoms_a.size(); ++i) {
-    if ( (i+1) % 25 == 0 ) log.printf("  \n");
+    if ( (i+1) % 25 == 0 ) {
+      log.printf("  \n");
+    }
     log.printf("  %d", atoms_a[i].serial());
   }
-  log.printf("\n"); std::vector<AtomNumber> atoms_b; parseAtomList("POSITIONS2", atoms_b );
-  if( atoms_b.size()!=getPntrToArgument(1)->getShape()[1] ) error("mismatch between number of atoms specified using POSITIONS2 and number of arguments in vector input");
+  log.printf("\n");
+  std::vector<AtomNumber> atoms_b;
+  parseAtomList("POSITIONS2", atoms_b );
+  if( atoms_b.size()!=getPntrToArgument(1)->getShape()[1] ) {
+    error("mismatch between number of atoms specified using POSITIONS2 and number of arguments in vector input");
+  }
   log.printf("  using positions of these atoms for vectors in second matrix \n");
   for(unsigned i=0; i<atoms_b.size(); ++i) {
-    if ( (i+1) % 25 == 0 ) log.printf("  \n");
-    log.printf("  %d", atoms_b[i].serial()); atoms_a.push_back( atoms_b[i] );
+    if ( (i+1) % 25 == 0 ) {
+      log.printf("  \n");
+    }
+    log.printf("  %d", atoms_b[i].serial());
+    atoms_a.push_back( atoms_b[i] );
   }
-  log.printf("\n"); requestAtoms( atoms_a, false );
-
-  std::vector<unsigned> shape(2); shape[0]=getPntrToArgument(0)->getShape()[0]; shape[1]=getPntrToArgument(1)->getShape()[1];
-  addValue( shape ); setPeriodic("-pi","pi"); nderivatives = buildArgumentStore(0) + 3*getNumberOfAtoms() + 9;
+  log.printf("\n");
+  requestAtoms( atoms_a, false );
+
+  std::vector<unsigned> shape(2);
+  shape[0]=getPntrToArgument(0)->getShape()[0];
+  shape[1]=getPntrToArgument(1)->getShape()[1];
+  addValue( shape );
+  setPeriodic("-pi","pi");
+  nderivatives = buildArgumentStore(0) + 3*getNumberOfAtoms() + 9;
   std::string headstr=getFirstActionInChain()->getLabel();
   stored_matrix1 = getPntrToArgument(0)->ignoreStoredValue( headstr );
   stored_matrix2 = getPntrToArgument(1)->ignoreStoredValue( headstr );
@@ -96,19 +123,27 @@ unsigned TorsionsMatrix::getNumberOfDerivatives() {
 
 void TorsionsMatrix::setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const {
   unsigned start_n = getPntrToArgument(0)->getShape()[0], size_v = getPntrToArgument(1)->getShape()[1];
-  if( indices.size()!=size_v+1 ) indices.resize( size_v+1 );
-  for(unsigned i=0; i<size_v; ++i) indices[i+1] = start_n + i;
+  if( indices.size()!=size_v+1 ) {
+    indices.resize( size_v+1 );
+  }
+  for(unsigned i=0; i<size_v; ++i) {
+    indices[i+1] = start_n + i;
+  }
   myvals.setSplitIndex( size_v + 1 );
 }
 
 void TorsionsMatrix::performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const {
   unsigned ostrn = getConstPntrToComponent(0)->getPositionInStream(), ind2=index2;
-  if( index2>=getPntrToArgument(0)->getShape()[0] ) ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  if( index2>=getPntrToArgument(0)->getShape()[0] ) {
+    ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  }
 
   Vector v1, v2, dv1, dv2, dconn;
   // Compute the distance connecting the two centers
   Vector conn=pbcDistance( getPosition(index1), getPosition(index2) );
-  if( conn.modulo2()<epsilon ) return;
+  if( conn.modulo2()<epsilon ) {
+    return;
+  }
 
   // Get the two vectors
   for(unsigned i=0; i<3; ++i) {
@@ -116,10 +151,13 @@ void TorsionsMatrix::performTask( const std::string& controller, const unsigned&
     v2[i] = getElementOfMatrixArgument( 1, i, ind2, myvals );
   }
   // Evaluate angle
-  Torsion t; double angle = t.compute( v1, conn, v2, dv1, dconn, dv2 );
+  Torsion t;
+  double angle = t.compute( v1, conn, v2, dv1, dconn, dv2 );
   myvals.addValue( ostrn, angle );
 
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
 
   // Add the derivatives on the matrices
   for(unsigned i=0; i<3; ++i) {
@@ -129,31 +167,52 @@ void TorsionsMatrix::performTask( const std::string& controller, const unsigned&
   // And derivatives on positions
   unsigned narg_derivatives = getPntrToArgument(0)->getNumberOfValues() + getPntrToArgument(1)->getNumberOfValues();
   for(unsigned i=0; i<3; ++i) {
-    myvals.addDerivative( ostrn, narg_derivatives + 3*index1+i, -dconn[i] ); myvals.addDerivative( ostrn, narg_derivatives + 3*index2+i, dconn[i] );
-    myvals.updateIndex( ostrn, narg_derivatives + 3*index1+i ); myvals.updateIndex( ostrn, narg_derivatives + 3*index2+i );
+    myvals.addDerivative( ostrn, narg_derivatives + 3*index1+i, -dconn[i] );
+    myvals.addDerivative( ostrn, narg_derivatives + 3*index2+i, dconn[i] );
+    myvals.updateIndex( ostrn, narg_derivatives + 3*index1+i );
+    myvals.updateIndex( ostrn, narg_derivatives + 3*index2+i );
   }
   //And virial
-  Tensor vir( -extProduct( conn, dconn ) ); unsigned virbase = narg_derivatives + 3*getNumberOfAtoms();
-  for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j ) { myvals.addDerivative( ostrn, virbase+3*i+j, vir(i,j) ); myvals.updateIndex( ostrn, virbase+3*i+j ); }
+  Tensor vir( -extProduct( conn, dconn ) );
+  unsigned virbase = narg_derivatives + 3*getNumberOfAtoms();
+  for(unsigned i=0; i<3; ++i)
+    for(unsigned j=0; j<3; ++j ) {
+      myvals.addDerivative( ostrn, virbase+3*i+j, vir(i,j) );
+      myvals.updateIndex( ostrn, virbase+3*i+j );
+    }
 }
 
 void TorsionsMatrix::runEndOfRowJobs( const unsigned& ival, const std::vector<unsigned> & indices, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() || !matrixChainContinues() ) return ;
+  if( doNotCalculateDerivatives() || !matrixChainContinues() ) {
+    return ;
+  }
 
   unsigned mat1s = 3*ival, ss = getPntrToArgument(1)->getShape()[1];
   unsigned nmat = getConstPntrToComponent(0)->getPositionInMatrixStash(), nmat_ind = myvals.getNumberOfMatrixRowDerivatives( nmat );
   unsigned narg_derivatives = getPntrToArgument(0)->getNumberOfValues() + getPntrToArgument(1)->getNumberOfValues();
-  std::vector<unsigned>& matrix_indices( myvals.getMatrixRowDerivativeIndices( nmat ) ); unsigned ntwo_atoms = myvals.getSplitIndex();
+  std::vector<unsigned>& matrix_indices( myvals.getMatrixRowDerivativeIndices( nmat ) );
+  unsigned ntwo_atoms = myvals.getSplitIndex();
   for(unsigned j=0; j<3; ++j) {
-    matrix_indices[nmat_ind] = mat1s + j; nmat_ind++;
-    matrix_indices[nmat_ind] = narg_derivatives + mat1s + j; nmat_ind++;
+    matrix_indices[nmat_ind] = mat1s + j;
+    nmat_ind++;
+    matrix_indices[nmat_ind] = narg_derivatives + mat1s + j;
+    nmat_ind++;
     for(unsigned i=1; i<ntwo_atoms; ++i) {
-      unsigned ind2 = indices[i]; if( ind2>=getPntrToArgument(0)->getShape()[0] ) ind2 = indices[i] - getPntrToArgument(0)->getShape()[0];
-      matrix_indices[nmat_ind] = arg_deriv_starts[1] + j*ss + ind2; nmat_ind++;
-      matrix_indices[nmat_ind] = narg_derivatives + 3*indices[i] + j; nmat_ind++;
+      unsigned ind2 = indices[i];
+      if( ind2>=getPntrToArgument(0)->getShape()[0] ) {
+        ind2 = indices[i] - getPntrToArgument(0)->getShape()[0];
+      }
+      matrix_indices[nmat_ind] = arg_deriv_starts[1] + j*ss + ind2;
+      nmat_ind++;
+      matrix_indices[nmat_ind] = narg_derivatives + 3*indices[i] + j;
+      nmat_ind++;
     }
   }
-  unsigned base = narg_derivatives + 3*getNumberOfAtoms(); for(unsigned j=0; j<9; ++j) { matrix_indices[nmat_ind] = base + j; nmat_ind++; }
+  unsigned base = narg_derivatives + 3*getNumberOfAtoms();
+  for(unsigned j=0; j<9; ++j) {
+    matrix_indices[nmat_ind] = base + j;
+    nmat_ind++;
+  }
   myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind );
 }
 
diff --git a/src/annfunc/ANN.cpp b/src/annfunc/ANN.cpp
index 37a488f00c..5421645560 100644
--- a/src/annfunc/ANN.cpp
+++ b/src/annfunc/ANN.cpp
@@ -87,8 +87,7 @@ To access its components, we use "ann.node-0", "ann.node-1", ..., which represen
 */
 //+ENDPLUMEDOC
 
-class ANN : public Function
-{
+class ANN : public Function {
 private:
   int num_layers;
   vector<int> num_nodes;
@@ -111,7 +110,8 @@ PLUMED_REGISTER_ACTION(ANN,"ANN")
 
 void ANN::registerKeywords( Keywords& keys ) {
   Function::registerKeywords(keys);
-  keys.use("ARG"); keys.use("PERIODIC");
+  keys.use("ARG");
+  keys.use("PERIODIC");
   keys.add("compulsory", "NUM_LAYERS", "number of layers of the neural network");
   keys.add("compulsory", "NUM_NODES", "numbers of nodes in each layer of the neural network");
   keys.add("compulsory", "ACTIVATIONS", "activation functions for the neural network");
@@ -126,8 +126,7 @@ void ANN::registerKeywords( Keywords& keys ) {
 
 ANN::ANN(const ActionOptions&ao):
   Action(ao),
-  Function(ao)
-{
+  Function(ao) {
   parse("NUM_LAYERS", num_layers);
   num_nodes = vector<int>(num_layers);
   activations = vector<string>(num_layers - 1);
@@ -229,13 +228,11 @@ void ANN::calculate_output_of_each_layer(const vector<double>& input) {
       for(int jj = 0; jj < num_nodes[ii]; jj ++) {
         output_of_each_layer[ii][jj] = input_of_each_layer[ii][jj];
       }
-    }
-    else if (activations[ii - 1] == string("Tanh")) {
+    } else if (activations[ii - 1] == string("Tanh")) {
       for(int jj = 0; jj < num_nodes[ii]; jj ++) {
         output_of_each_layer[ii][jj] = tanh(input_of_each_layer[ii][jj]);
       }
-    }
-    else if (activations[ii - 1] == string("Circular")) {
+    } else if (activations[ii - 1] == string("Circular")) {
       assert (num_nodes[ii] % 2 == 0);
       for(int jj = 0; jj < num_nodes[ii] / 2; jj ++) {
         double radius = sqrt(input_of_each_layer[ii][2 * jj] * input_of_each_layer[ii][2 * jj]
@@ -244,8 +241,7 @@ void ANN::calculate_output_of_each_layer(const vector<double>& input) {
         output_of_each_layer[ii][2 * jj + 1] = input_of_each_layer[ii][2 * jj + 1] / radius;
 
       }
-    }
-    else {
+    } else {
       printf("layer type not found!\n\n");
       return;
     }
@@ -258,8 +254,7 @@ void ANN::calculate_output_of_each_layer(const vector<double>& input) {
     printf("layer[%d]: ", ii);
     if (ii != 0) {
       cout << activations[ii - 1] << "\t";
-    }
-    else {
+    } else {
       cout << "input \t" ;
     }
     for (int jj = 0; jj < num_nodes[ii]; jj ++) {
@@ -278,8 +273,7 @@ void ANN::back_prop(vector<vector<double> >& derivatives_of_each_layer, int inde
   for (int ii = 0; ii < num_nodes[num_nodes.size() - 1]; ii ++ ) {
     if (ii == index_of_output_component) {
       derivatives_of_each_layer[num_nodes.size() - 1][ii] = 1;
-    }
-    else {
+    } else {
       derivatives_of_each_layer[num_nodes.size() - 1][ii] = 0;
     }
   }
@@ -323,8 +317,7 @@ void ANN::back_prop(vector<vector<double> >& derivatives_of_each_layer, int inde
         }
       }
       // TODO: should be fine, pass all tests, although there seems to be some problems here previously
-    }
-    else {
+    } else {
       for (int mm = 0; mm < num_nodes[jj]; mm ++) {
         derivatives_of_each_layer[jj][mm] = 0;
         for (int kk = 0; kk < num_nodes[jj + 1]; kk ++) {
@@ -333,14 +326,12 @@ void ANN::back_prop(vector<vector<double> >& derivatives_of_each_layer, int inde
             derivatives_of_each_layer[jj][mm] += derivatives_of_each_layer[jj + 1][kk] \
                                                  * coeff[jj][kk][mm] \
                                                  * (1 - output_of_each_layer[jj + 1][kk] * output_of_each_layer[jj + 1][kk]);
-          }
-          else if (activations[jj] == string("Linear")) {
+          } else if (activations[jj] == string("Linear")) {
             // printf("linear\n");
             derivatives_of_each_layer[jj][mm] += derivatives_of_each_layer[jj + 1][kk] \
                                                  * coeff[jj][kk][mm] \
                                                  * 1;
-          }
-          else {
+          } else {
             printf("layer type not found!\n\n");
             return;
           }
diff --git a/src/astyle.sh b/src/astyle.sh
index c3239afac7..26a77d6568 100755
--- a/src/astyle.sh
+++ b/src/astyle.sh
@@ -1,50 +1,52 @@
 #! /usr/bin/env bash
-
+#formatted with shfmt v3.6.0
 DIRS=$1
 
 # keep only dirname
 DIRS=${DIRS##*/}
 echo "$DIRS"
-
+# shellcheck disable=SC2125
 test -z "$DIRS" && DIRS=*
 
-for dir in $DIRS
-do
-test -d "$dir" || continue
-
-test "$dir" = lapack && continue
-test "$dir" = blas && continue
-test "$dir" = molfile && continue
-test "$dir" = lepton && continue
-test "$dir" = asmjit && continue
-test "$dir" = xdrfile && continue
+options=../../.astyle.options
 
-cd $dir
+for dir in $DIRS; do
+  test -d "$dir" || continue
 
+  test "$dir" = lapack && continue
+  test "$dir" = blas && continue
+  test "$dir" = molfile && continue
+  test "$dir" = lepton && continue
+  test "$dir" = asmjit && continue
+  test "$dir" = xdrfile && continue
 
-for file in *.c *.cpp *.h *.inc.in
-do
+  cd "$dir" || {
+    echo "Problem with 'cd $dir'"
+    exit 1
+  }
 
-test -f "$file" || continue
+  for file in *.c *.cpp *.h *.inc.in; do
 
-echo -n "astyle $file"
+    test -f "$file" || continue
 
-../../astyle/astyle --options=../../.astyle.options < $file > $file.tmp && {
-if cmp -s $file $file.tmp ; then
-  echo 
-else
-  cp $file.tmp $file
-  echo " +++ PATCHED"
-  git add $file
-fi
-}
+    echo -n "astyle $file"
 
-rm $file.tmp
+    ../../astyle/astyle --options="$options" <"$file" >"$file.tmp" && {
+      if cmp -s "$file" "$file.tmp"; then
+        echo
+      else
+        cp "$file.tmp" "$file"
+        echo " +++ PATCHED"
+        git add "$file"
+      fi
+    }
 
-done
+    rm "$file.tmp"
 
-cd -
+  done
+  cd - || {
+    echo "Problem with 'cd -' from '$dir'"
+    exit 1
+  }
 
 done
-
-
diff --git a/src/bias/ABMD.cpp b/src/bias/ABMD.cpp
index 89ceb6f69a..a087c8e018 100644
--- a/src/bias/ABMD.cpp
+++ b/src/bias/ABMD.cpp
@@ -115,35 +115,50 @@ ABMD::ABMD(const ActionOptions&ao):
   kappa(getNumberOfArguments(),0.0),
   temp(getNumberOfArguments(),0.0),
   seed(getNumberOfArguments(),std::time(0)),
-  random(getNumberOfArguments())
-{
+  random(getNumberOfArguments()) {
   // Note : parseVector will check that number of arguments is correct
   parseVector("KAPPA",kappa);
   parseVector("MIN",min);
-  if(min.size()==0) min.assign(getNumberOfArguments(),-1.0);
-  if(min.size()!=getNumberOfArguments()) error("MIN array should have the same size as ARG array");
+  if(min.size()==0) {
+    min.assign(getNumberOfArguments(),-1.0);
+  }
+  if(min.size()!=getNumberOfArguments()) {
+    error("MIN array should have the same size as ARG array");
+  }
   parseVector("NOISE",temp);
   parseVector("SEED",seed);
   parseVector("TO",to);
   checkRead();
 
   log.printf("  min");
-  for(unsigned i=0; i<min.size(); i++) log.printf(" %f",min[i]);
+  for(unsigned i=0; i<min.size(); i++) {
+    log.printf(" %f",min[i]);
+  }
   log.printf("\n");
   log.printf("  to");
-  for(unsigned i=0; i<to.size(); i++) log.printf(" %f",to[i]);
+  for(unsigned i=0; i<to.size(); i++) {
+    log.printf(" %f",to[i]);
+  }
   log.printf("\n");
   log.printf("  with force constant");
-  for(unsigned i=0; i<kappa.size(); i++) log.printf(" %f",kappa[i]);
+  for(unsigned i=0; i<kappa.size(); i++) {
+    log.printf(" %f",kappa[i]);
+  }
   log.printf("\n");
 
   for(unsigned i=0; i<getNumberOfArguments(); i++) {
     std::string str_min=getPntrToArgument(i)->getName()+"_min";
-    addComponent(str_min); componentIsNotPeriodic(str_min);
-    if(min[i]!=-1.0) getPntrToComponent(str_min)->set(min[i]);
+    addComponent(str_min);
+    componentIsNotPeriodic(str_min);
+    if(min[i]!=-1.0) {
+      getPntrToComponent(str_min)->set(min[i]);
+    }
+  }
+  for(unsigned i=0; i<getNumberOfArguments(); i++) {
+    random[i].setSeed(-seed[i]);
   }
-  for(unsigned i=0; i<getNumberOfArguments(); i++) {random[i].setSeed(-seed[i]);}
-  addComponent("force2"); componentIsNotPeriodic("force2");
+  addComponent("force2");
+  componentIsNotPeriodic("force2");
 }
 
 
@@ -158,7 +173,10 @@ void ABMD::calculate() {
     double diff=temp[i];
     if(diff>0) {
       noise = 2.*random[i].Gaussian()*diff;
-      if(cv2<=diff) { diff=0.; temp[i]=0.; }
+      if(cv2<=diff) {
+        diff=0.;
+        temp[i]=0.;
+      }
     }
 
     // min < 0 means that the variable has not been used in the input file, so the current position of the CV is used
diff --git a/src/bias/Bias.cpp b/src/bias/Bias.cpp
index 1577eba03d..8139adc4f6 100644
--- a/src/bias/Bias.cpp
+++ b/src/bias/Bias.cpp
@@ -30,8 +30,7 @@ Bias::Bias(const ActionOptions&ao):
   ActionPilot(ao),
   ActionWithValue(ao),
   ActionWithArguments(ao),
-  outputForces(getNumberOfArguments(),0.0)
-{
+  outputForces(getNumberOfArguments(),0.0) {
   addComponentWithDerivatives("bias");
   componentIsNotPeriodic("bias");
   valueBias=getPntrToComponent("bias");
@@ -74,13 +73,18 @@ void Bias::apply() {
   for(unsigned i=0; i<ncp; ++i) {
     if(getPntrToComponent(i)->applyForce(forces)) {
       at_least_one_forced=true;
-      for(unsigned j=0; j<noa; j++) f[j]+=forces[j];
+      for(unsigned j=0; j<noa; j++) {
+        f[j]+=forces[j];
+      }
     }
   }
 
-  if(at_least_one_forced && !onStep()) error("you are biasing a bias with an inconsistent STRIDE");
+  if(at_least_one_forced && !onStep()) {
+    error("you are biasing a bias with an inconsistent STRIDE");
+  }
 
-  if(at_least_one_forced) for(unsigned i=0; i<noa; ++i) {
+  if(at_least_one_forced)
+    for(unsigned i=0; i<noa; ++i) {
       getPntrToArgument(i)->addForce(f[i]);
     }
 
diff --git a/src/bias/Bias.h b/src/bias/Bias.h
index 0da95bd6e7..c56d4eb5f6 100644
--- a/src/bias/Bias.h
+++ b/src/bias/Bias.h
@@ -40,8 +40,7 @@ information as to how to go about implementing a new bias.
 class Bias :
   public ActionPilot,
   public ActionWithValue,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
 /// the vector of the forces
   std::vector<double> outputForces;
 /// the pointer to the bias component
diff --git a/src/bias/BiasValue.cpp b/src/bias/BiasValue.cpp
index 7fa6ca2435..bc34c3edde 100644
--- a/src/bias/BiasValue.cpp
+++ b/src/bias/BiasValue.cpp
@@ -92,20 +92,21 @@ void BiasValue::registerKeywords(Keywords& keys) {
 }
 
 BiasValue::BiasValue(const ActionOptions&ao):
-  PLUMED_BIAS_INIT(ao)
-{
+  PLUMED_BIAS_INIT(ao) {
   checkRead();
   // add one bias for each argument
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
     std::string ss=getPntrToArgument(i)->getName()+"_bias";
-    addComponent(ss); componentIsNotPeriodic(ss);
+    addComponent(ss);
+    componentIsNotPeriodic(ss);
   }
 }
 
 void BiasValue::calculate() {
   double bias=0.0;
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    double val; val=getArgument(i);
+    double val;
+    val=getArgument(i);
     getPntrToComponent(i+1)->set(val);
     setOutputForce(i,-1.);
     bias+=val;
diff --git a/src/bias/ExtendedLagrangian.cpp b/src/bias/ExtendedLagrangian.cpp
index ecb96ed113..239e99e9a8 100644
--- a/src/bias/ExtendedLagrangian.cpp
+++ b/src/bias/ExtendedLagrangian.cpp
@@ -154,27 +154,36 @@ ExtendedLagrangian::ExtendedLagrangian(const ActionOptions&ao):
   friction(getNumberOfArguments(),0.0),
   fictValue(getNumberOfArguments(),NULL),
   vfictValue(getNumberOfArguments(),NULL),
-  kbt(0.0)
-{
+  kbt(0.0) {
   parseVector("TAU",tau);
   parseVector("FRICTION",friction);
   parseVector("KAPPA",kappa);
-  kbt=getkBT(); checkRead();
+  kbt=getkBT();
+  checkRead();
 
   log.printf("  with harmonic force constant");
-  for(unsigned i=0; i<kappa.size(); i++) log.printf(" %f",kappa[i]);
+  for(unsigned i=0; i<kappa.size(); i++) {
+    log.printf(" %f",kappa[i]);
+  }
   log.printf("\n");
 
   log.printf("  with relaxation time");
-  for(unsigned i=0; i<tau.size(); i++) log.printf(" %f",tau[i]);
+  for(unsigned i=0; i<tau.size(); i++) {
+    log.printf(" %f",tau[i]);
+  }
   log.printf("\n");
 
   bool hasFriction=false;
-  for(unsigned i=0; i<getNumberOfArguments(); ++i) if(friction[i]>0.0) hasFriction=true;
+  for(unsigned i=0; i<getNumberOfArguments(); ++i)
+    if(friction[i]>0.0) {
+      hasFriction=true;
+    }
 
   if(hasFriction) {
     log.printf("  with friction");
-    for(unsigned i=0; i<friction.size(); i++) log.printf(" %f",friction[i]);
+    for(unsigned i=0; i<friction.size(); i++) {
+      log.printf(" %f",friction[i]);
+    }
     log.printf("\n");
   }
 
@@ -189,7 +198,9 @@ ExtendedLagrangian::ExtendedLagrangian(const ActionOptions&ao):
       std::string a,b;
       getPntrToArgument(i)->getDomain(a,b);
       componentIsPeriodic(comp,a,b);
-    } else componentIsNotPeriodic(comp);
+    } else {
+      componentIsNotPeriodic(comp);
+    }
     fictValue[i]=getPntrToComponent(comp);
     comp=getPntrToArgument(i)->getName()+"_vfict";
     addComponent(comp);
diff --git a/src/bias/External.cpp b/src/bias/External.cpp
index ce422c1682..3299a1466d 100644
--- a/src/bias/External.cpp
+++ b/src/bias/External.cpp
@@ -130,11 +130,12 @@ void External::registerKeywords(Keywords& keys) {
 }
 
 External::External(const ActionOptions& ao):
-  PLUMED_BIAS_INIT(ao)
-{
+  PLUMED_BIAS_INIT(ao) {
   std::string filename;
   parse("FILE",filename);
-  if( filename.length()==0 ) error("No external potential file was specified");
+  if( filename.length()==0 ) {
+    error("No external potential file was specified");
+  }
   bool sparsegrid=false;
   parseFlag("SPARSE",sparsegrid);
   bool nospline=false;
@@ -146,25 +147,35 @@ External::External(const ActionOptions& ao):
 
   log.printf("  External potential from file %s\n",filename.c_str());
   log.printf("  Multiplied by %lf\n",scale_);
-  if(spline) {log.printf("  External potential uses spline interpolation\n");}
-  if(sparsegrid) {log.printf("  External potential uses sparse grid\n");}
+  if(spline) {
+    log.printf("  External potential uses spline interpolation\n");
+  }
+  if(sparsegrid) {
+    log.printf("  External potential uses sparse grid\n");
+  }
 
 // read grid
-  IFile gridfile; gridfile.open(filename);
+  IFile gridfile;
+  gridfile.open(filename);
   std::string funcl=getLabel() + ".bias";
   BiasGrid_=GridBase::create(funcl,getArguments(),gridfile,sparsegrid,spline,true);
-  if(BiasGrid_->getDimension()!=getNumberOfArguments()) error("mismatch between dimensionality of input grid and number of arguments");
+  if(BiasGrid_->getDimension()!=getNumberOfArguments()) {
+    error("mismatch between dimensionality of input grid and number of arguments");
+  }
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->isPeriodic()!=BiasGrid_->getIsPeriodic()[i] ) error("periodicity mismatch between arguments and input bias");
+    if( getPntrToArgument(i)->isPeriodic()!=BiasGrid_->getIsPeriodic()[i] ) {
+      error("periodicity mismatch between arguments and input bias");
+    }
   }
 }
 
-void External::calculate()
-{
+void External::calculate() {
   unsigned ncv=getNumberOfArguments();
   std::vector<double> cv(ncv), der(ncv);
 
-  for(unsigned i=0; i<ncv; ++i) {cv[i]=getArgument(i);}
+  for(unsigned i=0; i<ncv; ++i) {
+    cv[i]=getArgument(i);
+  }
 
   double ene=scale_*BiasGrid_->getValueAndDerivatives(cv,der);
 
diff --git a/src/bias/LWalls.cpp b/src/bias/LWalls.cpp
index d6553a3d86..a8ea6af348 100644
--- a/src/bias/LWalls.cpp
+++ b/src/bias/LWalls.cpp
@@ -86,8 +86,10 @@ class LWalls : public Bias {
 PLUMED_REGISTER_ACTION(LWalls,"LOWER_WALLS_SCALAR")
 
 void LWalls::registerKeywords(Keywords& keys) {
-  Bias::registerKeywords(keys); keys.setDisplayName("LOWER_WALLS");
-  keys.use("ARG"); keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
+  Bias::registerKeywords(keys);
+  keys.setDisplayName("LOWER_WALLS");
+  keys.use("ARG");
+  keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
   keys.add("compulsory","AT","the positions of the wall. The a_i in the expression for a wall.");
   keys.add("compulsory","KAPPA","the force constant for the wall.  The k_i in the expression for a wall.");
   keys.add("compulsory","OFFSET","0.0","the offset for the start of the wall.  The o_i in the expression for a wall.");
@@ -102,8 +104,7 @@ LWalls::LWalls(const ActionOptions&ao):
   kappa(getNumberOfArguments(),0.0),
   exp(getNumberOfArguments(),2.0),
   eps(getNumberOfArguments(),1.0),
-  offset(getNumberOfArguments(),0.0)
-{
+  offset(getNumberOfArguments(),0.0) {
   // Note sizes of these vectors are automatically checked by parseVector :-)
   parseVector("OFFSET",offset);
   parseVector("EPS",eps);
@@ -113,22 +114,33 @@ LWalls::LWalls(const ActionOptions&ao):
   checkRead();
 
   log.printf("  at");
-  for(unsigned i=0; i<at.size(); i++) log.printf(" %f",at[i]);
+  for(unsigned i=0; i<at.size(); i++) {
+    log.printf(" %f",at[i]);
+  }
   log.printf("\n");
   log.printf("  with an offset");
-  for(unsigned i=0; i<offset.size(); i++) log.printf(" %f",offset[i]);
+  for(unsigned i=0; i<offset.size(); i++) {
+    log.printf(" %f",offset[i]);
+  }
   log.printf("\n");
   log.printf("  with force constant");
-  for(unsigned i=0; i<kappa.size(); i++) log.printf(" %f",kappa[i]);
+  for(unsigned i=0; i<kappa.size(); i++) {
+    log.printf(" %f",kappa[i]);
+  }
   log.printf("\n");
   log.printf("  and exponent");
-  for(unsigned i=0; i<exp.size(); i++) log.printf(" %f",exp[i]);
+  for(unsigned i=0; i<exp.size(); i++) {
+    log.printf(" %f",exp[i]);
+  }
   log.printf("\n");
   log.printf("  rescaled");
-  for(unsigned i=0; i<eps.size(); i++) log.printf(" %f",eps[i]);
+  for(unsigned i=0; i<eps.size(); i++) {
+    log.printf(" %f",eps[i]);
+  }
   log.printf("\n");
 
-  addComponent("force2"); componentIsNotPeriodic("force2");
+  addComponent("force2");
+  componentIsNotPeriodic("force2");
 }
 
 void LWalls::calculate() {
diff --git a/src/bias/MaxEnt.cpp b/src/bias/MaxEnt.cpp
index 2de92a8762..4b1da8910e 100644
--- a/src/bias/MaxEnt.cpp
+++ b/src/bias/MaxEnt.cpp
@@ -216,10 +216,13 @@ MaxEnt::MaxEnt(const ActionOptions&ao):
   reweight(false),
   no_broadcast(false),
   printFirstStep(true),
-  done_average(getNumberOfArguments(),false)
-{
-  if(comm.Get_rank()==0) nrep=multi_sim_comm.Get_size();
-  if(comm.Get_rank()==0) myrep=multi_sim_comm.Get_rank();
+  done_average(getNumberOfArguments(),false) {
+  if(comm.Get_rank()==0) {
+    nrep=multi_sim_comm.Get_size();
+  }
+  if(comm.Get_rank()==0) {
+    myrep=multi_sim_comm.Get_rank();
+  }
   comm.Bcast(nrep,0);
   comm.Bcast(myrep,0);
   parseFlag("NO_BROADCAST",no_broadcast);
@@ -236,7 +239,9 @@ MaxEnt::MaxEnt(const ActionOptions&ao):
 
   parse("LEARN_REPLICA",learn_replica);
   parseVector("APPLY_WEIGHTS",apply_weights);
-  if(apply_weights.size()==0) apply_weights.resize(nrep,1.0);
+  if(apply_weights.size()==0) {
+    apply_weights.resize(nrep,1.0);
+  }
   parseVector("KAPPA",kappa);
   parseVector("AT",at);
   parseVector("TAU",tau);
@@ -246,60 +251,86 @@ MaxEnt::MaxEnt(const ActionOptions&ao):
   parse("ALPHA",alpha);
   parse("SIGMA",sigma);
   parse("TSTART",tstart);
-  if(tstart <0 && tstart != -1.0) error("TSTART should be a positive number");
+  if(tstart <0 && tstart != -1.0) {
+    error("TSTART should be a positive number");
+  }
   parse("TEND",tend);
-  if(tend<0 && tend != -1.0) error("TSTART should be a positive number");
-  if(tend<tstart) error("TEND should be >= TSTART");
+  if(tend<0 && tend != -1.0) {
+    error("TSTART should be a positive number");
+  }
+  if(tend<tstart) {
+    error("TEND should be >= TSTART");
+  }
   lagmultfname=getLabel()+".LAGMULT";
   parse("FILE",lagmultfname);
   parse("FMT",fmt);
   parse("PACE",pace_);
-  if(pace_<=0 ) error("frequency for Lagrangian multipliers update (PACE) is nonsensical");
+  if(pace_<=0 ) {
+    error("frequency for Lagrangian multipliers update (PACE) is nonsensical");
+  }
   stride_=pace_;  //if no STRIDE is passed, then Lagrangian multipliers willbe printed at each update
   parse("PRINT_STRIDE",stride_);
-  if(stride_<=0 ) error("frequency for Lagrangian multipliers printing (STRIDE) is nonsensical");
+  if(stride_<=0 ) {
+    error("frequency for Lagrangian multipliers printing (STRIDE) is nonsensical");
+  }
   simtemp=getkBT();
   parseFlag("REWEIGHT",reweight);
-  if(simtemp<=0 && reweight) error("Set the temperature (TEMP) if you want to do reweighting.");
+  if(simtemp<=0 && reweight) {
+    error("Set the temperature (TEMP) if you want to do reweighting.");
+  }
 
   checkRead();
 
   log.printf("  at");
-  for(unsigned i=0; i<at.size(); i++) log.printf(" %f",at[i]);
+  for(unsigned i=0; i<at.size(); i++) {
+    log.printf(" %f",at[i]);
+  }
   log.printf("\n");
   log.printf("  with initial learning rate for optimization of");
-  for(unsigned i=0; i<kappa.size(); i++) log.printf(" %f",kappa[i]);
+  for(unsigned i=0; i<kappa.size(); i++) {
+    log.printf(" %f",kappa[i]);
+  }
   log.printf("\n");
   log.printf("Dumping times for the learning rates are (ps): ");
-  for(unsigned i=0; i<tau.size(); i++) log.printf(" %f",tau[i]);
+  for(unsigned i=0; i<tau.size(); i++) {
+    log.printf(" %f",tau[i]);
+  }
   log.printf("\n");
   log.printf("Lagrangian multipliers are updated every %lld steps (PACE)\n",pace_);
   log.printf("Lagrangian multipliers output file %s\n",lagmultfname.c_str());
   log.printf("Lagrangian multipliers are written every %lld steps (PRINT_STRIDE)\n",stride_);
-  if(fmt.length()>0)
+  if(fmt.length()>0) {
     log.printf("The format for real number in Lagrangian multipliers file is %s\n",fmt.c_str());
-  if(tstart >-1.0 && tend>-1.0)
+  }
+  if(tstart >-1.0 && tend>-1.0) {
     log.printf("Lagrangian multipliers are averaged from %lf ps to %lf ps\n",tstart,tend);
-  if(no_broadcast)
+  }
+  if(no_broadcast) {
     log.printf("Using NO_BROADCAST options. Lagrangian multipliers will not be comunicated to other replicas.\n");
+  }
   //for(int irep=0;irep<nrep;irep++){
   //  if(apply_weights[irep]!=0)
   //    log.printf("%d",irep);
   //  }
-  addComponent("force2"); componentIsNotPeriodic("force2");
-  addComponent("work"); componentIsNotPeriodic("work");
+  addComponent("force2");
+  componentIsNotPeriodic("force2");
+  addComponent("work");
+  componentIsNotPeriodic("work");
   valueForce2=getPntrToComponent("force2");
   valueWork=getPntrToComponent("work");
 
   std::string comp;
   for(unsigned i=0; i< getNumberOfArguments() ; i++) {
     comp=getPntrToArgument(i)->getName()+"_coupling";
-    addComponent(comp); componentIsNotPeriodic(comp);
+    addComponent(comp);
+    componentIsNotPeriodic(comp);
     comp=getPntrToArgument(i)->getName()+"_work";
-    addComponent(comp); componentIsNotPeriodic(comp);
+    addComponent(comp);
+    componentIsNotPeriodic(comp);
     work.push_back(0.); // initialize the work value
     comp=getPntrToArgument(i)->getName()+"_error";
-    addComponent(comp); componentIsNotPeriodic(comp);
+    addComponent(comp);
+    componentIsNotPeriodic(comp);
   }
   std::string fname;
   fname=lagmultfname;
@@ -316,24 +347,28 @@ MaxEnt::MaxEnt(const ActionOptions&ao):
 
   lagmultOfile_.link(*this);
   lagmultOfile_.open(fname);
-  if(fmt.length()>0) {fmt=" "+fmt; lagmultOfile_.fmtField(fmt);}
+  if(fmt.length()>0) {
+    fmt=" "+fmt;
+    lagmultOfile_.fmtField(fmt);
+  }
 }
 ////MEMBER FUNCTIONS
-void MaxEnt::ReadLagrangians(IFile &ifile)
-{
+void MaxEnt::ReadLagrangians(IFile &ifile) {
   double dummy;
   while(ifile.scanField("time",dummy)) {
     for(unsigned j=0; j<getNumberOfArguments(); ++j) {
       ifile.scanField(getPntrToArgument(j)->getName()+"_coupling",lambda[j]);
-      if(dummy>=tstart && dummy <=tend)
+      if(dummy>=tstart && dummy <=tend) {
         avglambda[j]+=lambda[j];
+      }
       if(dummy>=tend) {
         avglambda[j]=lambda[j];
         done_average[j]=true;
       }
     }
-    if(dummy>=tstart && dummy <=tend)
+    if(dummy>=tstart && dummy <=tend) {
       avg_counter++;
+    }
     ifile.scanField();
   }
 }
@@ -341,15 +376,17 @@ void MaxEnt::WriteLagrangians(std::vector<double> &lagmult,OFile &file) {
   if(printFirstStep) {
     unsigned ncv=getNumberOfArguments();
     file.printField("time",getTimeStep()*getStep());
-    for(unsigned i=0; i<ncv; ++i)
+    for(unsigned i=0; i<ncv; ++i) {
       file.printField(getPntrToArgument(i)->getName()+"_coupling",lagmult[i]);
+    }
     file.printField();
   } else {
     if(!isFirstStep) {
       unsigned ncv=getNumberOfArguments();
       file.printField("time",getTimeStep()*getStep());
-      for(unsigned i=0; i<ncv; ++i)
+      for(unsigned i=0; i<ncv; ++i) {
         file.printField(getPntrToArgument(i)->getName()+"_coupling",lagmult[i]);
+      }
       file.printField();
     }
   }
@@ -358,9 +395,9 @@ double MaxEnt::compute_error(const std::string &err_type,double l) {
   double sigma2=std::pow(sigma,2.0);
   double l2=convert_lambda(type,l);
   double return_error=0;
-  if(err_type=="GAUSSIAN" && sigma!=0.0)
+  if(err_type=="GAUSSIAN" && sigma!=0.0) {
     return_error=-l2*sigma2;
-  else {
+  } else {
     if(err_type=="LAPLACE" && sigma!=0) {
       return_error=-l2*sigma2/(1.0-l2*l2*sigma2/(alpha+1));
     }
@@ -369,21 +406,22 @@ double MaxEnt::compute_error(const std::string &err_type,double l) {
 }
 double MaxEnt::convert_lambda(const std::string &type,double lold) {
   double return_lambda=0;
-  if(type=="EQUAL")
+  if(type=="EQUAL") {
     return_lambda=lold;
-  else {
+  } else {
     if(type=="INEQUAL>") {
-      if(lold>0.0)
+      if(lold>0.0) {
         return_lambda=0.0;
-      else
+      } else {
         return_lambda=lold;
-    }
-    else {
+      }
+    } else {
       if(type=="INEQUAL<") {
-        if(lold<0.0)
+        if(lold<0.0) {
           return_lambda=0.0;
-        else
+        } else {
           return_lambda=lold;
+        }
       }
     }
   }
@@ -410,18 +448,20 @@ void MaxEnt::update_lambda() {
   const double step=getStep();
   double KbT=simtemp;
   double learning_rate;
-  if(reweight)
+  if(reweight) {
     BetaReweightBias=plumed.getBias()/KbT;
-  else
+  } else {
     BetaReweightBias=0.0;
+  }
 
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
     const double k=kappa[i];
     double cv=(getArgument(i)+compute_error(error_type,lambda[i])-at[i]);
-    if(reweight)
+    if(reweight) {
       learning_rate=1.0*k/(1+step/tau[i]);
-    else
+    } else {
       learning_rate=1.0*k/(1+time/tau[i]);
+    }
     lambda[i]+=learning_rate*cv*std::exp(-BetaReweightBias); //update Lagrangian multipliers and reweight them if REWEIGHT is set
     check_lambda_boundaries(error_type,lambda[i]);      //check that Lagrangians multipliers not exceed the allowed range
     if(time>=tstart && time <=tend && !done_average[i]) {
@@ -432,17 +472,18 @@ void MaxEnt::update_lambda() {
         avglambda[i]=avglambda[i]/avg_counter;
         done_average[i]=true;
         lambda[i]=avglambda[i];
+      } else {
+        lambda[i]=avglambda[i];  //keep Lagrangian multipliers fixed to the previously computed average.
       }
-      else
-        lambda[i]=avglambda[i]; //keep Lagrangian multipliers fixed to the previously computed average.
     }
     work[i]+=(convert_lambda(type,lambda[i])-oldlambda[i])*getArgument(i); //compute the work performed in updating lambda
     totalWork_+=work[i];
     totalWork=totalWork_;
     oldlambda[i]=convert_lambda(type,lambda[i]);
   };
-  if(time>=tstart && time <=tend)
+  if(time>=tstart && time <=tend) {
     avg_counter++;
+  }
 }
 
 void MaxEnt::calculate() {
@@ -465,13 +506,15 @@ void MaxEnt::calculate() {
 
 void MaxEnt::update() {
 
-  if(getStep()%stride_ == 0)
+  if(getStep()%stride_ == 0) {
     WriteLagrangians(lambda,lagmultOfile_);
+  }
   if(getStep()%pace_ == 0) {
     update_lambda();
     if(!no_broadcast) {
-      if(comm.Get_rank()==0) //Comunicate Lagrangian multipliers from reference replica to higher ones
+      if(comm.Get_rank()==0) { //Comunicate Lagrangian multipliers from reference replica to higher ones
         multi_sim_comm.Bcast(lambda,learn_replica);
+      }
     }
     comm.Bcast(lambda,0);
   }
diff --git a/src/bias/MetaD.cpp b/src/bias/MetaD.cpp
index f468de9261..f69c87810a 100644
--- a/src/bias/MetaD.cpp
+++ b/src/bias/MetaD.cpp
@@ -381,8 +381,11 @@ class MetaD : public Bias {
       multivariate(m),height(h),center(c),sigma(s),invsigma(s) {
       // to avoid troubles from zero element in flexible hills
       for(unsigned i=0; i<invsigma.size(); ++i) {
-        if(std::abs(invsigma[i])>1.e-20) invsigma[i]=1.0/invsigma[i] ;
-        else invsigma[i]=0.0;
+        if(std::abs(invsigma[i])>1.e-20) {
+          invsigma[i]=1.0/invsigma[i] ;
+        } else {
+          invsigma[i]=0.0;
+        }
       }
     }
   };
@@ -626,8 +629,7 @@ MetaD::MetaD(const ActionOptions& ao):
   work_(0),
   nlist_(false),
   nlist_update_(false),
-  nlist_steps_(0)
-{
+  nlist_steps_(0) {
   if(!dp2cutoffNoStretch()) {
     stretchA=dp2cutoffA;
     stretchB=dp2cutoffB;
@@ -654,7 +656,9 @@ MetaD::MetaD(const ActionOptions& ao):
   parseVector("SIGMA",sigma0_);
   if(adaptive_==FlexibleBin::none) {
     // if you use normal sigma you need one sigma per argument
-    if( sigma0_.size()!=getNumberOfArguments() ) error("number of arguments does not match number of SIGMA parameters");
+    if( sigma0_.size()!=getNumberOfArguments() ) {
+      error("number of arguments does not match number of SIGMA parameters");
+    }
   } else {
     // if you use flexible hills you need one sigma
     if(sigma0_.size()!=1) {
@@ -672,7 +676,9 @@ MetaD::MetaD(const ActionOptions& ao):
       error("the number of SIGMA_MIN values be the same of the number of the arguments");
     } else if(sigma0min_.size()==0) {
       sigma0min_.resize(getNumberOfArguments());
-      for(unsigned i=0; i<getNumberOfArguments(); i++) {sigma0min_[i]=-1.;}
+      for(unsigned i=0; i<getNumberOfArguments(); i++) {
+        sigma0min_[i]=-1.;
+      }
     }
 
     parseVector("SIGMA_MAX",sigma0max_);
@@ -680,7 +686,9 @@ MetaD::MetaD(const ActionOptions& ao):
       error("the number of SIGMA_MAX values be the same of the number of the arguments");
     } else if(sigma0max_.size()==0) {
       sigma0max_.resize(getNumberOfArguments());
-      for(unsigned i=0; i<getNumberOfArguments(); i++) {sigma0max_[i]=-1.;}
+      for(unsigned i=0; i<getNumberOfArguments(); i++) {
+        sigma0max_[i]=-1.;
+      }
     }
 
     flexbin_=Tools::make_unique<FlexibleBin>(adaptive_,this,sigma0_[0],sigma0min_,sigma0max_);
@@ -689,7 +697,9 @@ MetaD::MetaD(const ActionOptions& ao):
   // note: HEIGHT is not compulsory, since one could use the TAU keyword, see below
   parse("HEIGHT",height0_);
   parse("PACE",stride_);
-  if(stride_<=0) error("frequency for hill addition is nonsensical");
+  if(stride_<=0) {
+    error("frequency for hill addition is nonsensical");
+  }
   current_stride_ = stride_;
   std::string hillsfname="HILLS";
   parse("FILE",hillsfname);
@@ -704,21 +714,30 @@ MetaD::MetaD(const ActionOptions& ao):
   parseVector("RECT",rect_biasf_);
   if(rect_biasf_.size()>0) {
     int r=0;
-    if(comm.Get_rank()==0) r=multi_sim_comm.Get_rank();
+    if(comm.Get_rank()==0) {
+      r=multi_sim_comm.Get_rank();
+    }
     comm.Bcast(r,0);
     biasf_=rect_biasf_[r];
     log<<"  You are using RECT\n";
   } else {
     parse("BIASFACTOR",biasf_);
   }
-  if( biasf_<1.0  && biasf_!=-1.0) error("well tempered bias factor is nonsensical");
-  parse("DAMPFACTOR",dampfactor_); kbt_=getkBT();
+  if( biasf_<1.0  && biasf_!=-1.0) {
+    error("well tempered bias factor is nonsensical");
+  }
+  parse("DAMPFACTOR",dampfactor_);
+  kbt_=getkBT();
   if(biasf_>=1.0) {
-    if(kbt_==0.0) error("Unless the MD engine passes the temperature to plumed, with well-tempered metad you must specify it using TEMP");
+    if(kbt_==0.0) {
+      error("Unless the MD engine passes the temperature to plumed, with well-tempered metad you must specify it using TEMP");
+    }
     welltemp_=true;
   }
   if(dampfactor_>0.0) {
-    if(kbt_==0.0) error("Unless the MD engine passes the temperature to plumed, with damped metad you must specify it using TEMP");
+    if(kbt_==0.0) {
+      error("Unless the MD engine passes the temperature to plumed, with damped metad you must specify it using TEMP");
+    }
   }
 
   parseFlag("CALC_WORK",calc_work_);
@@ -726,14 +745,18 @@ MetaD::MetaD(const ActionOptions& ao):
   // Set transition tempering parameters.
   // Transition wells are read later via calc_transition_bias_.
   readTemperingSpecs(tt_specs_);
-  if (tt_specs_.is_active) calc_transition_bias_ = true;
+  if (tt_specs_.is_active) {
+    calc_transition_bias_ = true;
+  }
 
   // If any previous option specified to calculate a transition bias,
   // now read the transition wells for that quantity.
   if (calc_transition_bias_) {
     std::vector<double> tempcoords(getNumberOfArguments());
     for (unsigned i = 0; ; i++) {
-      if (!parseNumberedVector("TRANSITIONWELL", i, tempcoords) ) break;
+      if (!parseNumberedVector("TRANSITIONWELL", i, tempcoords) ) {
+        break;
+      }
       if (tempcoords.size() != getNumberOfArguments()) {
         error("incorrect number of coordinates for transition tempering well");
       }
@@ -742,53 +765,88 @@ MetaD::MetaD(const ActionOptions& ao):
   }
 
   parse("TARGET",targetfilename_);
-  if(targetfilename_.length()>0 && kbt_==0.0)  error("with TARGET temperature must be specified");
+  if(targetfilename_.length()>0 && kbt_==0.0) {
+    error("with TARGET temperature must be specified");
+  }
   double tau=0.0;
   parse("TAU",tau);
   if(tau==0.0) {
-    if(height0_==std::numeric_limits<double>::max()) error("At least one between HEIGHT and TAU should be specified");
+    if(height0_==std::numeric_limits<double>::max()) {
+      error("At least one between HEIGHT and TAU should be specified");
+    }
     // if tau is not set, we compute it here from the other input parameters
-    if(welltemp_) tau=(kbt_*(biasf_-1.0))/height0_*getTimeStep()*stride_;
-    else if(dampfactor_>0.0) tau=(kbt_*dampfactor_)/height0_*getTimeStep()*stride_;
+    if(welltemp_) {
+      tau=(kbt_*(biasf_-1.0))/height0_*getTimeStep()*stride_;
+    } else if(dampfactor_>0.0) {
+      tau=(kbt_*dampfactor_)/height0_*getTimeStep()*stride_;
+    }
   } else {
-    if(height0_!=std::numeric_limits<double>::max()) error("At most one between HEIGHT and TAU should be specified");
+    if(height0_!=std::numeric_limits<double>::max()) {
+      error("At most one between HEIGHT and TAU should be specified");
+    }
     if(welltemp_) {
-      if(biasf_!=1.0) height0_=(kbt_*(biasf_-1.0))/tau*getTimeStep()*stride_;
-      else           height0_=kbt_/tau*getTimeStep()*stride_; // special case for gamma=1
+      if(biasf_!=1.0) {
+        height0_=(kbt_*(biasf_-1.0))/tau*getTimeStep()*stride_;
+      } else {
+        height0_=kbt_/tau*getTimeStep()*stride_;  // special case for gamma=1
+      }
+    } else if(dampfactor_>0.0) {
+      height0_=(kbt_*dampfactor_)/tau*getTimeStep()*stride_;
+    } else {
+      error("TAU only makes sense in well-tempered or damped metadynamics");
     }
-    else if(dampfactor_>0.0) height0_=(kbt_*dampfactor_)/tau*getTimeStep()*stride_;
-    else error("TAU only makes sense in well-tempered or damped metadynamics");
   }
 
   // Grid Stuff
   std::vector<std::string> gmin(getNumberOfArguments());
   parseVector("GRID_MIN",gmin);
-  if(gmin.size()!=getNumberOfArguments() && gmin.size()!=0) error("not enough values for GRID_MIN");
+  if(gmin.size()!=getNumberOfArguments() && gmin.size()!=0) {
+    error("not enough values for GRID_MIN");
+  }
   std::vector<std::string> gmax(getNumberOfArguments());
   parseVector("GRID_MAX",gmax);
-  if(gmax.size()!=getNumberOfArguments() && gmax.size()!=0) error("not enough values for GRID_MAX");
+  if(gmax.size()!=getNumberOfArguments() && gmax.size()!=0) {
+    error("not enough values for GRID_MAX");
+  }
   std::vector<unsigned> gbin(getNumberOfArguments());
   std::vector<double>   gspacing;
   parseVector("GRID_BIN",gbin);
-  if(gbin.size()!=getNumberOfArguments() && gbin.size()!=0) error("not enough values for GRID_BIN");
+  if(gbin.size()!=getNumberOfArguments() && gbin.size()!=0) {
+    error("not enough values for GRID_BIN");
+  }
   parseVector("GRID_SPACING",gspacing);
-  if(gspacing.size()!=getNumberOfArguments() && gspacing.size()!=0) error("not enough values for GRID_SPACING");
-  if(gmin.size()!=gmax.size()) error("GRID_MAX and GRID_MIN should be either present or absent");
-  if(gspacing.size()!=0 && gmin.size()==0) error("If GRID_SPACING is present also GRID_MIN and GRID_MAX should be present");
-  if(gbin.size()!=0     && gmin.size()==0) error("If GRID_BIN is present also GRID_MIN and GRID_MAX should be present");
+  if(gspacing.size()!=getNumberOfArguments() && gspacing.size()!=0) {
+    error("not enough values for GRID_SPACING");
+  }
+  if(gmin.size()!=gmax.size()) {
+    error("GRID_MAX and GRID_MIN should be either present or absent");
+  }
+  if(gspacing.size()!=0 && gmin.size()==0) {
+    error("If GRID_SPACING is present also GRID_MIN and GRID_MAX should be present");
+  }
+  if(gbin.size()!=0     && gmin.size()==0) {
+    error("If GRID_BIN is present also GRID_MIN and GRID_MAX should be present");
+  }
   if(gmin.size()!=0) {
     if(gbin.size()==0 && gspacing.size()==0) {
       if(adaptive_==FlexibleBin::none) {
         log<<"  Binsize not specified, 1/5 of sigma will be be used\n";
         plumed_assert(sigma0_.size()==getNumberOfArguments());
         gspacing.resize(getNumberOfArguments());
-        for(unsigned i=0; i<gspacing.size(); i++) gspacing[i]=0.2*sigma0_[i];
+        for(unsigned i=0; i<gspacing.size(); i++) {
+          gspacing[i]=0.2*sigma0_[i];
+        }
       } else {
         // with adaptive hills and grid a sigma min must be specified
-        for(unsigned i=0; i<sigma0min_.size(); i++) if(sigma0min_[i]<=0) error("When using ADAPTIVE Gaussians on a grid SIGMA_MIN must be specified");
+        for(unsigned i=0; i<sigma0min_.size(); i++)
+          if(sigma0min_[i]<=0) {
+            error("When using ADAPTIVE Gaussians on a grid SIGMA_MIN must be specified");
+          }
         log<<"  Binsize not specified, 1/5 of sigma_min will be be used\n";
         gspacing.resize(getNumberOfArguments());
-        for(unsigned i=0; i<gspacing.size(); i++) gspacing[i]=0.2*sigma0min_[i];
+        for(unsigned i=0; i<gspacing.size(); i++) {
+          gspacing[i]=0.2*sigma0min_[i];
+        }
       }
     } else if(gspacing.size()!=0 && gbin.size()==0) {
       log<<"  The number of bins will be estimated from GRID_SPACING\n";
@@ -796,16 +854,23 @@ MetaD::MetaD(const ActionOptions& ao):
       log<<"  You specified both GRID_BIN and GRID_SPACING\n";
       log<<"  The more conservative (highest) number of bins will be used for each variable\n";
     }
-    if(gbin.size()==0) gbin.assign(getNumberOfArguments(),1);
-    if(gspacing.size()!=0) for(unsigned i=0; i<getNumberOfArguments(); i++) {
+    if(gbin.size()==0) {
+      gbin.assign(getNumberOfArguments(),1);
+    }
+    if(gspacing.size()!=0)
+      for(unsigned i=0; i<getNumberOfArguments(); i++) {
         double a,b;
         Tools::convert(gmin[i],a);
         Tools::convert(gmax[i],b);
         unsigned n=std::ceil(((b-a)/gspacing[i]));
-        if(gbin[i]<n) gbin[i]=n;
+        if(gbin[i]<n) {
+          gbin[i]=n;
+        }
       }
   }
-  if(gbin.size()>0) grid_=true;
+  if(gbin.size()>0) {
+    grid_=true;
+  }
 
   bool sparsegrid=false;
   parseFlag("GRID_SPARSE",sparsegrid);
@@ -817,32 +882,39 @@ MetaD::MetaD(const ActionOptions& ao):
   parse("GRID_WFILE",gridfilename_);
   parseFlag("STORE_GRIDS",storeOldGrids_);
   if(grid_ && gridfilename_.length()>0) {
-    if(wgridstride_==0 ) error("frequency with which to output grid not specified use GRID_WSTRIDE");
+    if(wgridstride_==0 ) {
+      error("frequency with which to output grid not specified use GRID_WSTRIDE");
+    }
   }
   if(grid_ && wgridstride_>0) {
-    if(gridfilename_.length()==0) error("grid filename not specified use GRID_WFILE");
+    if(gridfilename_.length()==0) {
+      error("grid filename not specified use GRID_WFILE");
+    }
   }
 
   std::string gridreadfilename_;
   parse("GRID_RFILE",gridreadfilename_);
 
-  if(!grid_&&gridfilename_.length()> 0) error("To write a grid you need first to define it!");
-  if(!grid_&&gridreadfilename_.length()>0) error("To read a grid you need first to define it!");
+  if(!grid_&&gridfilename_.length()> 0) {
+    error("To write a grid you need first to define it!");
+  }
+  if(!grid_&&gridreadfilename_.length()>0) {
+    error("To read a grid you need first to define it!");
+  }
 
   /*setup neighbor list stuff*/
   parseFlag("NLIST", nlist_);
   nlist_center_.resize(getNumberOfArguments());
   nlist_dev2_.resize(getNumberOfArguments());
-  if(nlist_&&grid_) error("NLIST and GRID cannot be combined!");
+  if(nlist_&&grid_) {
+    error("NLIST and GRID cannot be combined!");
+  }
   std::vector<double> nlist_param;
   parseVector("NLIST_PARAMETERS",nlist_param);
-  if(nlist_param.size()==0)
-  {
+  if(nlist_param.size()==0) {
     nlist_param_[0]=6.0;//*DP2CUTOFF -> max distance of neighbors
     nlist_param_[1]=0.5;//*nlist_dev2_[i] -> condition for rebuilding
-  }
-  else
-  {
+  } else {
     plumed_massert(nlist_param.size()==2,"two cutoff parameters are needed for the neighbor list");
     plumed_massert(nlist_param[0]>1.0,"the first of NLIST_PARAMETERS must be greater than 1. The smaller the first, the smaller should be the second as well");
     const double min_PARAM_1=(1.-1./std::sqrt(nlist_param[0]/2))+0.16;
@@ -854,17 +926,23 @@ MetaD::MetaD(const ActionOptions& ao):
 
   // Reweighting factor rct
   parseFlag("CALC_RCT",calc_rct_);
-  if (calc_rct_) plumed_massert(grid_,"CALC_RCT is supported only if bias is on a grid");
+  if (calc_rct_) {
+    plumed_massert(grid_,"CALC_RCT is supported only if bias is on a grid");
+  }
   parse("RCT_USTRIDE",rct_ustride_);
 
   if(dampfactor_>0.0) {
-    if(!grid_) error("With DAMPFACTOR you should use grids");
+    if(!grid_) {
+      error("With DAMPFACTOR you should use grids");
+    }
   }
 
   // Multiple walkers
   parse("WALKERS_N",mw_n_);
   parse("WALKERS_ID",mw_id_);
-  if(mw_n_<=mw_id_) error("walker ID should be a numerical value less than the total number of walkers");
+  if(mw_n_<=mw_id_) {
+    error("walker ID should be a numerical value less than the total number of walkers");
+  }
   parse("WALKERS_DIR",mw_dir_);
   parse("WALKERS_RSTRIDE",mw_rstride_);
 
@@ -883,13 +961,20 @@ MetaD::MetaD(const ActionOptions& ao):
   // Inteval keyword
   std::vector<double> tmpI(2);
   parseVector("INTERVAL",tmpI);
-  if(tmpI.size()!=2&&tmpI.size()!=0) error("both a lower and an upper limits must be provided with INTERVAL");
-  else if(tmpI.size()==2) {
+  if(tmpI.size()!=2&&tmpI.size()!=0) {
+    error("both a lower and an upper limits must be provided with INTERVAL");
+  } else if(tmpI.size()==2) {
     lowI_=tmpI.at(0);
     uppI_=tmpI.at(1);
-    if(getNumberOfArguments()!=1) error("INTERVAL limits correction works only for monodimensional metadynamics!");
-    if(uppI_<lowI_) error("The Upper limit must be greater than the Lower limit!");
-    if(getPntrToArgument(0)->isPeriodic()) error("INTERVAL cannot be used with periodic variables!");
+    if(getNumberOfArguments()!=1) {
+      error("INTERVAL limits correction works only for monodimensional metadynamics!");
+    }
+    if(uppI_<lowI_) {
+      error("The Upper limit must be greater than the Lower limit!");
+    }
+    if(getPntrToArgument(0)->isPeriodic()) {
+      error("INTERVAL cannot be used with periodic variables!");
+    }
     doInt_=true;
   }
 
@@ -927,9 +1012,15 @@ MetaD::MetaD(const ActionOptions& ao):
   checkRead();
 
   log.printf("  Gaussian width ");
-  if (adaptive_==FlexibleBin::diffusion)log.printf(" (Note: The units of sigma are in timesteps) ");
-  if (adaptive_==FlexibleBin::geometry)log.printf(" (Note: The units of sigma are in dist units) ");
-  for(unsigned i=0; i<sigma0_.size(); ++i) log.printf(" %f",sigma0_[i]);
+  if (adaptive_==FlexibleBin::diffusion) {
+    log.printf(" (Note: The units of sigma are in timesteps) ");
+  }
+  if (adaptive_==FlexibleBin::geometry) {
+    log.printf(" (Note: The units of sigma are in dist units) ");
+  }
+  for(unsigned i=0; i<sigma0_.size(); ++i) {
+    log.printf(" %f",sigma0_[i]);
+  }
   log.printf("  Gaussian height %f\n",height0_);
   log.printf("  Gaussian deposition pace %d\n",stride_);
   log.printf("  Gaussian file %s\n",hillsfname.c_str());
@@ -961,25 +1052,49 @@ MetaD::MetaD(const ActionOptions& ao):
   if (welltemp_ || dampfactor_ > 0.0 || tt_specs_.is_active) {
     // Determine the number of active temperings.
     int n_active = 0;
-    if (welltemp_) n_active++;
-    if (dampfactor_ > 0.0) n_active++;
-    if (tt_specs_.is_active) n_active++;
+    if (welltemp_) {
+      n_active++;
+    }
+    if (dampfactor_ > 0.0) {
+      n_active++;
+    }
+    if (tt_specs_.is_active) {
+      n_active++;
+    }
     // Find the greatest alpha.
     double greatest_alpha = 0.0;
-    if (welltemp_) greatest_alpha = std::max(greatest_alpha, 1.0);
-    if (dampfactor_ > 0.0) greatest_alpha = std::max(greatest_alpha, 1.0);
-    if (tt_specs_.is_active) greatest_alpha = std::max(greatest_alpha, tt_specs_.alpha);
+    if (welltemp_) {
+      greatest_alpha = std::max(greatest_alpha, 1.0);
+    }
+    if (dampfactor_ > 0.0) {
+      greatest_alpha = std::max(greatest_alpha, 1.0);
+    }
+    if (tt_specs_.is_active) {
+      greatest_alpha = std::max(greatest_alpha, tt_specs_.alpha);
+    }
     // Find the least alpha.
     double least_alpha = 1.0;
-    if (welltemp_) least_alpha = std::min(least_alpha, 1.0);
-    if (dampfactor_ > 0.0) least_alpha = std::min(least_alpha, 1.0);
-    if (tt_specs_.is_active) least_alpha = std::min(least_alpha, tt_specs_.alpha);
+    if (welltemp_) {
+      least_alpha = std::min(least_alpha, 1.0);
+    }
+    if (dampfactor_ > 0.0) {
+      least_alpha = std::min(least_alpha, 1.0);
+    }
+    if (tt_specs_.is_active) {
+      least_alpha = std::min(least_alpha, tt_specs_.alpha);
+    }
     // Find the inverse harmonic average of the delta T parameters for all
     // of the temperings with the greatest alpha values.
     double total_governing_deltaT_inv = 0.0;
-    if (welltemp_ && 1.0 == greatest_alpha && biasf_ != 1.0) total_governing_deltaT_inv += 1.0 / (biasf_ - 1.0);
-    if (dampfactor_ > 0.0 && 1.0 == greatest_alpha) total_governing_deltaT_inv += 1.0 / (dampfactor_);
-    if (tt_specs_.is_active && tt_specs_.alpha == greatest_alpha) total_governing_deltaT_inv += 1.0 / (tt_specs_.biasf - 1.0);
+    if (welltemp_ && 1.0 == greatest_alpha && biasf_ != 1.0) {
+      total_governing_deltaT_inv += 1.0 / (biasf_ - 1.0);
+    }
+    if (dampfactor_ > 0.0 && 1.0 == greatest_alpha) {
+      total_governing_deltaT_inv += 1.0 / (dampfactor_);
+    }
+    if (tt_specs_.is_active && tt_specs_.alpha == greatest_alpha) {
+      total_governing_deltaT_inv += 1.0 / (tt_specs_.biasf - 1.0);
+    }
     // Give a newbie-friendly error message for people using one tempering if
     // only one is active.
     if (n_active == 1 && total_governing_deltaT_inv < 0.0) {
@@ -995,33 +1110,53 @@ MetaD::MetaD(const ActionOptions& ao):
     }
   }
 
-  if(doInt_) log.printf("  Upper and Lower limits boundaries for the bias are activated at %f - %f\n", lowI_, uppI_);
+  if(doInt_) {
+    log.printf("  Upper and Lower limits boundaries for the bias are activated at %f - %f\n", lowI_, uppI_);
+  }
 
   if(grid_) {
     log.printf("  Grid min");
-    for(unsigned i=0; i<gmin.size(); ++i) log.printf(" %s",gmin[i].c_str() );
+    for(unsigned i=0; i<gmin.size(); ++i) {
+      log.printf(" %s",gmin[i].c_str() );
+    }
     log.printf("\n");
     log.printf("  Grid max");
-    for(unsigned i=0; i<gmax.size(); ++i) log.printf(" %s",gmax[i].c_str() );
+    for(unsigned i=0; i<gmax.size(); ++i) {
+      log.printf(" %s",gmax[i].c_str() );
+    }
     log.printf("\n");
     log.printf("  Grid bin");
-    for(unsigned i=0; i<gbin.size(); ++i) log.printf(" %u",gbin[i]);
+    for(unsigned i=0; i<gbin.size(); ++i) {
+      log.printf(" %u",gbin[i]);
+    }
     log.printf("\n");
-    if(spline) {log.printf("  Grid uses spline interpolation\n");}
-    if(sparsegrid) {log.printf("  Grid uses sparse grid\n");}
-    if(wgridstride_>0) {log.printf("  Grid is written on file %s with stride %d\n",gridfilename_.c_str(),wgridstride_);}
+    if(spline) {
+      log.printf("  Grid uses spline interpolation\n");
+    }
+    if(sparsegrid) {
+      log.printf("  Grid uses sparse grid\n");
+    }
+    if(wgridstride_>0) {
+      log.printf("  Grid is written on file %s with stride %d\n",gridfilename_.c_str(),wgridstride_);
+    }
   }
 
   if(mw_n_>1) {
-    if(walkers_mpi_) error("MPI version of multiple walkers is not compatible with filesystem version of multiple walkers");
+    if(walkers_mpi_) {
+      error("MPI version of multiple walkers is not compatible with filesystem version of multiple walkers");
+    }
     log.printf("  %d multiple walkers active\n",mw_n_);
     log.printf("  walker id %d\n",mw_id_);
     log.printf("  reading stride %d\n",mw_rstride_);
-    if(mw_dir_!="")log.printf("  directory with hills files %s\n",mw_dir_.c_str());
+    if(mw_dir_!="") {
+      log.printf("  directory with hills files %s\n",mw_dir_.c_str());
+    }
   } else {
     if(walkers_mpi_) {
       log.printf("  Multiple walkers active using MPI communnication\n");
-      if(mw_dir_!="")log.printf("  directory with hills files %s\n",mw_dir_.c_str());
+      if(mw_dir_!="") {
+        log.printf("  directory with hills files %s\n",mw_dir_.c_str());
+      }
       if(comm.Get_rank()==0) {
         // Only root of group can communicate with other walkers
         mpi_nw_=multi_sim_comm.Get_size();
@@ -1033,7 +1168,9 @@ MetaD::MetaD(const ActionOptions& ao):
   }
 
   if(flying_) {
-    if(!walkers_mpi_) error("Flying Gaussian method must be used with MPI version of multiple walkers");
+    if(!walkers_mpi_) {
+      error("Flying Gaussian method must be used with MPI version of multiple walkers");
+    }
     log.printf("  Flying Gaussian method with %d walkers active\n",mpi_nw_);
   }
 
@@ -1045,20 +1182,26 @@ MetaD::MetaD(const ActionOptions& ao):
   }
 
   if(calc_rct_) {
-    addComponent("rbias"); componentIsNotPeriodic("rbias");
-    addComponent("rct"); componentIsNotPeriodic("rct");
+    addComponent("rbias");
+    componentIsNotPeriodic("rbias");
+    addComponent("rct");
+    componentIsNotPeriodic("rct");
     log.printf("  The c(t) reweighting factor will be calculated every %u hills\n",rct_ustride_);
     getPntrToComponent("rct")->set(reweight_factor_);
   }
 
-  if(calc_work_) { addComponent("work"); componentIsNotPeriodic("work"); }
+  if(calc_work_) {
+    addComponent("work");
+    componentIsNotPeriodic("work");
+  }
 
   if(acceleration_) {
     if (kbt_ == 0.0) {
       error("The calculation of the acceleration works only if simulation temperature has been defined");
     }
     log.printf("  calculation on the fly of the acceleration factor\n");
-    addComponent("acc"); componentIsNotPeriodic("acc");
+    addComponent("acc");
+    componentIsNotPeriodic("acc");
     // Set the initial value of the the acceleration.
     // If this is not a restart, set to 1.0.
     if (acc_rfilename.length() == 0) {
@@ -1092,7 +1235,9 @@ MetaD::MetaD(const ActionOptions& ao):
         acc_rfile.scanField();
         found=true;
       }
-      if(!found) error("The ACCELERATION_RFILE file you want to read: " + acc_rfilename + ", does not contain a time field!");
+      if(!found) {
+        error("The ACCELERATION_RFILE file you want to read: " + acc_rfilename + ", does not contain a time field!");
+      }
       acc_restart_mean_ = acc_rmean;
       // Set component based on the read values.
       getPntrToComponent("acc")->set(acc_rmean);
@@ -1101,33 +1246,45 @@ MetaD::MetaD(const ActionOptions& ao):
   }
 
   if (calc_max_bias_) {
-    if (!grid_) error("Calculating the maximum bias on the fly works only with a grid");
+    if (!grid_) {
+      error("Calculating the maximum bias on the fly works only with a grid");
+    }
     log.printf("  calculation on the fly of the maximum bias max(V(s,t)) \n");
     addComponent("maxbias");
     componentIsNotPeriodic("maxbias");
   }
 
   if (calc_transition_bias_) {
-    if (!grid_) error("Calculating the transition bias on the fly works only with a grid");
+    if (!grid_) {
+      error("Calculating the transition bias on the fly works only with a grid");
+    }
     log.printf("  calculation on the fly of the transition bias V*(t)\n");
     addComponent("transbias");
     componentIsNotPeriodic("transbias");
     log<<"  Number of transition wells "<<transitionwells_.size()<<"\n";
-    if (transitionwells_.size() == 0) error("Calculating the transition bias on the fly requires definition of at least one transition well");
+    if (transitionwells_.size() == 0) {
+      error("Calculating the transition bias on the fly requires definition of at least one transition well");
+    }
     // Check that a grid is in use.
-    if (!grid_) error(" transition barrier finding requires a grid for the bias");
+    if (!grid_) {
+      error(" transition barrier finding requires a grid for the bias");
+    }
     // Log the wells and check that they are in the grid.
     for (unsigned i = 0; i < transitionwells_.size(); i++) {
       // Log the coordinate.
       log.printf("  Transition well %d at coordinate ", i);
-      for (unsigned j = 0; j < getNumberOfArguments(); j++) log.printf("%f ", transitionwells_[i][j]);
+      for (unsigned j = 0; j < getNumberOfArguments(); j++) {
+        log.printf("%f ", transitionwells_[i][j]);
+      }
       log.printf("\n");
       // Check that the coordinate is in the grid.
       for (unsigned j = 0; j < getNumberOfArguments(); j++) {
         double max, min;
         Tools::convert(gmin[j], min);
         Tools::convert(gmax[j], max);
-        if (transitionwells_[i][j] < min || transitionwells_[i][j] > max) error(" transition well is not in grid");
+        if (transitionwells_[i][j] < min || transitionwells_[i][j] > max) {
+          error(" transition well is not in grid");
+        }
       }
     }
   }
@@ -1153,7 +1310,8 @@ MetaD::MetaD(const ActionOptions& ao):
     if(fa_max_stride_!=0) {
       log.printf("  The hill addition frequency will not become larger than %d steps\n",fa_max_stride_);
     }
-    addComponent("pace"); componentIsNotPeriodic("pace");
+    addComponent("pace");
+    componentIsNotPeriodic("pace");
     updateFrequencyAdaptiveStride();
   }
 
@@ -1168,22 +1326,35 @@ MetaD::MetaD(const ActionOptions& ao):
         Tools::convert(gmax[i],b);
         double mesh=(b-a)/((double)gbin[i]);
         if(adaptive_==FlexibleBin::none) {
-          if(mesh>0.5*sigma0_[i]) log<<"  WARNING: Using a METAD with a Grid Spacing larger than half of the Gaussians width (SIGMA) can produce artifacts\n";
+          if(mesh>0.5*sigma0_[i]) {
+            log<<"  WARNING: Using a METAD with a Grid Spacing larger than half of the Gaussians width (SIGMA) can produce artifacts\n";
+          }
         } else {
-          if(sigma0min_[i]<0.) error("When using ADAPTIVE Gaussians on a grid SIGMA_MIN must be specified");
-          if(mesh>0.5*sigma0min_[i]) log<<"  WARNING: to use a METAD with a GRID and ADAPTIVE you need to set a Grid Spacing lower than half of the Gaussians (SIGMA_MIN) \n";
+          if(sigma0min_[i]<0.) {
+            error("When using ADAPTIVE Gaussians on a grid SIGMA_MIN must be specified");
+          }
+          if(mesh>0.5*sigma0min_[i]) {
+            log<<"  WARNING: to use a METAD with a GRID and ADAPTIVE you need to set a Grid Spacing lower than half of the Gaussians (SIGMA_MIN) \n";
+          }
         }
       }
       std::string funcl=getLabel() + ".bias";
-      if(!sparsegrid) {BiasGrid_=Tools::make_unique<Grid>(funcl,getArguments(),gmin,gmax,gbin,spline,true);}
-      else {BiasGrid_=Tools::make_unique<SparseGrid>(funcl,getArguments(),gmin,gmax,gbin,spline,true);}
+      if(!sparsegrid) {
+        BiasGrid_=Tools::make_unique<Grid>(funcl,getArguments(),gmin,gmax,gbin,spline,true);
+      } else {
+        BiasGrid_=Tools::make_unique<SparseGrid>(funcl,getArguments(),gmin,gmax,gbin,spline,true);
+      }
       std::vector<std::string> actualmin=BiasGrid_->getMin();
       std::vector<std::string> actualmax=BiasGrid_->getMax();
       for(unsigned i=0; i<getNumberOfArguments(); i++) {
         std::string is;
         Tools::convert(i,is);
-        if(gmin[i]!=actualmin[i]) error("GRID_MIN["+is+"] must be adjusted to "+actualmin[i]+" to fit periodicity");
-        if(gmax[i]!=actualmax[i]) error("GRID_MAX["+is+"] must be adjusted to "+actualmax[i]+" to fit periodicity");
+        if(gmin[i]!=actualmin[i]) {
+          error("GRID_MIN["+is+"] must be adjusted to "+actualmin[i]+" to fit periodicity");
+        }
+        if(gmax[i]!=actualmax[i]) {
+          error("GRID_MAX["+is+"] must be adjusted to "+actualmax[i]+" to fit periodicity");
+        }
       }
     } else {
       // read the grid in input, find the keys
@@ -1192,7 +1363,9 @@ MetaD::MetaD(const ActionOptions& ao):
         const std::string ret = std::filesystem::current_path();
         gridreadfilename_ = "/" + gridreadfilename_;
         gridreadfilename_ = ret + gridreadfilename_;
-        if(comm.Get_rank()==0) multi_sim_comm.Bcast(gridreadfilename_,0);
+        if(comm.Get_rank()==0) {
+          multi_sim_comm.Bcast(gridreadfilename_,0);
+        }
         comm.Bcast(gridreadfilename_,0);
       }
       IFile gridfile;
@@ -1204,27 +1377,39 @@ MetaD::MetaD(const ActionOptions& ao):
       }
       std::string funcl=getLabel() + ".bias";
       BiasGrid_=GridBase::create(funcl, getArguments(), gridfile, gmin, gmax, gbin, sparsegrid, spline, true);
-      if(BiasGrid_->getDimension()!=getNumberOfArguments()) error("mismatch between dimensionality of input grid and number of arguments");
+      if(BiasGrid_->getDimension()!=getNumberOfArguments()) {
+        error("mismatch between dimensionality of input grid and number of arguments");
+      }
       for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-        if( getPntrToArgument(i)->isPeriodic()!=BiasGrid_->getIsPeriodic()[i] ) error("periodicity mismatch between arguments and input bias");
+        if( getPntrToArgument(i)->isPeriodic()!=BiasGrid_->getIsPeriodic()[i] ) {
+          error("periodicity mismatch between arguments and input bias");
+        }
         double a, b;
         Tools::convert(gmin[i],a);
         Tools::convert(gmax[i],b);
         double mesh=(b-a)/((double)gbin[i]);
-        if(mesh>0.5*sigma0_[i]) log<<"  WARNING: Using a METAD with a Grid Spacing larger than half of the Gaussians width can produce artifacts\n";
+        if(mesh>0.5*sigma0_[i]) {
+          log<<"  WARNING: Using a METAD with a Grid Spacing larger than half of the Gaussians width can produce artifacts\n";
+        }
       }
       log.printf("  Restarting from %s\n",gridreadfilename_.c_str());
-      if(getRestart()) restartedFromGrid=true;
+      if(getRestart()) {
+        restartedFromGrid=true;
+      }
     }
   }
 
   // if we are restarting from GRID and using WALKERS_MPI we can check that all walkers have actually read the grid
   if(getRestart()&&walkers_mpi_) {
     std::vector<int> restarted(mpi_nw_,0);
-    if(comm.Get_rank()==0) multi_sim_comm.Allgather(int(restartedFromGrid), restarted);
+    if(comm.Get_rank()==0) {
+      multi_sim_comm.Allgather(int(restartedFromGrid), restarted);
+    }
     comm.Bcast(restarted,0);
     int result = std::accumulate(restarted.begin(),restarted.end(),0);
-    if(result!=0&&result!=mpi_nw_) error("in this WALKERS_MPI run some replica have restarted from GRID while other do not!");
+    if(result!=0&&result!=mpi_nw_) {
+      error("in this WALKERS_MPI run some replica have restarted from GRID while other do not!");
+    }
   }
 
   if(walkers_mpi_&&mw_dir_==""&&hillsfname.at(0)!='/') {
@@ -1232,7 +1417,9 @@ MetaD::MetaD(const ActionOptions& ao):
     const std::string ret = std::filesystem::current_path();
     mw_dir_ = ret;
     mw_dir_ = mw_dir_ + "/";
-    if(comm.Get_rank()==0) multi_sim_comm.Bcast(mw_dir_,0);
+    if(comm.Get_rank()==0) {
+      multi_sim_comm.Bcast(mw_dir_,0);
+    }
     comm.Bcast(mw_dir_,0);
   }
 
@@ -1243,7 +1430,8 @@ MetaD::MetaD(const ActionOptions& ao):
     std::string fname;
     if(mw_dir_!="") {
       if(mw_n_>1) {
-        std::stringstream out; out << i;
+        std::stringstream out;
+        out << i;
         fname = mw_dir_+"/"+hillsfname+"."+out.str();
       } else if(walkers_mpi_) {
         fname = mw_dir_+"/"+hillsfname;
@@ -1252,7 +1440,8 @@ MetaD::MetaD(const ActionOptions& ao):
       }
     } else {
       if(mw_n_>1) {
-        std::stringstream out; out << i;
+        std::stringstream out;
+        out << i;
         fname = hillsfname+"."+out.str();
       } else {
         fname = hillsfname;
@@ -1272,20 +1461,28 @@ MetaD::MetaD(const ActionOptions& ao):
       }
       ifiles_[i]->reset(false);
       // close only the walker own hills file for later writing
-      if(i==mw_id_) ifiles_[i]->close();
+      if(i==mw_id_) {
+        ifiles_[i]->close();
+      }
     } else {
       // in case a file does not exist and we are restarting, complain that the file was not found
-      if(getRestart()&&!restartedFromGrid) error("restart file "+fname+" not found");
+      if(getRestart()&&!restartedFromGrid) {
+        error("restart file "+fname+" not found");
+      }
     }
   }
 
   // if we are restarting from FILE and using WALKERS_MPI we can check that all walkers have actually read the FILE
   if(getRestart()&&walkers_mpi_) {
     std::vector<int> restarted(mpi_nw_,0);
-    if(comm.Get_rank()==0) multi_sim_comm.Allgather(int(restartedFromHills), restarted);
+    if(comm.Get_rank()==0) {
+      multi_sim_comm.Allgather(int(restartedFromHills), restarted);
+    }
     comm.Bcast(restarted,0);
     int result = std::accumulate(restarted.begin(),restarted.end(),0);
-    if(result!=0&&result!=mpi_nw_) error("in this WALKERS_MPI run some replica have restarted from FILE while other do not!");
+    if(result!=0&&result!=mpi_nw_) {
+      error("in this WALKERS_MPI run some replica have restarted from FILE while other do not!");
+    }
   }
 
   comm.Barrier();
@@ -1296,23 +1493,34 @@ MetaD::MetaD(const ActionOptions& ao):
   // it would introduce troubles when using replicas without METAD
   // (e.g. in bias exchange with a neutral replica)
   // see issue #168 on github
-  if(comm.Get_rank()==0 && walkers_mpi_) multi_sim_comm.Barrier();
+  if(comm.Get_rank()==0 && walkers_mpi_) {
+    multi_sim_comm.Barrier();
+  }
 
   if(targetfilename_.length()>0) {
-    IFile gridfile; gridfile.open(targetfilename_);
+    IFile gridfile;
+    gridfile.open(targetfilename_);
     std::string funcl=getLabel() + ".target";
     TargetGrid_=GridBase::create(funcl,getArguments(),gridfile,false,false,true);
-    if(TargetGrid_->getDimension()!=getNumberOfArguments()) error("mismatch between dimensionality of input grid and number of arguments");
+    if(TargetGrid_->getDimension()!=getNumberOfArguments()) {
+      error("mismatch between dimensionality of input grid and number of arguments");
+    }
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-      if( getPntrToArgument(i)->isPeriodic()!=TargetGrid_->getIsPeriodic()[i] ) error("periodicity mismatch between arguments and input bias");
+      if( getPntrToArgument(i)->isPeriodic()!=TargetGrid_->getIsPeriodic()[i] ) {
+        error("periodicity mismatch between arguments and input bias");
+      }
     }
   }
 
   if(getRestart()) {
     // if this is a restart the neighbor list should be immediately updated
-    if(nlist_) nlist_update_=true;
+    if(nlist_) {
+      nlist_update_=true;
+    }
     // Calculate the Tiwary-Parrinello reweighting factor if we are restarting from previous hills
-    if(calc_rct_) computeReweightingFactor();
+    if(calc_rct_) {
+      computeReweightingFactor();
+    }
     // Calculate all special bias quantities desired if restarting with nonzero bias.
     if(calc_max_bias_) {
       max_bias_ = BiasGrid_->getMaxValue();
@@ -1329,12 +1537,18 @@ MetaD::MetaD(const ActionOptions& ao):
     gridfile_.link(*this);
     if(walkers_mpi_) {
       int r=0;
-      if(comm.Get_rank()==0) r=multi_sim_comm.Get_rank();
+      if(comm.Get_rank()==0) {
+        r=multi_sim_comm.Get_rank();
+      }
       comm.Bcast(r,0);
-      if(r>0) gridfilename_="/dev/null";
+      if(r>0) {
+        gridfilename_="/dev/null";
+      }
+      gridfile_.enforceSuffix("");
+    }
+    if(mw_n_>1) {
       gridfile_.enforceSuffix("");
     }
-    if(mw_n_>1) gridfile_.enforceSuffix("");
     gridfile_.open(gridfilename_);
   }
 
@@ -1342,14 +1556,22 @@ MetaD::MetaD(const ActionOptions& ao):
   hillsOfile_.link(*this);
   if(walkers_mpi_) {
     int r=0;
-    if(comm.Get_rank()==0) r=multi_sim_comm.Get_rank();
+    if(comm.Get_rank()==0) {
+      r=multi_sim_comm.Get_rank();
+    }
     comm.Bcast(r,0);
-    if(r>0) ifilesnames_[mw_id_]="/dev/null";
+    if(r>0) {
+      ifilesnames_[mw_id_]="/dev/null";
+    }
+    hillsOfile_.enforceSuffix("");
+  }
+  if(mw_n_>1) {
     hillsOfile_.enforceSuffix("");
   }
-  if(mw_n_>1) hillsOfile_.enforceSuffix("");
   hillsOfile_.open(ifilesnames_[mw_id_]);
-  if(fmt_.length()>0) hillsOfile_.fmtField(fmt_);
+  if(fmt_.length()>0) {
+    hillsOfile_.fmtField(fmt_);
+  }
   hillsOfile_.addConstantField("multivariate");
   hillsOfile_.addConstantField("kerneltype");
   if(doInt_) {
@@ -1358,12 +1580,20 @@ MetaD::MetaD(const ActionOptions& ao):
   }
   hillsOfile_.setHeavyFlush();
   // output periodicities of variables
-  for(unsigned i=0; i<getNumberOfArguments(); ++i) hillsOfile_.setupPrintValue( getPntrToArgument(i) );
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    hillsOfile_.setupPrintValue( getPntrToArgument(i) );
+  }
 
   bool concurrent=false;
   const ActionSet&actionSet(plumed.getActionSet());
-  for(const auto & p : actionSet) if(dynamic_cast<MetaD*>(p.get())) { concurrent=true; break; }
-  if(concurrent) log<<"  You are using concurrent metadynamics\n";
+  for(const auto & p : actionSet)
+    if(dynamic_cast<MetaD*>(p.get())) {
+      concurrent=true;
+      break;
+    }
+  if(concurrent) {
+    log<<"  You are using concurrent metadynamics\n";
+  }
   if(rect_biasf_.size()>0) {
     if(walkers_mpi_) {
       log<<"  You are using RECT in its 'altruistic' implementation\n";
@@ -1373,29 +1603,46 @@ MetaD::MetaD(const ActionOptions& ao):
   }
 
   log<<"  Bibliography "<<plumed.cite("Laio and Parrinello, PNAS 99, 12562 (2002)");
-  if(welltemp_) log<<plumed.cite("Barducci, Bussi, and Parrinello, Phys. Rev. Lett. 100, 020603 (2008)");
+  if(welltemp_) {
+    log<<plumed.cite("Barducci, Bussi, and Parrinello, Phys. Rev. Lett. 100, 020603 (2008)");
+  }
   if(tt_specs_.is_active) {
     log << plumed.cite("Dama, Rotskoff, Parrinello, and Voth, J. Chem. Theory Comput. 10, 3626 (2014)");
     log << plumed.cite("Dama, Parrinello, and Voth, Phys. Rev. Lett. 112, 240602 (2014)");
   }
-  if(mw_n_>1||walkers_mpi_) log<<plumed.cite("Raiteri, Laio, Gervasio, Micheletti, and Parrinello, J. Phys. Chem. B 110, 3533 (2006)");
-  if(adaptive_!=FlexibleBin::none) log<<plumed.cite("Branduardi, Bussi, and Parrinello, J. Chem. Theory Comput. 8, 2247 (2012)");
-  if(doInt_) log<<plumed.cite("Baftizadeh, Cossio, Pietrucci, and Laio, Curr. Phys. Chem. 2, 79 (2012)");
-  if(acceleration_) log<<plumed.cite("Pratyush and Parrinello, Phys. Rev. Lett. 111, 230602 (2013)");
-  if(calc_rct_) log<<plumed.cite("Pratyush and Parrinello, J. Phys. Chem. B, 119, 736 (2015)");
-  if(concurrent || rect_biasf_.size()>0) log<<plumed.cite("Gil-Ley and Bussi, J. Chem. Theory Comput. 11, 1077 (2015)");
-  if(rect_biasf_.size()>0 && walkers_mpi_) log<<plumed.cite("Hosek, Toulcova, Bortolato, and Spiwok, J. Phys. Chem. B 120, 2209 (2016)");
+  if(mw_n_>1||walkers_mpi_) {
+    log<<plumed.cite("Raiteri, Laio, Gervasio, Micheletti, and Parrinello, J. Phys. Chem. B 110, 3533 (2006)");
+  }
+  if(adaptive_!=FlexibleBin::none) {
+    log<<plumed.cite("Branduardi, Bussi, and Parrinello, J. Chem. Theory Comput. 8, 2247 (2012)");
+  }
+  if(doInt_) {
+    log<<plumed.cite("Baftizadeh, Cossio, Pietrucci, and Laio, Curr. Phys. Chem. 2, 79 (2012)");
+  }
+  if(acceleration_) {
+    log<<plumed.cite("Pratyush and Parrinello, Phys. Rev. Lett. 111, 230602 (2013)");
+  }
+  if(calc_rct_) {
+    log<<plumed.cite("Pratyush and Parrinello, J. Phys. Chem. B, 119, 736 (2015)");
+  }
+  if(concurrent || rect_biasf_.size()>0) {
+    log<<plumed.cite("Gil-Ley and Bussi, J. Chem. Theory Comput. 11, 1077 (2015)");
+  }
+  if(rect_biasf_.size()>0 && walkers_mpi_) {
+    log<<plumed.cite("Hosek, Toulcova, Bortolato, and Spiwok, J. Phys. Chem. B 120, 2209 (2016)");
+  }
   if(targetfilename_.length()>0) {
     log<<plumed.cite("White, Dama, and Voth, J. Chem. Theory Comput. 11, 2451 (2015)");
     log<<plumed.cite("Marinelli and Faraldo-Gómez,  Biophys. J. 108, 2779 (2015)");
     log<<plumed.cite("Gil-Ley, Bottaro, and Bussi, J. Chem. Theory Comput. 12, 2790 (2016)");
   }
-  if(freq_adaptive_) log<<plumed.cite("Wang, Valsson, Tiwary, Parrinello, and Lindorff-Larsen, J. Chem. Phys. 149, 072309 (2018)");
+  if(freq_adaptive_) {
+    log<<plumed.cite("Wang, Valsson, Tiwary, Parrinello, and Lindorff-Larsen, J. Chem. Phys. 149, 072309 (2018)");
+  }
   log<<"\n";
 }
 
-void MetaD::readTemperingSpecs(TemperingSpecs &t_specs)
-{
+void MetaD::readTemperingSpecs(TemperingSpecs &t_specs) {
   // Set global tempering parameters.
   parse(t_specs.name_stem + "BIASFACTOR", t_specs.biasf);
   if (t_specs.biasf != -1.0) {
@@ -1417,16 +1664,18 @@ void MetaD::readTemperingSpecs(TemperingSpecs &t_specs)
   }
 }
 
-void MetaD::logTemperingSpecs(const TemperingSpecs &t_specs)
-{
+void MetaD::logTemperingSpecs(const TemperingSpecs &t_specs) {
   log.printf("  %s bias factor %f\n", t_specs.name.c_str(), t_specs.biasf);
   log.printf("  KbT %f\n", kbt_);
-  if (t_specs.threshold != 0.0) log.printf("  %s bias threshold %f\n", t_specs.name.c_str(), t_specs.threshold);
-  if (t_specs.alpha != 1.0) log.printf("  %s decay shape parameter alpha %f\n", t_specs.name.c_str(), t_specs.alpha);
+  if (t_specs.threshold != 0.0) {
+    log.printf("  %s bias threshold %f\n", t_specs.name.c_str(), t_specs.threshold);
+  }
+  if (t_specs.alpha != 1.0) {
+    log.printf("  %s decay shape parameter alpha %f\n", t_specs.name.c_str(), t_specs.alpha);
+  }
 }
 
-void MetaD::readGaussians(IFile *ifile)
-{
+void MetaD::readGaussians(IFile *ifile) {
   unsigned ncv=getNumberOfArguments();
   std::vector<double> center(ncv);
   std::vector<double> sigma(ncv);
@@ -1435,20 +1684,22 @@ void MetaD::readGaussians(IFile *ifile)
   bool multivariate=false;
 
   std::vector<Value> tmpvalues;
-  for(unsigned j=0; j<getNumberOfArguments(); ++j) tmpvalues.push_back( Value( this, getPntrToArgument(j)->getName(), false ) );
+  for(unsigned j=0; j<getNumberOfArguments(); ++j) {
+    tmpvalues.push_back( Value( this, getPntrToArgument(j)->getName(), false ) );
+  }
 
-  while(scanOneHill(ifile,tmpvalues,center,sigma,height,multivariate))
-  {
+  while(scanOneHill(ifile,tmpvalues,center,sigma,height,multivariate)) {
     nhills++;
     // note that for gamma=1 we store directly -F
-    if(welltemp_ && biasf_>1.0) height*=(biasf_-1.0)/biasf_;
+    if(welltemp_ && biasf_>1.0) {
+      height*=(biasf_-1.0)/biasf_;
+    }
     addGaussian(Gaussian(multivariate,height,center,sigma));
   }
   log.printf("      %d Gaussians read\n",nhills);
 }
 
-void MetaD::writeGaussian(const Gaussian& hill, OFile&file)
-{
+void MetaD::writeGaussian(const Gaussian& hill, OFile&file) {
   unsigned ncv=getNumberOfArguments();
   file.printField("time",getTimeStep()*getStep());
   for(unsigned i=0; i<ncv; ++i) {
@@ -1487,19 +1738,23 @@ void MetaD::writeGaussian(const Gaussian& hill, OFile&file)
     }
   } else {
     hillsOfile_.printField("multivariate","false");
-    for(unsigned i=0; i<ncv; ++i)
+    for(unsigned i=0; i<ncv; ++i) {
       file.printField("sigma_"+getPntrToArgument(i)->getName(),hill.sigma[i]);
+    }
   }
   double height=hill.height;
   // note that for gamma=1 we store directly -F
-  if(welltemp_ && biasf_>1.0) height*=biasf_/(biasf_-1.0);
+  if(welltemp_ && biasf_>1.0) {
+    height*=biasf_/(biasf_-1.0);
+  }
   file.printField("height",height).printField("biasf",biasf_);
-  if(mw_n_>1) file.printField("clock",int(std::time(0)));
+  if(mw_n_>1) {
+    file.printField("clock",int(std::time(0)));
+  }
   file.printField();
 }
 
-void MetaD::addGaussian(const Gaussian& hill)
-{
+void MetaD::addGaussian(const Gaussian& hill) {
   if(grid_) {
     size_t ncv=getNumberOfArguments();
     std::vector<unsigned> nneighb=getGaussianSupport(hill);
@@ -1511,7 +1766,9 @@ void MetaD::addGaussian(const Gaussian& hill)
       std::vector<double> dp(ncv);
       for(size_t i=0; i<neighbors.size(); ++i) {
         Grid::index_t ineigh=neighbors[i];
-        for(unsigned j=0; j<ncv; ++j) der[j]=0.0;
+        for(unsigned j=0; j<ncv; ++j) {
+          der[j]=0.0;
+        }
         BiasGrid_->getPoint(ineigh,xx);
         double bias=evaluateGaussianAndDerivatives(xx,hill,der,dp);
         BiasGrid_->addValueAndDerivatives(ineigh,bias,der);
@@ -1526,24 +1783,31 @@ void MetaD::addGaussian(const Gaussian& hill)
       std::vector<double> dp(ncv);
       for(unsigned i=rank; i<neighbors.size(); i+=stride) {
         Grid::index_t ineigh=neighbors[i];
-        for(unsigned j=0; j<ncv; ++j) n_der[j]=0.0;
+        for(unsigned j=0; j<ncv; ++j) {
+          n_der[j]=0.0;
+        }
         BiasGrid_->getPoint(ineigh,xx);
         allbias[i]=evaluateGaussianAndDerivatives(xx,hill,n_der,dp);
-        for(unsigned j=0; j<ncv; j++) allder[ncv*i+j]=n_der[j];
+        for(unsigned j=0; j<ncv; j++) {
+          allder[ncv*i+j]=n_der[j];
+        }
       }
       comm.Sum(allbias);
       comm.Sum(allder);
       for(unsigned i=0; i<neighbors.size(); ++i) {
         Grid::index_t ineigh=neighbors[i];
-        for(unsigned j=0; j<ncv; ++j) der[j]=allder[ncv*i+j];
+        for(unsigned j=0; j<ncv; ++j) {
+          der[j]=allder[ncv*i+j];
+        }
         BiasGrid_->addValueAndDerivatives(ineigh,allbias[i],der);
       }
     }
-  } else hills_.push_back(hill);
+  } else {
+    hills_.push_back(hill);
+  }
 }
 
-std::vector<unsigned> MetaD::getGaussianSupport(const Gaussian& hill)
-{
+std::vector<unsigned> MetaD::getGaussianSupport(const Gaussian& hill) {
   std::vector<unsigned> nneigh;
   std::vector<double> cutoff;
   unsigned ncv=getNumberOfArguments();
@@ -1566,9 +1830,13 @@ std::vector<unsigned> MetaD::getGaussianSupport(const Gaussian& hill)
     std::vector<double> myautoval(ncv); //should I take this or their square root?
     diagMat(myinv,myautoval,myautovec);
     double maxautoval=0.;
-    unsigned ind_maxautoval; ind_maxautoval=ncv;
+    unsigned ind_maxautoval;
+    ind_maxautoval=ncv;
     for(unsigned i=0; i<ncv; i++) {
-      if(myautoval[i]>maxautoval) {maxautoval=myautoval[i]; ind_maxautoval=i;}
+      if(myautoval[i]>maxautoval) {
+        maxautoval=myautoval[i];
+        ind_maxautoval=i;
+      }
     }
     for(unsigned i=0; i<ncv; i++) {
       cutoff.push_back(std::sqrt(2.0*dp2cutoff)*std::abs(std::sqrt(maxautoval)*myautovec(i,ind_maxautoval)));
@@ -1596,11 +1864,11 @@ std::vector<unsigned> MetaD::getGaussianSupport(const Gaussian& hill)
   return nneigh;
 }
 
-double MetaD::getBias(const std::vector<double>& cv)
-{
+double MetaD::getBias(const std::vector<double>& cv) {
   double bias=0.0;
-  if(grid_) bias = BiasGrid_->getValue(cv);
-  else {
+  if(grid_) {
+    bias = BiasGrid_->getValue(cv);
+  } else {
     unsigned nt=OpenMP::getNumThreads();
     unsigned stride=comm.Get_size();
     unsigned rank=comm.Get_rank();
@@ -1609,13 +1877,17 @@ double MetaD::getBias(const std::vector<double>& cv)
       #pragma omp parallel num_threads(nt)
       {
         #pragma omp for reduction(+:bias) nowait
-        for(unsigned i=rank; i<hills_.size(); i+=stride) bias+=evaluateGaussian(cv,hills_[i]);
+        for(unsigned i=rank; i<hills_.size(); i+=stride) {
+          bias+=evaluateGaussian(cv,hills_[i]);
+        }
       }
     } else {
       #pragma omp parallel num_threads(nt)
       {
         #pragma omp for reduction(+:bias) nowait
-        for(unsigned i=rank; i<nlist_hills_.size(); i+=stride) bias+=evaluateGaussian(cv,nlist_hills_[i]);
+        for(unsigned i=rank; i<nlist_hills_.size(); i+=stride) {
+          bias+=evaluateGaussian(cv,nlist_hills_[i]);
+        }
       }
     }
     comm.Sum(bias);
@@ -1624,14 +1896,15 @@ double MetaD::getBias(const std::vector<double>& cv)
   return bias;
 }
 
-double MetaD::getBiasAndDerivatives(const std::vector<double>& cv, std::vector<double>& der)
-{
+double MetaD::getBiasAndDerivatives(const std::vector<double>& cv, std::vector<double>& der) {
   unsigned ncv=getNumberOfArguments();
   double bias=0.0;
   if(grid_) {
     std::vector<double> vder(ncv);
     bias=BiasGrid_->getValueAndDerivatives(cv,vder);
-    for(unsigned i=0; i<ncv; i++) der[i]=vder[i];
+    for(unsigned i=0; i<ncv; i++) {
+      der[i]=vder[i];
+    }
   } else {
     unsigned nt=OpenMP::getNumThreads();
     unsigned stride=comm.Get_size();
@@ -1655,7 +1928,9 @@ double MetaD::getBiasAndDerivatives(const std::vector<double>& cv, std::vector<d
             bias+=evaluateGaussianAndDerivatives(cv,hills_[i],omp_deriv,dp);
           }
           #pragma omp critical
-          for(unsigned i=0; i<ncv; i++) der[i]+=omp_deriv[i];
+          for(unsigned i=0; i<ncv; i++) {
+            der[i]+=omp_deriv[i];
+          }
         }
       }
     } else {
@@ -1676,7 +1951,9 @@ double MetaD::getBiasAndDerivatives(const std::vector<double>& cv, std::vector<d
             bias+=evaluateGaussianAndDerivatives(cv,nlist_hills_[i],omp_deriv,dp);
           }
           #pragma omp critical
-          for(unsigned i=0; i<ncv; i++) der[i]+=omp_deriv[i];
+          for(unsigned i=0; i<ncv; i++) {
+            der[i]+=omp_deriv[i];
+          }
         }
       }
     }
@@ -1687,8 +1964,7 @@ double MetaD::getBiasAndDerivatives(const std::vector<double>& cv, std::vector<d
   return bias;
 }
 
-double MetaD::getGaussianNormalization(const Gaussian& hill)
-{
+double MetaD::getGaussianNormalization(const Gaussian& hill) {
   double norm=1;
   unsigned ncv=hill.center.size();
 
@@ -1701,18 +1977,20 @@ double MetaD::getGaussianNormalization(const Gaussian& hill)
         mymatrix(i,j)=mymatrix(j,i)=hill.sigma[k]; // recompose the full inverse matrix
         k++;
       }
-      double ldet; logdet( mymatrix, ldet );
+      double ldet;
+      logdet( mymatrix, ldet );
       norm = std::exp( ldet );  // Not sure here if mymatrix is sigma or inverse
     }
   } else {
-    for(unsigned i=0; i<hill.sigma.size(); i++) norm*=hill.sigma[i];
+    for(unsigned i=0; i<hill.sigma.size(); i++) {
+      norm*=hill.sigma[i];
+    }
   }
 
   return norm*std::pow(2*pi,static_cast<double>(ncv)/2.0);
 }
 
-double MetaD::evaluateGaussian(const std::vector<double>& cv, const Gaussian& hill)
-{
+double MetaD::evaluateGaussian(const std::vector<double>& cv, const Gaussian& hill) {
   unsigned ncv=cv.size();
 
   // I use a pointer here because cv is const (and should be const)
@@ -1720,12 +1998,18 @@ double MetaD::evaluateGaussian(const std::vector<double>& cv, const Gaussian& hi
   // the upper/lower limit in case it is out of range
   double tmpcv[1];
   const double *pcv=NULL; // pointer to cv
-  if(ncv>0) pcv=&cv[0];
+  if(ncv>0) {
+    pcv=&cv[0];
+  }
   if(doInt_) {
     plumed_assert(ncv==1);
     tmpcv[0]=cv[0];
-    if(cv[0]<lowI_) tmpcv[0]=lowI_;
-    if(cv[0]>uppI_) tmpcv[0]=uppI_;
+    if(cv[0]<lowI_) {
+      tmpcv[0]=lowI_;
+    }
+    if(cv[0]>uppI_) {
+      tmpcv[0]=uppI_;
+    }
     pcv=&(tmpcv[0]);
   }
 
@@ -1760,13 +2044,14 @@ double MetaD::evaluateGaussian(const std::vector<double>& cv, const Gaussian& hi
   }
 
   double bias=0.0;
-  if(dp2<dp2cutoff) bias=hill.height*(stretchA*std::exp(-dp2)+stretchB);
+  if(dp2<dp2cutoff) {
+    bias=hill.height*(stretchA*std::exp(-dp2)+stretchB);
+  }
 
   return bias;
 }
 
-double MetaD::evaluateGaussianAndDerivatives(const std::vector<double>& cv, const Gaussian& hill, std::vector<double>& der, std::vector<double>& dp_)
-{
+double MetaD::evaluateGaussianAndDerivatives(const std::vector<double>& cv, const Gaussian& hill, std::vector<double>& der, std::vector<double>& dp_) {
   unsigned ncv=cv.size();
 
   // I use a pointer here because cv is const (and should be const)
@@ -1774,18 +2059,26 @@ double MetaD::evaluateGaussianAndDerivatives(const std::vector<double>& cv, cons
   // the upper/lower limit in case it is out of range
   const double *pcv=NULL; // pointer to cv
   double tmpcv[1]; // tmp array with cv (to be used with doInt_)
-  if(ncv>0) pcv=&cv[0];
+  if(ncv>0) {
+    pcv=&cv[0];
+  }
   if(doInt_) {
     plumed_assert(ncv==1);
     tmpcv[0]=cv[0];
-    if(cv[0]<lowI_) tmpcv[0]=lowI_;
-    if(cv[0]>uppI_) tmpcv[0]=uppI_;
+    if(cv[0]<lowI_) {
+      tmpcv[0]=lowI_;
+    }
+    if(cv[0]>uppI_) {
+      tmpcv[0]=uppI_;
+    }
     pcv=&(tmpcv[0]);
   }
 
   bool int_der=false;
   if(doInt_) {
-    if(cv[0]<lowI_ || cv[0]>uppI_) int_der=true;
+    if(cv[0]<lowI_ || cv[0]>uppI_) {
+      int_der=true;
+    }
   }
 
   double dp2=0.0;
@@ -1816,11 +2109,15 @@ double MetaD::evaluateGaussianAndDerivatives(const std::vector<double>& cv, cons
       if(!int_der) {
         for(unsigned i=0; i<ncv; i++) {
           double tmp=0.0;
-          for(unsigned j=0; j<ncv; j++) tmp += dp_[j]*mymatrix(i,j)*bias;
+          for(unsigned j=0; j<ncv; j++) {
+            tmp += dp_[j]*mymatrix(i,j)*bias;
+          }
           der[i]-=tmp*stretchA;
         }
       } else {
-        for(unsigned i=0; i<ncv; i++) der[i]=0.;
+        for(unsigned i=0; i<ncv; i++) {
+          der[i]=0.;
+        }
       }
       bias=stretchA*bias+hill.height*stretchB;
     }
@@ -1833,9 +2130,13 @@ double MetaD::evaluateGaussianAndDerivatives(const std::vector<double>& cv, cons
     if(dp2<dp2cutoff) {
       bias=hill.height*std::exp(-dp2);
       if(!int_der) {
-        for(unsigned i=0; i<ncv; i++) der[i]-=bias*dp_[i]*hill.invsigma[i]*stretchA;
+        for(unsigned i=0; i<ncv; i++) {
+          der[i]-=bias*dp_[i]*hill.invsigma[i]*stretchA;
+        }
       } else {
-        for(unsigned i=0; i<ncv; i++) der[i]=0.;
+        for(unsigned i=0; i<ncv; i++) {
+          der[i]=0.;
+        }
       }
       bias=stretchA*bias+hill.height*stretchB;
     }
@@ -1844,8 +2145,7 @@ double MetaD::evaluateGaussianAndDerivatives(const std::vector<double>& cv, cons
   return bias;
 }
 
-double MetaD::getHeight(const std::vector<double>& cv)
-{
+double MetaD::getHeight(const std::vector<double>& cv) {
   double height=height0_;
   if(welltemp_) {
     double vbias = getBias(cv);
@@ -1872,8 +2172,7 @@ double MetaD::getHeight(const std::vector<double>& cv)
   return height;
 }
 
-void MetaD::temperHeight(double& height, const TemperingSpecs& t_specs, const double tempering_bias)
-{
+void MetaD::temperHeight(double& height, const TemperingSpecs& t_specs, const double tempering_bias) {
   if (t_specs.alpha == 1.0) {
     height *= std::exp(-std::max(0.0, tempering_bias - t_specs.threshold) / (kbt_ * (t_specs.biasf - 1.0)));
   } else {
@@ -1881,37 +2180,54 @@ void MetaD::temperHeight(double& height, const TemperingSpecs& t_specs, const do
   }
 }
 
-void MetaD::calculate()
-{
+void MetaD::calculate() {
   // this is because presently there is no way to properly pass information
   // on adaptive hills (diff) after exchanges:
-  if(adaptive_==FlexibleBin::diffusion && getExchangeStep()) error("ADAPTIVE=DIFF is not compatible with replica exchange");
+  if(adaptive_==FlexibleBin::diffusion && getExchangeStep()) {
+    error("ADAPTIVE=DIFF is not compatible with replica exchange");
+  }
 
   const unsigned ncv=getNumberOfArguments();
   std::vector<double> cv(ncv);
-  for(unsigned i=0; i<ncv; ++i) cv[i]=getArgument(i);
+  for(unsigned i=0; i<ncv; ++i) {
+    cv[i]=getArgument(i);
+  }
 
   if(nlist_) {
     nlist_steps_++;
-    if(getExchangeStep()) nlist_update_=true;
-    else {
+    if(getExchangeStep()) {
+      nlist_update_=true;
+    } else {
       for(unsigned i=0; i<ncv; ++i) {
         double d = difference(i, cv[i], nlist_center_[i]);
         double nk_dist2 = d*d/nlist_dev2_[i];
-        if(nk_dist2>nlist_param_[1]) {nlist_update_=true; break;}
+        if(nk_dist2>nlist_param_[1]) {
+          nlist_update_=true;
+          break;
+        }
       }
     }
-    if(nlist_update_) updateNlist();
+    if(nlist_update_) {
+      updateNlist();
+    }
   }
 
   double ene = 0.;
   std::vector<double> der(ncv,0.);
-  if(biasf_!=1.0) ene = getBiasAndDerivatives(cv,der);
+  if(biasf_!=1.0) {
+    ene = getBiasAndDerivatives(cv,der);
+  }
   setBias(ene);
-  for(unsigned i=0; i<ncv; i++) setOutputForce(i,-der[i]);
+  for(unsigned i=0; i<ncv; i++) {
+    setOutputForce(i,-der[i]);
+  }
 
-  if(calc_work_) getPntrToComponent("work")->set(work_);
-  if(calc_rct_) getPntrToComponent("rbias")->set(ene - reweight_factor_);
+  if(calc_work_) {
+    getPntrToComponent("work")->set(work_);
+  }
+  if(calc_rct_) {
+    getPntrToComponent("rbias")->set(ene - reweight_factor_);
+  }
   // calculate the acceleration factor
   if(acceleration_&&!isFirstStep_) {
     acc_ += static_cast<double>(getStride()) * std::exp(ene/(kbt_));
@@ -1926,22 +2242,26 @@ void MetaD::calculate()
   }
 }
 
-void MetaD::update()
-{
+void MetaD::update() {
   // adding hills criteria (could be more complex though)
   bool nowAddAHill;
-  if(getStep()%current_stride_==0 && !isFirstStep_) nowAddAHill=true;
-  else {
+  if(getStep()%current_stride_==0 && !isFirstStep_) {
+    nowAddAHill=true;
+  } else {
     nowAddAHill=false;
     isFirstStep_=false;
   }
 
   unsigned ncv=getNumberOfArguments();
   std::vector<double> cv(ncv);
-  for(unsigned i=0; i<ncv; ++i) cv[i] = getArgument(i);
+  for(unsigned i=0; i<ncv; ++i) {
+    cv[i] = getArgument(i);
+  }
 
   double vbias=0.;
-  if(calc_work_) vbias=getBias(cv);
+  if(calc_work_) {
+    vbias=getBias(cv);
+  }
 
   // if you use adaptive, call the FlexibleBin
   bool multivariate=false;
@@ -1955,9 +2275,13 @@ void MetaD::update()
     // add a Gaussian
     double height=getHeight(cv);
     // returns upper diagonal inverse
-    if(adaptive_!=FlexibleBin::none) thissigma=flexbin_->getInverseMatrix();
+    if(adaptive_!=FlexibleBin::none) {
+      thissigma=flexbin_->getInverseMatrix();
+    }
     // returns normal sigma
-    else thissigma=sigma0_;
+    else {
+      thissigma=sigma0_;
+    }
 
     // In case we use walkers_mpi, it is now necessary to communicate with other replicas.
     if(walkers_mpi_) {
@@ -1990,13 +2314,19 @@ void MetaD::update()
         // actually add hills one by one
         std::vector<double> cv_now(ncv);
         std::vector<double> sigma_now(thissigma.size());
-        for(unsigned j=0; j<ncv; j++) cv_now[j]=all_cv[i*ncv+j];
-        for(unsigned j=0; j<thissigma.size(); j++) sigma_now[j]=all_sigma[i*thissigma.size()+j];
+        for(unsigned j=0; j<ncv; j++) {
+          cv_now[j]=all_cv[i*ncv+j];
+        }
+        for(unsigned j=0; j<thissigma.size(); j++) {
+          sigma_now[j]=all_sigma[i*thissigma.size()+j];
+        }
         // notice that if gamma=1 we store directly -F so this scaling is not necessary:
         double fact=(biasf_>1.0?(biasf_-1.0)/biasf_:1.0);
         Gaussian newhill=Gaussian(all_multivariate[i],all_height[i]*fact,cv_now,sigma_now);
         addGaussian(newhill);
-        if(!flying_) writeGaussian(newhill,hillsOfile_);
+        if(!flying_) {
+          writeGaussian(newhill,hillsOfile_);
+        }
       }
     } else {
       Gaussian newhill=Gaussian(multivariate,height,cv,thissigma);
@@ -2005,15 +2335,21 @@ void MetaD::update()
     }
 
     // this is to update the hills neighbor list
-    if(nlist_) nlist_update_=true;
+    if(nlist_) {
+      nlist_update_=true;
+    }
   }
 
   // this should be outside of the if block in case
   // mw_rstride_ is not a multiple of stride_
-  if(mw_n_>1 && getStep()%mw_rstride_==0) hillsOfile_.flush();
+  if(mw_n_>1 && getStep()%mw_rstride_==0) {
+    hillsOfile_.flush();
+  }
 
   if(calc_work_) {
-    if(nlist_) updateNlist();
+    if(nlist_) {
+      updateNlist();
+    }
     double vbias1=getBias(cv);
     work_+=vbias1-vbias;
   }
@@ -2022,16 +2358,22 @@ void MetaD::update()
   if(wgridstride_>0&&(getStep()%wgridstride_==0||getCPT())) {
     // in case old grids are stored, a sequence of grids should appear
     // this call results in a repetition of the header:
-    if(storeOldGrids_) gridfile_.clearFields();
+    if(storeOldGrids_) {
+      gridfile_.clearFields();
+    }
     // in case only latest grid is stored, file should be rewound
     // this will overwrite previously written grids
     else {
       int r = 0;
       if(walkers_mpi_) {
-        if(comm.Get_rank()==0) r=multi_sim_comm.Get_rank();
+        if(comm.Get_rank()==0) {
+          r=multi_sim_comm.Get_rank();
+        }
         comm.Bcast(r,0);
       }
-      if(r==0) gridfile_.rewind();
+      if(r==0) {
+        gridfile_.rewind();
+      }
     }
     BiasGrid_->writeToFile(gridfile_);
     // if a single grid is stored, it is necessary to flush it, otherwise
@@ -2040,14 +2382,18 @@ void MetaD::update()
     // on the other hand, if grids are stored one after the other this is
     // no necessary, and we leave the flushing control to the user as usual
     // (with FLUSH keyword)
-    if(!storeOldGrids_) gridfile_.flush();
+    if(!storeOldGrids_) {
+      gridfile_.flush();
+    }
   }
 
   // if multiple walkers and time to read Gaussians
   if(mw_n_>1 && getStep()%mw_rstride_==0) {
     for(int i=0; i<mw_n_; ++i) {
       // don't read your own Gaussians
-      if(i==mw_id_) continue;
+      if(i==mw_id_) {
+        continue;
+      }
       // if the file is not open yet
       if(!(ifiles_[i]->isOpen())) {
         // check if it exists now and open it!
@@ -2063,12 +2409,16 @@ void MetaD::update()
       }
     }
     // this is to update the hills neighbor list
-    if(nlist_) nlist_update_=true;
+    if(nlist_) {
+      nlist_update_=true;
+    }
   }
 
   // Recalculate special bias quantities whenever the bias has been changed by the update.
   bool bias_has_changed = (nowAddAHill || (mw_n_ > 1 && getStep() % mw_rstride_ == 0));
-  if (calc_rct_ && bias_has_changed && getStep()%(stride_*rct_ustride_)==0) computeReweightingFactor();
+  if (calc_rct_ && bias_has_changed && getStep()%(stride_*rct_ustride_)==0) {
+    computeReweightingFactor();
+  }
   if (calc_max_bias_ && bias_has_changed) {
     max_bias_ = BiasGrid_->getMaxValue();
     getPntrToComponent("maxbias")->set(max_bias_);
@@ -2085,8 +2435,7 @@ void MetaD::update()
 }
 
 /// takes a pointer to the file and a template std::string with values v and gives back the next center, sigma and height
-bool MetaD::scanOneHill(IFile* ifile, std::vector<Value>& tmpvalues, std::vector<double>& center, std::vector<double>& sigma, double& height, bool& multivariate)
-{
+bool MetaD::scanOneHill(IFile* ifile, std::vector<Value>& tmpvalues, std::vector<double>& center, std::vector<double>& sigma, double& height, bool& multivariate) {
   double dummy;
   multivariate=false;
   if(ifile->scanField("time",dummy)) {
@@ -2096,8 +2445,10 @@ bool MetaD::scanOneHill(IFile* ifile, std::vector<Value>& tmpvalues, std::vector
       if( tmpvalues[i].isPeriodic() && ! getPntrToArgument(i)->isPeriodic() ) {
         error("in hills file periodicity for variable " + tmpvalues[i].getName() + " does not match periodicity in input");
       } else if( tmpvalues[i].isPeriodic() ) {
-        std::string imin, imax; tmpvalues[i].getDomain( imin, imax );
-        std::string rmin, rmax; getPntrToArgument(i)->getDomain( rmin, rmax );
+        std::string imin, imax;
+        tmpvalues[i].getDomain( imin, imax );
+        std::string rmin, rmax;
+        getPntrToArgument(i)->getDomain( rmin, rmax );
         if( imin!=rmin || imax!=rmax ) {
           error("in hills file periodicity for variable " + tmpvalues[i].getName() + " does not match periodicity in input");
         }
@@ -2106,7 +2457,9 @@ bool MetaD::scanOneHill(IFile* ifile, std::vector<Value>& tmpvalues, std::vector
     }
     // scan for kerneltype
     std::string ktype="stretched-gaussian";
-    if( ifile->FieldExist("kerneltype") ) ifile->scanField("kerneltype",ktype);
+    if( ifile->FieldExist("kerneltype") ) {
+      ifile->scanField("kerneltype",ktype);
+    }
     if( ktype=="gaussian" ) {
       noStretchWarning();
     } else if( ktype!="stretched-gaussian") {
@@ -2115,9 +2468,13 @@ bool MetaD::scanOneHill(IFile* ifile, std::vector<Value>& tmpvalues, std::vector
     // scan for multivariate label: record the actual file position so to eventually rewind
     std::string sss;
     ifile->scanField("multivariate",sss);
-    if(sss=="true") multivariate=true;
-    else if(sss=="false") multivariate=false;
-    else plumed_merror("cannot parse multivariate = "+ sss);
+    if(sss=="true") {
+      multivariate=true;
+    } else if(sss=="false") {
+      multivariate=false;
+    } else {
+      plumed_merror("cannot parse multivariate = "+ sss);
+    }
     if(multivariate) {
       sigma.resize(ncv*(ncv+1)/2);
       Matrix<double> upper(ncv,ncv);
@@ -2149,9 +2506,15 @@ bool MetaD::scanOneHill(IFile* ifile, std::vector<Value>& tmpvalues, std::vector
 
     ifile->scanField("height",height);
     ifile->scanField("biasf",dummy);
-    if(ifile->FieldExist("clock")) ifile->scanField("clock",dummy);
-    if(ifile->FieldExist("lower_int")) ifile->scanField("lower_int",dummy);
-    if(ifile->FieldExist("upper_int")) ifile->scanField("upper_int",dummy);
+    if(ifile->FieldExist("clock")) {
+      ifile->scanField("clock",dummy);
+    }
+    if(ifile->FieldExist("lower_int")) {
+      ifile->scanField("lower_int",dummy);
+    }
+    if(ifile->FieldExist("upper_int")) {
+      ifile->scanField("upper_int",dummy);
+    }
     ifile->scanField();
     return true;
   } else {
@@ -2159,8 +2522,7 @@ bool MetaD::scanOneHill(IFile* ifile, std::vector<Value>& tmpvalues, std::vector
   }
 }
 
-void MetaD::computeReweightingFactor()
-{
+void MetaD::computeReweightingFactor() {
   if(biasf_==1.0) { // in this case we have no bias, so reweight factor is 0.0
     getPntrToComponent("rct")->set(0.0);
     return;
@@ -2190,8 +2552,7 @@ void MetaD::computeReweightingFactor()
   getPntrToComponent("rct")->set(reweight_factor_);
 }
 
-double MetaD::getTransitionBarrierBias()
-{
+double MetaD::getTransitionBarrierBias() {
   // If there is only one well of interest, return the bias at that well point.
   if (transitionwells_.size() == 1) {
     double tb_bias = getBias(transitionwells_[0]);
@@ -2224,14 +2585,15 @@ double MetaD::getTransitionBarrierBias()
   }
 }
 
-void MetaD::updateFrequencyAdaptiveStride()
-{
+void MetaD::updateFrequencyAdaptiveStride() {
   plumed_massert(freq_adaptive_,"should only be used if frequency adaptive metadynamics is enabled");
   plumed_massert(acceleration_,"frequency adaptive metadynamics can only be used if the acceleration factor is calculated");
   const double mean_acc = acc_/((double) getStep());
   int tmp_stride= stride_*floor((mean_acc/fa_min_acceleration_)+0.5);
   if(mean_acc >= fa_min_acceleration_) {
-    if(tmp_stride > current_stride_) {current_stride_ = tmp_stride;}
+    if(tmp_stride > current_stride_) {
+      current_stride_ = tmp_stride;
+    }
   }
   if(fa_max_stride_!=0 && current_stride_>fa_max_stride_) {
     current_stride_=fa_max_stride_;
@@ -2239,37 +2601,44 @@ void MetaD::updateFrequencyAdaptiveStride()
   getPntrToComponent("pace")->set(current_stride_);
 }
 
-bool MetaD::checkNeedsGradients()const
-{
+bool MetaD::checkNeedsGradients()const {
   if(adaptive_==FlexibleBin::geometry) {
-    if(getStep()%stride_==0 && !isFirstStep_) return true;
-    else return false;
-  } else return false;
+    if(getStep()%stride_==0 && !isFirstStep_) {
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
 }
 
-void MetaD::updateNlist()
-{
+void MetaD::updateNlist() {
   // no need to check for neighbors
-  if(hills_.size()==0) return;
+  if(hills_.size()==0) {
+    return;
+  }
 
   // here we generate the neighbor list
   nlist_hills_.clear();
   std::vector<Gaussian> local_flat_nl;
   unsigned nt=OpenMP::getNumThreads();
-  if(hills_.size()<2*nt) nt=1;
+  if(hills_.size()<2*nt) {
+    nt=1;
+  }
   #pragma omp parallel num_threads(nt)
   {
     std::vector<Gaussian> private_flat_nl;
     #pragma omp for nowait
-    for(unsigned k=0; k<hills_.size(); k++)
-    {
+    for(unsigned k=0; k<hills_.size(); k++) {
       double dist2=0;
-      for(unsigned i=0; i<getNumberOfArguments(); i++)
-      {
+      for(unsigned i=0; i<getNumberOfArguments(); i++) {
         const double d=difference(i,getArgument(i),hills_[k].center[i])/hills_[k].sigma[i];
         dist2+=d*d;
       }
-      if(dist2<=nlist_param_[0]*dp2cutoff) private_flat_nl.push_back(hills_[k]);
+      if(dist2<=nlist_param_[0]*dp2cutoff) {
+        private_flat_nl.push_back(hills_[k]);
+      }
     }
     #pragma omp critical
     local_flat_nl.insert(local_flat_nl.end(), private_flat_nl.begin(), private_flat_nl.end());
@@ -2277,20 +2646,23 @@ void MetaD::updateNlist()
   nlist_hills_ = local_flat_nl;
 
   // here we set some properties that are used to decide when to update it again
-  for(unsigned i=0; i<getNumberOfArguments(); i++) nlist_center_[i]=getArgument(i);
+  for(unsigned i=0; i<getNumberOfArguments(); i++) {
+    nlist_center_[i]=getArgument(i);
+  }
   std::vector<double> dev2;
   dev2.resize(getNumberOfArguments(),0);
-  for(unsigned k=0; k<nlist_hills_.size(); k++)
-  {
-    for(unsigned i=0; i<getNumberOfArguments(); i++)
-    {
+  for(unsigned k=0; k<nlist_hills_.size(); k++) {
+    for(unsigned i=0; i<getNumberOfArguments(); i++) {
       const double d=difference(i,getArgument(i),nlist_hills_[k].center[i]);
       dev2[i]+=d*d;
     }
   }
   for(unsigned i=0; i<getNumberOfArguments(); i++) {
-    if(dev2[i]>0.) nlist_dev2_[i]=dev2[i]/static_cast<double>(nlist_hills_.size());
-    else nlist_dev2_[i]=hills_.back().sigma[i]*hills_.back().sigma[i];
+    if(dev2[i]>0.) {
+      nlist_dev2_[i]=dev2[i]/static_cast<double>(nlist_hills_.size());
+    } else {
+      nlist_dev2_[i]=hills_.back().sigma[i]*hills_.back().sigma[i];
+    }
   }
 
   // we are done
diff --git a/src/bias/MovingRestraint.cpp b/src/bias/MovingRestraint.cpp
index 029dc57005..e6898468a7 100644
--- a/src/bias/MovingRestraint.cpp
+++ b/src/bias/MovingRestraint.cpp
@@ -159,25 +159,33 @@ MovingRestraint::MovingRestraint(const ActionOptions&ao):
   kk(getNumberOfArguments()),
   aa(getNumberOfArguments()),
   f(getNumberOfArguments()),
-  dpotdk(getNumberOfArguments())
-{
+  dpotdk(getNumberOfArguments()) {
   parseVector("VERSE",verse);
-  std::vector<long long int> ss(1); ss[0]=-1;
+  std::vector<long long int> ss(1);
+  ss[0]=-1;
   std::vector<double> kk( getNumberOfArguments() ), aa( getNumberOfArguments() );
   for(int i=0;; i++) {
     // Read in step
-    if( !parseNumberedVector("STEP",i,ss) ) break;
+    if( !parseNumberedVector("STEP",i,ss) ) {
+      break;
+    }
     for(unsigned j=0; j<step.size(); j++) {
-      if(ss[0]<step[j]) error("in moving restraint step number must always increase");
+      if(ss[0]<step[j]) {
+        error("in moving restraint step number must always increase");
+      }
     }
     step.push_back(ss[0]);
 
     // Try to read kappa
-    if( !parseNumberedVector("KAPPA",i,kk) ) kk=kappa[i-1];
+    if( !parseNumberedVector("KAPPA",i,kk) ) {
+      kk=kappa[i-1];
+    }
     kappa.push_back(kk);
 
     // Now read AT
-    if( !parseNumberedVector("AT",i,aa) ) aa=at[i-1];
+    if( !parseNumberedVector("AT",i,aa) ) {
+      aa=at[i-1];
+    }
     at.push_back(aa);
   }
   checkRead();
@@ -185,14 +193,19 @@ MovingRestraint::MovingRestraint(const ActionOptions&ao):
   for(unsigned i=0; i<step.size(); i++) {
     log.printf("  step%u %lld\n",i,step[i]);
     log.printf("  at");
-    for(unsigned j=0; j<at[i].size(); j++) log.printf(" %f",at[i][j]);
+    for(unsigned j=0; j<at[i].size(); j++) {
+      log.printf(" %f",at[i][j]);
+    }
     log.printf("\n");
     log.printf("  with force constant");
-    for(unsigned j=0; j<kappa[i].size(); j++) log.printf(" %f",kappa[i][j]);
+    for(unsigned j=0; j<kappa[i].size(); j++) {
+      log.printf(" %f",kappa[i][j]);
+    }
     log.printf("\n");
   };
 
-  addComponent("force2"); componentIsNotPeriodic("force2");
+  addComponent("force2");
+  componentIsNotPeriodic("force2");
   valueForce2=getPntrToComponent("force2");
 
   // add the centers of the restraint as additional components that can be retrieved (useful for debug)
@@ -200,17 +213,21 @@ MovingRestraint::MovingRestraint(const ActionOptions&ao):
   std::string comp;
   for(unsigned i=0; i< getNumberOfArguments() ; i++) {
     comp=getPntrToArgument(i)->getName()+"_cntr"; // each spring has its own center
-    addComponent(comp); componentIsNotPeriodic(comp);
+    addComponent(comp);
+    componentIsNotPeriodic(comp);
     valueCntr.push_back(getPntrToComponent(comp));
     comp=getPntrToArgument(i)->getName()+"_work"; // each spring has its own work
-    addComponent(comp); componentIsNotPeriodic(comp);
+    addComponent(comp);
+    componentIsNotPeriodic(comp);
     valueWork.push_back(getPntrToComponent(comp));
     comp=getPntrToArgument(i)->getName()+"_kappa"; // each spring has its own kappa
-    addComponent(comp); componentIsNotPeriodic(comp);
+    addComponent(comp);
+    componentIsNotPeriodic(comp);
     valueKappa.push_back(getPntrToComponent(comp));
     work.push_back(0.); // initialize the work value
   }
-  addComponent("work"); componentIsNotPeriodic("work");
+  addComponent("work");
+  componentIsNotPeriodic("work");
   valueTotWork=getPntrToComponent("work");
   tot_work=0.0;
 
@@ -237,10 +254,15 @@ void MovingRestraint::calculate() {
     aa=at[step.size()-1];
   } else {
     unsigned i=0;
-    for(i=1; i<step.size()-1; i++) if(now<step[i]) break;
+    for(i=1; i<step.size()-1; i++)
+      if(now<step[i]) {
+        break;
+      }
     double c2=(now-step[i-1])/double(step[i]-step[i-1]);
     double c1=1.0-c2;
-    for(unsigned j=0; j<narg; j++) kk[j]=(c1*kappa[i-1][j]+c2*kappa[i][j]);
+    for(unsigned j=0; j<narg; j++) {
+      kk[j]=(c1*kappa[i-1][j]+c2*kappa[i][j]);
+    }
     for(unsigned j=0; j<narg; j++) {
       const double a1=at[i-1][j];
       const double a2=at[i][j];
@@ -253,11 +275,17 @@ void MovingRestraint::calculate() {
     valueCntr[i]->set(aa[i]);
     const double k=kk[i];
     f[i]=-k*cv;
-    if(verse[i]=="U" && cv<0) continue;
-    if(verse[i]=="L" && cv>0) continue;
+    if(verse[i]=="U" && cv<0) {
+      continue;
+    }
+    if(verse[i]=="L" && cv>0) {
+      continue;
+    }
     plumed_assert(verse[i]=="U" || verse[i]=="L" || verse[i]=="B");
     dpotdk[i]=0.5*cv*cv;
-    if(oldaa.size()==aa.size() && oldf.size()==f.size()) work[i]+=0.5*(oldf[i]+f[i])*(aa[i]-oldaa[i]) + 0.5*( dpotdk[i]+olddpotdk[i] )*(kk[i]-oldk[i]);
+    if(oldaa.size()==aa.size() && oldf.size()==f.size()) {
+      work[i]+=0.5*(oldf[i]+f[i])*(aa[i]-oldaa[i]) + 0.5*( dpotdk[i]+olddpotdk[i] )*(kk[i]-oldk[i]);
+    }
     valueWork[i]->set(work[i]);
     valueKappa[i]->set(kk[i]);
     tot_work+=work[i];
diff --git a/src/bias/PBMetaD.cpp b/src/bias/PBMetaD.cpp
index 3f7c4b1b8d..0d20a5078a 100644
--- a/src/bias/PBMetaD.cpp
+++ b/src/bias/PBMetaD.cpp
@@ -244,7 +244,12 @@ class PBMetaD : public Bias {
     Gaussian(const std::vector<double> & center,const std::vector<double> & sigma, double height, bool multivariate):
       center(center),sigma(sigma),height(height),multivariate(multivariate),invsigma(sigma) {
       // to avoid troubles from zero element in flexible hills
-        for(unsigned i=0; i<invsigma.size(); ++i) if(std::abs(invsigma[i])>1.e-20) invsigma[i]=1.0/invsigma[i] ; else invsigma[i]=0.0;
+      for(unsigned i=0; i<invsigma.size(); ++i)
+        if(std::abs(invsigma[i])>1.e-20) {
+          invsigma[i]=1.0/invsigma[i] ;
+        } else {
+          invsigma[i]=0.0;
+        }
     }
   };
   // general setup
@@ -380,8 +385,7 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
   pf_n_(0), do_pf_(false),
   mw_n_(1), mw_dir_(""), mw_id_(0), mw_rstride_(1),
   walkers_mpi_(false), mpi_nw_(0),
-  do_select_(false)
-{
+  do_select_(false) {
 
   // parse the flexible hills
   std::string adaptiveoption;
@@ -407,7 +411,9 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
   std::vector<Value*> familyargs;
   for(int i = 0;; i++) {
     parseArgumentList("PF", i, familyargs);
-    if (familyargs.empty()) break;
+    if (familyargs.empty()) {
+      break;
+    }
 
     do_pf_ = true;
     log << "  Identified Partitioned Family " << i << ":";
@@ -446,7 +452,9 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
   } else {
     // If we are doing PF, make sure each argument got assigned to a family.
     for (unsigned i = 0; i < getNumberOfArguments(); i++) {
-      if (pfs_[i] == -1) error(getPntrToArgument(i)->getName() + " was not assigned a PF");
+      if (pfs_[i] == -1) {
+        error(getPntrToArgument(i)->getName() + " was not assigned a PF");
+      }
     }
   }
 
@@ -475,7 +483,9 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
       error("the number of SIGMA_MIN values be the same of the number of the arguments/PF");
     } else if(sigma0min_.size()==0) {
       sigma0min_.resize(pf_n_);
-      for(unsigned i=0; i<pf_n_; i++) {sigma0min_[i]=-1.;}
+      for(unsigned i=0; i<pf_n_; i++) {
+        sigma0min_[i]=-1.;
+      }
     }
 
     parseVector("SIGMA_MAX",sigma0max_);
@@ -483,7 +493,9 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
       error("the number of SIGMA_MAX values be the same of the number of the arguments/PF");
     } else if(sigma0max_.size()==0) {
       sigma0max_.resize(pf_n_);
-      for(unsigned i=0; i<pf_n_; i++) {sigma0max_[i]=-1.;}
+      for(unsigned i=0; i<pf_n_; i++) {
+        sigma0max_[i]=-1.;
+      }
     }
 
     for(unsigned i=0; i<pf_n_; i++) {
@@ -497,7 +509,9 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
   // note: HEIGHT is not compulsory, since one could use the TAU keyword, see below
   parse("HEIGHT",height0_);
   parse("PACE",stride_);
-  if(stride_<=0) error("frequency for hill addition is nonsensical");
+  if(stride_<=0) {
+    error("frequency for hill addition is nonsensical");
+  }
 
 
   parseVector("FILE",hillsfname_);
@@ -512,21 +526,33 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
   }
 
   parse("BIASFACTOR",biasf_);
-  if( biasf_<1.0 ) error("well tempered bias factor is nonsensical");
+  if( biasf_<1.0 ) {
+    error("well tempered bias factor is nonsensical");
+  }
   kbt_=getkBT();
   if(biasf_>1.0) {
-    if(kbt_==0.0) error("Unless the MD engine passes the temperature to plumed, with well-tempered metad you must specify it using TEMP");
+    if(kbt_==0.0) {
+      error("Unless the MD engine passes the temperature to plumed, with well-tempered metad you must specify it using TEMP");
+    }
     welltemp_=true;
   }
   double tau=0.0;
   parse("TAU",tau);
   if(tau==0.0) {
-    if(height0_==std::numeric_limits<double>::max()) error("At least one between HEIGHT and TAU should be specified");
+    if(height0_==std::numeric_limits<double>::max()) {
+      error("At least one between HEIGHT and TAU should be specified");
+    }
     // if tau is not set, we compute it here from the other input parameters
-    if(welltemp_) tau=(kbt_*(biasf_-1.0))/height0_*getTimeStep()*stride_;
+    if(welltemp_) {
+      tau=(kbt_*(biasf_-1.0))/height0_*getTimeStep()*stride_;
+    }
   } else {
-    if(!welltemp_)error("TAU only makes sense in well-tempered metadynamics");
-    if(height0_!=std::numeric_limits<double>::max()) error("At most one between HEIGHT and TAU should be specified");
+    if(!welltemp_) {
+      error("TAU only makes sense in well-tempered metadynamics");
+    }
+    if(height0_!=std::numeric_limits<double>::max()) {
+      error("At most one between HEIGHT and TAU should be specified");
+    }
     height0_=(kbt_*(biasf_-1.0))/tau*getTimeStep()*stride_;
   }
 
@@ -534,7 +560,9 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
   // Multiple walkers
   parse("WALKERS_N",mw_n_);
   parse("WALKERS_ID",mw_id_);
-  if(mw_n_<=mw_id_) error("walker ID should be a numerical value less than the total number of walkers");
+  if(mw_n_<=mw_id_) {
+    error("walker ID should be a numerical value less than the total number of walkers");
+  }
   parse("WALKERS_DIR",mw_dir_);
   parse("WALKERS_RSTRIDE",mw_rstride_);
 
@@ -554,8 +582,9 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
       gridfilenames_.push_back(name);
     }
   }
-  if(gridfilenames_.size() > 0 && hillsfname_.size() > 0 && gridfilenames_.size() != hillsfname_.size())
+  if(gridfilenames_.size() > 0 && hillsfname_.size() > 0 && gridfilenames_.size() != hillsfname_.size()) {
     error("number of GRID_WFILES arguments does not match number of HILLS files");
+  }
 
   // Read grid
   std::vector<std::string> gridreadfilenames_;
@@ -564,32 +593,53 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
   // Grid Stuff
   std::vector<std::string> gmin(pf_n_);
   parseVector("GRID_MIN",gmin);
-  if(gmin.size()!=pf_n_ && gmin.size()!=0) error("not enough values for GRID_MIN");
+  if(gmin.size()!=pf_n_ && gmin.size()!=0) {
+    error("not enough values for GRID_MIN");
+  }
   std::vector<std::string> gmax(pf_n_);
   parseVector("GRID_MAX",gmax);
-  if(gmax.size()!=pf_n_ && gmax.size()!=0) error("not enough values for GRID_MAX");
+  if(gmax.size()!=pf_n_ && gmax.size()!=0) {
+    error("not enough values for GRID_MAX");
+  }
   std::vector<unsigned> gbin(pf_n_);
   std::vector<double>   gspacing;
   parseVector("GRID_BIN",gbin);
-  if(gbin.size()!=pf_n_ && gbin.size()!=0) error("not enough values for GRID_BIN");
+  if(gbin.size()!=pf_n_ && gbin.size()!=0) {
+    error("not enough values for GRID_BIN");
+  }
   parseVector("GRID_SPACING",gspacing);
-  if(gspacing.size()!=pf_n_ && gspacing.size()!=0) error("not enough values for GRID_SPACING");
-  if(gmin.size()!=gmax.size()) error("GRID_MAX and GRID_MIN should be either present or absent");
-  if(gspacing.size()!=0 && gmin.size()==0) error("If GRID_SPACING is present also GRID_MIN and GRID_MAX should be present");
-  if(gbin.size()!=0     && gmin.size()==0) error("If GRID_BIN is present also GRID_MIN and GRID_MAX should be present");
+  if(gspacing.size()!=pf_n_ && gspacing.size()!=0) {
+    error("not enough values for GRID_SPACING");
+  }
+  if(gmin.size()!=gmax.size()) {
+    error("GRID_MAX and GRID_MIN should be either present or absent");
+  }
+  if(gspacing.size()!=0 && gmin.size()==0) {
+    error("If GRID_SPACING is present also GRID_MIN and GRID_MAX should be present");
+  }
+  if(gbin.size()!=0     && gmin.size()==0) {
+    error("If GRID_BIN is present also GRID_MIN and GRID_MAX should be present");
+  }
   if(gmin.size()!=0) {
     if(gbin.size()==0 && gspacing.size()==0) {
       if(adaptive_==FlexibleBin::none) {
         log<<"  Binsize not specified, 1/5 of sigma will be be used\n";
         plumed_assert(sigma0_.size()==pf_n_);
         gspacing.resize(pf_n_);
-        for(unsigned i=0; i<gspacing.size(); i++) gspacing[i]=0.2*sigma0_[i];
+        for(unsigned i=0; i<gspacing.size(); i++) {
+          gspacing[i]=0.2*sigma0_[i];
+        }
       } else {
         // with adaptive hills and grid a sigma min must be specified
-        for(unsigned i=0; i<sigma0min_.size(); i++) if(sigma0min_[i]<=0) error("When using ADAPTIVE Gaussians on a grid SIGMA_MIN must be specified");
+        for(unsigned i=0; i<sigma0min_.size(); i++)
+          if(sigma0min_[i]<=0) {
+            error("When using ADAPTIVE Gaussians on a grid SIGMA_MIN must be specified");
+          }
         log<<"  Binsize not specified, 1/5 of sigma_min will be be used\n";
         gspacing.resize(pf_n_);
-        for(unsigned i=0; i<gspacing.size(); i++) gspacing[i]=0.2*sigma0min_[i];
+        for(unsigned i=0; i<gspacing.size(); i++) {
+          gspacing[i]=0.2*sigma0min_[i];
+        }
       }
     } else if(gspacing.size()!=0 && gbin.size()==0) {
       log<<"  The number of bins will be estimated from GRID_SPACING\n";
@@ -597,36 +647,56 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
       log<<"  You specified both GRID_BIN and GRID_SPACING\n";
       log<<"  The more conservative (highest) number of bins will be used for each variable\n";
     }
-    if(gbin.size()==0) gbin.assign(pf_n_,1);
-    if(gspacing.size()!=0) for(unsigned i=0; i<pf_n_; i++) {
+    if(gbin.size()==0) {
+      gbin.assign(pf_n_,1);
+    }
+    if(gspacing.size()!=0)
+      for(unsigned i=0; i<pf_n_; i++) {
         double a,b;
         Tools::convert(gmin[i],a);
         Tools::convert(gmax[i],b);
         unsigned n=std::ceil(((b-a)/gspacing[i]));
-        if(gbin[i]<n) gbin[i]=n;
+        if(gbin[i]<n) {
+          gbin[i]=n;
+        }
       }
   }
-  if(gbin.size()>0) grid_=true;
+  if(gbin.size()>0) {
+    grid_=true;
+  }
 
   bool sparsegrid=false;
   parseFlag("GRID_SPARSE",sparsegrid);
   bool nospline=false;
   parseFlag("GRID_NOSPLINE",nospline);
   bool spline=!nospline;
-  if(!grid_&&gridfilenames_.size() > 0) error("To write a grid you need first to define it!");
-  if(!grid_&&gridreadfilenames_.size() > 0) error("To read a grid you need first to define it!");
+  if(!grid_&&gridfilenames_.size() > 0) {
+    error("To write a grid you need first to define it!");
+  }
+  if(!grid_&&gridreadfilenames_.size() > 0) {
+    error("To read a grid you need first to define it!");
+  }
 
   doInt_.resize(pf_n_,false);
   // Interval keyword
   parseVector("INTERVAL_MIN",lowI_);
   parseVector("INTERVAL_MAX",uppI_);
   // various checks
-  if(lowI_.size()!=uppI_.size()) error("both a lower and an upper limits must be provided with INTERVAL");
-  if(lowI_.size()!=0 && lowI_.size()!=pf_n_) error("check number of argument of INTERVAL");
+  if(lowI_.size()!=uppI_.size()) {
+    error("both a lower and an upper limits must be provided with INTERVAL");
+  }
+  if(lowI_.size()!=0 && lowI_.size()!=pf_n_) {
+    error("check number of argument of INTERVAL");
+  }
   for(unsigned i=0; i<lowI_.size(); ++i) {
-    if(uppI_[i]<lowI_[i]) error("The Upper limit must be greater than the Lower limit!");
-    if(pfhold_[i]->isPeriodic()) warning("INTERVAL is not used for periodic variables");
-    else doInt_[i]=true;
+    if(uppI_[i]<lowI_[i]) {
+      error("The Upper limit must be greater than the Lower limit!");
+    }
+    if(pfhold_[i]->isPeriodic()) {
+      warning("INTERVAL is not used for periodic variables");
+    } else {
+      doInt_[i]=true;
+    }
   }
 
   // parse selector stuff
@@ -639,13 +709,21 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
   checkRead();
 
   log.printf("  Gaussian width ");
-  if (adaptive_==FlexibleBin::diffusion)log.printf(" (Note: The units of sigma are in timesteps) ");
-  if (adaptive_==FlexibleBin::geometry)log.printf(" (Note: The units of sigma are in dist units) ");
-  for(unsigned i=0; i<sigma0_.size(); ++i) log.printf(" %f",sigma0_[i]);
+  if (adaptive_==FlexibleBin::diffusion) {
+    log.printf(" (Note: The units of sigma are in timesteps) ");
+  }
+  if (adaptive_==FlexibleBin::geometry) {
+    log.printf(" (Note: The units of sigma are in dist units) ");
+  }
+  for(unsigned i=0; i<sigma0_.size(); ++i) {
+    log.printf(" %f",sigma0_[i]);
+  }
   log.printf("  Gaussian height %f\n",height0_);
   log.printf("  Gaussian deposition pace %d\n",stride_);
   log.printf("  Gaussian files ");
-  for(unsigned i=0; i<hillsfname_.size(); ++i) log.printf("%s ",hillsfname_[i].c_str());
+  for(unsigned i=0; i<hillsfname_.size(); ++i) {
+    log.printf("%s ",hillsfname_[i].c_str());
+  }
   log.printf("\n");
   if(welltemp_) {
     log.printf("  Well-Tempered Bias Factor %f\n",biasf_);
@@ -659,15 +737,21 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
   }
 
   if(mw_n_>1) {
-    if(walkers_mpi_) error("MPI version of multiple walkers is not compatible with filesystem version of multiple walkers");
+    if(walkers_mpi_) {
+      error("MPI version of multiple walkers is not compatible with filesystem version of multiple walkers");
+    }
     log.printf("  %d multiple walkers active\n",mw_n_);
     log.printf("  walker id %d\n",mw_id_);
     log.printf("  reading stride %d\n",mw_rstride_);
-    if(mw_dir_!="")log.printf("  directory with hills files %s\n",mw_dir_.c_str());
+    if(mw_dir_!="") {
+      log.printf("  directory with hills files %s\n",mw_dir_.c_str());
+    }
   } else {
     if(walkers_mpi_) {
       log.printf("  Multiple walkers active using MPI communnication\n");
-      if(mw_dir_!="")log.printf("  directory with hills files %s\n",mw_dir_.c_str());
+      if(mw_dir_!="") {
+        log.printf("  directory with hills files %s\n",mw_dir_.c_str());
+      }
       if(comm.Get_rank()==0) {
         // Only root of group can communicate with other walkers
         mpi_nw_ = multi_sim_comm.Get_size();
@@ -681,20 +765,32 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
   }
 
   for(unsigned i=0; i<doInt_.size(); i++) {
-    if(doInt_[i]) log.printf("  Upper and Lower limits boundaries for the bias of CV %u are activated\n", i);
+    if(doInt_[i]) {
+      log.printf("  Upper and Lower limits boundaries for the bias of CV %u are activated\n", i);
+    }
   }
   if(grid_) {
     log.printf("  Grid min");
-    for(unsigned i=0; i<gmin.size(); ++i) log.printf(" %s",gmin[i].c_str() );
+    for(unsigned i=0; i<gmin.size(); ++i) {
+      log.printf(" %s",gmin[i].c_str() );
+    }
     log.printf("\n");
     log.printf("  Grid max");
-    for(unsigned i=0; i<gmax.size(); ++i) log.printf(" %s",gmax[i].c_str() );
+    for(unsigned i=0; i<gmax.size(); ++i) {
+      log.printf(" %s",gmax[i].c_str() );
+    }
     log.printf("\n");
     log.printf("  Grid bin");
-    for(unsigned i=0; i<gbin.size(); ++i) log.printf(" %u",gbin[i]);
+    for(unsigned i=0; i<gbin.size(); ++i) {
+      log.printf(" %u",gbin[i]);
+    }
     log.printf("\n");
-    if(spline) {log.printf("  Grid uses spline interpolation\n");}
-    if(sparsegrid) {log.printf("  Grid uses sparse grid\n");}
+    if(spline) {
+      log.printf("  Grid uses spline interpolation\n");
+    }
+    if(sparsegrid) {
+      log.printf("  Grid uses sparse grid\n");
+    }
     if(wgridstride_>0) {
       for(unsigned i=0; i<gridfilenames_.size(); ++i) {
         log.printf("  Grid is written on file %s with stride %d\n",gridfilenames_[i].c_str(),wgridstride_);
@@ -723,9 +819,13 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
       Tools::convert(gmax[family],b);
       double mesh=(b-a)/((double)gbin[family]);
       if(adaptive_==FlexibleBin::none) {
-        if(mesh>0.5*sigma0_[i]) log<<"  WARNING: Using a PBMETAD with a Grid Spacing larger than half of the Gaussians width can produce artifacts\n";
+        if(mesh>0.5*sigma0_[i]) {
+          log<<"  WARNING: Using a PBMETAD with a Grid Spacing larger than half of the Gaussians width can produce artifacts\n";
+        }
       } else {
-        if(mesh>0.5*sigma0min_[i]||sigma0min_[i]<0.) log<<"  WARNING: to use a PBMETAD with a GRID and ADAPTIVE you need to set a Grid Spacing larger than half of the Gaussians \n";
+        if(mesh>0.5*sigma0min_[i]||sigma0min_[i]<0.) {
+          log<<"  WARNING: to use a PBMETAD with a GRID and ADAPTIVE you need to set a Grid Spacing larger than half of the Gaussians \n";
+        }
       }
     }
     std::string funcl=getLabel() + ".bias";
@@ -757,16 +857,25 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
           error("periodicity mismatch between arguments and input bias");
         }
         log.printf("  Restarting from %s:\n",gridreadfilenames_[i].c_str());
-        if(getRestart()) restartedFromGrid=true;
+        if(getRestart()) {
+          restartedFromGrid=true;
+        }
       } else {
-        if(!sparsegrid) {BiasGrid_=Tools::make_unique<Grid>(funcl,args,gmin_t,gmax_t,gbin_t,spline,true);}
-        else           {BiasGrid_=Tools::make_unique<SparseGrid>(funcl,args,gmin_t,gmax_t,gbin_t,spline,true);}
+        if(!sparsegrid) {
+          BiasGrid_=Tools::make_unique<Grid>(funcl,args,gmin_t,gmax_t,gbin_t,spline,true);
+        } else           {
+          BiasGrid_=Tools::make_unique<SparseGrid>(funcl,args,gmin_t,gmax_t,gbin_t,spline,true);
+        }
         std::vector<std::string> actualmin=BiasGrid_->getMin();
         std::vector<std::string> actualmax=BiasGrid_->getMax();
         std::string is;
         Tools::convert(i,is);
-        if(gmin_t[0]!=actualmin[0]) error("GRID_MIN["+is+"] must be adjusted to "+actualmin[0]+" to fit periodicity");
-        if(gmax_t[0]!=actualmax[0]) error("GRID_MAX["+is+"] must be adjusted to "+actualmax[0]+" to fit periodicity");
+        if(gmin_t[0]!=actualmin[0]) {
+          error("GRID_MIN["+is+"] must be adjusted to "+actualmin[0]+" to fit periodicity");
+        }
+        if(gmax_t[0]!=actualmax[0]) {
+          error("GRID_MAX["+is+"] must be adjusted to "+actualmax[0]+" to fit periodicity");
+        }
       }
       BiasGrids_.emplace_back(std::move(BiasGrid_));
     }
@@ -783,7 +892,8 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
       std::string fname;
       if(mw_dir_!="") {
         if(mw_n_>1) {
-          std::stringstream out; out << j;
+          std::stringstream out;
+          out << j;
           fname = mw_dir_+"/"+hillsfname_[i]+"."+out.str();
         } else if(walkers_mpi_) {
           fname = mw_dir_+"/"+hillsfname_[i];
@@ -792,7 +902,8 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
         }
       } else {
         if(mw_n_>1) {
-          std::stringstream out; out << j;
+          std::stringstream out;
+          out << j;
           fname = hillsfname_[i]+"."+out.str();
         } else {
           fname = hillsfname_[i];
@@ -811,16 +922,22 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
         }
         ifiles_[k]->reset(false);
         // close only the walker own hills file for later writing
-        if(j==mw_id_) ifiles_[k]->close();
+        if(j==mw_id_) {
+          ifiles_[k]->close();
+        }
       } else {
         // in case a file does not exist and we are restarting, complain that the file was not found
-        if(getRestart()) log<<"  WARNING: restart file "<<fname<<" not found\n";
+        if(getRestart()) {
+          log<<"  WARNING: restart file "<<fname<<" not found\n";
+        }
       }
     }
   }
 
   comm.Barrier();
-  if(comm.Get_rank()==0 && walkers_mpi_) multi_sim_comm.Barrier();
+  if(comm.Get_rank()==0 && walkers_mpi_) {
+    multi_sim_comm.Barrier();
+  }
 
   // open hills files for writing
   for(unsigned i=0; i<hillsfname_.size(); ++i) {
@@ -829,14 +946,22 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
     // if MPI multiple walkers, only rank 0 will write to file
     if(walkers_mpi_) {
       int r=0;
-      if(comm.Get_rank()==0) r=multi_sim_comm.Get_rank();
+      if(comm.Get_rank()==0) {
+        r=multi_sim_comm.Get_rank();
+      }
       comm.Bcast(r,0);
-      if(r>0) ifilesnames_[mw_id_*hillsfname_.size()+i]="/dev/null";
+      if(r>0) {
+        ifilesnames_[mw_id_*hillsfname_.size()+i]="/dev/null";
+      }
+      ofile->enforceSuffix("");
+    }
+    if(mw_n_>1) {
       ofile->enforceSuffix("");
     }
-    if(mw_n_>1) ofile->enforceSuffix("");
     ofile->open(ifilesnames_[mw_id_*hillsfname_.size()+i]);
-    if(fmt_.length()>0) ofile->fmtField(fmt_);
+    if(fmt_.length()>0) {
+      ofile->fmtField(fmt_);
+    }
     ofile->addConstantField("multivariate");
     ofile->addConstantField("kerneltype");
     if(doInt_[i]) {
@@ -867,7 +992,9 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
         }
         ofile->enforceSuffix("");
       }
-      if(mw_n_>1) ofile->enforceSuffix("");
+      if(mw_n_>1) {
+        ofile->enforceSuffix("");
+      }
       ofile->open(gridfname_tmp);
       ofile->setHeavyFlush();
       gridfiles_.emplace_back(std::move(ofile));
@@ -875,20 +1002,24 @@ PBMetaD::PBMetaD(const ActionOptions& ao):
   }
 
   log<<"  Bibliography "<<plumed.cite("Pfaendtner and Bonomi. J. Chem. Theory Comput. 11, 5062 (2015)");
-  if(doInt_[0]) log<<plumed.cite(
-                       "Baftizadeh, Cossio, Pietrucci, and Laio, Curr. Phys. Chem. 2, 79 (2012)");
-  if(mw_n_>1||walkers_mpi_) log<<plumed.cite(
-                                   "Raiteri, Laio, Gervasio, Micheletti, and Parrinello, J. Phys. Chem. B 110, 3533 (2006)");
-  if(adaptive_!=FlexibleBin::none) log<<plumed.cite(
-                                          "Branduardi, Bussi, and Parrinello, J. Chem. Theory Comput. 8, 2247 (2012)");
-  if (do_pf_) log<<plumed.cite("Prakash, Fu, Bonomi, and Pfaendtner, J. Chem. Theory Comput. 14, 4985 (2018)");
+  if(doInt_[0])
+    log<<plumed.cite(
+         "Baftizadeh, Cossio, Pietrucci, and Laio, Curr. Phys. Chem. 2, 79 (2012)");
+  if(mw_n_>1||walkers_mpi_)
+    log<<plumed.cite(
+         "Raiteri, Laio, Gervasio, Micheletti, and Parrinello, J. Phys. Chem. B 110, 3533 (2006)");
+  if(adaptive_!=FlexibleBin::none)
+    log<<plumed.cite(
+         "Branduardi, Bussi, and Parrinello, J. Chem. Theory Comput. 8, 2247 (2012)");
+  if (do_pf_) {
+    log<<plumed.cite("Prakash, Fu, Bonomi, and Pfaendtner, J. Chem. Theory Comput. 14, 4985 (2018)");
+  }
   log<<"\n";
 
 
 }
 
-void PBMetaD::readGaussians(unsigned iarg, IFile *ifile)
-{
+void PBMetaD::readGaussians(unsigned iarg, IFile *ifile) {
   std::vector<double> center(1);
   std::vector<double> sigma(1);
   double height;
@@ -902,14 +1033,15 @@ void PBMetaD::readGaussians(unsigned iarg, IFile *ifile)
   while(scanOneHill(iarg,ifile,tmpvalues,center,sigma,height,multivariate)) {
     ;
     nhills++;
-    if(welltemp_) {height*=(biasf_-1.0)/biasf_;}
+    if(welltemp_) {
+      height*=(biasf_-1.0)/biasf_;
+    }
     addGaussian(family, Gaussian(center,sigma,height,multivariate));
   }
   log.printf("      %d Gaussians read\n",nhills);
 }
 
-void PBMetaD::writeGaussian(unsigned iarg, const Gaussian& hill, OFile *ofile)
-{
+void PBMetaD::writeGaussian(unsigned iarg, const Gaussian& hill, OFile *ofile) {
   int family=pfs_[iarg];
   ofile->printField("time",getTimeStep()*getStep());
   ofile->printField(pfhold_[family],hill.center[0]);
@@ -925,17 +1057,21 @@ void PBMetaD::writeGaussian(unsigned iarg, const Gaussian& hill, OFile *ofile)
     ofile->printField("sigma_"+pfhold_[family]->getName(),hill.sigma[0]);
   }
   double height=hill.height;
-  if(welltemp_) height *= biasf_/(biasf_-1.0);
+  if(welltemp_) {
+    height *= biasf_/(biasf_-1.0);
+  }
   ofile->printField("height",height);
   ofile->printField("biasf",biasf_);
-  if(mw_n_>1) ofile->printField("clock",int(std::time(0)));
+  if(mw_n_>1) {
+    ofile->printField("clock",int(std::time(0)));
+  }
   ofile->printField();
 }
 
-void PBMetaD::addGaussian(unsigned iarg, const Gaussian& hill)
-{
-  if(!grid_) {hills_[iarg].push_back(hill);}
-  else {
+void PBMetaD::addGaussian(unsigned iarg, const Gaussian& hill) {
+  if(!grid_) {
+    hills_[iarg].push_back(hill);
+  } else {
     std::vector<unsigned> nneighb=getGaussianSupport(iarg, hill);
     std::vector<Grid::index_t> neighbors=BiasGrids_[iarg]->getNeighbors(hill.center,nneighb);
     std::vector<double> der(1);
@@ -969,8 +1105,7 @@ void PBMetaD::addGaussian(unsigned iarg, const Gaussian& hill)
   }
 }
 
-std::vector<unsigned> PBMetaD::getGaussianSupport(unsigned iarg, const Gaussian& hill)
-{
+std::vector<unsigned> PBMetaD::getGaussianSupport(unsigned iarg, const Gaussian& hill) {
   std::vector<unsigned> nneigh;
   double cutoff;
   if(hill.multivariate) {
@@ -995,8 +1130,7 @@ std::vector<unsigned> PBMetaD::getGaussianSupport(unsigned iarg, const Gaussian&
   return nneigh;
 }
 
-double PBMetaD::getBiasAndDerivatives(unsigned iarg, const std::vector<double>& cv, double* der)
-{
+double PBMetaD::getBiasAndDerivatives(unsigned iarg, const std::vector<double>& cv, double* der) {
   double bias=0.0;
   int family = pfs_[iarg];
   if(!grid_) {
@@ -1006,7 +1140,9 @@ double PBMetaD::getBiasAndDerivatives(unsigned iarg, const std::vector<double>&
       bias += evaluateGaussian(iarg,cv,hills_[family][i],der);
     }
     comm.Sum(bias);
-    if(der) comm.Sum(der,1);
+    if(der) {
+      comm.Sum(der,1);
+    }
   } else {
     if(der) {
       std::vector<double> vder(1);
@@ -1020,8 +1156,7 @@ double PBMetaD::getBiasAndDerivatives(unsigned iarg, const std::vector<double>&
   return bias;
 }
 
-double PBMetaD::evaluateGaussian(unsigned iarg, const std::vector<double>& cv, const Gaussian& hill, double* der)
-{
+double PBMetaD::evaluateGaussian(unsigned iarg, const std::vector<double>& cv, const Gaussian& hill, double* der) {
   double bias=0.0;
 // I use a pointer here because cv is const (and should be const)
 // but when using doInt it is easier to locally replace cv[0] with
@@ -1031,8 +1166,13 @@ double PBMetaD::evaluateGaussian(unsigned iarg, const std::vector<double>& cv, c
   tmpcv[0]=cv[0];
   bool isOutOfInt = false;
   if(doInt_[iarg]) {
-    if(cv[0]<lowI_[iarg]) { tmpcv[0]=lowI_[iarg]; isOutOfInt = true; }
-    else if(cv[0]>uppI_[iarg]) { tmpcv[0]=uppI_[iarg]; isOutOfInt = true; }
+    if(cv[0]<lowI_[iarg]) {
+      tmpcv[0]=lowI_[iarg];
+      isOutOfInt = true;
+    } else if(cv[0]>uppI_[iarg]) {
+      tmpcv[0]=uppI_[iarg];
+      isOutOfInt = true;
+    }
   }
   pcv=&(tmpcv[0]);
 
@@ -1061,11 +1201,12 @@ double PBMetaD::evaluateGaussian(unsigned iarg, const std::vector<double>& cv, c
   return bias;
 }
 
-void PBMetaD::calculate()
-{
+void PBMetaD::calculate() {
   // this is because presently there is no way to properly pass information
   // on adaptive hills (diff) after exchanges:
-  if(adaptive_==FlexibleBin::diffusion && getExchangeStep()) error("ADAPTIVE=DIFF is not compatible with replica exchange");
+  if(adaptive_==FlexibleBin::diffusion && getExchangeStep()) {
+    error("ADAPTIVE=DIFF is not compatible with replica exchange");
+  }
 
   std::vector<double> cv(1);
   double der[1];
@@ -1079,7 +1220,9 @@ void PBMetaD::calculate()
     der[0]   = 0.0;
     bias[i]  = getBiasAndDerivatives(i, cv, der);
     deriv[i] = der[0];
-    if(bias[i] < bmin) bmin = bias[i];
+    if(bias[i] < bmin) {
+      bmin = bias[i];
+    }
   }
   double ene = 0.;
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
@@ -1087,7 +1230,9 @@ void PBMetaD::calculate()
   }
 
   // set Forces - set them to zero if SELECTOR is active
-  if(do_select_) current_value_ = static_cast<unsigned>(plumed.passMap[selector_]);
+  if(do_select_) {
+    current_value_ = static_cast<unsigned>(plumed.passMap[selector_]);
+  }
 
   if(!do_select_ || select_value_==current_value_) {
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
@@ -1097,7 +1242,9 @@ void PBMetaD::calculate()
   }
 
   if(do_select_ && select_value_!=current_value_) {
-    for(unsigned i=0; i<getNumberOfArguments(); ++i) setOutputForce(i, 0.0);
+    for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+      setOutputForce(i, 0.0);
+    }
   }
 
   // set bias
@@ -1105,20 +1252,22 @@ void PBMetaD::calculate()
   setBias(ene);
 }
 
-void PBMetaD::update()
-{
+void PBMetaD::update() {
   bool multivariate;
   // adding hills criteria
   bool nowAddAHill;
-  if(getStep()%stride_==0 && !isFirstStep_) nowAddAHill=true;
-  else {
+  if(getStep()%stride_==0 && !isFirstStep_) {
+    nowAddAHill=true;
+  } else {
     nowAddAHill=false;
     isFirstStep_=false;
   }
 
   // if you use adaptive, call the FlexibleBin
   if(adaptive_!=FlexibleBin::none) {
-    for(unsigned i=0; i<getNumberOfArguments(); i++) flexbin_[i].update(nowAddAHill,i);
+    for(unsigned i=0; i<getNumberOfArguments(); i++) {
+      flexbin_[i].update(nowAddAHill,i);
+    }
     multivariate=true;
   } else {
     multivariate=false;
@@ -1137,12 +1286,17 @@ void PBMetaD::update()
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
       int family=pfs_[i];
       // get flex/sigmas for each family and assign them to this args sigma
-      if(adaptive_!=FlexibleBin::none) thissigma[i]=flexbin_[family].getInverseMatrix(i)[0];
-      else thissigma[i]=sigma0_[family];
+      if(adaptive_!=FlexibleBin::none) {
+        thissigma[i]=flexbin_[family].getInverseMatrix(i)[0];
+      } else {
+        thissigma[i]=sigma0_[family];
+      }
       cv[i]     = getArgument(i);
       cv_tmp[0] = getArgument(i);
       bias[i] = getBiasAndDerivatives(i, cv_tmp);
-      if(bias[i] < bmin) bmin = bias[i];
+      if(bias[i] < bmin) {
+        bmin = bias[i];
+      }
     }
     // calculate heights and norm
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
@@ -1153,7 +1307,9 @@ void PBMetaD::update()
     // normalize and apply welltemp correction
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
       height[i] *=  height0_ / norm;
-      if(welltemp_) height[i] *= std::exp(-bias[i]/(kbt_*(biasf_-1.0)));
+      if(welltemp_) {
+        height[i] *= std::exp(-bias[i]/(kbt_*(biasf_-1.0)));
+      }
     }
 
     // MPI Multiple walkers: share hills and add them all
@@ -1198,8 +1354,11 @@ void PBMetaD::update()
         // Add CVs of same family together and write to same file
         int family = pfs_[i];
         cv_tmp[0] = cv[i];
-        if(adaptive_!=FlexibleBin::none) sigma_tmp[0]=thissigma[i];
-        else sigma_tmp[0] = sigma0_[family];
+        if(adaptive_!=FlexibleBin::none) {
+          sigma_tmp[0]=thissigma[i];
+        } else {
+          sigma_tmp[0] = sigma0_[family];
+        }
         Gaussian newhill = Gaussian(cv_tmp, sigma_tmp, height[i], multivariate);
         addGaussian(family, newhill);
         writeGaussian(i, newhill, hillsOfiles_[family].get());
@@ -1211,7 +1370,9 @@ void PBMetaD::update()
   if(wgridstride_>0 && (getStep()%wgridstride_==0 || getCPT())) {
     int r = 0;
     if(walkers_mpi_) {
-      if(comm.Get_rank()==0) r=multi_sim_comm.Get_rank();
+      if(comm.Get_rank()==0) {
+        r=multi_sim_comm.Get_rank();
+      }
       comm.Bcast(r,0);
     }
     if(r==0) {
@@ -1229,7 +1390,9 @@ void PBMetaD::update()
       for(unsigned i=0; i<hillsfname_.size(); ++i) {
         unsigned k=j*hillsfname_.size()+i;
         // don't read your own Gaussians
-        if(j==mw_id_) continue;
+        if(j==mw_id_) {
+          continue;
+        }
         // if the file is not open yet
         if(!(ifiles_[k]->isOpen())) {
           // check if it exists now and open it!
@@ -1250,8 +1413,7 @@ void PBMetaD::update()
 }
 
 /// takes a pointer to the file and a template string with values v and gives back the next center, sigma and height
-bool PBMetaD::scanOneHill(unsigned iarg, IFile *ifile, std::vector<Value> &tmpvalues, std::vector<double> &center, std::vector<double> &sigma, double &height, bool &multivariate)
-{
+bool PBMetaD::scanOneHill(unsigned iarg, IFile *ifile, std::vector<Value> &tmpvalues, std::vector<double> &center, std::vector<double> &sigma, double &height, bool &multivariate) {
   double dummy;
   multivariate=false;
   Value* argPtr = pfhold_[pfs_[iarg]];
@@ -1260,15 +1422,19 @@ bool PBMetaD::scanOneHill(unsigned iarg, IFile *ifile, std::vector<Value> &tmpva
     if( tmpvalues[0].isPeriodic() && ! argPtr->isPeriodic() ) {
       error("in hills file periodicity for variable " + tmpvalues[0].getName() + " does not match periodicity in input");
     } else if( tmpvalues[0].isPeriodic() ) {
-      std::string imin, imax; tmpvalues[0].getDomain( imin, imax );
-      std::string rmin, rmax; argPtr->getDomain( rmin, rmax );
+      std::string imin, imax;
+      tmpvalues[0].getDomain( imin, imax );
+      std::string rmin, rmax;
+      argPtr->getDomain( rmin, rmax );
       if( imin!=rmin || imax!=rmax ) {
         error("in hills file periodicity for variable " + tmpvalues[0].getName() + " does not match periodicity in input");
       }
     }
     center[0]=tmpvalues[0].get();
     std::string ktype="stretched-gaussian";
-    if( ifile->FieldExist("kerneltype") ) ifile->scanField("kerneltype",ktype);
+    if( ifile->FieldExist("kerneltype") ) {
+      ifile->scanField("kerneltype",ktype);
+    }
 
     if( ktype=="gaussian" ) {
       noStretchWarning();
@@ -1278,9 +1444,13 @@ bool PBMetaD::scanOneHill(unsigned iarg, IFile *ifile, std::vector<Value> &tmpva
 
     std::string sss;
     ifile->scanField("multivariate",sss);
-    if(sss=="true") multivariate=true;
-    else if(sss=="false") multivariate=false;
-    else plumed_merror("cannot parse multivariate = "+ sss);
+    if(sss=="true") {
+      multivariate=true;
+    } else if(sss=="false") {
+      multivariate=false;
+    } else {
+      plumed_merror("cannot parse multivariate = "+ sss);
+    }
     if(multivariate) {
       ifile->scanField("sigma_"+argPtr->getName()+"_"+
                        argPtr->getName(),sigma[0]);
@@ -1290,9 +1460,15 @@ bool PBMetaD::scanOneHill(unsigned iarg, IFile *ifile, std::vector<Value> &tmpva
     }
     ifile->scanField("height",height);
     ifile->scanField("biasf",dummy);
-    if(ifile->FieldExist("clock")) ifile->scanField("clock",dummy);
-    if(ifile->FieldExist("lower_int")) ifile->scanField("lower_int",dummy);
-    if(ifile->FieldExist("upper_int")) ifile->scanField("upper_int",dummy);
+    if(ifile->FieldExist("clock")) {
+      ifile->scanField("clock",dummy);
+    }
+    if(ifile->FieldExist("lower_int")) {
+      ifile->scanField("lower_int",dummy);
+    }
+    if(ifile->FieldExist("upper_int")) {
+      ifile->scanField("upper_int",dummy);
+    }
     ifile->scanField();
     return true;
   } else {
@@ -1301,12 +1477,16 @@ bool PBMetaD::scanOneHill(unsigned iarg, IFile *ifile, std::vector<Value> &tmpva
 
 }
 
-bool PBMetaD::checkNeedsGradients()const
-{
+bool PBMetaD::checkNeedsGradients()const {
   if(adaptive_==FlexibleBin::geometry) {
-    if(getStep()%stride_==0 && !isFirstStep_) return true;
-    else return false;
-  } else return false;
+    if(getStep()%stride_==0 && !isFirstStep_) {
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    return false;
+  }
 }
 
 }
diff --git a/src/bias/Restraint.cpp b/src/bias/Restraint.cpp
index 481d07a93f..862f5e26be 100644
--- a/src/bias/Restraint.cpp
+++ b/src/bias/Restraint.cpp
@@ -80,7 +80,8 @@ PLUMED_REGISTER_ACTION(Restraint,"RESTRAINT_SCALAR")
 
 void Restraint::registerKeywords(Keywords& keys) {
   Bias::registerKeywords(keys);
-  keys.use("ARG"); keys.setDisplayName("RESTRAINT");
+  keys.use("ARG");
+  keys.setDisplayName("RESTRAINT");
   keys.add("compulsory","SLOPE","0.0","specifies that the restraint is linear and what the values of the force constants on each of the variables are");
   keys.add("compulsory","KAPPA","0.0","specifies that the restraint is harmonic and what the values of the force constants on each of the variables are");
   keys.add("compulsory","AT","the position of the restraint");
@@ -91,21 +92,26 @@ Restraint::Restraint(const ActionOptions&ao):
   PLUMED_BIAS_INIT(ao),
   at(getNumberOfArguments()),
   kappa(getNumberOfArguments(),0.0),
-  slope(getNumberOfArguments(),0.0)
-{
+  slope(getNumberOfArguments(),0.0) {
   parseVector("SLOPE",slope);
   parseVector("KAPPA",kappa);
   parseVector("AT",at);
   checkRead();
 
   log.printf("  at");
-  for(unsigned i=0; i<at.size(); i++) log.printf(" %f",at[i]);
+  for(unsigned i=0; i<at.size(); i++) {
+    log.printf(" %f",at[i]);
+  }
   log.printf("\n");
   log.printf("  with harmonic force constant");
-  for(unsigned i=0; i<kappa.size(); i++) log.printf(" %f",kappa[i]);
+  for(unsigned i=0; i<kappa.size(); i++) {
+    log.printf(" %f",kappa[i]);
+  }
   log.printf("\n");
   log.printf("  and linear force constant");
-  for(unsigned i=0; i<slope.size(); i++) log.printf(" %f",slope[i]);
+  for(unsigned i=0; i<slope.size(); i++) {
+    log.printf(" %f",slope[i]);
+  }
   log.printf("\n");
 
   addComponent("force2");
diff --git a/src/bias/RestraintShortcut.cpp b/src/bias/RestraintShortcut.cpp
index 304120b1ab..49c9307f6e 100644
--- a/src/bias/RestraintShortcut.cpp
+++ b/src/bias/RestraintShortcut.cpp
@@ -45,64 +45,112 @@ void RestraintShortcut::registerKeywords(Keywords& keys) {
   keys.add("hidden","STRIDE","1","the frequency with which the forces due to the bias should be calculated.  This can be used to correctly set up multistep algorithms");
   keys.addOutputComponent("bias","default","the instantaneous value of the bias potential");
   keys.addOutputComponent("force2","default","the instantaneous value of the squared force due to this bias potential");
-  keys.addActionNameSuffix("_SCALAR"); keys.needsAction("COMBINE"); keys.needsAction("SUM"); keys.needsAction("CUSTOM"); keys.needsAction("BIASVALUE");
+  keys.addActionNameSuffix("_SCALAR");
+  keys.needsAction("COMBINE");
+  keys.needsAction("SUM");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("BIASVALUE");
 }
 
 RestraintShortcut::RestraintShortcut(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in the args
-  std::vector<std::string> args; parseVector("ARG",args);
-  if( args.size()==0 ) error("found no input arguments");
-  std::vector<Value*> vals; ActionWithArguments::interpretArgumentList( args, plumed.getActionSet(), this, vals );
-  if( vals.size()==0 ) error("found no input arguments");
+  std::vector<std::string> args;
+  parseVector("ARG",args);
+  if( args.size()==0 ) {
+    error("found no input arguments");
+  }
+  std::vector<Value*> vals;
+  ActionWithArguments::interpretArgumentList( args, plumed.getActionSet(), this, vals );
+  if( vals.size()==0 ) {
+    error("found no input arguments");
+  }
 
   // Find the rank
   unsigned rank=vals[0]->getRank();
   for(unsigned i=0; i<vals.size(); ++i) {
-    if( vals[i]->getRank()>0 && vals[i]->hasDerivatives() ) error("argument should not be function on grid");
-    if( vals[i]->getRank()!=rank ) error("all arguments should have same rank");
+    if( vals[i]->getRank()>0 && vals[i]->hasDerivatives() ) {
+      error("argument should not be function on grid");
+    }
+    if( vals[i]->getRank()!=rank ) {
+      error("all arguments should have same rank");
+    }
   }
   if( rank==0 ) {
-    std::vector<std::string> slope(args.size()); parseVector("SLOPE",slope); std::string slopestr="";
-    if( slope[0]!="0.0" ) { slopestr="SLOPE=" + slope[0]; for(unsigned i=1; i<slope.size(); ++i) slopestr += "," + slope[i]; }
-    std::string allargs=args[0]; for(unsigned i=1; i<args.size(); ++i) allargs += "," + args[i];
+    std::vector<std::string> slope(args.size());
+    parseVector("SLOPE",slope);
+    std::string slopestr="";
+    if( slope[0]!="0.0" ) {
+      slopestr="SLOPE=" + slope[0];
+      for(unsigned i=1; i<slope.size(); ++i) {
+        slopestr += "," + slope[i];
+      }
+    }
+    std::string allargs=args[0];
+    for(unsigned i=1; i<args.size(); ++i) {
+      allargs += "," + args[i];
+    }
     readInputLine( getShortcutLabel() + ": RESTRAINT_SCALAR ARG=" + allargs + " " + slopestr + " " + convertInputLineToString() );
     return;
   }
 
-  std::string stride; parse("STRIDE",stride);
-  std::vector<std::string> at; parseVector("AT",at);
-  std::vector<std::string> slope(at.size()); parseVector("SLOPE",slope);
-  std::vector<std::string> kappa(at.size()); parseVector("KAPPA",kappa);
-
-  std::string biasargs, forceargs; bool non_constant_force=false;
+  std::string stride;
+  parse("STRIDE",stride);
+  std::vector<std::string> at;
+  parseVector("AT",at);
+  std::vector<std::string> slope(at.size());
+  parseVector("SLOPE",slope);
+  std::vector<std::string> kappa(at.size());
+  parseVector("KAPPA",kappa);
+
+  std::string biasargs, forceargs;
+  bool non_constant_force=false;
   for(unsigned i=0; i<args.size(); ++i) {
-    std::string argn; std::size_t dot=args[i].find_first_of(".");
-    if(dot!=std::string::npos) argn = args[i].substr(0,dot) + "_" + args[i].substr(dot+1);
-    else argn = args[i];
+    std::string argn;
+    std::size_t dot=args[i].find_first_of(".");
+    if(dot!=std::string::npos) {
+      argn = args[i].substr(0,dot) + "_" + args[i].substr(dot+1);
+    } else {
+      argn = args[i];
+    }
     readInputLine( getShortcutLabel() + "_cv_" + argn + ": COMBINE PERIODIC=NO ARG=" + args[i] + " PARAMETERS=" + at[i] );
-    double kap; Tools::convert(  kappa[i], kap );
+    double kap;
+    Tools::convert(  kappa[i], kap );
     if( fabs(kap)>0 ) {
       non_constant_force = true;
       readInputLine( getShortcutLabel() + "_harm_" + argn + ": CUSTOM PERIODIC=NO FUNC=0.5*" + kappa[i] + "*x^2 ARG=" + getShortcutLabel() + "_cv_" + argn );
       readInputLine( getShortcutLabel() + "_kap_" + argn + ": SUM PERIODIC=NO ARG=" + getShortcutLabel() + "_harm_" + argn );
       readInputLine( getShortcutLabel() + "_f2_" + argn + ": CUSTOM PERIODIC=NO FUNC=" + kappa[i] + "*2*x+" + slope[i] + "*" + slope[i] + " ARG=" + getShortcutLabel() + "_harm_" + argn );
-      if( i==0 ) biasargs = "ARG=" + getShortcutLabel() + "_kap_" + argn; else biasargs += "," + getShortcutLabel() + "_kap_" + argn;
-      if( i==0 ) forceargs = "ARG=" + getShortcutLabel() + "_f2_" + argn; else forceargs += "," + getShortcutLabel() + "_f2_" + argn;
+      if( i==0 ) {
+        biasargs = "ARG=" + getShortcutLabel() + "_kap_" + argn;
+      } else {
+        biasargs += "," + getShortcutLabel() + "_kap_" + argn;
+      }
+      if( i==0 ) {
+        forceargs = "ARG=" + getShortcutLabel() + "_f2_" + argn;
+      } else {
+        forceargs += "," + getShortcutLabel() + "_f2_" + argn;
+      }
     }
-    double slo; Tools::convert( slope[i], slo );
+    double slo;
+    Tools::convert( slope[i], slo );
     if( fabs(slo)>0 ) {
       readInputLine( getShortcutLabel() + "_linear_" + argn + ": CUSTOM PERIODIC=NO FUNC=" + slope[i] + "*x ARG=" + getShortcutLabel() + "_cv_" + argn );
       readInputLine( getShortcutLabel() + "_slope_" + argn + ": SUM PERIODIC=NO ARG=" + getShortcutLabel() + "_linear_" + argn );
-      if( biasargs.length()==0 ) biasargs = "ARG=" + getShortcutLabel() + "_slope_" + argn; else biasargs += "," + getShortcutLabel() + "_slope_" + argn;
+      if( biasargs.length()==0 ) {
+        biasargs = "ARG=" + getShortcutLabel() + "_slope_" + argn;
+      } else {
+        biasargs += "," + getShortcutLabel() + "_slope_" + argn;
+      }
     }
   }
   // This is the bias
   readInputLine( getShortcutLabel() + "_bias: COMBINE PERIODIC=NO " + biasargs );
   readInputLine( getShortcutLabel() + ": BIASVALUE ARG=" + getShortcutLabel() + "_bias STRIDE=" + stride );
-  if( non_constant_force ) readInputLine( getShortcutLabel() + "_force2: COMBINE PERIODIC=NO " + forceargs );
+  if( non_constant_force ) {
+    readInputLine( getShortcutLabel() + "_force2: COMBINE PERIODIC=NO " + forceargs );
+  }
 }
 
 }
diff --git a/src/bias/ReweightBase.cpp b/src/bias/ReweightBase.cpp
index d06a2614b3..abaf820092 100644
--- a/src/bias/ReweightBase.cpp
+++ b/src/bias/ReweightBase.cpp
@@ -36,12 +36,14 @@ void ReweightBase::registerKeywords(Keywords& keys) {
 ReweightBase::ReweightBase(const ActionOptions&ao):
   Action(ao),
   ActionWithValue(ao),
-  ActionWithArguments(ao)
-{
+  ActionWithArguments(ao) {
   simtemp=getkBT();
-  if(simtemp==0) error("The MD engine does not pass the temperature to plumed so you have to specify it using TEMP");
+  if(simtemp==0) {
+    error("The MD engine does not pass the temperature to plumed so you have to specify it using TEMP");
+  }
   // Create something to hold the weight
-  addValue(); setNotPeriodic();
+  addValue();
+  setNotPeriodic();
 }
 
 void ReweightBase::calculate() {
diff --git a/src/bias/ReweightBase.h b/src/bias/ReweightBase.h
index ac690f8c39..34a5ff2c6f 100644
--- a/src/bias/ReweightBase.h
+++ b/src/bias/ReweightBase.h
@@ -30,20 +30,25 @@ namespace bias {
 
 class ReweightBase :
   public ActionWithValue,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
 protected:
 /// The temperature at which you are running the simulation
   double simtemp;
 public:
   static void registerKeywords(Keywords&);
   explicit ReweightBase(const ActionOptions&ao);
-  unsigned getNumberOfDerivatives() override { return 0; }
-  virtual bool buildsWeightStore() const { return false; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
+  virtual bool buildsWeightStore() const {
+    return false;
+  }
   void calculate() override;
   virtual void calculateWeights( const unsigned& nframes ) {}
   virtual double getLogWeight() = 0;
-  virtual double getWeight( const unsigned& iweight ) const { plumed_error(); }
+  virtual double getWeight( const unsigned& iweight ) const {
+    plumed_error();
+  }
   virtual void clearData() {}
   void apply() override {}
 };
diff --git a/src/bias/ReweightBias.cpp b/src/bias/ReweightBias.cpp
index e394eb471c..4ace231443 100644
--- a/src/bias/ReweightBias.cpp
+++ b/src/bias/ReweightBias.cpp
@@ -78,20 +78,23 @@ class ReweightBias : public ReweightBase {
 PLUMED_REGISTER_ACTION(ReweightBias,"REWEIGHT_BIAS")
 
 void ReweightBias::registerKeywords(Keywords& keys ) {
-  ReweightBase::registerKeywords( keys ); keys.remove("ARG");
+  ReweightBase::registerKeywords( keys );
+  keys.remove("ARG");
   keys.add("compulsory","ARG","*.bias","the biases that must be taken into account when reweighting");
   keys.setValueDescription("the weight to use for this frame to negate the effect the bias");
 }
 
 ReweightBias::ReweightBias(const ActionOptions&ao):
   Action(ao),
-  ReweightBase(ao)
-{
+  ReweightBase(ao) {
 }
 
 double ReweightBias::getLogWeight() {
   // Retrieve the bias
-  double bias=0.0; for(unsigned i=0; i<getNumberOfArguments(); ++i) bias+=getArgument(i);
+  double bias=0.0;
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    bias+=getArgument(i);
+  }
   return bias / simtemp;
 }
 
diff --git a/src/bias/ReweightMetad.cpp b/src/bias/ReweightMetad.cpp
index 05e5901892..fcc84828c5 100644
--- a/src/bias/ReweightMetad.cpp
+++ b/src/bias/ReweightMetad.cpp
@@ -75,20 +75,23 @@ class ReweightMetad : public ReweightBase {
 PLUMED_REGISTER_ACTION(ReweightMetad,"REWEIGHT_METAD")
 
 void ReweightMetad::registerKeywords(Keywords& keys ) {
-  ReweightBase::registerKeywords( keys ); keys.remove("ARG");
+  ReweightBase::registerKeywords( keys );
+  keys.remove("ARG");
   keys.add("compulsory","ARG","*.rbias","the biases that must be taken into account when reweighting");
   keys.setValueDescription("the weight to use for this frame to negate the effect the metadynamics bias");
 }
 
 ReweightMetad::ReweightMetad(const ActionOptions&ao):
   Action(ao),
-  ReweightBase(ao)
-{
+  ReweightBase(ao) {
 }
 
 double ReweightMetad::getLogWeight() {
   // Retrieve the bias
-  double bias=0.0; for(unsigned i=0; i<getNumberOfArguments(); ++i) bias+=getArgument(i);
+  double bias=0.0;
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    bias+=getArgument(i);
+  }
   return bias / simtemp;
 }
 
diff --git a/src/bias/ReweightTemperaturePressure.cpp b/src/bias/ReweightTemperaturePressure.cpp
index 71e55aadeb..86b7e72d66 100644
--- a/src/bias/ReweightTemperaturePressure.cpp
+++ b/src/bias/ReweightTemperaturePressure.cpp
@@ -200,8 +200,7 @@ void ReweightTemperaturePressure::registerKeywords(Keywords& keys ) {
 
 ReweightTemperaturePressure::ReweightTemperaturePressure(const ActionOptions&ao):
   Action(ao),
-  ReweightBase(ao)
-{
+  ReweightBase(ao) {
   // Initialize to not defined (negative)
   rpress_=-1;
   press_=-1;
@@ -214,7 +213,9 @@ ReweightTemperaturePressure::ReweightTemperaturePressure(const ActionOptions&ao)
   parseArgumentList("ENERGY",myenergy);
   if(!myenergy.empty()) {
     log.printf("  with energies: ");
-    for(unsigned i=0; i<myenergy.size(); i++) log.printf(" %s",myenergy[i]->getName().c_str());
+    for(unsigned i=0; i<myenergy.size(); i++) {
+      log.printf(" %s",myenergy[i]->getName().c_str());
+    }
     log.printf("\n");
   }
   //requestArguments(myenergy);
@@ -222,7 +223,9 @@ ReweightTemperaturePressure::ReweightTemperaturePressure(const ActionOptions&ao)
   parseArgumentList("VOLUME",myvol);
   if(!myvol.empty()) {
     log.printf("  with volumes: ");
-    for(unsigned i=0; i<myvol.size(); i++) log.printf(" %s",myvol[i]->getName().c_str());
+    for(unsigned i=0; i<myvol.size(); i++) {
+      log.printf(" %s",myvol[i]->getName().c_str());
+    }
     log.printf("\n");
   }
 
@@ -238,27 +241,49 @@ ReweightTemperaturePressure::ReweightTemperaturePressure(const ActionOptions&ao)
     log.printf("  WARNING: If the simulation is performed at constant pressure add the keywords PRESSURE and VOLUME \n" );
   }
   // Case 2) Reweight from T to T' with P=const (isothermal-isobaric)
-  else if (rtemp_>=0 && press_>=0 && rpress_<0 && !myenergy.empty() && !myvol.empty() ) log.printf("  reweighting simulation from temperature %f to temperature %f at constant pressure %f \n",simtemp/getKBoltzmann(),rtemp_/getKBoltzmann(), press_ );
+  else if (rtemp_>=0 && press_>=0 && rpress_<0 && !myenergy.empty() && !myvol.empty() ) {
+    log.printf("  reweighting simulation from temperature %f to temperature %f at constant pressure %f \n",simtemp/getKBoltzmann(),rtemp_/getKBoltzmann(), press_ );
+  }
   // Case 3) Reweight from P to P' with T=const (isothermal-isobaric)
-  else if (rtemp_<0 && press_>=0 && rpress_>=0 && myenergy.empty() && !myvol.empty() ) log.printf("  reweighting simulation from pressure %f to pressure %f at constant temperature %f\n",press_,rpress_,simtemp/getKBoltzmann() );
+  else if (rtemp_<0 && press_>=0 && rpress_>=0 && myenergy.empty() && !myvol.empty() ) {
+    log.printf("  reweighting simulation from pressure %f to pressure %f at constant temperature %f\n",press_,rpress_,simtemp/getKBoltzmann() );
+  }
   // Case 4) Reweight from T,P to T',P' (isothermal-isobaric)
-  else if (rtemp_>0 && press_>=0 && rpress_>=0 && !myenergy.empty() && !myvol.empty() ) log.printf("  reweighting simulation from temperature %f and pressure %f to temperature %f and pressure %f \n",simtemp/getKBoltzmann(), press_, rtemp_/getKBoltzmann(), rpress_);
-  else error("Combination of ENERGY, VOLUME, REWEIGHT_PRESSURE, PRESSURE and REWEIGHT_TEMP not supported. Please refer to the manual for supported combinations.");
+  else if (rtemp_>0 && press_>=0 && rpress_>=0 && !myenergy.empty() && !myvol.empty() ) {
+    log.printf("  reweighting simulation from temperature %f and pressure %f to temperature %f and pressure %f \n",simtemp/getKBoltzmann(), press_, rtemp_/getKBoltzmann(), rpress_);
+  } else {
+    error("Combination of ENERGY, VOLUME, REWEIGHT_PRESSURE, PRESSURE and REWEIGHT_TEMP not supported. Please refer to the manual for supported combinations.");
+  }
 }
 
 double ReweightTemperaturePressure::getLogWeight() {
-  double energy=0.0; for(unsigned i=0; i<myenergy.size(); ++i) energy+=getArgument(i);
-  double volume=0.0; for(unsigned i=0; i<myvol.size(); ++i) volume+=getArgument(myenergy.size()+i);
+  double energy=0.0;
+  for(unsigned i=0; i<myenergy.size(); ++i) {
+    energy+=getArgument(i);
+  }
+  double volume=0.0;
+  for(unsigned i=0; i<myvol.size(); ++i) {
+    volume+=getArgument(myenergy.size()+i);
+  }
   // 4 possible cases
   // Case 1) Reweight from T to T' with V=const (canonical)
-  if (rtemp_>=0 && press_<0 && rpress_<0) return ((1.0/simtemp)- (1.0/rtemp_) )*energy;
+  if (rtemp_>=0 && press_<0 && rpress_<0) {
+    return ((1.0/simtemp)- (1.0/rtemp_) )*energy;
+  }
   // Case 2) Reweight from T to T' with P=const (isothermal-isobaric)
-  else if (rtemp_>=0 && press_>=0 && rpress_<0)  return ((1.0/simtemp)- (1.0/rtemp_) )*energy + ((1.0/simtemp) - (1.0/rtemp_))*press_*volume;
+  else if (rtemp_>=0 && press_>=0 && rpress_<0) {
+    return ((1.0/simtemp)- (1.0/rtemp_) )*energy + ((1.0/simtemp) - (1.0/rtemp_))*press_*volume;
+  }
   // Case 3) Reweight from P to P' with T=const (isothermal-isobaric)
-  else if (rtemp_<0 && press_>=0 && rpress_>=0)  return (1.0/simtemp)*(press_ - rpress_)*volume;
+  else if (rtemp_<0 && press_>=0 && rpress_>=0) {
+    return (1.0/simtemp)*(press_ - rpress_)*volume;
+  }
   // Case 4) Reweight from T,P to T',P' (isothermal-isobaric)
-  else if (rtemp_>0 && press_>=0 && rpress_>=0) return ((1.0/simtemp)- (1.0/rtemp_) )*energy + ((1.0/simtemp)*press_ - (1.0/rtemp_)*rpress_ )*volume;
-  else return 0;
+  else if (rtemp_>0 && press_>=0 && rpress_>=0) {
+    return ((1.0/simtemp)- (1.0/rtemp_) )*energy + ((1.0/simtemp)*press_ - (1.0/rtemp_)*rpress_ )*volume;
+  } else {
+    return 0;
+  }
 }
 
 }
diff --git a/src/bias/UWalls.cpp b/src/bias/UWalls.cpp
index 9bcb4b3ae0..91a177eb20 100644
--- a/src/bias/UWalls.cpp
+++ b/src/bias/UWalls.cpp
@@ -85,8 +85,10 @@ class UWalls : public Bias {
 PLUMED_REGISTER_ACTION(UWalls,"UPPER_WALLS_SCALAR")
 
 void UWalls::registerKeywords(Keywords& keys) {
-  Bias::registerKeywords(keys); keys.setDisplayName("UPPER_WALLS");
-  keys.use("ARG"); keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
+  Bias::registerKeywords(keys);
+  keys.setDisplayName("UPPER_WALLS");
+  keys.use("ARG");
+  keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
   keys.add("compulsory","AT","the positions of the wall. The a_i in the expression for a wall.");
   keys.add("compulsory","KAPPA","the force constant for the wall.  The k_i in the expression for a wall.");
   keys.add("compulsory","OFFSET","0.0","the offset for the start of the wall.  The o_i in the expression for a wall.");
@@ -101,8 +103,7 @@ UWalls::UWalls(const ActionOptions&ao):
   kappa(getNumberOfArguments(),0.0),
   exp(getNumberOfArguments(),2.0),
   eps(getNumberOfArguments(),1.0),
-  offset(getNumberOfArguments(),0.0)
-{
+  offset(getNumberOfArguments(),0.0) {
   // Note : the sizes of these vectors are checked automatically by parseVector
   parseVector("OFFSET",offset);
   parseVector("EPS",eps);
@@ -112,22 +113,33 @@ UWalls::UWalls(const ActionOptions&ao):
   checkRead();
 
   log.printf("  at");
-  for(unsigned i=0; i<at.size(); i++) log.printf(" %f",at[i]);
+  for(unsigned i=0; i<at.size(); i++) {
+    log.printf(" %f",at[i]);
+  }
   log.printf("\n");
   log.printf("  with an offset");
-  for(unsigned i=0; i<offset.size(); i++) log.printf(" %f",offset[i]);
+  for(unsigned i=0; i<offset.size(); i++) {
+    log.printf(" %f",offset[i]);
+  }
   log.printf("\n");
   log.printf("  with force constant");
-  for(unsigned i=0; i<kappa.size(); i++) log.printf(" %f",kappa[i]);
+  for(unsigned i=0; i<kappa.size(); i++) {
+    log.printf(" %f",kappa[i]);
+  }
   log.printf("\n");
   log.printf("  and exponent");
-  for(unsigned i=0; i<exp.size(); i++) log.printf(" %f",exp[i]);
+  for(unsigned i=0; i<exp.size(); i++) {
+    log.printf(" %f",exp[i]);
+  }
   log.printf("\n");
   log.printf("  rescaled");
-  for(unsigned i=0; i<eps.size(); i++) log.printf(" %f",eps[i]);
+  for(unsigned i=0; i<eps.size(); i++) {
+    log.printf(" %f",eps[i]);
+  }
   log.printf("\n");
 
-  addComponent("force2"); componentIsNotPeriodic("force2");
+  addComponent("force2");
+  componentIsNotPeriodic("force2");
 }
 
 void UWalls::calculate() {
diff --git a/src/bias/Walls.cpp b/src/bias/Walls.cpp
index 34530e8f1f..e8245cc061 100644
--- a/src/bias/Walls.cpp
+++ b/src/bias/Walls.cpp
@@ -48,46 +48,75 @@ void Walls::registerKeywords(Keywords& keys) {
   keys.add("hidden","STRIDE","the frequency with which the forces due to the bias should be calculated.  This can be used to correctly set up multistep algorithms");
   keys.addOutputComponent("bias","default","the instantaneous value of the bias potential");
   keys.addOutputComponent("force2","default","the instantaneous value of the squared force due to this bias potential");
-  keys.addActionNameSuffix("_SCALAR"); keys.needsAction("COMBINE"); keys.needsAction("CUSTOM");
-  keys.needsAction("SUM"); keys.needsAction("COMBINE"); keys.needsAction("BIASVALUE");
+  keys.addActionNameSuffix("_SCALAR");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("SUM");
+  keys.needsAction("COMBINE");
+  keys.needsAction("BIASVALUE");
 }
 
 Walls::Walls(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read the arguments
-  std::vector<std::string> args; parseVector("ARG",args);
-  if( args.size()==0 ) error("found no input arguments");
-  std::string allargs=args[0]; for(unsigned i=1; i<args.size(); ++i) allargs += "," + args[i];
-  std::vector<Value*> vals; ActionWithArguments::interpretArgumentList( args, plumed.getActionSet(), this, vals );
-  if( vals.size()==0 ) error("found no input arguments");
+  std::vector<std::string> args;
+  parseVector("ARG",args);
+  if( args.size()==0 ) {
+    error("found no input arguments");
+  }
+  std::string allargs=args[0];
+  for(unsigned i=1; i<args.size(); ++i) {
+    allargs += "," + args[i];
+  }
+  std::vector<Value*> vals;
+  ActionWithArguments::interpretArgumentList( args, plumed.getActionSet(), this, vals );
+  if( vals.size()==0 ) {
+    error("found no input arguments");
+  }
 
   // Find the rank
   unsigned rank=vals[0]->getRank();
   for(unsigned i=0; i<vals.size(); ++i) {
-    if( vals[i]->getRank()>0 && vals[i]->hasDerivatives() ) error("argument should not be function on grid");
-    if( vals[i]->getRank()!=rank ) error("all arguments should have same rank");
+    if( vals[i]->getRank()>0 && vals[i]->hasDerivatives() ) {
+      error("argument should not be function on grid");
+    }
+    if( vals[i]->getRank()!=rank ) {
+      error("all arguments should have same rank");
+    }
   }
   if( rank==0 ) {
-    if( getName()=="UPPER_WALLS") readInputLine( getShortcutLabel() + ": UPPER_WALLS_SCALAR ARG=" + allargs + " " + convertInputLineToString() );
-    else if( getName()=="LOWER_WALLS") readInputLine( getShortcutLabel() + ": LOWER_WALLS_SCALAR ARG=" + allargs + " " + convertInputLineToString() );
-    else plumed_merror( getName() + " is not valid");
+    if( getName()=="UPPER_WALLS") {
+      readInputLine( getShortcutLabel() + ": UPPER_WALLS_SCALAR ARG=" + allargs + " " + convertInputLineToString() );
+    } else if( getName()=="LOWER_WALLS") {
+      readInputLine( getShortcutLabel() + ": LOWER_WALLS_SCALAR ARG=" + allargs + " " + convertInputLineToString() );
+    } else {
+      plumed_merror( getName() + " is not valid");
+    }
     return;
   }
 
   // Note : the sizes of these vectors are checked automatically by parseVector
-  std::vector<std::string> kappa(args.size()); parseVector("KAPPA",kappa);
-  std::vector<std::string> offset(kappa.size()); parseVector("OFFSET",offset);
-  std::vector<std::string> eps(kappa.size()); parseVector("EPS",eps);
-  std::vector<std::string> exp(kappa.size()); parseVector("EXP",exp);
-  std::vector<std::string> at(kappa.size()); parseVector("AT",at);
+  std::vector<std::string> kappa(args.size());
+  parseVector("KAPPA",kappa);
+  std::vector<std::string> offset(kappa.size());
+  parseVector("OFFSET",offset);
+  std::vector<std::string> eps(kappa.size());
+  parseVector("EPS",eps);
+  std::vector<std::string> exp(kappa.size());
+  parseVector("EXP",exp);
+  std::vector<std::string> at(kappa.size());
+  parseVector("AT",at);
 
   std::string biasinp, forceinp;
   for(unsigned i=0; i<args.size(); ++i) {
-    std::string argn; std::size_t dot=args[i].find_first_of(".");
-    if(dot!=std::string::npos) argn = args[i].substr(0,dot) + "_" + args[i].substr(dot+1);
-    else argn = args[i];
+    std::string argn;
+    std::size_t dot=args[i].find_first_of(".");
+    if(dot!=std::string::npos) {
+      argn = args[i].substr(0,dot) + "_" + args[i].substr(dot+1);
+    } else {
+      argn = args[i];
+    }
     readInputLine( getShortcutLabel() + "_cv_" + argn + ": COMBINE PERIODIC=NO ARG=" + args[i] + " PARAMETERS=" + at[i] );
     if( getName()=="UPPER_WALLS" ) {
       readInputLine( getShortcutLabel() + "_scale_" + argn + ": CUSTOM PERIODIC=NO FUNC=(x+" + offset[i] +")/" + eps[i] + " ARG=" + getShortcutLabel() + "_cv_" + argn );
diff --git a/src/cltools/Benchmark.cpp b/src/cltools/Benchmark.cpp
index 9f251fc6f0..90baf45b16 100644
--- a/src/cltools/Benchmark.cpp
+++ b/src/cltools/Benchmark.cpp
@@ -216,11 +216,13 @@ struct KernelBase {
     path(path_),
     plumed_dat(plumed_dat_),
     handle([&]() {
-    if(path_=="this") return PlumedHandle();
-    else return PlumedHandle::dlopen(path.c_str());
+    if(path_=="this") {
+      return PlumedHandle();
+    } else {
+      return PlumedHandle::dlopen(path.c_str());
+    }
   }()),
-  stopwatch(*log_)
-  {
+  stopwatch(*log_) {
   }
 };
 
@@ -232,8 +234,7 @@ struct Kernel :
   Log* log=nullptr;
   Kernel(const std::string & path_,const std::string & the_plumed_dat, Log* log_):
     KernelBase(path_,the_plumed_dat,log_),
-    log(log_)
-  {
+    log(log_) {
   }
 
   ~Kernel() {
@@ -249,13 +250,11 @@ struct Kernel :
 
   Kernel(Kernel && other) noexcept:
     KernelBase(std::move(other)),
-    log(other.log)
-  {
+    log(other.log) {
     other.log=nullptr; // ensure no log is done in the moved away object
   }
 
-  Kernel & operator=(Kernel && other) noexcept
-  {
+  Kernel & operator=(Kernel && other) noexcept {
     if(this != &other) {
       KernelBase::operator=(std::move(other));
       log=other.log;
@@ -324,9 +323,15 @@ struct uniformSphere:public AtomDistribution {
   }
   void box(std::vector<double>& box, unsigned natoms, unsigned /*step*/, Random&) override {
     const double rmax= 2.0*std::cbrt((3.0/(4.0*PLMD::pi)) * natoms);
-    box[0]=rmax; box[1]=0.0;  box[2]=0.0;
-    box[3]=0.0;  box[4]=rmax; box[5]=0.0;
-    box[6]=0.0;  box[7]=0.0;  box[8]=rmax;
+    box[0]=rmax;
+    box[1]=0.0;
+    box[2]=0.0;
+    box[3]=0.0;
+    box[4]=rmax;
+    box[5]=0.0;
+    box[6]=0.0;
+    box[7]=0.0;
+    box[8]=rmax;
 
   }
 };
@@ -352,9 +357,15 @@ struct twoGlobs: public AtomDistribution {
   virtual void box(std::vector<double>& box, unsigned natoms, unsigned /*step*/, Random&) {
 
     const double rmax= 4.0 * std::cbrt ((3.0/(8.0*PLMD::pi)) * natoms);
-    box[0]=rmax; box[1]=0.0;  box[2]=0.0;
-    box[3]=0.0;  box[4]=rmax; box[5]=0.0;
-    box[6]=0.0;  box[7]=0.0;  box[8]=rmax;
+    box[0]=rmax;
+    box[1]=0.0;
+    box[2]=0.0;
+    box[3]=0.0;
+    box[4]=rmax;
+    box[5]=0.0;
+    box[6]=0.0;
+    box[7]=0.0;
+    box[8]=rmax;
   };
 };
 
@@ -379,9 +390,15 @@ struct uniformCube:public AtomDistribution {
   void box(std::vector<double>& box, unsigned natoms, unsigned /*step*/, Random&) override {
     //+0.05 to avoid overlap
     const double rmax= std::cbrt(natoms)+0.05;
-    box[0]=rmax; box[1]=0.0;  box[2]=0.0;
-    box[3]=0.0;  box[4]=rmax; box[5]=0.0;
-    box[6]=0.0;  box[7]=0.0;  box[8]=rmax;
+    box[0]=rmax;
+    box[1]=0.0;
+    box[2]=0.0;
+    box[3]=0.0;
+    box[4]=rmax;
+    box[5]=0.0;
+    box[6]=0.0;
+    box[7]=0.0;
+    box[8]=rmax;
 
   }
 };
@@ -408,9 +425,15 @@ struct tiledSimpleCubic:public AtomDistribution {
   }
   void box(std::vector<double>& box, unsigned natoms, unsigned /*step*/, Random&) override {
     const double rmax= std::ceil(std::cbrt(static_cast<double>(natoms)));;
-    box[0]=rmax; box[1]=0.0;  box[2]=0.0;
-    box[3]=0.0;  box[4]=rmax; box[5]=0.0;
-    box[6]=0.0;  box[7]=0.0;  box[8]=rmax;
+    box[0]=rmax;
+    box[1]=0.0;
+    box[2]=0.0;
+    box[3]=0.0;
+    box[4]=rmax;
+    box[5]=0.0;
+    box[6]=0.0;
+    box[7]=0.0;
+    box[8]=rmax;
 
   }
 };
@@ -434,8 +457,7 @@ std::unique_ptr<AtomDistribution> getAtomDistribution(std::string_view atomicDis
 }
 } //anonymus namespace for benchmark distributions
 class Benchmark:
-  public CLTool
-{
+  public CLTool {
 public:
   static void registerKeywords( Keywords& keys );
   explicit Benchmark(const CLToolOptions& co );
@@ -462,8 +484,7 @@ void Benchmark::registerKeywords( Keywords& keys ) {
 }
 
 Benchmark::Benchmark(const CLToolOptions& co ):
-  CLTool(co)
-{
+  CLTool(co) {
   inputdata=commandline;
 }
 
@@ -476,7 +497,9 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
 
   struct FileDeleter {
     void operator()(FILE*f) const noexcept {
-      if(f) std::fclose(f);
+      if(f) {
+        std::fclose(f);
+      }
     }
   };
 
@@ -516,7 +539,8 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
       log<<"Single run, skipping comparative analysis\n";
     } else if(size<10) {
       log<<"Too small sample, skipping comparative analysis\n";
-    } else try {
+    } else
+      try {
 
         log<<"Running comparative analysis, "<<numblocks<<" blocks with size "<<blocksize<<"\n";
 
@@ -524,7 +548,8 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
         std::uniform_int_distribution<> distrib(0, numblocks-1);
         std::vector<std::vector<long long int>> blocks(f->size());
 
-        { int i=0;
+        {
+          int i=0;
           for(auto it = f->rbegin(); it != f->rend(); ++it,++i) {
             size_t l=0;
             blocks[i].assign(numblocks,0);
@@ -546,7 +571,9 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
 
         //B are the bootstrap iterations
         for(unsigned b=0; b<B; b++) {
-          for(auto & c : choice) c=distrib(bootstrapRng);
+          for(auto & c : choice) {
+            c=distrib(bootstrapRng);
+          }
           long long int reference=0;
           for(auto & c : choice) {
             reference+=blocks[0][c];
@@ -581,7 +608,9 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
         log<<"Unexpected error during comparative analysis\n";
         log<<e.what()<<"\n";
       }
-    while(!f->empty()) f->pop_back();
+    while(!f->empty()) {
+      f->pop_back();
+    }
 
   };
   std::unique_ptr<decltype(kernels),decltype(kernels_deleter)> kernels_deleter_obj(&kernels,kernels_deleter);
@@ -611,7 +640,9 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
     // this check only works on MacOS
 #if defined(__APPLE__)
     // if any of the paths if different from "this", we check if libplumed was loaded locally to avoid conflicts.
-    if(std::any_of(allpaths.begin(),allpaths.end(),[](auto value) {return value != "this";})) {
+    if(std::any_of(allpaths.begin(),allpaths.end(),[](auto value) {
+    return value != "this";
+  })) {
       if(DLLoader::isPlumedGlobal()) {
         plumed_error()<<"It looks like libplumed is loaded in the global namespace, you cannot load a different version of the kernel\n"
                       <<"Please make sure you use the plumed-runtime executable and that the env var PLUMED_LOAD_NAMESPACE is not set to GLOBAL";
@@ -623,10 +654,18 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
       plumed_error() << "--kernel and --plumed should have either one element or the same number of elements";
     }
 
-    if(allplumed.size()>1 && allpaths.size()==1) for(unsigned i=1; i<allplumed.size(); i++) allpaths.push_back(allpaths[0]);
-    if(allplumed.size()==1 && allpaths.size()>1) for(unsigned i=1; i<allpaths.size(); i++) allplumed.push_back(allplumed[0]);
+    if(allplumed.size()>1 && allpaths.size()==1)
+      for(unsigned i=1; i<allplumed.size(); i++) {
+        allpaths.push_back(allpaths[0]);
+      }
+    if(allplumed.size()==1 && allpaths.size()>1)
+      for(unsigned i=1; i<allpaths.size(); i++) {
+        allplumed.push_back(allplumed[0]);
+      }
 
-    for(unsigned i=0; i<allpaths.size(); i++) kernels.emplace_back(allpaths[i],allplumed[i],&log);
+    for(unsigned i=0; i<allpaths.size(); i++) {
+      kernels.emplace_back(allpaths[i],allplumed[i],&log);
+    }
   }
 
   // reverse order so that log happens in the forward order:
@@ -635,22 +674,31 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
   // read other flags:
   bool shuffled=false;
   parseFlag("--shuffled",shuffled);
-  if (shuffled)
+  if (shuffled) {
     log << "Using --shuffled\n";
-  int nf; parse("--nsteps",nf);
+  }
+  int nf;
+  parse("--nsteps",nf);
   log << "Using --nsteps=" << nf << "\n";
-  unsigned natoms; parse("--natoms",natoms);
+  unsigned natoms;
+  parse("--natoms",natoms);
   log << "Using --natoms=" << natoms << "\n";
-  double maxtime; parse("--maxtime",maxtime);
+  double maxtime;
+  parse("--maxtime",maxtime);
   log << "Using --maxtime=" << maxtime << "\n";
 
   bool domain_decomposition=false;
   parseFlag("--domain-decomposition",domain_decomposition);
-  if (domain_decomposition)
+  if (domain_decomposition) {
     log << "Using --domain-decomposition\n";
+  }
 
-  if(pc.Get_size()>1) domain_decomposition=true;
-  if(domain_decomposition) shuffled=true;
+  if(pc.Get_size()>1) {
+    domain_decomposition=true;
+  }
+  if(domain_decomposition) {
+    shuffled=true;
+  }
 
   double timeToSleep;
   parse("--sleep",timeToSleep);
@@ -699,7 +747,9 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
   for(auto & k : kernels) {
     auto & p(k.handle);
     auto sw=k.stopwatch.startStop("A Initialization");
-    if(Communicator::plumedHasMPI() && domain_decomposition) p.cmd("setMPIComm",&pc.Get_comm());
+    if(Communicator::plumedHasMPI() && domain_decomposition) {
+      p.cmd("setMPIComm",&pc.Get_comm());
+    }
     p.cmd("setRealPrecision",(int)sizeof(double));
     p.cmd("setMDLengthUnits",1.0);
     p.cmd("setMDChargeUnits",1.0);
@@ -718,13 +768,17 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
 
   if(shuffled) {
     shuffled_indexes.resize(natoms);
-    for(unsigned i=0; i<natoms; i++) shuffled_indexes[i]=i;
+    for(unsigned i=0; i<natoms; i++) {
+      shuffled_indexes[i]=i;
+    }
     std::shuffle(shuffled_indexes.begin(),shuffled_indexes.end(),rng);
   }
 
   // non owning pointers, used for shuffling the execution order
   std::vector<Kernel*> kernels_ptr;
-  for(unsigned i=0; i<kernels.size(); i++) kernels_ptr.push_back(&kernels[i]);
+  for(unsigned i=0; i<kernels.size(); i++) {
+    kernels_ptr.push_back(&kernels[i]);
+  }
 
   int plumedStopCondition=0;
   bool fast_finish=false;
@@ -755,10 +809,14 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
       const auto myrank=pc.Get_rank();
       auto shift=0;
       n_local_atoms=nn;
-      if(myrank<excess) n_local_atoms+=1;
+      if(myrank<excess) {
+        n_local_atoms+=1;
+      }
       for(int i=0; i<myrank; i++) {
         shift+=nn;
-        if(i<excess) shift+=1;
+        if(i<excess) {
+          shift+=1;
+        }
       }
       pos_ptr=&pos[shift][0];
       for_ptr=&forces[shift][0];
@@ -775,10 +833,15 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
     }
 
     const char* sw_name;
-    if(part==0)      sw_name="B0 First step";
-    else if(part==1) sw_name="B1 Warm-up";
-    else if(part==2) sw_name="B2 Calculation part 1";
-    else             sw_name="B3 Calculation part 2";
+    if(part==0) {
+      sw_name="B0 First step";
+    } else if(part==1) {
+      sw_name="B1 Warm-up";
+    } else if(part==2) {
+      sw_name="B2 Calculation part 1";
+    } else {
+      sw_name="B3 Calculation part 2";
+    }
 
 
     for(unsigned i=0; i<kernels_ptr.size(); i++) {
@@ -805,7 +868,9 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
       {
         unsigned k=0;
         auto start=std::chrono::high_resolution_clock::now();
-        while(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now()-start).count()<(long long int)1e9*timeToSleep) k+=i*i;
+        while(std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now()-start).count()<(long long int)1e9*timeToSleep) {
+          k+=i*i;
+        }
         std::fprintf(log_dev_null.get(),"%u",k);
       }
 
@@ -814,11 +879,17 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
         p.cmd("performCalc");
       }
 
-      if(kernels_ptr.size()>1 && part>1) kernels_ptr[i]->timings.push_back(kernels_ptr[i]->stopwatch.getLastCycle(sw_name));
-      if(plumedStopCondition || signalReceived.load()) fast_finish=true;
+      if(kernels_ptr.size()>1 && part>1) {
+        kernels_ptr[i]->timings.push_back(kernels_ptr[i]->stopwatch.getLastCycle(sw_name));
+      }
+      if(plumedStopCondition || signalReceived.load()) {
+        fast_finish=true;
+      }
     }
     auto elapsed=std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now()-initial_time).count();
-    if(part==0) part=1;
+    if(part==0) {
+      part=1;
+    }
     if(part<2) {
       if((maxtime>0 && elapsed>(long long int)(0.2*1e9*maxtime)) || (nf>0 && step+1>=nf/5) || (maxtime<0 && nf<0 && step+1>=100)) {
         part=2;
@@ -832,14 +903,18 @@ int Benchmark::main(FILE* in, FILE*out,Communicator& pc) {
       }
     }
 
-    if(maxtime>0 && elapsed>(long long int)(1e9*maxtime)) fast_finish=true;
+    if(maxtime>0 && elapsed>(long long int)(1e9*maxtime)) {
+      fast_finish=true;
+    }
 
     {
       unsigned tmp=fast_finish;
       pc.Bcast(tmp,0);
       fast_finish=tmp;
     }
-    if(fast_finish) break;
+    if(fast_finish) {
+      break;
+    }
   }
 
   return 0;
diff --git a/src/cltools/Completion.cpp b/src/cltools/Completion.cpp
index 92c27bf0a1..e8d1a040e1 100644
--- a/src/cltools/Completion.cpp
+++ b/src/cltools/Completion.cpp
@@ -50,8 +50,7 @@ plumed completion
 //+ENDPLUMEDOC
 
 class Completion:
-  public CLTool
-{
+  public CLTool {
 public:
   static void registerKeywords( Keywords& keys );
   explicit Completion(const CLToolOptions& co );
@@ -68,8 +67,7 @@ void Completion::registerKeywords( Keywords& keys ) {
 }
 
 Completion::Completion(const CLToolOptions& co ):
-  CLTool(co)
-{
+  CLTool(co) {
   inputdata=commandline;
 }
 
@@ -86,11 +84,19 @@ int Completion::main(FILE* in, FILE*out,Communicator& pc) {
   std::vector<std::string> tmp=Tools::ls(std::string(config::getPlumedRoot()+"/scripts"));
   for(unsigned j=0; j<tmp.size(); ++j) {
     size_t ff=tmp[j].find(".sh");
-    if(ff==std::string::npos) tmp[j].erase();
-    else                 tmp[j].erase(ff);
+    if(ff==std::string::npos) {
+      tmp[j].erase();
+    } else {
+      tmp[j].erase(ff);
+    }
+  }
+  for(unsigned j=0; j<availableCxx.size(); j++) {
+    std::fprintf(out," %s",availableCxx[j].c_str());
   }
-  for(unsigned j=0; j<availableCxx.size(); j++) std::fprintf(out," %s",availableCxx[j].c_str());
-  for(unsigned j=0; j<tmp.size(); ++j) if(tmp[j].length()>0) std::fprintf(out," %s",tmp[j].c_str());
+  for(unsigned j=0; j<tmp.size(); ++j)
+    if(tmp[j].length()>0) {
+      std::fprintf(out," %s",tmp[j].c_str());
+    }
   std::fprintf(out,"\"\n");
 
   for(unsigned j=0; j<availableCxx.size(); j++) {
@@ -98,7 +104,9 @@ int Completion::main(FILE* in, FILE*out,Communicator& pc) {
 // handle - sign (convert to underscore)
     for(;;) {
       size_t n=s.find("-");
-      if(n==std::string::npos) break;
+      if(n==std::string::npos) {
+        break;
+      }
       s[n]='_';
     }
     std::fprintf(out,"local cmd_keys_%s=\"",s.c_str());
@@ -108,7 +116,9 @@ int Completion::main(FILE* in, FILE*out,Communicator& pc) {
       std::string s=keys[k];
       for(;;) {
         size_t n=s.find("/");
-        if(n==std::string::npos) break;
+        if(n==std::string::npos) {
+          break;
+        }
         s[n]=' ';
       }
       std::fprintf(out," %s",s.c_str());
diff --git a/src/cltools/Driver.cpp b/src/cltools/Driver.cpp
index 4a841d9f5f..d1250d165f 100644
--- a/src/cltools/Driver.cpp
+++ b/src/cltools/Driver.cpp
@@ -209,7 +209,8 @@ class Driver : public CLTool {
 
 template<typename real>
 void Driver<real>::registerKeywords( Keywords& keys ) {
-  CLTool::registerKeywords( keys ); keys.isDriver();
+  CLTool::registerKeywords( keys );
+  keys.isDriver();
   keys.addFlag("--help-debug",false,"print special options that can be used to create regtests");
   keys.add("compulsory","--plumed","plumed.dat","specify the name of the plumed input file");
   keys.add("compulsory","--timestep","1.0","the timestep that was used in the calculation that produced this trajectory in picoseconds");
@@ -259,12 +260,13 @@ void Driver<real>::registerKeywords( Keywords& keys ) {
 }
 template<typename real>
 Driver<real>::Driver(const CLToolOptions& co ):
-  CLTool(co)
-{
+  CLTool(co) {
   inputdata=commandline;
 }
 template<typename real>
-std::string Driver<real>::description()const { return "analyze trajectories with plumed"; }
+std::string Driver<real>::description()const {
+  return "analyze trajectories with plumed";
+}
 
 template<typename real>
 int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
@@ -273,7 +275,8 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
   PDB pdb;
 
 // Parse everything
-  bool printhelpdebug; parseFlag("--help-debug",printhelpdebug);
+  bool printhelpdebug;
+  parseFlag("--help-debug",printhelpdebug);
   if( printhelpdebug ) {
     std::fprintf(out,"%s",
                  "Additional options for debug (only to be used in regtest):\n"
@@ -284,19 +287,28 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
     return 0;
   }
   // Are we reading trajectory data
-  bool noatoms; parseFlag("--noatoms",noatoms);
-  bool parseOnly; parseFlag("--parse-only",parseOnly);
-  std::string full_outputfile; parse("--shortcut-ofile",full_outputfile);
-  std::string valuedict_file; parse("--valuedict-ofile",valuedict_file);
-  bool restart; parseFlag("--restart",restart);
+  bool noatoms;
+  parseFlag("--noatoms",noatoms);
+  bool parseOnly;
+  parseFlag("--parse-only",parseOnly);
+  std::string full_outputfile;
+  parse("--shortcut-ofile",full_outputfile);
+  std::string valuedict_file;
+  parse("--valuedict-ofile",valuedict_file);
+  bool restart;
+  parseFlag("--restart",restart);
 
   std::string fakein;
   bool debug_float=false;
   fakein="";
   if(parse("--debug-float",fakein)) {
-    if(fakein=="yes") debug_float=true;
-    else if(fakein=="no") debug_float=false;
-    else error("--debug-float should have argument yes or no");
+    if(fakein=="yes") {
+      debug_float=true;
+    } else if(fakein=="no") {
+      debug_float=false;
+    } else {
+      error("--debug-float should have argument yes or no");
+    }
   }
 
   if(debug_float && sizeof(real)!=sizeof(float)) {
@@ -309,23 +321,37 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
   bool debug_pd=false;
   fakein="";
   if(parse("--debug-pd",fakein)) {
-    if(fakein=="yes") debug_pd=true;
-    else if(fakein=="no") debug_pd=false;
-    else error("--debug-pd should have argument yes or no");
+    if(fakein=="yes") {
+      debug_pd=true;
+    } else if(fakein=="no") {
+      debug_pd=false;
+    } else {
+      error("--debug-pd should have argument yes or no");
+    }
+  }
+  if(debug_pd) {
+    std::fprintf(out,"DEBUGGING PARTICLE DECOMPOSITION\n");
   }
-  if(debug_pd) std::fprintf(out,"DEBUGGING PARTICLE DECOMPOSITION\n");
 
   bool debug_dd=false;
   fakein="";
   if(parse("--debug-dd",fakein)) {
-    if(fakein=="yes") debug_dd=true;
-    else if(fakein=="no") debug_dd=false;
-    else error("--debug-dd should have argument yes or no");
+    if(fakein=="yes") {
+      debug_dd=true;
+    } else if(fakein=="no") {
+      debug_dd=false;
+    } else {
+      error("--debug-dd should have argument yes or no");
+    }
+  }
+  if(debug_dd) {
+    std::fprintf(out,"DEBUGGING DOMAIN DECOMPOSITION\n");
   }
-  if(debug_dd) std::fprintf(out,"DEBUGGING DOMAIN DECOMPOSITION\n");
 
   if( debug_pd || debug_dd ) {
-    if(noatoms) error("cannot debug without atoms");
+    if(noatoms) {
+      error("cannot debug without atoms");
+    }
   }
 
 // set up for multi replica driver:
@@ -336,7 +362,9 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
   if(multi) {
     int ntot=pc.Get_size();
     int nintra=ntot/multi;
-    if(multi*nintra!=ntot) error("invalid number of processes for multi environment");
+    if(multi*nintra!=ntot) {
+      error("invalid number of processes for multi environment");
+    }
     pc.Split(pc.Get_rank()/nintra,pc.Get_rank(),intracomm);
     pc.Split(pc.Get_rank()%nintra,pc.Get_rank(),intercomm);
   } else {
@@ -348,14 +376,23 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
   int  grex_stride=0;
   FILE*grex_log=NULL;
 // call fclose when fp goes out of scope
-  auto deleter=[](auto f) { if(f) std::fclose(f); };
+  auto deleter=[](auto f) {
+    if(f) {
+      std::fclose(f);
+    }
+  };
   std::unique_ptr<FILE,decltype(deleter)> grex_log_deleter(grex_log,deleter);
 
   if(debug_grex) {
-    if(noatoms) error("must have atoms to debug_grex");
-    if(multi<2)  error("--debug_grex needs --multi with at least two replicas");
+    if(noatoms) {
+      error("must have atoms to debug_grex");
+    }
+    if(multi<2) {
+      error("--debug_grex needs --multi with at least two replicas");
+    }
     Tools::convert(fakein,grex_stride);
-    std::string n; Tools::convert(intercomm.Get_rank(),n);
+    std::string n;
+    Tools::convert(intercomm.Get_rank(),n);
     std::string file;
     parse("--debug-grex-log",file);
     if(file.length()>0) {
@@ -366,12 +403,15 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
   }
 
 // Read the plumed input file name
-  std::string plumedFile; parse("--plumed",plumedFile);
+  std::string plumedFile;
+  parse("--plumed",plumedFile);
 // the timestep
-  double t; parse("--timestep",t);
+  double t;
+  parse("--timestep",t);
   real timestep=real(t);
 // the stride
-  unsigned stride; parse("--trajectory-stride",stride);
+  unsigned stride;
+  parse("--trajectory-stride",stride);
 // are we writing forces
   std::string dumpforces(""), debugforces(""), dumpforcesFmt("%f");;
   bool dumpfullvirial=false;
@@ -379,10 +419,18 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
     parse("--dump-forces",dumpforces);
     parse("--debug-forces",debugforces);
   }
-  if(dumpforces!="" || debugforces!="" ) parse("--dump-forces-fmt",dumpforcesFmt);
-  if(dumpforces!="") parseFlag("--dump-full-virial",dumpfullvirial);
-  if( debugforces!="" && (debug_dd || debug_pd) ) error("cannot debug forces and domain/particle decomposition at same time");
-  if( debugforces!="" && sizeof(real)!=sizeof(double) ) error("cannot debug forces in single precision mode");
+  if(dumpforces!="" || debugforces!="" ) {
+    parse("--dump-forces-fmt",dumpforcesFmt);
+  }
+  if(dumpforces!="") {
+    parseFlag("--dump-full-virial",dumpfullvirial);
+  }
+  if( debugforces!="" && (debug_dd || debug_pd) ) {
+    error("cannot debug forces and domain/particle decomposition at same time");
+  }
+  if( debugforces!="" && sizeof(real)!=sizeof(double) ) {
+    error("cannot debug forces in single precision mode");
+  }
 
   real kt=-1.0;
   parse("--kt",kt);
@@ -393,13 +441,17 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
 
 // Read in an xyz file
   std::string trajectoryFile(""), pdbfile(""), mcfile("");
-  bool pbc_cli_given=false; std::vector<double> pbc_cli_box(9,0.0);
+  bool pbc_cli_given=false;
+  std::vector<double> pbc_cli_box(9,0.0);
   int command_line_natoms=-1;
 
   if(!noatoms) {
-    std::string traj_xyz; parse("--ixyz",traj_xyz);
-    std::string traj_gro; parse("--igro",traj_gro);
-    std::string traj_dlp4; parse("--idlp4",traj_dlp4);
+    std::string traj_xyz;
+    parse("--ixyz",traj_xyz);
+    std::string traj_gro;
+    parse("--igro",traj_gro);
+    std::string traj_dlp4;
+    parse("--idlp4",traj_dlp4);
     std::string traj_xtc;
     std::string traj_trr;
     parse("--ixtc",traj_xtc);
@@ -418,13 +470,24 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
       }
     }
 #endif
-    { // check that only one fmt is specified
+    {
+      // check that only one fmt is specified
       int nn=0;
-      if(traj_xyz.length()>0) nn++;
-      if(traj_gro.length()>0) nn++;
-      if(traj_dlp4.length()>0) nn++;
-      if(traj_xtc.length()>0) nn++;
-      if(traj_trr.length()>0) nn++;
+      if(traj_xyz.length()>0) {
+        nn++;
+      }
+      if(traj_gro.length()>0) {
+        nn++;
+      }
+      if(traj_dlp4.length()>0) {
+        nn++;
+      }
+      if(traj_xtc.length()>0) {
+        nn++;
+      }
+      if(traj_trr.length()>0) {
+        nn++;
+      }
       if(nn>1) {
         std::fprintf(stderr,"ERROR: cannot provide more than one trajectory file\n");
         return 1;
@@ -454,29 +517,45 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
       std::fprintf(stderr,"ERROR: missing trajectory data\n");
       return 1;
     }
-    std::string lengthUnits(""); parse("--length-units",lengthUnits);
-    if(lengthUnits.length()>0) units.setLength(lengthUnits);
-    std::string chargeUnits(""); parse("--charge-units",chargeUnits);
-    if(chargeUnits.length()>0) units.setCharge(chargeUnits);
-    std::string massUnits(""); parse("--mass-units",massUnits);
-    if(massUnits.length()>0) units.setMass(massUnits);
+    std::string lengthUnits("");
+    parse("--length-units",lengthUnits);
+    if(lengthUnits.length()>0) {
+      units.setLength(lengthUnits);
+    }
+    std::string chargeUnits("");
+    parse("--charge-units",chargeUnits);
+    if(chargeUnits.length()>0) {
+      units.setCharge(chargeUnits);
+    }
+    std::string massUnits("");
+    parse("--mass-units",massUnits);
+    if(massUnits.length()>0) {
+      units.setMass(massUnits);
+    }
 
     parse("--pdb",pdbfile);
     if(pdbfile.length()>0) {
       bool check=pdb.read(pdbfile,false,1.0);
-      if(!check) error("error reading pdb file");
+      if(!check) {
+        error("error reading pdb file");
+      }
     }
 
     parse("--mc",mcfile);
 
-    std::string pbc_cli_list; parse("--box",pbc_cli_list);
+    std::string pbc_cli_list;
+    parse("--box",pbc_cli_list);
     if(pbc_cli_list.length()>0) {
       pbc_cli_given=true;
       std::vector<std::string> words=Tools::getWords(pbc_cli_list,",");
       if(words.size()==3) {
-        for(int i=0; i<3; i++) std::sscanf(words[i].c_str(),"%100lf",&(pbc_cli_box[4*i]));
+        for(int i=0; i<3; i++) {
+          std::sscanf(words[i].c_str(),"%100lf",&(pbc_cli_box[4*i]));
+        }
       } else if(words.size()==9) {
-        for(int i=0; i<9; i++) std::sscanf(words[i].c_str(),"%100lf",&(pbc_cli_box[i]));
+        for(int i=0; i<9; i++) {
+          std::sscanf(words[i].c_str(),"%100lf",&(pbc_cli_box[i]));
+        }
       } else {
         std::string msg="ERROR: cannot parse command-line box "+pbc_cli_list;
         std::fprintf(stderr,"%s\n",msg.c_str());
@@ -493,7 +572,9 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
   auto mf_deleter=[api](void* h_in) {
     if(h_in) {
       std::unique_ptr<std::lock_guard<std::mutex>> lck;
-      if(api->is_reentrant==VMDPLUGIN_THREADUNSAFE) lck=Tools::molfile_lock();
+      if(api->is_reentrant==VMDPLUGIN_THREADUNSAFE) {
+        lck=Tools::molfile_lock();
+      }
       api->close_file_read(h_in);
     }
   };
@@ -511,22 +592,33 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
 
 
 
-  if(debug_dd && debug_pd) error("cannot use debug-dd and debug-pd at the same time");
+  if(debug_dd && debug_pd) {
+    error("cannot use debug-dd and debug-pd at the same time");
+  }
   if(debug_pd || debug_dd) {
-    if( !Communicator::initialized() ) error("needs mpi for debug-pd");
+    if( !Communicator::initialized() ) {
+      error("needs mpi for debug-pd");
+    }
   }
 
-  PlumedMain p; if( parseOnly ) p.activateParseOnlyMode();
+  PlumedMain p;
+  if( parseOnly ) {
+    p.activateParseOnlyMode();
+  }
   p.cmd("setRealPrecision",(int)sizeof(real));
   int checknatoms=-1;
   long long int step=0;
   parse("--initial-step",step);
 
-  if(restart) p.cmd("setRestart",1);
+  if(restart) {
+    p.cmd("setRestart",1);
+  }
 
   if(Communicator::initialized()) {
     if(multi) {
-      if(intracomm.Get_rank()==0) p.cmd("GREX setMPIIntercomm",&intercomm.Get_comm());
+      if(intracomm.Get_rank()==0) {
+        p.cmd("GREX setMPIIntercomm",&intercomm.Get_comm());
+      }
       p.cmd("GREX setMPIIntracomm",&intracomm.Get_comm());
       p.cmd("GREX init");
     }
@@ -537,7 +629,9 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
   p.cmd("setMDMassUnits",units.getMass());
   p.cmd("setMDEngine","driver");
   p.cmd("setTimestep",timestep);
-  if( !parseOnly || full_outputfile.length()==0 ) p.cmd("setPlumedDat",plumedFile.c_str());
+  if( !parseOnly || full_outputfile.length()==0 ) {
+    p.cmd("setPlumedDat",plumedFile.c_str());
+  }
   p.cmd("setLog",out);
 
   int natoms;
@@ -545,43 +639,59 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
   int pb=1;
 
   if(parseOnly) {
-    if(command_line_natoms<0) error("--parseOnly requires setting the number of atoms with --natoms");
+    if(command_line_natoms<0) {
+      error("--parseOnly requires setting the number of atoms with --natoms");
+    }
     natoms=command_line_natoms;
   }
 
 
-  FILE* fp=NULL; FILE* fp_forces=NULL; OFile fp_dforces;
+  FILE* fp=NULL;
+  FILE* fp_forces=NULL;
+  OFile fp_dforces;
 
   std::unique_ptr<FILE,decltype(deleter)> fp_deleter(fp,deleter);
   std::unique_ptr<FILE,decltype(deleter)> fp_forces_deleter(fp_forces,deleter);
 
-  auto xdr_deleter=[](auto xd) { if(xd) xdrfile::xdrfile_close(xd); };
+  auto xdr_deleter=[](auto xd) {
+    if(xd) {
+      xdrfile::xdrfile_close(xd);
+    }
+  };
 
   xdrfile::XDRFILE* xd=NULL;
 
   std::unique_ptr<xdrfile::XDRFILE,decltype(xdr_deleter)> xd_deleter(xd,xdr_deleter);
 
   if(!noatoms&&!parseOnly) {
-    if (trajectoryFile=="-")
+    if (trajectoryFile=="-") {
       fp=in;
-    else {
+    } else {
       if(multi) {
         std::string n;
         Tools::convert(intercomm.Get_rank(),n);
         std::string testfile=FileBase::appendSuffix(trajectoryFile,"."+n);
         FILE* tmp_fp=std::fopen(testfile.c_str(),"r");
         // no exceptions here
-        if(tmp_fp) { std::fclose(tmp_fp); trajectoryFile=testfile;}
+        if(tmp_fp) {
+          std::fclose(tmp_fp);
+          trajectoryFile=testfile;
+        }
       }
       if(use_molfile==true) {
 #ifdef __PLUMED_HAS_MOLFILE_PLUGINS
         std::unique_ptr<std::lock_guard<std::mutex>> lck;
-        if(api->is_reentrant==VMDPLUGIN_THREADUNSAFE) lck=Tools::molfile_lock();
+        if(api->is_reentrant==VMDPLUGIN_THREADUNSAFE) {
+          lck=Tools::molfile_lock();
+        }
         h_in = api->open_file_read(trajectoryFile.c_str(), trajectory_fmt.c_str(), &natoms);
         h_in_deleter.reset(h_in);
         if(natoms==MOLFILE_NUMATOMS_UNKNOWN) {
-          if(command_line_natoms>=0) natoms=command_line_natoms;
-          else error("this file format does not provide number of atoms; use --natoms on the command line");
+          if(command_line_natoms>=0) {
+            natoms=command_line_natoms;
+          } else {
+            error("this file format does not provide number of atoms; use --natoms on the command line");
+          }
         }
         ts_in_coords.resize(3*natoms);
         ts_in.coords = ts_in_coords.data();
@@ -594,8 +704,12 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
           std::fprintf(stderr,"%s\n",msg.c_str());
           return 1;
         }
-        if(trajectory_fmt=="xdr-xtc") xdrfile::read_xtc_natoms(&trajectoryFile[0],&natoms);
-        if(trajectory_fmt=="xdr-trr") xdrfile::read_trr_natoms(&trajectoryFile[0],&natoms);
+        if(trajectory_fmt=="xdr-xtc") {
+          xdrfile::read_xtc_natoms(&trajectoryFile[0],&natoms);
+        }
+        if(trajectory_fmt=="xdr-trr") {
+          xdrfile::read_trr_natoms(&trajectoryFile[0],&natoms);
+        }
       } else {
         fp=std::fopen(trajectoryFile.c_str(),"r");
         fp_deleter.reset(fp);
@@ -649,8 +763,12 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
   Random rnd;
 
   if(trajectory_fmt=="dlp4") {
-    if(!Tools::getline(fp,line)) error("error reading title");
-    if(!Tools::getline(fp,line)) error("error reading atoms");
+    if(!Tools::getline(fp,line)) {
+      error("error reading title");
+    }
+    if(!Tools::getline(fp,line)) {
+      error("error reading atoms");
+    }
     std::sscanf(line.c_str(),"%d %d %d",&lvl,&pb,&natoms);
 
   }
@@ -660,7 +778,9 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
       if(use_molfile==true) {
 #ifdef __PLUMED_HAS_MOLFILE_PLUGINS
         std::unique_ptr<std::lock_guard<std::mutex>> lck;
-        if(api->is_reentrant==VMDPLUGIN_THREADUNSAFE) lck=Tools::molfile_lock();
+        if(api->is_reentrant==VMDPLUGIN_THREADUNSAFE) {
+          lck=Tools::molfile_lock();
+        }
         int rc;
         rc = api->read_next_timestep(h_in, natoms, &ts_in);
         if(rc==MOLFILE_EOF) {
@@ -668,13 +788,18 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
         }
 #endif
       } else if(trajectory_fmt=="xyz" || trajectory_fmt=="gro" || trajectory_fmt=="dlp4") {
-        if(!Tools::getline(fp,line)) break;
+        if(!Tools::getline(fp,line)) {
+          break;
+        }
       }
     }
     bool first_step=false;
     if(!noatoms&&!parseOnly) {
       if(use_molfile==false && (trajectory_fmt=="xyz" || trajectory_fmt=="gro")) {
-        if(trajectory_fmt=="gro") if(!Tools::getline(fp,line)) error("premature end of trajectory file");
+        if(trajectory_fmt=="gro")
+          if(!Tools::getline(fp,line)) {
+            error("premature end of trajectory file");
+          }
         std::sscanf(line.c_str(),"%100d",&natoms);
       }
       if(use_molfile==false && trajectory_fmt=="dlp4") {
@@ -699,7 +824,9 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
         for(unsigned i=0; i<pdb.size(); ++i) {
           AtomNumber an=pdb.getAtomNumbers()[i];
           unsigned index=an.index();
-          if( index>=unsigned(natoms) ) error("atom index in pdb exceeds the number of atoms in trajectory");
+          if( index>=unsigned(natoms) ) {
+            error("atom index in pdb exceeds the number of atoms in trajectory");
+          }
           masses[index]=pdb.getOccupancy()[i];
           charges[index]=pdb.getBeta()[i];
         }
@@ -707,7 +834,9 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
       if(mcfile.length()>0) {
         IFile ifile;
         ifile.open(mcfile);
-        int index; double mass; double charge;
+        int index;
+        double mass;
+        double charge;
         while(ifile.scanField("index",index).scanField("mass",mass).scanField("charge",charge).scanField()) {
           masses[index]=mass;
           charges[index]=charge;
@@ -728,77 +857,124 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
 
         // Read in the plumed input file and store what is in there
         std::map<std::string,std::vector<std::string> > data;
-        IFile ifile; ifile.open(plumedFile); std::vector<std::string> words;
+        IFile ifile;
+        ifile.open(plumedFile);
+        std::vector<std::string> words;
         while( Tools::getParsedLine(ifile,words) && !p.getEndPlumed() ) {
           p.readInputWords(words,false);
           Action* aa=p.getActionSet()[p.getActionSet().size()-1].get();
           plumed_assert(aa); // needed for following calls, see #1046
           ActionWithValue* av=aa->castToActionWithValue();
           if( av && aa->getDefaultString().length()>0 ) {
-            std::vector<std::string> def; def.push_back( "defaults " + aa->getDefaultString() );
+            std::vector<std::string> def;
+            def.push_back( "defaults " + aa->getDefaultString() );
             data[ aa->getLabel() ] = def;
           }
           ActionShortcut* as=aa->castToActionShortcut();
           if( as ) {
             if( aa->getDefaultString().length()>0 ) {
-              std::vector<std::string> def; def.push_back( "defaults " + aa->getDefaultString() );
+              std::vector<std::string> def;
+              def.push_back( "defaults " + aa->getDefaultString() );
               data[ as->getShortcutLabel() ] = def;
             }
-            std::vector<std::string> shortcut_commands = as->getSavedInputLines(); if( shortcut_commands.size()==0 ) continue;
+            std::vector<std::string> shortcut_commands = as->getSavedInputLines();
+            if( shortcut_commands.size()==0 ) {
+              continue;
+            }
             if( data.find( as->getShortcutLabel() )!=data.end() ) {
-              for(unsigned i=0; i<shortcut_commands.size(); ++i) data[ as->getShortcutLabel() ].push_back( shortcut_commands[i] );
-            } else data[ as->getShortcutLabel() ] = shortcut_commands;
+              for(unsigned i=0; i<shortcut_commands.size(); ++i) {
+                data[ as->getShortcutLabel() ].push_back( shortcut_commands[i] );
+              }
+            } else {
+              data[ as->getShortcutLabel() ] = shortcut_commands;
+            }
           }
         }
         ifile.close();
         // Only output the full version of the input file if there are shortcuts
         if( data.size()>0 ) {
-          OFile long_file; long_file.open( full_outputfile ); long_file.printf("{\n"); bool firstpass=true;
+          OFile long_file;
+          long_file.open( full_outputfile );
+          long_file.printf("{\n");
+          bool firstpass=true;
           for(auto& x : data ) {
-            if( !firstpass ) long_file.printf("   },\n");
+            if( !firstpass ) {
+              long_file.printf("   },\n");
+            }
             long_file.printf("   \"%s\" : {\n", x.first.c_str() );
-            plumed_assert( x.second.size()>0 ); unsigned sstart=0;
+            plumed_assert( x.second.size()>0 );
+            unsigned sstart=0;
             if( x.second[0].find("defaults")!=std::string::npos ) {
-              sstart=1; long_file.printf("      \"defaults\" : \"%s\"", x.second[0].substr( 9 ).c_str() );
-              if( x.second.size()>1 ) long_file.printf(",\n"); else long_file.printf("\n");
+              sstart=1;
+              long_file.printf("      \"defaults\" : \"%s\"", x.second[0].substr( 9 ).c_str() );
+              if( x.second.size()>1 ) {
+                long_file.printf(",\n");
+              } else {
+                long_file.printf("\n");
+              }
             }
             if( x.second.size()>sstart ) {
               long_file.printf("      \"expansion\" : \"%s", x.second[sstart].c_str() );
-              for(unsigned j=sstart+1; j<x.second.size(); ++j) long_file.printf("\\n%s", x.second[j].c_str() );
+              for(unsigned j=sstart+1; j<x.second.size(); ++j) {
+                long_file.printf("\\n%s", x.second[j].c_str() );
+              }
               long_file.printf("\"\n");
             }
             firstpass=false;
           }
-          long_file.printf("   }\n}\n"); long_file.close();
+          long_file.printf("   }\n}\n");
+          long_file.close();
         }
       }
       if( valuedict_file.length()>0 ) {
-        OFile valuefile; valuefile.open( valuedict_file ); valuefile.printf("{\n"); bool firsta=true;
+        OFile valuefile;
+        valuefile.open( valuedict_file );
+        valuefile.printf("{\n");
+        bool firsta=true;
         for(const auto & pp : p.getActionSet()) {
-          if( pp.get()->getName()=="CENTER" ) continue ;
+          if( pp.get()->getName()=="CENTER" ) {
+            continue ;
+          }
           ActionWithVirtualAtom* avv=dynamic_cast<ActionWithVirtualAtom*>(pp.get());
           if( avv ||  pp.get()->getName()=="GROUP" || pp.get()->getName()=="DENSITY" ) {
             Action* p(pp.get());
-            if( firsta ) { valuefile.printf("  \"%s\" : {\n    \"action\" : \"%s\"", p->getLabel().c_str(), p->getName().c_str() ); firsta=false; }
-            else valuefile.printf(",\n  \"%s\" : {\n    \"action\" : \"%s\"", p->getLabel().c_str(), p->getName().c_str() );
-            if( avv ) valuefile.printf(",\n    \"%s\" : { \"type\": \"atoms\", \"description\": \"virtual atom calculated by %s action\" }", avv->getLabel().c_str(), avv->getName().c_str() );
-            else valuefile.printf(",\n    \"%s\" : { \"type\": \"atoms\", \"description\": \"indices of atoms specified in GROUP\" }", p->getLabel().c_str() );
-            valuefile.printf("\n  }"); continue;
+            if( firsta ) {
+              valuefile.printf("  \"%s\" : {\n    \"action\" : \"%s\"", p->getLabel().c_str(), p->getName().c_str() );
+              firsta=false;
+            } else {
+              valuefile.printf(",\n  \"%s\" : {\n    \"action\" : \"%s\"", p->getLabel().c_str(), p->getName().c_str() );
+            }
+            if( avv ) {
+              valuefile.printf(",\n    \"%s\" : { \"type\": \"atoms\", \"description\": \"virtual atom calculated by %s action\" }", avv->getLabel().c_str(), avv->getName().c_str() );
+            } else {
+              valuefile.printf(",\n    \"%s\" : { \"type\": \"atoms\", \"description\": \"indices of atoms specified in GROUP\" }", p->getLabel().c_str() );
+            }
+            valuefile.printf("\n  }");
+            continue;
           }
           ActionWithValue* av=dynamic_cast<ActionWithValue*>(pp.get());
           if( av && av->getNumberOfComponents()>0 ) {
-            Keywords keys; p.getKeywordsForAction( av->getName(), keys );
-            if( firsta ) { valuefile.printf("  \"%s\" : {\n    \"action\" : \"%s\"", av->getLabel().c_str(), keys.getDisplayName().c_str() ); firsta=false; }
-            else valuefile.printf(",\n  \"%s\" : {\n    \"action\" : \"%s\"", av->getLabel().c_str(), keys.getDisplayName().c_str() );
+            Keywords keys;
+            p.getKeywordsForAction( av->getName(), keys );
+            if( firsta ) {
+              valuefile.printf("  \"%s\" : {\n    \"action\" : \"%s\"", av->getLabel().c_str(), keys.getDisplayName().c_str() );
+              firsta=false;
+            } else {
+              valuefile.printf(",\n  \"%s\" : {\n    \"action\" : \"%s\"", av->getLabel().c_str(), keys.getDisplayName().c_str() );
+            }
             for(unsigned i=0; i<av->getNumberOfComponents(); ++i) {
-              Value* myval = av->copyOutput(i); std::string compname = myval->getName(), description;
+              Value* myval = av->copyOutput(i);
+              std::string compname = myval->getName(), description;
               if( av->getLabel()==compname ) {
                 description = keys.getOutputComponentDescription(".#!value");
               } else {
-                std::size_t dot=compname.find(av->getLabel() + "."); std::string cname = compname.substr(dot + av->getLabel().length() + 1);
+                std::size_t dot=compname.find(av->getLabel() + ".");
+                std::string cname = compname.substr(dot + av->getLabel().length() + 1);
                 description = av->getOutputComponentDescription( cname, keys );
               }
-              if( description.find("\\")!=std::string::npos ) error("found invalid backslash character in documentation for component " + compname + " in action " + av->getName() + " with label " + av->getLabel() );
+              if( description.find("\\")!=std::string::npos ) {
+                error("found invalid backslash character in documentation for component " + compname + " in action " + av->getName() + " with label " + av->getLabel() );
+              }
               valuefile.printf(",\n    \"%s\" : { \"type\": \"%s\", \"description\": \"%s\" }", myval->getName().c_str(), myval->getValueType().c_str(), description.c_str() );
             }
             valuefile.printf("\n  }");
@@ -806,30 +982,50 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
           ActionShortcut* as=pp->castToActionShortcut();
           if( as ) {
             std::vector<std::string> cnames( as->getSavedOutputs() );
-            if( cnames.size()==0 ) continue ;
+            if( cnames.size()==0 ) {
+              continue ;
+            }
 
-            if( firsta ) { valuefile.printf("  \"shortcut_%s\" : {\n    \"action\" : \"%s\"", as->getShortcutLabel().c_str(), as->getName().c_str() ); firsta=false; }
-            else valuefile.printf(",\n  \"shortcut_%s\" : {\n    \"action\" : \"%s\"", as->getShortcutLabel().c_str(), as->getName().c_str() );
-            Keywords keys; p.getKeywordsForAction( as->getName(), keys );
+            if( firsta ) {
+              valuefile.printf("  \"shortcut_%s\" : {\n    \"action\" : \"%s\"", as->getShortcutLabel().c_str(), as->getName().c_str() );
+              firsta=false;
+            } else {
+              valuefile.printf(",\n  \"shortcut_%s\" : {\n    \"action\" : \"%s\"", as->getShortcutLabel().c_str(), as->getName().c_str() );
+            }
+            Keywords keys;
+            p.getKeywordsForAction( as->getName(), keys );
             for(unsigned i=0; i<cnames.size(); ++i) {
               ActionWithValue* av2=p.getActionSet().selectWithLabel<ActionWithValue*>( cnames[i] );
-              if( !av2 ) plumed_merror("could not find value created by shortcut with name " + cnames[i] );
+              if( !av2 ) {
+                plumed_merror("could not find value created by shortcut with name " + cnames[i] );
+              }
               if( av2->getNumberOfComponents()==1 ) {
-                Value* myval = av2->copyOutput(0); std::string compname = myval->getName(), description;
-                if( compname==as->getShortcutLabel() ) description = keys.getOutputComponentDescription(".#!value");
-                else { std::size_t pp=compname.find(as->getShortcutLabel()); description = keys.getOutputComponentDescription( compname.substr(pp+as->getShortcutLabel().length()+1) ); }
-                if( description.find("\\")!=std::string::npos ) error("found invalid backslash character in documentation for component " + compname + " in action " + as->getName() + " with label " + as->getLabel() );
+                Value* myval = av2->copyOutput(0);
+                std::string compname = myval->getName(), description;
+                if( compname==as->getShortcutLabel() ) {
+                  description = keys.getOutputComponentDescription(".#!value");
+                } else {
+                  std::size_t pp=compname.find(as->getShortcutLabel());
+                  description = keys.getOutputComponentDescription( compname.substr(pp+as->getShortcutLabel().length()+1) );
+                }
+                if( description.find("\\")!=std::string::npos ) {
+                  error("found invalid backslash character in documentation for component " + compname + " in action " + as->getName() + " with label " + as->getLabel() );
+                }
                 valuefile.printf(",\n    \"%s\" : { \"type\": \"%s\", \"description\": \"%s\" }", myval->getName().c_str(), myval->getValueType().c_str(), description.c_str() );
               } else {
                 for(unsigned j=0; j<av2->getNumberOfComponents(); ++j) {
-                  Value* myval = av2->copyOutput(j); std::string compname = myval->getName(), description;
+                  Value* myval = av2->copyOutput(j);
+                  std::string compname = myval->getName(), description;
                   if( av2->getLabel()==compname ) {
                     plumed_merror("should not be outputting description of value from action when using shortcuts");
                   } else {
-                    std::size_t dot=compname.find(av2->getLabel() + "."); std::string cname = compname.substr(dot+av2->getLabel().length() + 1);
+                    std::size_t dot=compname.find(av2->getLabel() + ".");
+                    std::string cname = compname.substr(dot+av2->getLabel().length() + 1);
                     description = av2->getOutputComponentDescription( cname, keys );
                   }
-                  if( description.find("\\")!=std::string::npos ) error("found invalid backslash character in documentation for component " + compname + " in action " + av2->getName() + " with label " + av2->getLabel() );
+                  if( description.find("\\")!=std::string::npos ) {
+                    error("found invalid backslash character in documentation for component " + compname + " in action " + av2->getName() + " with label " + av2->getLabel() );
+                  }
                   valuefile.printf(",\n    \"%s\" : { \"type\": \"%s\", \"description\": \"%s\" }", myval->getName().c_str(), myval->getValueType().c_str(), description.c_str() );
                 }
               }
@@ -837,12 +1033,16 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
             valuefile.printf("\n  }");
           }
         }
-        valuefile.printf("\n}\n"); valuefile.close();
+        valuefile.printf("\n}\n");
+        valuefile.close();
+      }
+      if(parseOnly) {
+        break;
       }
-      if(parseOnly) break;
     }
     if(checknatoms!=natoms) {
-      std::string stepstr; Tools::convert(step,stepstr);
+      std::string stepstr;
+      Tools::convert(step,stepstr);
       error("number of atoms in frame " + stepstr + " does not match number of atoms in first frame");
     }
 
@@ -858,7 +1058,9 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
         std::vector<int> start(npe,0);
         for(int i=0; i<npe-1; i++) {
           int cc=(natoms*2*rnd.U01())/npe;
-          if(start[i]+cc>natoms) cc=natoms-start[i];
+          if(start[i]+cc>natoms) {
+            cc=natoms-start[i];
+          }
           loc[i]=cc;
           start[i+1]=start[i]+loc[i];
         }
@@ -869,8 +1071,16 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
         pd_start=start[intracomm.Get_rank()];
         if(intracomm.Get_rank()==0) {
           std::fprintf(out,"\nDRIVER: Reassigning particle decomposition\n");
-          std::fprintf(out,"DRIVER: "); for(int i=0; i<npe; i++) std::fprintf(out,"%d ",loc[i]); printf("\n");
-          std::fprintf(out,"DRIVER: "); for(int i=0; i<npe; i++) std::fprintf(out,"%d ",start[i]); printf("\n");
+          std::fprintf(out,"DRIVER: ");
+          for(int i=0; i<npe; i++) {
+            std::fprintf(out,"%d ",loc[i]);
+          }
+          printf("\n");
+          std::fprintf(out,"DRIVER: ");
+          for(int i=0; i<npe; i++) {
+            std::fprintf(out,"%d ",start[i]);
+          }
+          printf("\n");
         }
         p.cmd("setAtomsNlocal",pd_nlocal);
         p.cmd("setAtomsContiguous",pd_start);
@@ -886,7 +1096,11 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
         dd_nlocal=0;
         for(int i=0; i<natoms; ++i) {
           double r=rnd.U01()*npe;
-          int n; for(n=0; n<npe; n++) if(n+1>r)break;
+          int n;
+          for(n=0; n<npe; n++)
+            if(n+1>r) {
+              break;
+            }
           plumed_assert(n<npe);
           if(n==rank) {
             dd_gatindex[dd_nlocal]=i;
@@ -922,16 +1136,30 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
             real Cx=real(ts_in.C)*cosAC;
             real Cy=(real(ts_in.C)*real(ts_in.B)*cosBC-Cx*Bx)/By;
             real Cz=std::sqrt(real(ts_in.C)*real(ts_in.C)-Cx*Cx-Cy*Cy);
-            cell[0]=Ax/10.; cell[1]=0.; cell[2]=0.;
-            cell[3]=Bx/10.; cell[4]=By/10.; cell[5]=0.;
-            cell[6]=Cx/10.; cell[7]=Cy/10.; cell[8]=Cz/10.;
+            cell[0]=Ax/10.;
+            cell[1]=0.;
+            cell[2]=0.;
+            cell[3]=Bx/10.;
+            cell[4]=By/10.;
+            cell[5]=0.;
+            cell[6]=Cx/10.;
+            cell[7]=Cy/10.;
+            cell[8]=Cz/10.;
           } else {
-            cell[0]=0.0; cell[1]=0.0; cell[2]=0.0;
-            cell[3]=0.0; cell[4]=0.0; cell[5]=0.0;
-            cell[6]=0.0; cell[7]=0.0; cell[8]=0.0;
+            cell[0]=0.0;
+            cell[1]=0.0;
+            cell[2]=0.0;
+            cell[3]=0.0;
+            cell[4]=0.0;
+            cell[5]=0.0;
+            cell[6]=0.0;
+            cell[7]=0.0;
+            cell[8]=0.0;
           }
         } else {
-          for(unsigned i=0; i<9; i++)cell[i]=pbc_cli_box[i];
+          for(unsigned i=0; i<9; i++) {
+            cell[i]=pbc_cli_box[i];
+          }
         }
         // info on coords
         // the order is xyzxyz...
@@ -949,17 +1177,34 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
         auto pos=Tools::make_unique<xdrfile::rvec[]>(natoms);
         float prec,lambda;
         int ret=xdrfile::exdrOK;
-        if(trajectory_fmt=="xdr-xtc") ret=xdrfile::read_xtc(xd,natoms,&localstep,&time,box,pos.get(),&prec);
-        if(trajectory_fmt=="xdr-trr") ret=xdrfile::read_trr(xd,natoms,&localstep,&time,&lambda,box,pos.get(),NULL,NULL);
-        if(stride==0) step=localstep;
-        if(ret==xdrfile::exdrENDOFFILE) break;
-        if(ret!=xdrfile::exdrOK) break;
-        for(unsigned i=0; i<3; i++) for(unsigned j=0; j<3; j++) cell[3*i+j]=box[i][j];
-        for(int i=0; i<natoms; i++) for(unsigned j=0; j<3; j++)
+        if(trajectory_fmt=="xdr-xtc") {
+          ret=xdrfile::read_xtc(xd,natoms,&localstep,&time,box,pos.get(),&prec);
+        }
+        if(trajectory_fmt=="xdr-trr") {
+          ret=xdrfile::read_trr(xd,natoms,&localstep,&time,&lambda,box,pos.get(),NULL,NULL);
+        }
+        if(stride==0) {
+          step=localstep;
+        }
+        if(ret==xdrfile::exdrENDOFFILE) {
+          break;
+        }
+        if(ret!=xdrfile::exdrOK) {
+          break;
+        }
+        for(unsigned i=0; i<3; i++)
+          for(unsigned j=0; j<3; j++) {
+            cell[3*i+j]=box[i][j];
+          }
+        for(int i=0; i<natoms; i++)
+          for(unsigned j=0; j<3; j++) {
             coordinates[3*i+j]=real(pos[i][j]);
+          }
       } else {
         if(trajectory_fmt=="xyz") {
-          if(!Tools::getline(fp,line)) error("premature end of trajectory file");
+          if(!Tools::getline(fp,line)) {
+            error("premature end of trajectory file");
+          }
 
           std::vector<double> celld(9,0.0);
           if(pbc_cli_given==false) {
@@ -979,36 +1224,52 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
               Tools::convert(words[6],celld[6]);
               Tools::convert(words[7],celld[7]);
               Tools::convert(words[8],celld[8]);
-            } else error("needed box in second line of xyz file");
+            } else {
+              error("needed box in second line of xyz file");
+            }
           } else {			// from command line
             celld=pbc_cli_box;
           }
-          for(unsigned i=0; i<9; i++)cell[i]=real(celld[i]);
+          for(unsigned i=0; i<9; i++) {
+            cell[i]=real(celld[i]);
+          }
         }
         if(trajectory_fmt=="dlp4") {
           std::vector<double> celld(9,0.0);
           if(pbc_cli_given==false) {
-            if(!Tools::getline(fp,line)) error("error reading vector a of cell");
+            if(!Tools::getline(fp,line)) {
+              error("error reading vector a of cell");
+            }
             std::sscanf(line.c_str(),"%lf %lf %lf",&celld[0],&celld[1],&celld[2]);
-            if(!Tools::getline(fp,line)) error("error reading vector b of cell");
+            if(!Tools::getline(fp,line)) {
+              error("error reading vector b of cell");
+            }
             std::sscanf(line.c_str(),"%lf %lf %lf",&celld[3],&celld[4],&celld[5]);
-            if(!Tools::getline(fp,line)) error("error reading vector c of cell");
+            if(!Tools::getline(fp,line)) {
+              error("error reading vector c of cell");
+            }
             std::sscanf(line.c_str(),"%lf %lf %lf",&celld[6],&celld[7],&celld[8]);
           } else {
             celld=pbc_cli_box;
           }
-          for(auto i=0; i<9; i++)cell[i]=real(celld[i])*0.1;
+          for(auto i=0; i<9; i++) {
+            cell[i]=real(celld[i])*0.1;
+          }
         }
         int ddist=0;
         // Read coordinates
         for(int i=0; i<natoms; i++) {
           bool ok=Tools::getline(fp,line);
-          if(!ok) error("premature end of trajectory file");
+          if(!ok) {
+            error("premature end of trajectory file");
+          }
           double cc[3];
           if(trajectory_fmt=="xyz") {
             char dummy[1000];
             int ret=std::sscanf(line.c_str(),"%999s %100lf %100lf %100lf",dummy,&cc[0],&cc[1],&cc[2]);
-            if(ret!=4) error("cannot read line"+line);
+            if(ret!=4) {
+              error("cannot read line"+line);
+            }
           } else if(trajectory_fmt=="gro") {
             // do the gromacs way
             if(!i) {
@@ -1017,13 +1278,21 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
               //
               const char      *p1, *p2, *p3;
               p1 = std::strchr(line.c_str(), '.');
-              if (p1 == NULL) error("seems there are no coordinates in the gro file");
+              if (p1 == NULL) {
+                error("seems there are no coordinates in the gro file");
+              }
               p2 = std::strchr(&p1[1], '.');
-              if (p2 == NULL) error("seems there is only one coordinates in the gro file");
+              if (p2 == NULL) {
+                error("seems there is only one coordinates in the gro file");
+              }
               ddist = p2 - p1;
               p3 = std::strchr(&p2[1], '.');
-              if (p3 == NULL)error("seems there are only two coordinates in the gro file");
-              if (p3 - p2 != ddist)error("not uniform spacing in fields in the gro file");
+              if (p3 == NULL) {
+                error("seems there are only two coordinates in the gro file");
+              }
+              if (p3 - p2 != ddist) {
+                error("not uniform spacing in fields in the gro file");
+              }
             }
             Tools::convert(line.substr(20,ddist),cc[0]);
             Tools::convert(line.substr(20+ddist,ddist),cc[1]);
@@ -1035,18 +1304,26 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
             std::sscanf(line.c_str(),"%8s %d %lf %lf",dummy,&idummy,&m,&c);
             masses[i]=real(m);
             charges[i]=real(c);
-            if(!Tools::getline(fp,line)) error("error reading coordinates");
+            if(!Tools::getline(fp,line)) {
+              error("error reading coordinates");
+            }
             std::sscanf(line.c_str(),"%lf %lf %lf",&cc[0],&cc[1],&cc[2]);
             cc[0]*=0.1;
             cc[1]*=0.1;
             cc[2]*=0.1;
             if(lvl>0) {
-              if(!Tools::getline(fp,line)) error("error skipping velocities");
+              if(!Tools::getline(fp,line)) {
+                error("error skipping velocities");
+              }
             }
             if(lvl>1) {
-              if(!Tools::getline(fp,line)) error("error skipping forces");
+              if(!Tools::getline(fp,line)) {
+                error("error skipping forces");
+              }
             }
-          } else plumed_error();
+          } else {
+            plumed_error();
+          }
           if(!debug_pd || ( i>=pd_start && i<pd_start+pd_nlocal) ) {
             coordinates[3*i]=real(cc[0]);
             coordinates[3*i+1]=real(cc[1]);
@@ -1054,18 +1331,34 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
           }
         }
         if(trajectory_fmt=="gro") {
-          if(!Tools::getline(fp,line)) error("premature end of trajectory file");
+          if(!Tools::getline(fp,line)) {
+            error("premature end of trajectory file");
+          }
           std::vector<std::string> words=Tools::getWords(line);
-          if(words.size()<3) error("cannot understand box format");
+          if(words.size()<3) {
+            error("cannot understand box format");
+          }
           Tools::convert(words[0],cell[0]);
           Tools::convert(words[1],cell[4]);
           Tools::convert(words[2],cell[8]);
-          if(words.size()>3) Tools::convert(words[3],cell[1]);
-          if(words.size()>4) Tools::convert(words[4],cell[2]);
-          if(words.size()>5) Tools::convert(words[5],cell[3]);
-          if(words.size()>6) Tools::convert(words[6],cell[5]);
-          if(words.size()>7) Tools::convert(words[7],cell[6]);
-          if(words.size()>8) Tools::convert(words[8],cell[7]);
+          if(words.size()>3) {
+            Tools::convert(words[3],cell[1]);
+          }
+          if(words.size()>4) {
+            Tools::convert(words[4],cell[2]);
+          }
+          if(words.size()>5) {
+            Tools::convert(words[5],cell[3]);
+          }
+          if(words.size()>6) {
+            Tools::convert(words[6],cell[5]);
+          }
+          if(words.size()>7) {
+            Tools::convert(words[7],cell[6]);
+          }
+          if(words.size()>8) {
+            Tools::convert(words[8],cell[7]);
+          }
         }
 
       }
@@ -1110,7 +1403,9 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
 
 // this is necessary as only processor zero is adding to the virial:
     intracomm.Bcast(virial,0);
-    if(debug_pd) intracomm.Sum(forces);
+    if(debug_pd) {
+      intracomm.Sum(forces);
+    }
     if(debug_dd) {
       for(int i=0; i<dd_nlocal; i++) {
         forces[3*dd_gatindex[i]+0]=dd_forces[3*i+0];
@@ -1128,17 +1423,28 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
         int r=intercomm.Get_rank();
         int n=intercomm.Get_size();
         int partner=r+(2*((r+step/grex_stride)%2))-1;
-        if(partner<0)partner=0;
-        if(partner>=n) partner=n-1;
+        if(partner<0) {
+          partner=0;
+        }
+        if(partner>=n) {
+          partner=n-1;
+        }
         p.cmd("GREX setPartner",partner);
         p.cmd("GREX calculate");
         p.cmd("GREX shareAllDeltaBias");
         for(int i=0; i<n; i++) {
-          std::string s; Tools::convert(i,s);
-          real a=std::numeric_limits<real>::quiet_NaN(); s="GREX getDeltaBias "+s; p.cmd(s,&a);
-          if(grex_log) std::fprintf(grex_log," %f",a);
+          std::string s;
+          Tools::convert(i,s);
+          real a=std::numeric_limits<real>::quiet_NaN();
+          s="GREX getDeltaBias "+s;
+          p.cmd(s,&a);
+          if(grex_log) {
+            std::fprintf(grex_log," %f",a);
+          }
+        }
+        if(grex_log) {
+          std::fprintf(grex_log,"\n");
         }
-        if(grex_log) std::fprintf(grex_log,"\n");
       }
     }
 
@@ -1153,14 +1459,18 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
         std::fprintf(fp_forces,fmt.c_str(),virial[0],virial[4],virial[8]);
       }
       fmt="X "+fmt;
-      for(int i=0; i<natoms; i++)
+      for(int i=0; i<natoms; i++) {
         std::fprintf(fp_forces,fmt.c_str(),forces[3*i],forces[3*i+1],forces[3*i+2]);
+      }
     }
     if(debugforces.length()>0) {
       // Now call the routine to work out the derivatives numerically
-      numder.assign(3*natoms+9,real(0.0)); real base=0;
+      numder.assign(3*natoms+9,real(0.0));
+      real base=0;
       p.cmd("getBias",&base);
-      if( std::abs(base)<epsilon ) printf("WARNING: bias for configuration appears to be zero so debugging forces is trivial");
+      if( std::abs(base)<epsilon ) {
+        printf("WARNING: bias for configuration appears to be zero so debugging forces is trivial");
+      }
       evaluateNumericalDerivatives( step, p, coordinates, masses, charges, cell, base, numder );
 
       // And output everything to a file
@@ -1180,11 +1490,15 @@ int Driver<real>::main(FILE* in,FILE*out,Communicator& pc) {
       }
     }
 
-    if(plumedStopCondition) break;
+    if(plumedStopCondition) {
+      break;
+    }
 
     step+=stride;
   }
-  if(!parseOnly) p.cmd("runFinalJobs");
+  if(!parseOnly) {
+    p.cmd("runFinalJobs");
+  }
 
   return 0;
 }
@@ -1194,11 +1508,15 @@ void Driver<real>::evaluateNumericalDerivatives( const long long int& step, Plum
     const std::vector<real>& masses, const std::vector<real>& charges,
     std::vector<real>& cell, const double& base, std::vector<real>& numder ) {
 
-  int natoms = coordinates.size() / 3; real delta = std::sqrt(epsilon);
-  std::vector<Vector> pos(natoms); real bias=0;
+  int natoms = coordinates.size() / 3;
+  real delta = std::sqrt(epsilon);
+  std::vector<Vector> pos(natoms);
+  real bias=0;
   std::vector<real> fake_forces( 3*natoms ), fake_virial(9);
   for(int i=0; i<natoms; ++i) {
-    for(unsigned j=0; j<3; ++j) pos[i][j]=coordinates[3*i+j];
+    for(unsigned j=0; j<3; ++j) {
+      pos[i][j]=coordinates[3*i+j];
+    }
   }
 
   for(int i=0; i<natoms; ++i) {
@@ -1222,12 +1540,20 @@ void Driver<real>::evaluateNumericalDerivatives( const long long int& step, Plum
   // Create the cell
   Tensor box( cell[0], cell[1], cell[2], cell[3], cell[4], cell[5], cell[6], cell[7], cell[8] );
   // And the virial
-  Pbc pbc; pbc.setBox( box ); Tensor nvirial;
-  for(unsigned i=0; i<3; i++) for(unsigned k=0; k<3; k++) {
+  Pbc pbc;
+  pbc.setBox( box );
+  Tensor nvirial;
+  for(unsigned i=0; i<3; i++)
+    for(unsigned k=0; k<3; k++) {
       double arg0=box(i,k);
-      for(int j=0; j<natoms; ++j) pos[j]=pbc.realToScaled( pos[j] );
-      cell[3*i+k]=box(i,k)=box(i,k)+delta; pbc.setBox(box);
-      for(int j=0; j<natoms; j++) pos[j]=pbc.scaledToReal( pos[j] );
+      for(int j=0; j<natoms; ++j) {
+        pos[j]=pbc.realToScaled( pos[j] );
+      }
+      cell[3*i+k]=box(i,k)=box(i,k)+delta;
+      pbc.setBox(box);
+      for(int j=0; j<natoms; j++) {
+        pos[j]=pbc.scaledToReal( pos[j] );
+      }
       p.cmd("setStepLongLong",step);
       p.cmd("setPositions",&pos[0][0], {natoms,3});
       p.cmd("setForces",&fake_forces[0], {natoms,3});
@@ -1238,12 +1564,19 @@ void Driver<real>::evaluateNumericalDerivatives( const long long int& step, Plum
       p.cmd("prepareCalc");
       p.cmd("performCalcNoUpdate");
       p.cmd("getBias",&bias);
-      cell[3*i+k]=box(i,k)=arg0; pbc.setBox(box);
-      for(int j=0; j<natoms; j++) for(unsigned n=0; n<3; ++n) pos[j][n]=coordinates[3*j+n];
+      cell[3*i+k]=box(i,k)=arg0;
+      pbc.setBox(box);
+      for(int j=0; j<natoms; j++)
+        for(unsigned n=0; n<3; ++n) {
+          pos[j][n]=coordinates[3*j+n];
+        }
       nvirial(i,k) = ( bias - base ) / delta;
     }
   nvirial=-matmul(box.transpose(),nvirial);
-  for(unsigned i=0; i<3; i++) for(unsigned k=0; k<3; k++)  numder[3*natoms+3*i+k] = nvirial(i,k);
+  for(unsigned i=0; i<3; i++)
+    for(unsigned k=0; k<3; k++) {
+      numder[3*natoms+3*i+k] = nvirial(i,k);
+    }
 
 }
 
diff --git a/src/cltools/DriverFloat.cpp b/src/cltools/DriverFloat.cpp
index c7228c4376..98389d31a6 100644
--- a/src/cltools/DriverFloat.cpp
+++ b/src/cltools/DriverFloat.cpp
@@ -32,7 +32,9 @@ typedef Driver<float> DriverFloat;
 
 /// Specialized version
 template<>
-std::string Driver<float>::description()const { return "analyze trajectories with plumed (single precision version)"; }
+std::string Driver<float>::description()const {
+  return "analyze trajectories with plumed (single precision version)";
+}
 
 
 PLUMED_REGISTER_CLTOOL(DriverFloat,"driver-float")
diff --git a/src/cltools/GenExample.cpp b/src/cltools/GenExample.cpp
index 81a0a2a198..97779cb84b 100644
--- a/src/cltools/GenExample.cpp
+++ b/src/cltools/GenExample.cpp
@@ -60,8 +60,7 @@ plumed gen_example --plumed plumed.dat --status working
 //+ENDPLUMEDOC
 
 class GenExample:
-  public CLTool
-{
+  public CLTool {
 private:
   int multi;
   std::string status, version;
@@ -93,8 +92,7 @@ GenExample::GenExample(const CLToolOptions& co ):
   CLTool(co),
   multi(0),
   status("nobadge"),
-  version("master")
-{
+  version("master") {
   inputdata=commandline;
 }
 
@@ -103,32 +101,61 @@ int GenExample::main(FILE* in, FILE*out,Communicator& pc) {
 // set up for multi replica driver:
   parse("--multi",multi);
   if(multi) {
-    int ntot=pc.Get_size(); int nintra=ntot/multi;
-    if(multi*nintra!=ntot) error("invalid number of processes for multi environment");
+    int ntot=pc.Get_size();
+    int nintra=ntot/multi;
+    if(multi*nintra!=ntot) {
+      error("invalid number of processes for multi environment");
+    }
     pc.Split(pc.Get_rank()/nintra,pc.Get_rank(),intracomm);
     pc.Split(pc.Get_rank()%nintra,pc.Get_rank(),intercomm);
   } else {
     intracomm.Set_comm(pc.Get_comm());
   }
 
-  if( config::getVersionLong().find("dev")==std::string::npos ) version="v"+config::getVersion();
-  std::string fname, egname, outfile; parse("--plumed",fname);
-  parse("--name",egname); parse("--out",outfile); parse("--status",status);
+  if( config::getVersionLong().find("dev")==std::string::npos ) {
+    version="v"+config::getVersion();
+  }
+  std::string fname, egname, outfile;
+  parse("--plumed",fname);
+  parse("--name",egname);
+  parse("--out",outfile);
+  parse("--status",status);
 
   int r=0;
-  if(intracomm.Get_rank()==0) r=intercomm.Get_rank();
+  if(intracomm.Get_rank()==0) {
+    r=intercomm.Get_rank();
+  }
   intracomm.Bcast(r,0);
-  if(r>0) outfile="/dev/null";
+  if(r>0) {
+    outfile="/dev/null";
+  }
 
-  IFile ifile; ifile.open(fname); ifile.allowNoEOL(); std::ofstream ofile; ofile.open(outfile); std::vector<bool> shortcuts;
-  bool hasshortcuts=false, endplumed=false; std::vector<std::vector<std::string> > input; std::vector<std::string> words;
+  IFile ifile;
+  ifile.open(fname);
+  ifile.allowNoEOL();
+  std::ofstream ofile;
+  ofile.open(outfile);
+  std::vector<bool> shortcuts;
+  bool hasshortcuts=false, endplumed=false;
+  std::vector<std::vector<std::string> > input;
+  std::vector<std::string> words;
   while( Tools::getParsedLine(ifile, words, false) ) {
-    input.push_back( words ); shortcuts.push_back( false );
-    if( words.empty() || words[0].find("#")!=std::string::npos || endplumed ) continue;
-    std::vector<std::string> interpreted( words ); Tools::interpretLabel(interpreted);
-    if( interpreted[0]=="ENDPLUMED" ) { endplumed=true; continue; }
-    Keywords keys; actionRegister().getKeywords( interpreted[0], keys );
-    if( status=="working" && keys.exists("IS_SHORTCUT") ) hasshortcuts=shortcuts[shortcuts.size()-1]=true;
+    input.push_back( words );
+    shortcuts.push_back( false );
+    if( words.empty() || words[0].find("#")!=std::string::npos || endplumed ) {
+      continue;
+    }
+    std::vector<std::string> interpreted( words );
+    Tools::interpretLabel(interpreted);
+    if( interpreted[0]=="ENDPLUMED" ) {
+      endplumed=true;
+      continue;
+    }
+    Keywords keys;
+    actionRegister().getKeywords( interpreted[0], keys );
+    if( status=="working" && keys.exists("IS_SHORTCUT") ) {
+      hasshortcuts=shortcuts[shortcuts.size()-1]=true;
+    }
   }
   ifile.close();
   if( hasshortcuts ) {
@@ -139,11 +166,17 @@ int GenExample::main(FILE* in, FILE*out,Communicator& pc) {
   }
   ofile<<"<div style=\"width: 10%; float:left\">";
   ofile<<"<img src=\"https://img.shields.io/badge/";
-  if(status=="working") ofile<<version<<"-passing-green";
-  else if(status=="broken") ofile<<version<<"-failed-red";
-  else if(status=="loads") ofile<<"with-LOAD-yellow";
-  else if(status=="incomplete") ofile<<version<<"-incomplete-yellow";
-  else error("unknown status");
+  if(status=="working") {
+    ofile<<version<<"-passing-green";
+  } else if(status=="broken") {
+    ofile<<version<<"-failed-red";
+  } else if(status=="loads") {
+    ofile<<"with-LOAD-yellow";
+  } else if(status=="incomplete") {
+    ofile<<version<<"-incomplete-yellow";
+  } else {
+    error("unknown status");
+  }
   ofile<<".svg\" alt=\"tested on "<<version<<"\" /></div>";
   ofile.flush();
   if( hasshortcuts ) {
@@ -169,107 +202,204 @@ int GenExample::main(FILE* in, FILE*out,Communicator& pc) {
     std::vector<std::vector<std::string> > long_input = createLongInput( input );
     printExampleInput( long_input, egname + "long", egname, ofile );
     ofile<<"</div>"<<std::endl;
-  } else printExampleInput( input, egname, egname, ofile );
-  ofile.close(); return 0;
+  } else {
+    printExampleInput( input, egname, egname, ofile );
+  }
+  ofile.close();
+  return 0;
 }
 
 std::vector<std::vector<std::string> > GenExample::createLongInput( const std::vector<std::vector<std::string> >& input ) {
-  std::vector<std::vector<std::string> > long_input; PlumedMain myplumed; int rr=sizeof(double), natoms=10000000; double kt=2.49;
+  std::vector<std::vector<std::string> > long_input;
+  PlumedMain myplumed;
+  int rr=sizeof(double), natoms=10000000;
+  double kt=2.49;
   myplumed.cmd("setRealPrecision",&rr);
   if(Communicator::initialized()) {
     if(multi) {
-      if(intracomm.Get_rank()==0) myplumed.cmd("GREX setMPIIntercomm",&intercomm.Get_comm());
-      myplumed.cmd("GREX setMPIIntracomm",&intracomm.Get_comm()); myplumed.cmd("GREX init");
+      if(intracomm.Get_rank()==0) {
+        myplumed.cmd("GREX setMPIIntercomm",&intercomm.Get_comm());
+      }
+      myplumed.cmd("GREX setMPIIntracomm",&intracomm.Get_comm());
+      myplumed.cmd("GREX init");
     }
     myplumed.cmd("setMPIComm",&intracomm.Get_comm());
   }
-  bool endplumed=false; myplumed.cmd("setNatoms",&natoms); myplumed.cmd("setKbT",&kt); myplumed.cmd("init");
+  bool endplumed=false;
+  myplumed.cmd("setNatoms",&natoms);
+  myplumed.cmd("setKbT",&kt);
+  myplumed.cmd("init");
   for(unsigned ll=0; ll<input.size(); ++ll) {
-    if( input[ll].empty() || endplumed ) { long_input.push_back( input[ll] ); continue; }
-    if( input[ll][0].find("#")!=std::string::npos ) { long_input.push_back( input[ll] ); continue; }
-    std::vector<std::string> interpreted( input[ll] ); Tools::interpretLabel(interpreted);
-    if( interpreted[0]=="ENDPLUMED" ) { endplumed=true; long_input.push_back( input[ll] ); continue; }
-    Keywords keys; plumed_assert( actionRegister().check( interpreted[0] ) );
-    actionRegister().getKeywords( interpreted[0], keys ); std::string lab, myinputline;
-    if( Tools::parse(interpreted, "LABEL", lab ) ) myinputline = lab + ": ";
-    myinputline += interpreted[0] + " "; bool trailingcomment=false;
+    if( input[ll].empty() || endplumed ) {
+      long_input.push_back( input[ll] );
+      continue;
+    }
+    if( input[ll][0].find("#")!=std::string::npos ) {
+      long_input.push_back( input[ll] );
+      continue;
+    }
+    std::vector<std::string> interpreted( input[ll] );
+    Tools::interpretLabel(interpreted);
+    if( interpreted[0]=="ENDPLUMED" ) {
+      endplumed=true;
+      long_input.push_back( input[ll] );
+      continue;
+    }
+    Keywords keys;
+    plumed_assert( actionRegister().check( interpreted[0] ) );
+    actionRegister().getKeywords( interpreted[0], keys );
+    std::string lab, myinputline;
+    if( Tools::parse(interpreted, "LABEL", lab ) ) {
+      myinputline = lab + ": ";
+    }
+    myinputline += interpreted[0] + " ";
+    bool trailingcomment=false;
     for(unsigned i=1; i<interpreted.size(); ++i) {
-      if( trailingcomment && interpreted[i]=="@newline") { trailingcomment=false; continue; }
-      if( interpreted[i].find("#")!=std::string::npos ) { trailingcomment=true; continue; }
-      if( interpreted[i]=="@newline" || interpreted[i]=="..." ) continue;
-      std::size_t pos = 0;  while ((pos = interpreted[i].find("@newline",pos)) != std::string::npos) { interpreted[i].replace(pos, 8, "\n"); pos++; }
+      if( trailingcomment && interpreted[i]=="@newline") {
+        trailingcomment=false;
+        continue;
+      }
+      if( interpreted[i].find("#")!=std::string::npos ) {
+        trailingcomment=true;
+        continue;
+      }
+      if( interpreted[i]=="@newline" || interpreted[i]=="..." ) {
+        continue;
+      }
+      std::size_t pos = 0;
+      while ((pos = interpreted[i].find("@newline",pos)) != std::string::npos) {
+        interpreted[i].replace(pos, 8, "\n");
+        pos++;
+      }
       myinputline += interpreted[i] + " ";
     }
     if( status=="working" && keys.exists("IS_SHORTCUT") ) {
       myplumed.readInputLine( myinputline );
       ActionShortcut* as=dynamic_cast<ActionShortcut*>( myplumed.getActionSet()[myplumed.getActionSet().size()-1].get() );
-      plumed_assert( as ); std::vector<std::string> shortcut_commands = as->getSavedInputLines();
+      plumed_assert( as );
+      std::vector<std::string> shortcut_commands = as->getSavedInputLines();
       for(unsigned i=0; i<shortcut_commands.size(); ++i) {
-        std::vector<std::string> words = Tools::getWords( shortcut_commands[i] ); long_input.push_back( words );
+        std::vector<std::string> words = Tools::getWords( shortcut_commands[i] );
+        long_input.push_back( words );
       }
-    } else { long_input.push_back( input[ll] ); myplumed.readInputLine( myinputline ); }
+    } else {
+      long_input.push_back( input[ll] );
+      myplumed.readInputLine( myinputline );
+    }
   }
   return long_input;
 }
 
 void GenExample::printExampleInput( const std::vector<std::vector<std::string> >& input, const std::string& egname, const std::string& divname, std::ofstream& ofile ) {
-  PlumedMain myplumed; int rr=sizeof(double), natoms=10000000; double kt=2.49;
+  PlumedMain myplumed;
+  int rr=sizeof(double), natoms=10000000;
+  double kt=2.49;
   myplumed.cmd("setRealPrecision",&rr);
   if(Communicator::initialized()) {
     if(multi) {
-      if(intracomm.Get_rank()==0) myplumed.cmd("GREX setMPIIntercomm",&intercomm.Get_comm());
-      myplumed.cmd("GREX setMPIIntracomm",&intracomm.Get_comm()); myplumed.cmd("GREX init");
+      if(intracomm.Get_rank()==0) {
+        myplumed.cmd("GREX setMPIIntercomm",&intercomm.Get_comm());
+      }
+      myplumed.cmd("GREX setMPIIntracomm",&intracomm.Get_comm());
+      myplumed.cmd("GREX init");
     }
     myplumed.cmd("setMPIComm",&intracomm.Get_comm());
   }
-  myplumed.cmd("setNatoms",&natoms); myplumed.cmd("setKbT",&kt); myplumed.cmd("init");
-  std::vector<std::string> labellist; bool endplumed=false;
+  myplumed.cmd("setNatoms",&natoms);
+  myplumed.cmd("setKbT",&kt);
+  myplumed.cmd("init");
+  std::vector<std::string> labellist;
+  bool endplumed=false;
   ofile<<"<pre style=\"width: 97%;\" class=\"fragment\">"<<std::endl;
   for(unsigned ll=0; ll<input.size(); ++ll) {
-    if( input[ll].empty() ) { ofile<<std::endl; continue; }
+    if( input[ll].empty() ) {
+      ofile<<std::endl;
+      continue;
+    }
     if( input[ll][0].find("#")!=std::string::npos || endplumed ) {
       ofile<<"<span style=\"color:blue\">"<<input[ll][0];
-      for(unsigned i=1; i<input[ll].size(); ++i) ofile<<" "<<input[ll][i];
+      for(unsigned i=1; i<input[ll].size(); ++i) {
+        ofile<<" "<<input[ll][i];
+      }
       ofile<<"</span>"<<std::endl;;
     } else {
       // Interpret the label if this needs to be done
-      std::vector<std::string> interpreted( input[ll] ); Tools::interpretLabel(interpreted); std::string lab, myinputline;
+      std::vector<std::string> interpreted( input[ll] );
+      Tools::interpretLabel(interpreted);
+      std::string lab, myinputline;
       // Now read in the label
       if( Tools::parse(interpreted,"LABEL",lab) ) {
         ofile<<"<b name=\""<<egname<<lab<<"\" onclick=\'showPath(\""<<divname<<"\",\""<<egname<<lab<<"\")\'>"<<lab<<": </b>";
-        labellist.push_back(lab); myinputline = lab + ": ";
+        labellist.push_back(lab);
+        myinputline = lab + ": ";
       }
       // Print the keyword in use in the action
-      std::string action = interpreted[0]; myinputline += interpreted[0] + " ";
-      if( action=="ENDPLUMED" ) endplumed=true;
-      Keywords keys; actionRegister().getKeywords( interpreted[0], keys );
+      std::string action = interpreted[0];
+      myinputline += interpreted[0] + " ";
+      if( action=="ENDPLUMED" ) {
+        endplumed=true;
+      }
+      Keywords keys;
+      actionRegister().getKeywords( interpreted[0], keys );
       // Handle conversion of action names to links
-      std::transform(action.begin(), action.end(), action.begin(), [](unsigned char c) { return std::tolower(c); });
+      std::transform(action.begin(), action.end(), action.begin(), [](unsigned char c) {
+        return std::tolower(c);
+      });
       ofile<<"<a href=\"https://www.plumed.org/doc-"<<version<<"/user-doc/html/";
       for(unsigned n=0;; ++n) {
         std::size_t und=action.find_first_of("_");
-        if( und==std::string::npos ) break;
+        if( und==std::string::npos ) {
+          break;
+        }
         std::string first=action.substr(0,und);
-        for(auto c : first ) { if( isdigit(c) ) ofile<<c; else ofile<<"_"<<c; }
-        ofile<<"_"; action=action.substr(und+1);
+        for(auto c : first ) {
+          if( isdigit(c) ) {
+            ofile<<c;
+          } else {
+            ofile<<"_"<<c;
+          }
+        }
+        ofile<<"_";
+        action=action.substr(und+1);
+      }
+      for(auto c : action ) {
+        if( isdigit(c) ) {
+          ofile<<c;
+        } else {
+          ofile<<"_"<<c;
+        }
       }
-      for(auto c : action ) { if( isdigit(c) ) ofile<<c; else ofile<<"_"<<c; }
       ofile<<".html\" style=\"color:green\">"<<interpreted[0]<<"</a> ";
       // And write out everything else in the input line
       bool trailingcomment=false;
       for(unsigned i=1; i<interpreted.size(); ++i) {
-        if( interpreted[i]=="@newline" && i==1 ) { ofile<<"..."<<std::endl<<"   "; continue; }
-        else if( interpreted[i]=="@newline" ) {
-          if( trailingcomment ) { ofile<<"</span>"; trailingcomment=false; }
-          if( interpreted[i+1]=="..." ) ofile<<std::endl;
-          else ofile<<std::endl<<"   ";
+        if( interpreted[i]=="@newline" && i==1 ) {
+          ofile<<"..."<<std::endl<<"   ";
+          continue;
+        } else if( interpreted[i]=="@newline" ) {
+          if( trailingcomment ) {
+            ofile<<"</span>";
+            trailingcomment=false;
+          }
+          if( interpreted[i+1]=="..." ) {
+            ofile<<std::endl;
+          } else {
+            ofile<<std::endl<<"   ";
+          }
           continue;
         } else if( interpreted[i]=="__FILL__" ) {
-          if( status!="incomplete" ) error("found __FILL__ statement but status is " + status);
+          if( status!="incomplete" ) {
+            error("found __FILL__ statement but status is " + status);
+          }
           ofile<<"<span style=\"background-color:yellow\">__FILL__</span>";
           continue;
-        } else if( interpreted[i]==action ) continue;
-        if( interpreted[i].find("#")!=std::string::npos ) { trailingcomment=true; ofile<<"<span style=\"color:blue\">"; }
+        } else if( interpreted[i]==action ) {
+          continue;
+        }
+        if( interpreted[i].find("#")!=std::string::npos ) {
+          trailingcomment=true;
+          ofile<<"<span style=\"color:blue\">";
+        }
 
         if( !trailingcomment ) {
           std::size_t eq=interpreted[i].find_first_of("=");
@@ -277,22 +407,41 @@ void GenExample::printExampleInput( const std::vector<std::vector<std::string> >
             std::string keyword=interpreted[i].substr(0,eq), rest=interpreted[i].substr(eq+1);
             ofile<<"<div class=\"tooltip\">"<<keyword<<"<div class=\"right\">"<<keys.getTooltip(keyword)<<"<i></i></div></div>";
             if( rest=="__FILL__" ) {
-              if( status!="incomplete" ) error("found __FILL__ statement but status is " + status);
+              if( status!="incomplete" ) {
+                error("found __FILL__ statement but status is " + status);
+              }
               ofile<<"=<span style=\"background-color:yellow\">__FILL__</span>";
             } else if( rest.find_first_of("{")!=std::string::npos ) {
-              std::size_t pos = 0;  while ((pos = rest.find("@newline",pos)) != std::string::npos) { rest.replace(pos, 8, "\n"); pos++; }
-              ofile<<"="<<rest<<" "; myinputline += keyword + "=" + rest + " ";
+              std::size_t pos = 0;
+              while ((pos = rest.find("@newline",pos)) != std::string::npos) {
+                rest.replace(pos, 8, "\n");
+                pos++;
+              }
+              ofile<<"="<<rest<<" ";
+              myinputline += keyword + "=" + rest + " ";
             } else {
-              std::vector<std::string> args=Tools::getWords(rest,"\t\n ,"); ofile<<"=";
+              std::vector<std::string> args=Tools::getWords(rest,"\t\n ,");
+              ofile<<"=";
               for(unsigned i=0; i<args.size(); ++i) {
-                bool islabel=false; std::string thislab;
+                bool islabel=false;
+                std::string thislab;
                 for(unsigned j=0; j<labellist.size(); ++j) {
-                  std::size_t dot=args[i].find_first_of("."); std::string lll=args[i].substr(0,dot);
-                  if( lll==labellist[j] ) { islabel=true; thislab=labellist[j]; break; }
+                  std::size_t dot=args[i].find_first_of(".");
+                  std::string lll=args[i].substr(0,dot);
+                  if( lll==labellist[j] ) {
+                    islabel=true;
+                    thislab=labellist[j];
+                    break;
+                  }
+                }
+                if( islabel ) {
+                  ofile<<"<b name=\""<<egname<<thislab<<"\">"<<args[i]<<"</b>";
+                } else {
+                  ofile<<args[i];
+                }
+                if( i!=args.size()-1 ) {
+                  ofile<<",";
                 }
-                if( islabel ) ofile<<"<b name=\""<<egname<<thislab<<"\">"<<args[i]<<"</b>";
-                else ofile<<args[i];
-                if( i!=args.size()-1 ) ofile<<",";
               }
               myinputline += interpreted[i] + " ";
             }
@@ -300,10 +449,16 @@ void GenExample::printExampleInput( const std::vector<std::vector<std::string> >
           } else if( interpreted[i]!="@newline" && interpreted[i]!="..." ) {
             myinputline += interpreted[i] + " ";
             ofile<<"<div class=\"tooltip\">"<<interpreted[i]<<"<div class=\"right\">"<<keys.getTooltip(interpreted[i])<<"<i></i></div></div> ";
-          } else if( interpreted[i]=="..." ) ofile<<"...";
-        } else ofile<<interpreted[i]<<" ";
+          } else if( interpreted[i]=="..." ) {
+            ofile<<"...";
+          }
+        } else {
+          ofile<<interpreted[i]<<" ";
+        }
+      }
+      if( trailingcomment ) {
+        ofile<<"</span>";
       }
-      if( trailingcomment ) ofile<<"</span>";
       // This builds the hidden content that tells the user about what is calculated
       if( status=="working" ) {
         ofile<<"<span style=\"display:none;\" id=\""<<egname<<lab<<"\">";
@@ -311,14 +466,16 @@ void GenExample::printExampleInput( const std::vector<std::vector<std::string> >
         myplumed.readInputLine( myinputline );
         ActionWithValue* av=myplumed.getActionSet().selectWithLabel<ActionWithValue*>(lab);
         if( av ) {
-          if( av->getNumberOfComponents()==1 ) { ofile<<" calculates a single scalar value"; }
-          else if( av->getNumberOfComponents()>0 ) {
+          if( av->getNumberOfComponents()==1 ) {
+            ofile<<" calculates a single scalar value";
+          } else if( av->getNumberOfComponents()>0 ) {
             ofile<<" calculates the following quantities:"<<std::endl;
             ofile<<"<table  align=\"center\" frame=\"void\" width=\"95%%\" cellpadding=\"5%%\">"<<std::endl;
             ofile<<"<tr><td width=\"5%%\"><b> Quantity </b>  </td><td><b> Description </b> </td></tr>"<<std::endl;
             unsigned ncomp = av->getNumberOfComponents();
             for(unsigned k=0; k<ncomp; ++k ) {
-              std::string myname = av->copyOutput(k)->getName(); std::size_t dot=myname.find_first_of(".");
+              std::string myname = av->copyOutput(k)->getName();
+              std::size_t dot=myname.find_first_of(".");
               std::string tname=myname.substr(dot+1);
               ofile<<"<tr><td width=\"5%%\">"<<myname<<"</td><td>"<<av->getOutputComponentDescription(tname,keys)<<"</td></tr>"<<std::endl;
             }
@@ -326,8 +483,11 @@ void GenExample::printExampleInput( const std::vector<std::vector<std::string> >
           }
         } else {
           ActionWithVirtualAtom* avv=myplumed.getActionSet().selectWithLabel<ActionWithVirtualAtom*>(lab);
-          if( avv ) ofile<<" calculates the position of a virtual atom";
-          else if( interpreted[0]=="GROUP" ) ofile<<" defines a group of atoms so that they can be referred to later in the input";
+          if( avv ) {
+            ofile<<" calculates the position of a virtual atom";
+          } else if( interpreted[0]=="GROUP" ) {
+            ofile<<" defines a group of atoms so that they can be referred to later in the input";
+          }
         }
         ofile<<"</span>"<<std::endl;
       } else {
diff --git a/src/cltools/GenJson.cpp b/src/cltools/GenJson.cpp
index 86ed8f2ef4..1d873954ff 100644
--- a/src/cltools/GenJson.cpp
+++ b/src/cltools/GenJson.cpp
@@ -69,19 +69,26 @@ void GenJson::registerKeywords( Keywords& keys ) {
 
 GenJson::GenJson(const CLToolOptions& co ):
   CLTool(co),
-  version("master")
-{
+  version("master") {
   inputdata=commandline;
-  if( config::getVersionLong().find("dev")==std::string::npos ) version="v"+config::getVersion();
+  if( config::getVersionLong().find("dev")==std::string::npos ) {
+    version="v"+config::getVersion();
+  }
 }
 
 int GenJson::main(FILE* in, FILE*out,Communicator& pc) {
-  std::string line(""), actionfile; parse("--actions",actionfile);
-  IFile myfile; myfile.open(actionfile); bool stat;
+  std::string line(""), actionfile;
+  parse("--actions",actionfile);
+  IFile myfile;
+  myfile.open(actionfile);
+  bool stat;
   std::map<std::string,std::string> action_map;
   while((stat=myfile.getline(line))) {
-    std::size_t col = line.find_first_of(":"); std::string docs = line.substr(col+1);
-    if( docs.find("\\")!=std::string::npos ) error("found invalid backslash character in first line of documentation for action " + line.substr(0,col) );
+    std::size_t col = line.find_first_of(":");
+    std::string docs = line.substr(col+1);
+    if( docs.find("\\")!=std::string::npos ) {
+      error("found invalid backslash character in first line of documentation for action " + line.substr(0,col) );
+    }
     action_map.insert(std::pair<std::string,std::string>( line.substr(0,col), docs ) );
   }
   myfile.close();
@@ -95,34 +102,61 @@ int GenJson::main(FILE* in, FILE*out,Communicator& pc) {
   // Get the names of all the actions
   std::vector<std::string> action_names( actionRegister().getActionNames() );
   for(unsigned i=0; i<action_names.size(); ++i) {
-    std::cout<<"  \""<<action_names[i]<<'"'<<": {"<<std::endl; std::string action=action_names[i];
+    std::cout<<"  \""<<action_names[i]<<'"'<<": {"<<std::endl;
+    std::string action=action_names[i];
     // Handle conversion of action names to links
     std::cout<<"    \"hyperlink\" : \"https://www.plumed.org/doc-"<<version<<"/user-doc/html/";
-    std::transform(action.begin(), action.end(), action.begin(), [](unsigned char c) { return std::tolower(c); });
+    std::transform(action.begin(), action.end(), action.begin(), [](unsigned char c) {
+      return std::tolower(c);
+    });
     while(true) {
       std::size_t und=action.find_first_of("_");
-      if( und==std::string::npos ) break;
+      if( und==std::string::npos ) {
+        break;
+      }
       std::string first=action.substr(0,und);
-      for(auto c : first ) { if( isdigit(c) ) std::cout<<c; else std::cout<<"_"<<c; }
-      std::cout<<"_"; action=action.substr(und+1);
+      for(auto c : first ) {
+        if( isdigit(c) ) {
+          std::cout<<c;
+        } else {
+          std::cout<<"_"<<c;
+        }
+      }
+      std::cout<<"_";
+      action=action.substr(und+1);
+    }
+    for(auto c : action ) {
+      if( isdigit(c) ) {
+        std::cout<<c;
+      } else {
+        std::cout<<"_"<<c;
+      }
     }
-    for(auto c : action ) { if( isdigit(c) ) std::cout<<c; else std::cout<<"_"<<c; }
     std::cout<<".html\","<<std::endl;
     std::cout<<"    \"description\" : \""<<action_map[action_names[i]]<<"\",\n";
     std::cout<<"    \"module\" : \""<<getModuleMap().find(action_names[i])->second<<"\",\n";
     // Now output keyword information
-    Keywords keys; actionRegister().getKeywords( action_names[i], keys );
+    Keywords keys;
+    actionRegister().getKeywords( action_names[i], keys );
     std::cout<<"    \"displayname\" : \""<<keys.getDisplayName()<<"\",\n";
     std::cout<<"    \"syntax\" : {"<<std::endl;
     for(unsigned j=0; j<keys.size(); ++j) {
       std::string desc = keys.getKeywordDescription( keys.getKeyword(j) );
       if( desc.find("default=")!=std::string::npos ) {
-        std::size_t brac=desc.find_first_of(")"); desc = desc.substr(brac+1);
+        std::size_t brac=desc.find_first_of(")");
+        desc = desc.substr(brac+1);
+      }
+      std::size_t dot=desc.find_first_of(".");
+      std::string mydescrip = desc.substr(0,dot);
+      if( mydescrip.find("\\")!=std::string::npos ) {
+        error("found invalid backslash character documentation for keyword " + keys.getKeyword(j) + " in action " + action_names[i] );
       }
-      std::size_t dot=desc.find_first_of("."); std::string mydescrip = desc.substr(0,dot);
-      if( mydescrip.find("\\")!=std::string::npos ) error("found invalid backslash character documentation for keyword " + keys.getKeyword(j) + " in action " + action_names[i] );
       std::cout<<"       \""<<keys.getKeyword(j)<<"\" : { \"type\": \""<<keys.getStyle(keys.getKeyword(j))<<"\", \"description\": \""<<mydescrip<<"\", \"multiple\": "<<keys.numbered( keys.getKeyword(j) )<<"}";
-      if( j==keys.size()-1 && !keys.exists("HAS_VALUES") ) std::cout<<std::endl; else std::cout<<","<<std::endl;
+      if( j==keys.size()-1 && !keys.exists("HAS_VALUES") ) {
+        std::cout<<std::endl;
+      } else {
+        std::cout<<","<<std::endl;
+      }
     }
     if( keys.exists("HAS_VALUES") ) {
       std::cout<<"       \"output\" : {"<<std::endl;
@@ -130,19 +164,35 @@ int GenJson::main(FILE* in, FILE*out,Communicator& pc) {
       // Check if we have a value
       bool hasvalue=true;
       for(unsigned k=0; k<components.size(); ++k) {
-        if( keys.getOutputComponentFlag( components[k] )=="default" ) { hasvalue=false; break; }
+        if( keys.getOutputComponentFlag( components[k] )=="default" ) {
+          hasvalue=false;
+          break;
+        }
       }
       for(unsigned k=0; k<components.size(); ++k) {
-        std::string compname=components[k]; if( components[k]==".#!value" ) { hasvalue=false; compname="value"; }
+        std::string compname=components[k];
+        if( components[k]==".#!value" ) {
+          hasvalue=false;
+          compname="value";
+        }
         std::cout<<"         \""<<compname<<"\" : {"<<std::endl;
         std::cout<<"           \"flag\": \""<<keys.getOutputComponentFlag( components[k] )<<"\","<<std::endl;
         std::string desc=keys.getOutputComponentDescription( components[k] );
-        std::size_t dot=desc.find_first_of("."); std::string mydescrip = desc.substr(0,dot);
-        if( mydescrip.find("\\")!=std::string::npos ) error("found invalid backslash character documentation for output component " + compname + " in action " + action_names[i] );
+        std::size_t dot=desc.find_first_of(".");
+        std::string mydescrip = desc.substr(0,dot);
+        if( mydescrip.find("\\")!=std::string::npos ) {
+          error("found invalid backslash character documentation for output component " + compname + " in action " + action_names[i] );
+        }
         std::cout<<"           \"description\": \""<<mydescrip<<"\""<<std::endl;
-        if( k==components.size()-1 ) std::cout<<"         }"<<std::endl; else std::cout<<"         },"<<std::endl;
+        if( k==components.size()-1 ) {
+          std::cout<<"         }"<<std::endl;
+        } else {
+          std::cout<<"         },"<<std::endl;
+        }
+      }
+      if( hasvalue && components.size()==0 ) {
+        printf("WARNING: no components have been registered for action %s \n", action_names[i].c_str() );
       }
-      if( hasvalue && components.size()==0 ) printf("WARNING: no components have been registered for action %s \n", action_names[i].c_str() );
       std::cout<<"       }"<<std::endl;
 
     }
@@ -150,7 +200,9 @@ int GenJson::main(FILE* in, FILE*out,Communicator& pc) {
     if( keys.getNeededKeywords().size()>0 ) {
       std::vector<std::string> neededActions( keys.getNeededKeywords() );
       std::cout<<"    \"needs\" : ["<<"\""<<neededActions[0]<<"\"";
-      for(unsigned j=1; j<neededActions.size(); ++j) std::cout<<", \""<<neededActions[j]<<"\"";
+      for(unsigned j=1; j<neededActions.size(); ++j) {
+        std::cout<<", \""<<neededActions[j]<<"\"";
+      }
       std::cout<<"],"<<std::endl;
     }
     // This ensures that \n is replaced by \\n
@@ -158,7 +210,10 @@ int GenJson::main(FILE* in, FILE*out,Communicator& pc) {
     for( std::size_t pos = helpstr.find("\n");
          pos != std::string::npos;
          pos = helpstr.find("\n", pos)
-       ) { helpstr.replace(pos, unsafen.size(), safen); pos += safen.size(); }
+       ) {
+      helpstr.replace(pos, unsafen.size(), safen);
+      pos += safen.size();
+    }
     std::cout<<"    \"help\" : \""<<helpstr<<"\"\n";
     std::cout<<"  },"<<std::endl;
   }
diff --git a/src/cltools/GenTemplate.cpp b/src/cltools/GenTemplate.cpp
index c0579ab321..9df5c7e9e3 100644
--- a/src/cltools/GenTemplate.cpp
+++ b/src/cltools/GenTemplate.cpp
@@ -49,8 +49,7 @@ plumed gentemplate --action DISTANCE
 //+ENDPLUMEDOC
 
 class GenTemplate:
-  public CLTool
-{
+  public CLTool {
 public:
   static void registerKeywords( Keywords& keys );
   explicit GenTemplate(const CLToolOptions& co );
@@ -70,8 +69,7 @@ void GenTemplate::registerKeywords( Keywords& keys ) {
 }
 
 GenTemplate::GenTemplate(const CLToolOptions& co ):
-  CLTool(co)
-{
+  CLTool(co) {
   inputdata=commandline;
 }
 
@@ -91,7 +89,9 @@ int GenTemplate::main(FILE* in, FILE*out,Communicator& pc) {
       error("there is no registered action named " + action);
       return 1;
     }
-  } else return 1;
+  } else {
+    return 1;
+  }
 
 
 
diff --git a/src/cltools/Info.cpp b/src/cltools/Info.cpp
index bedb79b140..1a392a847a 100644
--- a/src/cltools/Info.cpp
+++ b/src/cltools/Info.cpp
@@ -47,8 +47,7 @@ plumed info --root
 //+ENDPLUMEDOC
 
 class Info:
-  public CLTool
-{
+  public CLTool {
 public:
   static void registerKeywords( Keywords& keys );
   explicit Info(const CLToolOptions& co );
@@ -74,45 +73,73 @@ void Info::registerKeywords( Keywords& keys ) {
 }
 
 Info::Info(const CLToolOptions& co ):
-  CLTool(co)
-{
+  CLTool(co) {
   inputdata=commandline;
 }
 
 int Info::main(FILE* in, FILE*out,Communicator& pc) {
 
-  bool printconfiguration; parseFlag("--configuration",printconfiguration);
-  bool printroot; parseFlag("--root",printroot);
-  bool printuserdoc; parseFlag("--user-doc",printuserdoc);
-  bool printdeveloperdoc; parseFlag("--developer-doc",printdeveloperdoc);
-  bool printversion; parseFlag("--version",printversion);
-  bool printlongversion; parseFlag("--long-version",printlongversion);
-  bool printgitversion; parseFlag("--git-version",printgitversion);
-  bool printincludedir; parseFlag("--include-dir",printincludedir);
-  bool printsoext; parseFlag("--soext",printsoext);
-  if(printroot) std::fprintf(out,"%s\n",config::getPlumedRoot().c_str());
-  if(printconfiguration) std::fprintf(out,"%s",config::getMakefile().c_str());
-  if(printincludedir) std::fprintf(out,"%s\n",config::getPlumedIncludedir().c_str());
+  bool printconfiguration;
+  parseFlag("--configuration",printconfiguration);
+  bool printroot;
+  parseFlag("--root",printroot);
+  bool printuserdoc;
+  parseFlag("--user-doc",printuserdoc);
+  bool printdeveloperdoc;
+  parseFlag("--developer-doc",printdeveloperdoc);
+  bool printversion;
+  parseFlag("--version",printversion);
+  bool printlongversion;
+  parseFlag("--long-version",printlongversion);
+  bool printgitversion;
+  parseFlag("--git-version",printgitversion);
+  bool printincludedir;
+  parseFlag("--include-dir",printincludedir);
+  bool printsoext;
+  parseFlag("--soext",printsoext);
+  if(printroot) {
+    std::fprintf(out,"%s\n",config::getPlumedRoot().c_str());
+  }
+  if(printconfiguration) {
+    std::fprintf(out,"%s",config::getMakefile().c_str());
+  }
+  if(printincludedir) {
+    std::fprintf(out,"%s\n",config::getPlumedIncludedir().c_str());
+  }
   if(printuserdoc) {
     std::string userdoc=config::getPlumedHtmldir()+"/user-doc/html/index.html";
     FILE *ff=std::fopen(userdoc.c_str(),"r");
     // no exception here
-    if(ff) std::fclose(ff);
-    else userdoc="http://www.plumed.org/doc-v" + config::getVersion() + "/user-doc/html/index.html";
+    if(ff) {
+      std::fclose(ff);
+    } else {
+      userdoc="http://www.plumed.org/doc-v" + config::getVersion() + "/user-doc/html/index.html";
+    }
     std::fprintf(out,"%s\n",userdoc.c_str());
   }
   if(printdeveloperdoc) {
     std::string developerdoc=config::getPlumedHtmldir()+"/developer-doc/html/index.html";
     FILE *ff=std::fopen(developerdoc.c_str(),"r");
     // no exception here
-    if(ff) std::fclose(ff);
-    else developerdoc="http://www.plumed.org/doc-v" + config::getVersion() + "/developer-doc/html/index.html";
+    if(ff) {
+      std::fclose(ff);
+    } else {
+      developerdoc="http://www.plumed.org/doc-v" + config::getVersion() + "/developer-doc/html/index.html";
+    }
     std::fprintf(out,"%s\n",developerdoc.c_str());
   }
-  if(printversion) std::fprintf(out,"%s\n",config::getVersion().c_str());
-  if(printlongversion) std::fprintf(out,"%s\n",config::getVersionLong().c_str());
-  if(printgitversion) std::fprintf(out,"%s\n",config::getVersionGit().c_str());
-  if(printsoext) std::fprintf(out,"%s\n",config::getSoExt().c_str());
+  if(printversion) {
+    std::fprintf(out,"%s\n",config::getVersion().c_str());
+  }
+  if(printlongversion) {
+    std::fprintf(out,"%s\n",config::getVersionLong().c_str());
+  }
+  if(printgitversion) {
+    std::fprintf(out,"%s\n",config::getVersionGit().c_str());
+  }
+  if(printsoext) {
+    std::fprintf(out,"%s\n",config::getSoExt().c_str());
+  }
 
   return 0;
 }
diff --git a/src/cltools/Manual.cpp b/src/cltools/Manual.cpp
index f6f95c3e7c..ce1833290f 100644
--- a/src/cltools/Manual.cpp
+++ b/src/cltools/Manual.cpp
@@ -52,8 +52,7 @@ plumed manual --action DISTANCE
 //+ENDPLUMEDOC
 
 class Manual:
-  public CLTool
-{
+  public CLTool {
 public:
   static void registerKeywords( Keywords& keys );
   explicit Manual(const CLToolOptions& co );
@@ -73,22 +72,27 @@ void Manual::registerKeywords( Keywords& keys ) {
 }
 
 Manual::Manual(const CLToolOptions& co ):
-  CLTool(co)
-{
+  CLTool(co) {
   inputdata=commandline;
 }
 
 int Manual::main(FILE* in, FILE*out,Communicator& pc) {
 
   std::string action;
-  if( !parse("--action",action) ) return 1;
+  if( !parse("--action",action) ) {
+    return 1;
+  }
   std::cerr<<"LIST OF DOCUMENTED ACTIONS:\n";
   std::cerr<<actionRegister()<<"\n";
   std::cerr<<"LIST OF DOCUMENTED COMMAND LINE TOOLS:\n";
   std::cerr<<cltoolRegister()<<"\n\n";
-  bool vimout; parseFlag("--vim",vimout);
-  bool spellout; parseFlag("--spelling",spellout);
-  if( vimout && spellout ) error("can only use one of --vim and --spelling at a time");
+  bool vimout;
+  parseFlag("--vim",vimout);
+  bool spellout;
+  parseFlag("--spelling",spellout);
+  if( vimout && spellout ) {
+    error("can only use one of --vim and --spelling at a time");
+  }
   if( !actionRegister().printManual(action,vimout,spellout) && !cltoolRegister().printManual(action,spellout) ) {
     std::fprintf(stderr,"specified action is not registered\n");
     return 1;
diff --git a/src/cltools/PdbRenumber.cpp b/src/cltools/PdbRenumber.cpp
index 33d382a324..00188a14c0 100644
--- a/src/cltools/PdbRenumber.cpp
+++ b/src/cltools/PdbRenumber.cpp
@@ -98,8 +98,7 @@ Additional lines in `list.txt` will just be ignored.
 //+ENDPLUMEDOC
 
 class PdbRenumber:
-  public CLTool
-{
+  public CLTool {
 public:
   static void registerKeywords( Keywords& keys );
   explicit PdbRenumber(const CLToolOptions& co );
@@ -120,8 +119,7 @@ void PdbRenumber::registerKeywords( Keywords& keys ) {
 }
 
 PdbRenumber::PdbRenumber(const CLToolOptions& co ):
-  CLTool(co)
-{
+  CLTool(co) {
   inputdata=commandline;
 }
 
@@ -158,7 +156,9 @@ int PdbRenumber::main(FILE* in, FILE*out,Communicator& pc) {
       serials.push_back(i);
     }
   } else {
-    if(iat==0) iat=1;
+    if(iat==0) {
+      iat=1;
+    }
     std::fprintf(out,"  with atoms starting from %u\n",iat);
   }
 
@@ -186,7 +186,9 @@ int PdbRenumber::main(FILE* in, FILE*out,Communicator& pc) {
       ofile << line.substr(0,6) << &at[0] << line.substr(11) << "\n";
       iat++;
     } else {
-      if(record=="END" || record=="ENDMDL") iat=0;
+      if(record=="END" || record=="ENDMDL") {
+        iat=0;
+      }
       ofile << line << "\n";
     }
   }
diff --git a/src/cltools/ShowGraph.cpp b/src/cltools/ShowGraph.cpp
index 4a5e0ec1d4..b00472a83c 100644
--- a/src/cltools/ShowGraph.cpp
+++ b/src/cltools/ShowGraph.cpp
@@ -58,8 +58,7 @@ plumed show_graph --plumed plumed.dat
 //+ENDPLUMEDOC
 
 class ShowGraph :
-  public CLTool
-{
+  public CLTool {
 public:
   static void registerKeywords( Keywords& keys );
   explicit ShowGraph(const CLToolOptions& co );
@@ -85,8 +84,7 @@ void ShowGraph::registerKeywords( Keywords& keys ) {
 }
 
 ShowGraph::ShowGraph(const CLToolOptions& co ):
-  CLTool(co)
-{
+  CLTool(co) {
   inputdata=commandline;
 }
 
@@ -95,50 +93,68 @@ std::string ShowGraph::getLabel(const Action* a, const bool& amp) {
 }
 
 std::string ShowGraph::getLabel( const std::string& s, const bool& amp ) {
-  if( s.find("@")==std::string::npos ) return s;
+  if( s.find("@")==std::string::npos ) {
+    return s;
+  }
   std::size_t p=s.find_first_of("@");
-  if( amp ) return "#64;" + s.substr(p+1);
+  if( amp ) {
+    return "#64;" + s.substr(p+1);
+  }
   return s.substr(p+1);
 }
 
 void ShowGraph::printStyle( const unsigned& linkcount, const Value* v, OFile& ofile ) {
-  if( v->getRank()>0 && v->hasDerivatives() ) ofile.printf("linkStyle %d stroke:green,color:green;\n", linkcount);
-  else if( v->getRank()==1 ) ofile.printf("linkStyle %d stroke:blue,color:blue;\n", linkcount);
-  else if ( v->getRank()==2 ) ofile.printf("linkStyle %d stroke:red,color:red;\n", linkcount);
+  if( v->getRank()>0 && v->hasDerivatives() ) {
+    ofile.printf("linkStyle %d stroke:green,color:green;\n", linkcount);
+  } else if( v->getRank()==1 ) {
+    ofile.printf("linkStyle %d stroke:blue,color:blue;\n", linkcount);
+  } else if ( v->getRank()==2 ) {
+    ofile.printf("linkStyle %d stroke:red,color:red;\n", linkcount);
+  }
 }
 
 void ShowGraph::printArgumentConnections( const ActionWithArguments* a, unsigned& linkcount, const bool& force, OFile& ofile ) {
-  if( !a ) return;
+  if( !a ) {
+    return;
+  }
   for(const auto & v : a->getArguments() ) {
     if( force && v->forcesWereAdded() ) {
       ofile.printf("%s -- %s --> %s\n", getLabel(a).c_str(), v->getName().c_str(), getLabel(v->getPntrToAction()).c_str() );
-      printStyle( linkcount, v, ofile ); linkcount++;
+      printStyle( linkcount, v, ofile );
+      linkcount++;
     } else if( !force ) {
       ofile.printf("%s -- %s --> %s\n", getLabel(v->getPntrToAction()).c_str(),v->getName().c_str(),getLabel(a).c_str() );
-      printStyle( linkcount, v, ofile ); linkcount++;
+      printStyle( linkcount, v, ofile );
+      linkcount++;
     }
   }
 }
 
 void ShowGraph::printAtomConnections( const ActionAtomistic* a, unsigned& linkcount, const bool& force, OFile& ofile ) {
-  if( !a ) return;
+  if( !a ) {
+    return;
+  }
   for(const auto & d : a->getDependencies() ) {
     ActionToPutData* dp=dynamic_cast<ActionToPutData*>(d);
     if( dp && dp->getLabel()=="posx" ) {
       if( force && (dp->copyOutput(0))->forcesWereAdded() ) {
         ofile.printf("%s --> MD\n", getLabel(a).c_str() );
-        ofile.printf("linkStyle %d stroke:violet,color:violet;\n", linkcount); linkcount++;
+        ofile.printf("linkStyle %d stroke:violet,color:violet;\n", linkcount);
+        linkcount++;
       } else {
         ofile.printf("MD --> %s\n", getLabel(a).c_str() );
-        ofile.printf("linkStyle %d stroke:violet,color:violet;\n", linkcount); linkcount++;
+        ofile.printf("linkStyle %d stroke:violet,color:violet;\n", linkcount);
+        linkcount++;
       }
     } else if( dp && dp->getLabel()!="posy" && dp->getLabel()!="posz" && dp->getLabel()!="Masses" && dp->getLabel()!="Charges" ) {
       if( force && (dp->copyOutput(0))->forcesWereAdded() ) {
         ofile.printf("%s -- %s --> %s\n",getLabel(a).c_str(), getLabel(d).c_str(), getLabel(d).c_str() );
-        printStyle( linkcount, dp->copyOutput(0), ofile ); linkcount++;
+        printStyle( linkcount, dp->copyOutput(0), ofile );
+        linkcount++;
       } else {
         ofile.printf("%s -- %s --> %s\n", getLabel(d).c_str(),getLabel(d).c_str(),getLabel(a).c_str() );
-        printStyle( linkcount, dp->copyOutput(0), ofile ); linkcount++;
+        printStyle( linkcount, dp->copyOutput(0), ofile );
+        linkcount++;
       }
       continue;
     }
@@ -146,10 +162,12 @@ void ShowGraph::printAtomConnections( const ActionAtomistic* a, unsigned& linkco
     if( dv ) {
       if( force && (dv->copyOutput(0))->forcesWereAdded() ) {
         ofile.printf("%s -- %s --> %s\n", getLabel(a).c_str(),getLabel(d).c_str(),getLabel(d).c_str() );
-        ofile.printf("linkStyle %d stroke:violet,color:violet;\n", linkcount); linkcount++;
+        ofile.printf("linkStyle %d stroke:violet,color:violet;\n", linkcount);
+        linkcount++;
       } else {
         ofile.printf("%s -- %s --> %s\n", getLabel(d).c_str(),getLabel(d).c_str(),getLabel(a).c_str() );
-        ofile.printf("linkStyle %d stroke:violet,color:violet;\n", linkcount); linkcount++;
+        ofile.printf("linkStyle %d stroke:violet,color:violet;\n", linkcount);
+        linkcount++;
       }
     }
   }
@@ -157,46 +175,67 @@ void ShowGraph::printAtomConnections( const ActionAtomistic* a, unsigned& linkco
 
 void ShowGraph::drawActionWithVectorNode( OFile& ofile, PlumedMain& p, Action* ag, const std::vector<std::string>& mychain, std::vector<bool>& printed ) {
   ActionWithVector* agg=dynamic_cast<ActionWithVector*>(ag);
-  std::vector<std::string> matchain; agg->getAllActionLabelsInMatrixChain( matchain );
+  std::vector<std::string> matchain;
+  agg->getAllActionLabelsInMatrixChain( matchain );
   if( matchain.size()>0 ) {
     ofile.printf("subgraph sub%s_mat [%s]\n",getLabel(agg).c_str(), getLabel(agg).c_str());
     for(unsigned j=0; j<matchain.size(); ++j ) {
       Action* agm=p.getActionSet().selectWithLabel<Action*>(matchain[j]);
       for(unsigned k=0; k<mychain.size(); ++k ) {
-        if( mychain[k]==matchain[j] ) { printed[k]=true; break; }
+        if( mychain[k]==matchain[j] ) {
+          printed[k]=true;
+          break;
+        }
       }
       ofile.printf("%s([\"label=%s \n %s \n\"])\n", getLabel(matchain[j]).c_str(), getLabel(matchain[j],true).c_str(), agm->writeInGraph().c_str() );
     }
     ofile.printf("end\n");
     ofile.printf("style sub%s_mat fill:lightblue\n",getLabel(ag).c_str());
-  } else ofile.printf("%s([\"label=%s \n %s \n\"])\n", getLabel(ag->getLabel()).c_str(), getLabel(ag->getLabel(),true).c_str(), ag->writeInGraph().c_str() );
+  } else {
+    ofile.printf("%s([\"label=%s \n %s \n\"])\n", getLabel(ag->getLabel()).c_str(), getLabel(ag->getLabel(),true).c_str(), ag->writeInGraph().c_str() );
+  }
 }
 
 int ShowGraph::main(FILE* in, FILE*out,Communicator& pc) {
 
-  std::string inpt; parse("--plumed",inpt);
-  std::string outp; parse("--out",outp);
-  bool forces; parseFlag("--force",forces);
+  std::string inpt;
+  parse("--plumed",inpt);
+  std::string outp;
+  parse("--out",outp);
+  bool forces;
+  parseFlag("--force",forces);
 
   // Create a plumed main object and initilize
-  PlumedMain p; int rr=sizeof(double);
+  PlumedMain p;
+  int rr=sizeof(double);
   p.cmd("setRealPrecision",&rr);
-  double lunit=1.0; p.cmd("setMDLengthUnits",&lunit);
-  double cunit=1.0; p.cmd("setMDChargeUnits",&cunit);
-  double munit=1.0; p.cmd("setMDMassUnits",&munit);
+  double lunit=1.0;
+  p.cmd("setMDLengthUnits",&lunit);
+  double cunit=1.0;
+  p.cmd("setMDChargeUnits",&cunit);
+  double munit=1.0;
+  p.cmd("setMDMassUnits",&munit);
   p.cmd("setPlumedDat",inpt.c_str());
   p.cmd("setLog",out);
-  int natoms=1000000; p.cmd("setNatoms",&natoms);
+  int natoms=1000000;
+  p.cmd("setNatoms",&natoms);
   p.cmd("init");
 
-  unsigned linkcount=0; OFile ofile; ofile.open(outp);
+  unsigned linkcount=0;
+  OFile ofile;
+  ofile.open(outp);
   if( forces ) {
-    unsigned step=1; p.cmd("setStep",step);
+    unsigned step=1;
+    p.cmd("setStep",step);
     p.cmd("prepareCalc");
-    ofile.printf("flowchart BT \n"); std::vector<std::string> drawn_nodes; std::set<std::string> atom_force_set;
+    ofile.printf("flowchart BT \n");
+    std::vector<std::string> drawn_nodes;
+    std::set<std::string> atom_force_set;
     for(auto pp=p.getActionSet().rbegin(); pp!=p.getActionSet().rend(); ++pp) {
       const auto & a(pp->get());
-      if( a->getName()=="DOMAIN_DECOMPOSITION" || a->getLabel()=="posx" || a->getLabel()=="posy" || a->getLabel()=="posz" || a->getLabel()=="Masses" || a->getLabel()=="Charges" ) continue;
+      if( a->getName()=="DOMAIN_DECOMPOSITION" || a->getLabel()=="posx" || a->getLabel()=="posy" || a->getLabel()=="posz" || a->getLabel()=="Masses" || a->getLabel()=="Charges" ) {
+        continue;
+      }
 
       if(a->isActive()) {
         ActionToPutData* ap=dynamic_cast<ActionToPutData*>(a);
@@ -205,55 +244,88 @@ int ShowGraph::main(FILE* in, FILE*out,Communicator& pc) {
           continue;
         }
         ActionWithValue* av=dynamic_cast<ActionWithValue*>(a);
-        if( !av ) continue ;
+        if( !av ) {
+          continue ;
+        }
         // Now apply the force if there is one
         a->apply();
         bool hasforce=false;
         for(int i=0; i<av->getNumberOfComponents(); ++i) {
-          if( (av->copyOutput(i))->forcesWereAdded() ) { hasforce=true; break; }
+          if( (av->copyOutput(i))->forcesWereAdded() ) {
+            hasforce=true;
+            break;
+          }
         }
         //Check if there are forces here
         ActionWithArguments* aaa=dynamic_cast<ActionWithArguments*>(a);
         if( aaa ) {
           for(const auto & v : aaa->getArguments() ) {
-            if( v->forcesWereAdded() ) { hasforce=true; break; }
+            if( v->forcesWereAdded() ) {
+              hasforce=true;
+              break;
+            }
           }
         }
-        if( !hasforce ) continue;
+        if( !hasforce ) {
+          continue;
+        }
         ActionWithVector* avec=dynamic_cast<ActionWithVector*>(a);
         if( avec ) {
           ActionWithVector* head=avec->getFirstActionInChain();
-          std::vector<std::string> mychain; head->getAllActionLabelsInChain( mychain ); std::vector<bool> printed(mychain.size(),false);
+          std::vector<std::string> mychain;
+          head->getAllActionLabelsInChain( mychain );
+          std::vector<bool> printed(mychain.size(),false);
           ofile.printf("subgraph sub%s [%s]\n",getLabel(head).c_str(),getLabel(head).c_str());
           for(unsigned i=0; i<mychain.size(); ++i) {
             bool drawn=false;
             for(unsigned j=0; j<drawn_nodes.size(); ++j ) {
-              if( drawn_nodes[j]==mychain[i] ) { drawn=true; break; }
+              if( drawn_nodes[j]==mychain[i] ) {
+                drawn=true;
+                break;
+              }
+            }
+            if( drawn ) {
+              continue;
+            }
+            ActionWithVector* ag=p.getActionSet().selectWithLabel<ActionWithVector*>(mychain[i]);
+            plumed_assert( ag );
+            drawn_nodes.push_back( mychain[i] );
+            if( !printed[i] ) {
+              drawActionWithVectorNode( ofile, p, ag, mychain, printed );
+              printed[i]=true;
             }
-            if( drawn ) continue;
-            ActionWithVector* ag=p.getActionSet().selectWithLabel<ActionWithVector*>(mychain[i]); plumed_assert( ag ); drawn_nodes.push_back( mychain[i] );
-            if( !printed[i] ) { drawActionWithVectorNode( ofile, p, ag, mychain, printed ); printed[i]=true; }
             for(const auto & v : ag->getArguments() ) {
               bool chain_conn=false;
               for(unsigned j=0; j<mychain.size(); ++j) {
-                if( (v->getPntrToAction())->getLabel()==mychain[j] ) { chain_conn=true; break; }
+                if( (v->getPntrToAction())->getLabel()==mychain[j] ) {
+                  chain_conn=true;
+                  break;
+                }
+              }
+              if( !chain_conn ) {
+                continue;
               }
-              if( !chain_conn ) continue;
               ofile.printf("%s -. %s .-> %s\n", getLabel(v->getPntrToAction()).c_str(),v->getName().c_str(),getLabel(ag).c_str() );
-              printStyle( linkcount, v, ofile ); linkcount++;
+              printStyle( linkcount, v, ofile );
+              linkcount++;
             }
           }
           ofile.printf("end\n");
           if( avec!=head ) {
             for(unsigned i=0; i<mychain.size(); ++i) {
-              ActionWithVector* c = p.getActionSet().selectWithLabel<ActionWithVector*>( mychain[i] ); plumed_assert(c);
+              ActionWithVector* c = p.getActionSet().selectWithLabel<ActionWithVector*>( mychain[i] );
+              plumed_assert(c);
               if( c->getNumberOfAtoms()>0 || c->hasStoredArguments() ) {
                 for(unsigned j=0; j<avec->getNumberOfComponents(); ++j ) {
-                  if( avec->copyOutput(j)->getRank()>0 ) continue;
+                  if( avec->copyOutput(j)->getRank()>0 ) {
+                    continue;
+                  }
                   ofile.printf("%s == %s ==> %s\n", getLabel(avec).c_str(), avec->copyOutput(j)->getName().c_str(), getLabel(c).c_str() );
                   linkcount++;
                 }
-                if( c->getNumberOfAtoms()>0 ) atom_force_set.insert( c->getLabel() );
+                if( c->getNumberOfAtoms()>0 ) {
+                  atom_force_set.insert( c->getLabel() );
+                }
               }
             }
           }
@@ -268,34 +340,43 @@ int ShowGraph::main(FILE* in, FILE*out,Communicator& pc) {
     // Now draw connections from action atomistic to relevant actions
     std::vector<ActionAtomistic*> all_atoms = p.getActionSet().select<ActionAtomistic*>();
     for(const auto & at : all_atoms ) {
-      ActionWithValue* av=dynamic_cast<ActionWithValue*>(at); bool hasforce=false;
+      ActionWithValue* av=dynamic_cast<ActionWithValue*>(at);
+      bool hasforce=false;
       if( av ) {
         for(unsigned i=0; i<av->getNumberOfComponents(); ++i ) {
           if( av->copyOutput(i)->forcesWereAdded() ) {
             printAtomConnections( at, linkcount, true, ofile );
-            atom_force_set.erase( av->getLabel() ); break;
+            atom_force_set.erase( av->getLabel() );
+            break;
           }
         }
       }
     }
     for(const auto & l : atom_force_set ) {
       ActionAtomistic* at = p.getActionSet().selectWithLabel<ActionAtomistic*>(l);
-      plumed_assert(at); printAtomConnections( at, linkcount, true, ofile );
+      plumed_assert(at);
+      printAtomConnections( at, linkcount, true, ofile );
     }
     ofile.printf("MD(positions from MD)\n");
     return 0;
   }
 
-  ofile.printf("flowchart TB \n"); ofile.printf("MD(positions from MD)\n");
+  ofile.printf("flowchart TB \n");
+  ofile.printf("MD(positions from MD)\n");
   for(const auto & aa : p.getActionSet() ) {
     Action* a(aa.get());
-    if( a->getName()=="DOMAIN_DECOMPOSITION" || a->getLabel()=="posx" || a->getLabel()=="posy" || a->getLabel()=="posz" || a->getLabel()=="Masses" || a->getLabel()=="Charges" ) continue;
+    if( a->getName()=="DOMAIN_DECOMPOSITION" || a->getLabel()=="posx" || a->getLabel()=="posy" || a->getLabel()=="posz" || a->getLabel()=="Masses" || a->getLabel()=="Charges" ) {
+      continue;
+    }
     ActionToPutData* ap=dynamic_cast<ActionToPutData*>(a);
     if( ap ) {
       ofile.printf("%s(\"label=%s \n %s \n\")\n", getLabel(a).c_str(), getLabel(a,true).c_str(), a->writeInGraph().c_str() );
       continue;
     }
-    ActionShortcut* as=dynamic_cast<ActionShortcut*>(a); if( as ) continue ;
+    ActionShortcut* as=dynamic_cast<ActionShortcut*>(a);
+    if( as ) {
+      continue ;
+    }
     ActionWithValue* av=dynamic_cast<ActionWithValue*>(a);
     ActionWithArguments* aaa=dynamic_cast<ActionWithArguments*>(a);
     ActionAtomistic* at=dynamic_cast<ActionAtomistic*>(a);
@@ -306,10 +387,15 @@ int ShowGraph::main(FILE* in, FILE*out,Communicator& pc) {
     // Print out the nodes
     if( avec && !avec->actionInChain() ) {
       ofile.printf("subgraph sub%s [%s]\n",getLabel(a).c_str(),getLabel(a).c_str());
-      std::vector<std::string> mychain; avec->getAllActionLabelsInChain( mychain ); std::vector<bool> printed(mychain.size(),false);
+      std::vector<std::string> mychain;
+      avec->getAllActionLabelsInChain( mychain );
+      std::vector<bool> printed(mychain.size(),false);
       for(unsigned i=0; i<mychain.size(); ++i) {
         Action* ag=p.getActionSet().selectWithLabel<Action*>(mychain[i]);
-        if( !printed[i] ) { drawActionWithVectorNode( ofile, p, ag, mychain, printed ); printed[i]=true; }
+        if( !printed[i] ) {
+          drawActionWithVectorNode( ofile, p, ag, mychain, printed );
+          printed[i]=true;
+        }
       }
       ofile.printf("end\n");
     } else if( !av ) {
diff --git a/src/cltools/SimpleMD.cpp b/src/cltools/SimpleMD.cpp
index 586f986dc3..0d4979e563 100644
--- a/src/cltools/SimpleMD.cpp
+++ b/src/cltools/SimpleMD.cpp
@@ -76,11 +76,14 @@ plumed simplemd --help
 // simple static function to close a file
 // defined once here since it's used in many places in this file
 // in addition, this seems the only way to use it in the write_statistics_fp_deleter member
-static void (*deleter)(FILE* f) = [](auto f) { if(f) std::fclose(f); };
+static void (*deleter)(FILE* f) = [](auto f) {
+  if(f) {
+    std::fclose(f);
+  }
+};
 
 class SimpleMD:
-  public PLMD::CLTool
-{
+  public PLMD::CLTool {
   std::string description()const override {
     return "run lj code";
   }
@@ -116,8 +119,7 @@ class SimpleMD:
     write_positions_first(true),
     write_statistics_first(true),
     write_statistics_last_time_reopened(0),
-    write_statistics_fp(NULL)
-  {
+    write_statistics_fp(NULL) {
     inputdata=ifile;
   }
 
@@ -140,17 +142,22 @@ class SimpleMD:
              int&    ndim,
              int&    idum,
              double& epsilon,
-             double& sigma)
-  {
+             double& sigma) {
 
     // Read everything from input file
     char buffer1[256];
-    std::string tempstr; parse("temperature",tempstr);
-    if( tempstr!="NVE" ) Tools::convert(tempstr,temperature);
+    std::string tempstr;
+    parse("temperature",tempstr);
+    if( tempstr!="NVE" ) {
+      Tools::convert(tempstr,temperature);
+    }
     parse("tstep",tstep);
-    std::string frictionstr; parse("friction",frictionstr);
+    std::string frictionstr;
+    parse("friction",frictionstr);
     if( tempstr!="NVE" ) {
-      if(frictionstr=="off") error("Specify friction for thermostat");
+      if(frictionstr=="off") {
+        error("Specify friction for thermostat");
+      }
       Tools::convert(frictionstr,friction);
     }
     parse("forcecutoff",forcecutoff);
@@ -162,62 +169,90 @@ class SimpleMD:
 
     // Read in stuff with sanity checks
     parse("inputfile",inputfile);
-    if(inputfile.length()==0) error("Specify input file");
+    if(inputfile.length()==0) {
+      error("Specify input file");
+    }
     parse("outputfile",outputfile);
-    if(outputfile.length()==0) error("Specify output file");
-    std::string nconfstr; parse("nconfig",nconfstr);
+    if(outputfile.length()==0) {
+      error("Specify output file");
+    }
+    std::string nconfstr;
+    parse("nconfig",nconfstr);
     std::sscanf(nconfstr.c_str(),"%100d %255s",&nconfig,buffer1);
     trajfile=buffer1;
-    if(trajfile.length()==0) error("Specify traj file");
-    std::string nstatstr; parse("nstat",nstatstr);
+    if(trajfile.length()==0) {
+      error("Specify traj file");
+    }
+    std::string nstatstr;
+    parse("nstat",nstatstr);
     std::sscanf(nstatstr.c_str(),"%100d %255s",&nstat,buffer1);
     statfile=buffer1;
-    if(statfile.length()==0) error("Specify stat file");
+    if(statfile.length()==0) {
+      error("Specify stat file");
+    }
     parse("ndim",ndim);
-    if(ndim<1 || ndim>3) error("ndim should be 1,2 or 3");
+    if(ndim<1 || ndim>3) {
+      error("ndim should be 1,2 or 3");
+    }
     std::string w;
     parse("wrapatoms",w);
     wrapatoms=false;
-    if(w.length()>0 && (w[0]=='T' || w[0]=='t')) wrapatoms=true;
+    if(w.length()>0 && (w[0]=='T' || w[0]=='t')) {
+      wrapatoms=true;
+    }
   }
 
   void read_natoms(const std::string & inputfile,int & natoms) {
 // read the number of atoms in file "input.xyz"
     FILE* fp=std::fopen(inputfile.c_str(),"r");
-    if(!fp) error(std::string("file ") + inputfile + std::string(" not found"));
+    if(!fp) {
+      error(std::string("file ") + inputfile + std::string(" not found"));
+    }
 
 // call fclose when fp goes out of scope
     std::unique_ptr<FILE,decltype(deleter)> fp_deleter(fp,deleter);
 
     int ret=std::fscanf(fp,"%1000d",&natoms);
-    if(ret==0) plumed_error() <<"Error reading number of atoms from file "<<inputfile;
+    if(ret==0) {
+      plumed_error() <<"Error reading number of atoms from file "<<inputfile;
+    }
   }
 
   void read_positions(const std::string& inputfile,int natoms,std::vector<Vector>& positions,double cell[3]) {
 // read positions and cell from a file called inputfile
 // natoms (input variable) and number of atoms in the file should be consistent
     FILE* fp=std::fopen(inputfile.c_str(),"r");
-    if(!fp) error(std::string("file ") + inputfile + std::string(" not found"));
+    if(!fp) {
+      error(std::string("file ") + inputfile + std::string(" not found"));
+    }
 // call fclose when fp goes out of scope
     std::unique_ptr<FILE,decltype(deleter)> fp_deleter(fp,deleter);
 
     char buffer[256];
     char atomname[256];
     char* cret=fgets(buffer,256,fp);
-    if(cret==nullptr) plumed_error() <<"Error reading buffer from file "<<inputfile;
+    if(cret==nullptr) {
+      plumed_error() <<"Error reading buffer from file "<<inputfile;
+    }
     int ret=std::fscanf(fp,"%1000lf %1000lf %1000lf",&cell[0],&cell[1],&cell[2]);
-    if(ret==0) plumed_error() <<"Error reading cell line from file "<<inputfile;
+    if(ret==0) {
+      plumed_error() <<"Error reading cell line from file "<<inputfile;
+    }
     for(int i=0; i<natoms; i++) {
       ret=std::fscanf(fp,"%255s %1000lf %1000lf %1000lf",atomname,&positions[i][0],&positions[i][1],&positions[i][2]);
 // note: atomname is read but not used
-      if(ret==0) plumed_error() <<"Error reading atom line from file "<<inputfile;
+      if(ret==0) {
+        plumed_error() <<"Error reading atom line from file "<<inputfile;
+      }
     }
   }
 
   void randomize_velocities(const int natoms,const int ndim,const double temperature,const std::vector<double>&masses,std::vector<Vector>& velocities,Random&random) {
 // randomize the velocities according to the temperature
-    for(int iatom=0; iatom<natoms; iatom++) for(int i=0; i<ndim; i++)
+    for(int iatom=0; iatom<natoms; iatom++)
+      for(int i=0; i<ndim; i++) {
         velocities[iatom][i]=std::sqrt(temperature/masses[iatom])*random.Gaussian();
+      }
   }
 
   void pbc(const double cell[3],const Vector & vin,Vector & vout) {
@@ -228,14 +263,15 @@ class SimpleMD:
   }
 
   void check_list(const int natoms,const std::vector<Vector>& positions,const std::vector<Vector>&positions0,const double listcutoff,
-                  const double forcecutoff,bool & recompute)
-  {
+                  const double forcecutoff,bool & recompute) {
 // check if the neighbour list have to be recomputed
     recompute=false;
     auto delta2=(0.5*(listcutoff-forcecutoff))*(0.5*(listcutoff-forcecutoff));
 // if ANY atom moved more than half of the skin thickness, recompute is set to .true.
     for(int iatom=0; iatom<natoms; iatom++) {
-      if(modulo2(positions[iatom]-positions0[iatom])>delta2) recompute=true;
+      if(modulo2(positions[iatom]-positions0[iatom])>delta2) {
+        recompute=true;
+      }
     }
   }
 
@@ -251,19 +287,23 @@ class SimpleMD:
         Vector distance_pbc; // minimum-image distance of the two atoms
         pbc(cell,distance,distance_pbc);
 // if the interparticle distance is larger than the cutoff, skip
-        if(modulo2(distance_pbc)>listcutoff2)continue;
+        if(modulo2(distance_pbc)>listcutoff2) {
+          continue;
+        }
         list[iatom].push_back(jatom);
       }
     }
   }
 
   void compute_forces(const int natoms,double epsilon, double sigma,const std::vector<Vector>& positions,const double cell[3],
-                      double forcecutoff,const std::vector<std::vector<int> >& list,std::vector<Vector>& forces,double & engconf)
-  {
+                      double forcecutoff,const std::vector<std::vector<int> >& list,std::vector<Vector>& forces,double & engconf) {
     double forcecutoff2=forcecutoff*forcecutoff; // squared force cutoff
     engconf=0.0;
     double engconf_tmp=0.0; // separate variable for reduction (gcc 4.8 does not make reductions on references)
-    for(int i=0; i<natoms; i++)for(int k=0; k<3; k++) forces[i][k]=0.0;
+    for(int i=0; i<natoms; i++)
+      for(int k=0; k<3; k++) {
+        forces[i][k]=0.0;
+      }
     double engcorrection=4.0*epsilon*(1.0/std::pow(forcecutoff2/(sigma*sigma),6.0)-1.0/std::pow(forcecutoff2/(sigma*sigma),3)); // energy necessary shift the potential avoiding discontinuities
     #   pragma omp parallel num_threads(OpenMP::getNumThreads())
     {
@@ -277,7 +317,9 @@ class SimpleMD:
           pbc(cell,distance,distance_pbc);
           auto distance_pbc2=modulo2(distance_pbc);   // squared minimum-image distance
 // if the interparticle distance is larger than the cutoff, skip
-          if(distance_pbc2>forcecutoff2) continue;
+          if(distance_pbc2>forcecutoff2) {
+            continue;
+          }
           auto distance_pbcm2=sigma*sigma/distance_pbc2;
           auto distance_pbcm6=distance_pbcm2*distance_pbcm2*distance_pbcm2;
           auto distance_pbcm8=distance_pbcm6*distance_pbcm2;
@@ -290,15 +332,16 @@ class SimpleMD:
         }
       }
       #     pragma omp critical
-      for(unsigned i=0; i<omp_forces.size(); i++) forces[i]+=omp_forces[i];
+      for(unsigned i=0; i<omp_forces.size(); i++) {
+        forces[i]+=omp_forces[i];
+      }
     }
 
     engconf=engconf_tmp;
 
   }
 
-  void compute_engkin(const int natoms,const std::vector<double>& masses,const std::vector<Vector>& velocities,double & engkin)
-  {
+  void compute_engkin(const int natoms,const std::vector<double>& masses,const std::vector<Vector>& velocities,double & engkin) {
 // calculate the kinetic energy from the velocities
     engkin=0.0;
     for(int iatom=0; iatom<natoms; iatom++) {
@@ -323,8 +366,7 @@ class SimpleMD:
     }
   }
 
-  void write_positions(const std::string& trajfile,int natoms,const std::vector<Vector>& positions,const double cell[3],const bool wrapatoms)
-  {
+  void write_positions(const std::string& trajfile,int natoms,const std::vector<Vector>& positions,const double cell[3],const bool wrapatoms) {
 // write positions on file trajfile
 // positions are appended at the end of the file
     Vector pos;
@@ -343,14 +385,16 @@ class SimpleMD:
     for(int iatom=0; iatom<natoms; iatom++) {
 // usually, it is better not to apply pbc here, so that diffusion
 // is more easily calculated from a trajectory file:
-      if(wrapatoms) pbc(cell,positions[iatom],pos);
-      else pos=positions[iatom];
+      if(wrapatoms) {
+        pbc(cell,positions[iatom],pos);
+      } else {
+        pos=positions[iatom];
+      }
       std::fprintf(fp,"Ar %10.7f %10.7f %10.7f\n",pos[0],pos[1],pos[2]);
     }
   }
 
-  void write_final_positions(const std::string& outputfile,int natoms,const std::vector<Vector>& positions,const double cell[3],const bool wrapatoms)
-  {
+  void write_final_positions(const std::string& outputfile,int natoms,const std::vector<Vector>& positions,const double cell[3],const bool wrapatoms) {
 // write positions on file outputfile
     Vector pos;
     FILE*fp;
@@ -363,8 +407,11 @@ class SimpleMD:
     for(int iatom=0; iatom<natoms; iatom++) {
 // usually, it is better not to apply pbc here, so that diffusion
 // is more easily calculated from a trajectory file:
-      if(wrapatoms) pbc(cell,positions[iatom],pos);
-      else pos=positions[iatom];
+      if(wrapatoms) {
+        pbc(cell,positions[iatom],pos);
+      } else {
+        pos=positions[iatom];
+      }
       std::fprintf(fp,"Ar %10.7f %10.7f %10.7f\n",pos[0],pos[1],pos[2]);
     }
   }
@@ -439,7 +486,9 @@ class SimpleMD:
 // Commenting the next line it is possible to switch-off plumed
     plumed=Tools::make_unique<PLMD::PlumedMain>();
 
-    if(plumed) plumed->cmd("setRealPrecision",int(sizeof(double)));
+    if(plumed) {
+      plumed->cmd("setRealPrecision",int(sizeof(double)));
+    }
 
     read_input(temperature,tstep,friction,forcecutoff,
                listcutoff,nstep,nconfig,nstat,
@@ -481,7 +530,9 @@ class SimpleMD:
     list.resize(natoms);
 
 // masses are hard-coded to 1
-    for(int i=0; i<natoms; ++i) masses[i]=1.0;
+    for(int i=0; i<natoms; ++i) {
+      masses[i]=1.0;
+    }
 
 // energy integral initialized to 0
     engint=0.0;
@@ -503,7 +554,9 @@ class SimpleMD:
 // setting kbT is only implemented with api>1
 // even if not necessary in principle in SimpleMD (which is part of plumed)
 // we leave the check here as a reference
-      if(pversion>1) plumed->cmd("setKbT",temperature);
+      if(pversion>1) {
+        plumed->cmd("setKbT",temperature);
+      }
       plumed->cmd("init");
     }
 
@@ -511,16 +564,23 @@ class SimpleMD:
     compute_list(natoms,positions,cell,listcutoff,list);
 
     int list_size=0;
-    for(int i=0; i<list.size(); i++) list_size+=list[i].size();
+    for(int i=0; i<list.size(); i++) {
+      list_size+=list[i].size();
+    }
     std::fprintf(out,"List size: %d\n",list_size);
-    for(int iatom=0; iatom<natoms; ++iatom) positions0[iatom]=positions[iatom];
+    for(int iatom=0; iatom<natoms; ++iatom) {
+      positions0[iatom]=positions[iatom];
+    }
 
 // forces are computed before starting md
     compute_forces(natoms,epsilon,sigma,positions,cell,forcecutoff,list,forces,engconf);
 
 // remove forces if ndim<3
     if(ndim<3)
-      for(int iatom=0; iatom<natoms; ++iatom) for(int k=ndim; k<3; ++k) forces[iatom][k]=0.0;
+      for(int iatom=0; iatom<natoms; ++iatom)
+        for(int k=ndim; k<3; ++k) {
+          forces[iatom][k]=0.0;
+        }
 
 // here is the main md loop
 // Langevin thermostat is applied before and after a velocity-Verlet integrator
@@ -536,19 +596,25 @@ class SimpleMD:
     for(int istep=0; istep<nstep; istep++) {
       thermostat(natoms,ndim,masses,0.5*tstep,friction,temperature,velocities,engint,random);
 
-      for(int iatom=0; iatom<natoms; iatom++)
+      for(int iatom=0; iatom<natoms; iatom++) {
         velocities[iatom]+=forces[iatom]*0.5*tstep/masses[iatom];
+      }
 
-      for(int iatom=0; iatom<natoms; iatom++)
+      for(int iatom=0; iatom<natoms; iatom++) {
         positions[iatom]+=velocities[iatom]*tstep;
+      }
 
 // a check is performed to decide whether to recalculate the neighbour list
       check_list(natoms,positions,positions0,listcutoff,forcecutoff,recompute_list);
       if(recompute_list) {
         compute_list(natoms,positions,cell,listcutoff,list);
-        for(int iatom=0; iatom<natoms; ++iatom) positions0[iatom]=positions[iatom];
+        for(int iatom=0; iatom<natoms; ++iatom) {
+          positions0[iatom]=positions[iatom];
+        }
         int list_size=0;
-        for(int i=0; i<list.size(); i++) list_size+=list[i].size();
+        for(int i=0; i<list.size(); i++) {
+          list_size+=list[i].size();
+        }
         std::fprintf(out,"List size: %d\n",list_size);
       }
 
@@ -556,8 +622,13 @@ class SimpleMD:
 
       if(plumed) {
         plumedWantsToStop=0;
-        for(int i=0; i<3; i++)for(int k=0; k<3; k++) cell9[i][k]=0.0;
-        for(int i=0; i<3; i++) cell9[i][i]=cell[i];
+        for(int i=0; i<3; i++)
+          for(int k=0; k<3; k++) {
+            cell9[i][k]=0.0;
+          }
+        for(int i=0; i<3; i++) {
+          cell9[i][i]=cell[i];
+        }
         plumed->cmd("setStep",istep+1);
         plumed->cmd("setMasses",&masses[0]);
         plumed->cmd("setForces",&forces[0][0]);
@@ -566,14 +637,20 @@ class SimpleMD:
         plumed->cmd("setBox",&cell9[0][0]);
         plumed->cmd("setStopFlag",&plumedWantsToStop);
         plumed->cmd("calc");
-        if(plumedWantsToStop) nstep=istep;
+        if(plumedWantsToStop) {
+          nstep=istep;
+        }
       }
 // remove forces if ndim<3
       if(ndim<3)
-        for(int iatom=0; iatom<natoms; ++iatom) for(int k=ndim; k<3; ++k) forces[iatom][k]=0.0;
+        for(int iatom=0; iatom<natoms; ++iatom)
+          for(int k=ndim; k<3; ++k) {
+            forces[iatom][k]=0.0;
+          }
 
-      for(int iatom=0; iatom<natoms; iatom++)
+      for(int iatom=0; iatom<natoms; iatom++) {
         velocities[iatom]+=forces[iatom]*0.5*tstep/masses[iatom];
+      }
 
       thermostat(natoms,ndim,masses,0.5*tstep,friction,temperature,velocities,engint,random);
 
@@ -581,8 +658,12 @@ class SimpleMD:
       compute_engkin(natoms,masses,velocities,engkin);
 
 // eventually, write positions and statistics
-      if((istep+1)%nconfig==0) write_positions(trajfile,natoms,positions,cell,wrapatoms);
-      if((istep+1)%nstat==0)   write_statistics(statfile,istep+1,tstep,natoms,ndim,engkin,engconf,engint);
+      if((istep+1)%nconfig==0) {
+        write_positions(trajfile,natoms,positions,cell,wrapatoms);
+      }
+      if((istep+1)%nstat==0) {
+        write_statistics(statfile,istep+1,tstep,natoms,ndim,engkin,engconf,engint);
+      }
 
     }
 
diff --git a/src/cltools/SumHills.cpp b/src/cltools/SumHills.cpp
index ef9ab0f169..10765d2f68 100644
--- a/src/cltools/SumHills.cpp
+++ b/src/cltools/SumHills.cpp
@@ -217,12 +217,13 @@ void CLToolSumHills::registerKeywords( Keywords& keys ) {
 }
 
 CLToolSumHills::CLToolSumHills(const CLToolOptions& co ):
-  CLTool(co)
-{
+  CLTool(co) {
   inputdata=commandline;
 }
 
-std::string CLToolSumHills::description()const { return "sum the hills with  plumed"; }
+std::string CLToolSumHills::description()const {
+  return "sum the hills with  plumed";
+}
 
 int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
 
@@ -257,7 +258,9 @@ int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
     findCvsAndPeriodic(histoFiles[0], hcvs, hpmin, hpmax, hmultivariate, lowI_, uppI_);
     // here need also the vector of sigmas
     parseVector("--sigma",sigma);
-    if(sigma.size()==0)plumed_merror("you should define --sigma vector when using histogram");
+    if(sigma.size()==0) {
+      plumed_merror("you should define --sigma vector when using histogram");
+    }
     lowI_=uppI_="-1.";  // Interval is not use for histograms
   }
 
@@ -289,24 +292,34 @@ int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
   unsigned grid_check=0;
   std::vector<std::string> gmin(cvs.size());
   if(parseVector("--min",gmin)) {
-    if(gmin.size()!=cvs.size() && gmin.size()!=0) plumed_merror("not enough values for --min");
+    if(gmin.size()!=cvs.size() && gmin.size()!=0) {
+      plumed_merror("not enough values for --min");
+    }
     grid_check++;
   }
   std::vector<std::string> gmax(cvs.size() );
   if(parseVector("--max",gmax)) {
-    if(gmax.size()!=cvs.size() && gmax.size()!=0) plumed_merror("not enough values for --max");
+    if(gmax.size()!=cvs.size() && gmax.size()!=0) {
+      plumed_merror("not enough values for --max");
+    }
     grid_check++;
   }
   std::vector<std::string> gbin(cvs.size());
-  bool grid_has_bin; grid_has_bin=false;
+  bool grid_has_bin;
+  grid_has_bin=false;
   if(parseVector("--bin",gbin)) {
-    if(gbin.size()!=cvs.size() && gbin.size()!=0) plumed_merror("not enough values for --bin");
+    if(gbin.size()!=cvs.size() && gbin.size()!=0) {
+      plumed_merror("not enough values for --bin");
+    }
     grid_has_bin=true;
   }
   std::vector<std::string> gspacing(cvs.size());
-  bool grid_has_spacing; grid_has_spacing=false;
+  bool grid_has_spacing;
+  grid_has_spacing=false;
   if(parseVector("--spacing",gspacing)) {
-    if(gspacing.size()!=cvs.size() && gspacing.size()!=0) plumed_merror("not enough values for --spacing");
+    if(gspacing.size()!=cvs.size() && gspacing.size()!=0) {
+      plumed_merror("not enough values for --spacing");
+    }
     grid_has_spacing=true;
   }
   // allowed: no grids only bin
@@ -320,7 +333,9 @@ int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
   unsigned nn=1;
   ss="setNatoms";
   plumed.cmd(ss,&nn);
-  if(Communicator::initialized())  plumed.cmd("setMPIComm",&pc.Get_comm());
+  if(Communicator::initialized()) {
+    plumed.cmd("setMPIComm",&pc.Get_comm());
+  }
   plumed.cmd("init",&nn);
   std::vector <bool> isdone(cvs.size(),false);
   for(unsigned i=0; i<cvs.size(); i++) {
@@ -332,15 +347,23 @@ int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
       actioninput.push_back("ATOMS=1");
       actioninput.push_back("LABEL="+cvs[i][0]);
       std::vector<std::string> comps, periods;
-      if(cvs[i].size()>1) {comps.push_back(cvs[i][1]); inds.push_back(i);}
-      periods.push_back(pmin[i]); periods.push_back(pmax[i]);
+      if(cvs[i].size()>1) {
+        comps.push_back(cvs[i][1]);
+        inds.push_back(i);
+      }
+      periods.push_back(pmin[i]);
+      periods.push_back(pmax[i]);
       for(unsigned j=i+1; j<cvs.size(); j++) {
         if(cvs[i][0]==cvs[j][0] && !isdone[j]) {
-          if(cvs[i].size()==1 || cvs[j].size()==1  )plumed_merror("you cannot have twice the same label and no components ");
+          if(cvs[i].size()==1 || cvs[j].size()==1  ) {
+            plumed_merror("you cannot have twice the same label and no components ");
+          }
           if(cvs[j].size()>1) {
             comps.push_back(cvs[j][1]);
-            periods.push_back(pmin[j]); periods.push_back(pmax[j]);
-            isdone[j]=true; inds.push_back(j);
+            periods.push_back(pmin[j]);
+            periods.push_back(pmax[j]);
+            isdone[j]=true;
+            inds.push_back(j);
           }
         }
 
@@ -349,7 +372,9 @@ int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
       std::string addme;
       if(comps.size()>0) {
         addme="COMPONENTS=";
-        for(unsigned i=0; i<comps.size()-1; i++)addme+=comps[i]+",";
+        for(unsigned i=0; i<comps.size()-1; i++) {
+          addme+=comps[i]+",";
+        }
         addme+=comps.back();
         actioninput.push_back(addme);
       }
@@ -361,7 +386,8 @@ int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
       addme+=periods.back();
       actioninput.push_back(addme);
       for(unsigned j=0; j<inds.size(); j++) {
-        unsigned jj; jj=inds[j];
+        unsigned jj;
+        jj=inds[j];
         if(grid_check==2) {
           double gm;
           double pm;
@@ -398,18 +424,25 @@ int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
       bool found=false;
       for(unsigned j=0; j<cvs.size(); j++) {
         if(cvs[j].size()>1) {
-          if(idw[i]==cvs[j][0]+"."+cvs[j][1])found=true;
+          if(idw[i]==cvs[j][0]+"."+cvs[j][1]) {
+            found=true;
+          }
         } else {
-          if(idw[i]==cvs[j][0])found=true;
+          if(idw[i]==cvs[j][0]) {
+            found=true;
+          }
         }
       }
-      if(!found)plumed_merror("variable "+idw[i]+" is not found in the bunch of cvs: revise your --idw option" );
+      if(!found) {
+        plumed_merror("variable "+idw[i]+" is not found in the bunch of cvs: revise your --idw option" );
+      }
     }
     plumed_massert( idw.size()<=cvs.size(),"the number of variables to be integrated should be at most equal to the total number of cvs  ");
     // in this case you need a beta factor!
   }
 
-  std::string kt; kt=std::string("1.");// assign an arbitrary value just in case that idw.size()==cvs.size()
+  std::string kt;
+  kt=std::string("1.");// assign an arbitrary value just in case that idw.size()==cvs.size()
   if ( dohisto || idw.size()!=0  ) {
     plumed_massert(parse("--kt",kt),"if you make a dimensionality reduction (--idw) or a histogram (--histo) then you need to define --kt ");
   }
@@ -448,25 +481,46 @@ int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
   //  cerr<<"AA "<<actioninput[i]<<endl;
   //}
   if(dohills) {
-    addme="HILLSFILES="; for(unsigned i=0; i<hillsFiles.size()-1; i++)addme+=hillsFiles[i]+","; addme+=hillsFiles[hillsFiles.size()-1];
+    addme="HILLSFILES=";
+    for(unsigned i=0; i<hillsFiles.size()-1; i++) {
+      addme+=hillsFiles[i]+",";
+    }
+    addme+=hillsFiles[hillsFiles.size()-1];
     actioninput.push_back(addme);
     // set the grid
   }
   if(grid_check==2) {
-    addme="GRID_MAX="; for(unsigned i=0; i<(ncv-1); i++)addme+=gmax[i]+","; addme+=gmax[ncv-1];
+    addme="GRID_MAX=";
+    for(unsigned i=0; i<(ncv-1); i++) {
+      addme+=gmax[i]+",";
+    }
+    addme+=gmax[ncv-1];
     actioninput.push_back(addme);
-    addme="GRID_MIN="; for(unsigned i=0; i<(ncv-1); i++)addme+=gmin[i]+","; addme+=gmin[ncv-1];
+    addme="GRID_MIN=";
+    for(unsigned i=0; i<(ncv-1); i++) {
+      addme+=gmin[i]+",";
+    }
+    addme+=gmin[ncv-1];
     actioninput.push_back(addme);
   }
   if(grid_has_bin) {
-    addme="GRID_BIN="; for(unsigned i=0; i<(ncv-1); i++)addme+=gbin[i]+","; addme+=gbin[ncv-1];
+    addme="GRID_BIN=";
+    for(unsigned i=0; i<(ncv-1); i++) {
+      addme+=gbin[i]+",";
+    }
+    addme+=gbin[ncv-1];
     actioninput.push_back(addme);
   }
   if(grid_has_spacing) {
-    addme="GRID_SPACING="; for(unsigned i=0; i<(ncv-1); i++)addme+=gspacing[i]+","; addme+=gspacing[ncv-1];
+    addme="GRID_SPACING=";
+    for(unsigned i=0; i<(ncv-1); i++) {
+      addme+=gspacing[i]+",";
+    }
+    addme+=gspacing[ncv-1];
     actioninput.push_back(addme);
   }
-  std::string  stride; stride="";
+  std::string  stride;
+  stride="";
   if(parse("--stride",stride)) {
     actioninput.push_back("INITSTRIDE="+stride);
     bool  nohistory;
@@ -482,16 +536,22 @@ int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
   }
   if(idw.size()!=0) {
     addme="PROJ=";
-    for(unsigned i=0; i<idw.size()-1; i++) {addme+=idw[i]+",";}
+    for(unsigned i=0; i<idw.size()-1; i++) {
+      addme+=idw[i]+",";
+    }
     addme+=idw.back();
     actioninput.push_back(addme);
   }
 
   if(dohisto) {
     if(idw.size()==0) {
-      if(sigma.size()!=hcvs.size()) plumed_merror("you should define as many --sigma vector as the number of collective variable used for the histogram ");
+      if(sigma.size()!=hcvs.size()) {
+        plumed_merror("you should define as many --sigma vector as the number of collective variable used for the histogram ");
+      }
     } else {
-      if(idw.size()!=sigma.size()) plumed_merror("you should define as many --sigma vector as the number of collective variable used for the histogram ");
+      if(idw.size()!=sigma.size()) {
+        plumed_merror("you should define as many --sigma vector as the number of collective variable used for the histogram ");
+      }
     }
   }
 
@@ -499,11 +559,17 @@ int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
     actioninput.push_back("KT="+kt);
   }
   if(dohisto) {
-    addme="HISTOFILES="; for(unsigned i=0; i<histoFiles.size()-1; i++) {addme+=histoFiles[i]+",";} addme+=histoFiles[histoFiles.size()-1];
+    addme="HISTOFILES=";
+    for(unsigned i=0; i<histoFiles.size()-1; i++) {
+      addme+=histoFiles[i]+",";
+    }
+    addme+=histoFiles[histoFiles.size()-1];
     actioninput.push_back(addme);
 
     addme="HISTOSIGMA=";
-    for(unsigned i=0; i<sigma.size()-1; i++) {addme+=sigma[i]+",";}
+    for(unsigned i=0; i<sigma.size()-1; i++) {
+      addme+=sigma[i]+",";
+    }
     addme+=sigma.back();
     actioninput.push_back(addme);
   }
@@ -515,13 +581,18 @@ int CLToolSumHills::main(FILE* in,FILE*out,Communicator& pc) {
   }
 
   if(lowI_!=uppI_) {
-    addme="INTERVAL="; addme+=lowI_+","; addme+=uppI_;
+    addme="INTERVAL=";
+    addme+=lowI_+",";
+    addme+=uppI_;
     actioninput.push_back(addme);
   }
 
-  std::string fmt; fmt="";
+  std::string fmt;
+  fmt="";
   parse("--fmt",fmt);
-  if(fmt!="")actioninput.push_back("FMT="+fmt);
+  if(fmt!="") {
+    actioninput.push_back("FMT="+fmt);
+  }
 
 
 //  for(unsigned i=0;i< actioninput.size();i++){
@@ -537,7 +608,9 @@ bool CLToolSumHills::findCvsAndPeriodic(const std::string & filename, std::vecto
   ifile.allowIgnoredFields();
   std::vector<std::string> fields;
   if(ifile.FileExist(filename)) {
-    cvs.clear(); pmin.clear(); pmax.clear();
+    cvs.clear();
+    pmin.clear();
+    pmax.clear();
     ifile.open(filename);
     ifile.scanFieldList(fields);
     bool before_sigma=true;
@@ -548,7 +621,9 @@ bool CLToolSumHills::findCvsAndPeriodic(const std::string & filename, std::vecto
       founds=fields[i].find("sigma_", pos)  ;
       foundm=fields[i].find("min_", pos)  ;
       foundp=fields[i].find("max_", pos)  ;
-      if (founds!=std::string::npos || foundm!=std::string::npos ||  foundp!=std::string::npos )before_sigma=false;
+      if (founds!=std::string::npos || foundm!=std::string::npos ||  foundp!=std::string::npos ) {
+        before_sigma=false;
+      }
       // cvs are after time and before sigmas
       size_t  found;
       found=fields[i].find("time", pos);
@@ -575,7 +650,12 @@ bool CLToolSumHills::findCvsAndPeriodic(const std::string & filename, std::vecto
         // get periodicity
         pmin.push_back("none");
         pmax.push_back("none");
-        std::string mm; if((cvs.back()).size()>1) {mm=cvs.back()[0]+"."+cvs.back()[1];} else {mm=cvs.back()[0];}
+        std::string mm;
+        if((cvs.back()).size()>1) {
+          mm=cvs.back()[0]+"."+cvs.back()[1];
+        } else {
+          mm=cvs.back()[0];
+        }
         if(ifile.FieldExist("min_"+mm)) {
           std::string val;
           ifile.scanField("min_"+mm,val);
@@ -598,8 +678,11 @@ bool CLToolSumHills::findCvsAndPeriodic(const std::string & filename, std::vecto
     if(ifile.FieldExist("multivariate")) {
       ;
       ifile.scanField("multivariate",sss);
-      if(sss=="true") { multivariate=true;}
-      else if(sss=="false") { multivariate=false;}
+      if(sss=="true") {
+        multivariate=true;
+      } else if(sss=="false") {
+        multivariate=false;
+      }
     }
     // do interval?
     if(ifile.FieldExist("lower_int")) {
diff --git a/src/cltools/SwitchingPlotter.cpp b/src/cltools/SwitchingPlotter.cpp
index 58ab537a1e..0d2f069951 100644
--- a/src/cltools/SwitchingPlotter.cpp
+++ b/src/cltools/SwitchingPlotter.cpp
@@ -163,7 +163,8 @@ int SwitchingPlotter::main( FILE*, FILE*, Communicator& ) {
       return  (r0-lowerLimit)/(interval *Nsteps);
     }
     return (upperLimit-lowerLimit)/double(Nsteps);
-  }();
+  }
+  ();
   if (step <0.0) {
     error("I calculated a negative step");
   }
diff --git a/src/cltools/kT.cpp b/src/cltools/kT.cpp
index edefb93596..45c19e942f 100644
--- a/src/cltools/kT.cpp
+++ b/src/cltools/kT.cpp
@@ -48,8 +48,7 @@ plumed kt --temp 300 --units eV
 //+ENDPLUMEDOC
 
 class kt:
-  public CLTool
-{
+  public CLTool {
 public:
   static void registerKeywords( Keywords& keys );
   explicit kt(const CLToolOptions& co );
@@ -68,16 +67,18 @@ void kt::registerKeywords( Keywords& keys ) {
 }
 
 kt::kt(const CLToolOptions& co ):
-  CLTool(co)
-{
+  CLTool(co) {
   inputdata=commandline;
 }
 
 int kt::main(FILE* in, FILE*out,Communicator& pc) {
 
-  std::string unitname; parse("--units",unitname);
-  Units units; units.setEnergy( unitname );
-  double temp; parse("--temp",temp);
+  std::string unitname;
+  parse("--units",unitname);
+  Units units;
+  units.setEnergy( unitname );
+  double temp;
+  parse("--temp",temp);
   double kk=(kBoltzmann*temp)/units.getEnergy();
   std::fprintf(out,"When the temperature is %f kelvin kT is equal to %f %s\n",temp,kk,unitname.c_str());
   return 0;
diff --git a/src/cltools/pesmd.cpp b/src/cltools/pesmd.cpp
index e98e8da597..718edf5528 100644
--- a/src/cltools/pesmd.cpp
+++ b/src/cltools/pesmd.cpp
@@ -115,8 +115,7 @@ class PesMD  : public PLMD::CLTool {
   }
 
   explicit PesMD( const CLToolOptions& co ) :
-    CLTool(co)
-  {
+    CLTool(co) {
     inputdata=ifile;
   }
 
@@ -131,29 +130,43 @@ class PesMD  : public PLMD::CLTool {
                   int&    nstep,
                   bool&   lperiod,
                   std::vector<double>& periods,
-                  int&    idum)
-  {
+                  int&    idum) {
     // Read everything from input file
-    std::string tempstr; parse("temperature",tempstr);
-    if( tempstr!="NVE" ) Tools::convert(tempstr,temperature);
+    std::string tempstr;
+    parse("temperature",tempstr);
+    if( tempstr!="NVE" ) {
+      Tools::convert(tempstr,temperature);
+    }
     parse("tstep",tstep);
-    std::string frictionstr; parse("friction",frictionstr);
+    std::string frictionstr;
+    parse("friction",frictionstr);
     if( tempstr!="NVE" ) {
-      if(frictionstr=="off") error("pecify friction for thermostat");
+      if(frictionstr=="off") {
+        error("pecify friction for thermostat");
+      }
       Tools::convert(frictionstr,friction);
     }
-    parse("plumed",plumedin); parse("dimension",dim);
-    parse("nstep",nstep); parse("idum",idum);
-    ipos.resize( dim ); parseVector("ipos",ipos);
+    parse("plumed",plumedin);
+    parse("dimension",dim);
+    parse("nstep",nstep);
+    parse("idum",idum);
+    ipos.resize( dim );
+    parseVector("ipos",ipos);
 
     parseFlag("periodic",lperiod);
     if( lperiod ) {
-      if( dim>3 ) error("can only do three dimensional periodic functions");
-      std::vector<double> min( dim ); parseVector("min",min);
-      std::vector<double> max( dim ); parseVector("max",max);
+      if( dim>3 ) {
+        error("can only do three dimensional periodic functions");
+      }
+      std::vector<double> min( dim );
+      parseVector("min",min);
+      std::vector<double> max( dim );
+      parseVector("max",max);
       periods.resize( dim );
       for(int i=0; i<dim; ++i) {
-        if( max[i]<min[i] ) error("invalid periods specified max is less than min");
+        if( max[i]<min[i] ) {
+          error("invalid periods specified max is less than min");
+        }
         periods[i]=max[i]-min[i];
       }
     }
@@ -163,9 +176,12 @@ class PesMD  : public PLMD::CLTool {
 public:
 
   int main( FILE* in, FILE* out, PLMD::Communicator& pc) override {
-    std::string plumedin; std::vector<double> ipos;
-    double temp, tstep, friction; bool lperiod;
-    int dim, nsteps, seed; std::vector<double> periods;
+    std::string plumedin;
+    std::vector<double> ipos;
+    double temp, tstep, friction;
+    bool lperiod;
+    int dim, nsteps, seed;
+    std::vector<double> periods;
     int plumedWantsToStop;
     Random random;
 
@@ -175,16 +191,26 @@ class PesMD  : public PLMD::CLTool {
 
     // Setup box if we have periodic domain
     std::vector<double> box(9, 0.0);
-    if( lperiod && dim==1 ) { box[0]=box[4]=box[8]=periods[0]; }
-    else if( lperiod && dim==2 ) { box[0]=periods[0]; box[4]=box[8]=periods[1]; }
-    else if( lperiod && dim==3 ) { box[0]=periods[0]; box[4]=periods[1]; box[8]=periods[2]; }
-    else if( lperiod ) error("invalid dimension for periodic potential must be 1, 2 or 3");
+    if( lperiod && dim==1 ) {
+      box[0]=box[4]=box[8]=periods[0];
+    } else if( lperiod && dim==2 ) {
+      box[0]=periods[0];
+      box[4]=box[8]=periods[1];
+    } else if( lperiod && dim==3 ) {
+      box[0]=periods[0];
+      box[4]=periods[1];
+      box[8]=periods[2];
+    } else if( lperiod ) {
+      error("invalid dimension for periodic potential must be 1, 2 or 3");
+    }
 
     // Create plumed object and initialize
     auto plumed=Tools::make_unique<PLMD::PlumedMain>();
     int s=sizeof(double);
     plumed->cmd("setRealPrecision",&s);
-    if(Communicator::initialized()) plumed->cmd("setMPIComm",&pc.Get_comm());
+    if(Communicator::initialized()) {
+      plumed->cmd("setMPIComm",&pc.Get_comm());
+    }
     int natoms=( std::floor(dim/3) +  2 );
     plumed->cmd("setNatoms",&natoms);
     plumed->cmd("setNoVirial");
@@ -198,30 +224,44 @@ class PesMD  : public PLMD::CLTool {
     std::vector<double> masses( 1+nat, 1 );
     std::vector<Vector> velocities( nat ), positions( nat+1 ), forces( nat+1 );
     // Will set these properly eventually
-    int k=0; positions[0].zero(); // Atom zero is fixed at origin
-    for(int i=0; i<nat; ++i) for(unsigned j=0; j<3; ++j) {
-        if( k<dim ) { positions[1+i][j]=ipos[k]; } else { positions[1+i][j]=0;}
+    int k=0;
+    positions[0].zero(); // Atom zero is fixed at origin
+    for(int i=0; i<nat; ++i)
+      for(unsigned j=0; j<3; ++j) {
+        if( k<dim ) {
+          positions[1+i][j]=ipos[k];
+        } else {
+          positions[1+i][j]=0;
+        }
         k++;
       }
     // And initialize the velocities
-    for(int i=0; i<nat; ++i) for(int j=0; j<3; ++j) velocities[i][j]=random.Gaussian() * std::sqrt( temp );
+    for(int i=0; i<nat; ++i)
+      for(int j=0; j<3; ++j) {
+        velocities[i][j]=random.Gaussian() * std::sqrt( temp );
+      }
     // And calculate the kinetic energy
     double tke=0;
     for(int i=0; i<nat; ++i) {
       for(int j=0; j<3; ++j) {
-        if( 3*i+j>dim-1 ) break;
+        if( 3*i+j>dim-1 ) {
+          break;
+        }
         tke += 0.5*velocities[i][j]*velocities[i][j];
       }
     }
 
     // Now call plumed to get initial forces
-    int istep=0; double zero=0;
+    int istep=0;
+    double zero=0;
     plumed->cmd("setStep",&istep);
     plumed->cmd("setMasses",&masses[0]);
     Tools::set_to_zero(forces);
     plumed->cmd("setForces",&forces[0][0]);
     plumed->cmd("setEnergy",&zero);
-    if( lperiod ) plumed->cmd("setBox",&box[0]);
+    if( lperiod ) {
+      plumed->cmd("setBox",&box[0]);
+    }
     plumed->cmd("setPositions",&positions[0][0]);
     plumed->cmd("calc");
 
@@ -230,14 +270,18 @@ class PesMD  : public PLMD::CLTool {
 
     for(int istep=0; istep<nsteps; ++istep) {
 
-      if( istep%20==0 && pc.Get_rank()==0 ) std::printf("Doing step %i\n",istep);
+      if( istep%20==0 && pc.Get_rank()==0 ) {
+        std::printf("Doing step %i\n",istep);
+      }
 
       // Langevin thermostat
       double lscale=std::exp(-0.5*tstep/friction);
       double lrand=std::sqrt((1.-lscale*lscale)*temp);
       for(int j=0; j<nat; ++j) {
         for(int k=0; k<3; ++k) {
-          if( 3*j+k>dim-1 ) break;
+          if( 3*j+k>dim-1 ) {
+            break;
+          }
           therm_eng=therm_eng+0.5*velocities[j][k]*velocities[j][k];
           velocities[j][k]=lscale*velocities[j][k]+lrand*random.Gaussian();
           therm_eng=therm_eng-0.5*velocities[j][k]*velocities[0][k];
@@ -247,7 +291,9 @@ class PesMD  : public PLMD::CLTool {
       // First step of velocity verlet
       for(int j=0; j<nat; ++j) {
         for(int k=0; k<3; ++k) {
-          if( 3*j+k>dim-1 ) break;
+          if( 3*j+k>dim-1 ) {
+            break;
+          }
           velocities[j][k] = velocities[j][k] + 0.5*tstep*forces[1+j][k];
           positions[1+j][k] = positions[1+j][k] + tstep*velocities[j][k];
         }
@@ -265,12 +311,16 @@ class PesMD  : public PLMD::CLTool {
       plumed->cmd("setStopFlag",&plumedWantsToStop);
       plumed->cmd("calc");
       // if(istep%2000==0) plumed->cmd("writeCheckPointFile");
-      if(plumedWantsToStop) nsteps=istep;
+      if(plumedWantsToStop) {
+        nsteps=istep;
+      }
 
       // Second step of velocity verlet
       for(int j=0; j<nat; ++j) {
         for(int k=0; k<3; ++k) {
-          if( 3*j+k>dim-1 ) break;
+          if( 3*j+k>dim-1 ) {
+            break;
+          }
           velocities[j][k] = velocities[j][k] + 0.5*tstep*forces[1+j][k];
         }
       }
@@ -280,7 +330,9 @@ class PesMD  : public PLMD::CLTool {
       lrand=std::sqrt((1.-lscale*lscale)*temp);
       for(int j=0; j<nat; ++j) {
         for(int k=0; k<3; ++k) {
-          if( 3*j+k>dim-1) break;
+          if( 3*j+k>dim-1) {
+            break;
+          }
           therm_eng=therm_eng+0.5*velocities[j][k]*velocities[j][k];
           velocities[j][k]=lscale*velocities[j][k]+lrand*random.Gaussian();
           therm_eng=therm_eng-0.5*velocities[j][k]*velocities[j][k];
@@ -290,14 +342,18 @@ class PesMD  : public PLMD::CLTool {
       tke=0;
       for(int i=0; i<nat; ++i) {
         for(int j=0; j<3; ++j) {
-          if( 3*i+j>dim-1 ) break;
+          if( 3*i+j>dim-1 ) {
+            break;
+          }
           tke += 0.5*velocities[i][j]*velocities[i][j];
         }
       }
 
       // Print everything
       // conserved = potential+1.5*ttt+therm_eng;
-      if( pc.Get_rank()==0 ) std::fprintf(fp,"%i %f %f %f \n", istep, istep*tstep, tke, therm_eng );
+      if( pc.Get_rank()==0 ) {
+        std::fprintf(fp,"%i %f %f %f \n", istep, istep*tstep, tke, therm_eng );
+      }
     }
 
     fclose(fp);
diff --git a/src/clusters/ClusterDiameter.cpp b/src/clusters/ClusterDiameter.cpp
index 79318a62c9..bf6b4574a3 100644
--- a/src/clusters/ClusterDiameter.cpp
+++ b/src/clusters/ClusterDiameter.cpp
@@ -73,16 +73,20 @@ void ClusterDiameter::registerKeywords( Keywords& keys ) {
   keys.add("optional","ARG","calculate ths radius of the cluster that are in this particular cluster");
   keys.add("compulsory","ATOMS","the atoms that were used to calculate the matrix that was clustered");
   keys.setValueDescription("the largest of all the distances between the pairs of atom in the cluster");
-  keys.needsAction("DISTANCE_MATRIX"); keys.needsAction("OUTER_PRODUCT"); keys.needsAction("CUSTOM");
-  keys.needsAction("FLATTEN"); keys.needsAction("HIGHEST");
+  keys.needsAction("DISTANCE_MATRIX");
+  keys.needsAction("OUTER_PRODUCT");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("FLATTEN");
+  keys.needsAction("HIGHEST");
 }
 
 ClusterDiameter::ClusterDiameter(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in the argument
-  std::string arg_str, atdata; parse("ARG",arg_str); parse("ATOMS",atdata);
+  std::string arg_str, atdata;
+  parse("ARG",arg_str);
+  parse("ATOMS",atdata);
   // Distance matrix
   readInputLine( getShortcutLabel() + "_dmat: DISTANCE_MATRIX GROUP=" + atdata );
   // Matrix of bonds in cluster
diff --git a/src/clusters/ClusterDistribution.cpp b/src/clusters/ClusterDistribution.cpp
index 7a38671a1c..7bca694b7a 100644
--- a/src/clusters/ClusterDistribution.cpp
+++ b/src/clusters/ClusterDistribution.cpp
@@ -98,8 +98,10 @@ PLUMED_REGISTER_ACTION(ClusterDistribution,"CLUSTER_DISTRIBUTION_CALC")
 void ClusterDistribution::registerKeywords( Keywords& keys ) {
   Action::registerKeywords( keys );
   ActionWithArguments::registerKeywords( keys );
-  ActionWithValue::registerKeywords( keys ); keys.remove("NUMERICAL_DERIVATIVES");
-  keys.add("compulsory","CLUSTERS","the label of the action that does the clustering"); keys.setDisplayName("CLUSTER_DISTRIBUTION");
+  ActionWithValue::registerKeywords( keys );
+  keys.remove("NUMERICAL_DERIVATIVES");
+  keys.add("compulsory","CLUSTERS","the label of the action that does the clustering");
+  keys.setDisplayName("CLUSTER_DISTRIBUTION");
   keys.add("optional","WEIGHTS","use the vector of values calculated by this action as weights rather than giving each atom a unit weight");
   keys.setValueDescription("a vector containing the sum of a atomic-cv that is calculated for each of the identified clusters");
 }
@@ -107,19 +109,28 @@ void ClusterDistribution::registerKeywords( Keywords& keys ) {
 ClusterDistribution::ClusterDistribution(const ActionOptions&ao):
   Action(ao),
   ActionWithArguments(ao),
-  ActionWithValue(ao)
-{
+  ActionWithValue(ao) {
   // Read in the clustering object
-  std::vector<Value*> clusters; parseArgumentList("CLUSTERS",clusters);
-  if( clusters.size()!=1 ) error("should pass only one matrix to clustering base");
+  std::vector<Value*> clusters;
+  parseArgumentList("CLUSTERS",clusters);
+  if( clusters.size()!=1 ) {
+    error("should pass only one matrix to clustering base");
+  }
   ClusteringBase* cc = dynamic_cast<ClusteringBase*>( clusters[0]->getPntrToAction() );
-  if( !cc ) error("input to CLUSTERS keyword should be a clustering action");
-  std::vector<Value*> weights; parseArgumentList("WEIGHTS",weights);
+  if( !cc ) {
+    error("input to CLUSTERS keyword should be a clustering action");
+  }
+  std::vector<Value*> weights;
+  parseArgumentList("WEIGHTS",weights);
   if( weights.size()==0 ) {
     log.printf("  using unit weights in cluster distribution \n");
   } else if( weights.size()==1 ) {
-    if( weights[0]->getRank()!=1 ) error("input weights has wrong shape");
-    if( weights[0]->getShape()[0]!=clusters[0]->getShape()[0] ) error("mismatch between number of weights and number of atoms");
+    if( weights[0]->getRank()!=1 ) {
+      error("input weights has wrong shape");
+    }
+    if( weights[0]->getShape()[0]!=clusters[0]->getShape()[0] ) {
+      error("mismatch between number of weights and number of atoms");
+    }
     log.printf("  using weights from action with label %s in cluster distribution \n", weights[0]->getName().c_str() );
     clusters.push_back( weights[0] );
   } else {
@@ -128,10 +139,15 @@ ClusterDistribution::ClusterDistribution(const ActionOptions&ao):
   // Request the arguments
   requestArguments( clusters );
   getPntrToArgument(0)->buildDataStore();
-  if( getNumberOfArguments()>1 ) getPntrToArgument(1)->buildDataStore();
+  if( getNumberOfArguments()>1 ) {
+    getPntrToArgument(1)->buildDataStore();
+  }
   // Now create the value
-  std::vector<unsigned> shape(1); shape[0]=clusters[0]->getShape()[0];
-  addValue( shape ); setNotPeriodic(); getPntrToValue()->buildDataStore();
+  std::vector<unsigned> shape(1);
+  shape[0]=clusters[0]->getShape()[0];
+  addValue( shape );
+  setNotPeriodic();
+  getPntrToValue()->buildDataStore();
 }
 
 unsigned ClusterDistribution::getNumberOfDerivatives() {
@@ -140,17 +156,24 @@ unsigned ClusterDistribution::getNumberOfDerivatives() {
 
 void ClusterDistribution::calculate() {
   plumed_assert( getPntrToArgument(0)->valueHasBeenSet() );
-  if( getNumberOfArguments()>1 ) plumed_assert( getPntrToArgument(1)->valueHasBeenSet() );
+  if( getNumberOfArguments()>1 ) {
+    plumed_assert( getPntrToArgument(1)->valueHasBeenSet() );
+  }
   double csize = getPntrToArgument(0)->get(0);
   for(unsigned i=1; i<getPntrToArgument(0)->getShape()[0]; ++i) {
-    if( getPntrToArgument(0)->get(i)>csize ) csize = getPntrToArgument(0)->get(i);
+    if( getPntrToArgument(0)->get(i)>csize ) {
+      csize = getPntrToArgument(0)->get(i);
+    }
   }
   unsigned ntasks = static_cast<unsigned>( csize );
   for(unsigned i=0; i<ntasks; ++i) {
     for(unsigned j=0; j<getPntrToArgument(0)->getShape()[0]; ++j) {
       if( fabs(getPntrToArgument(0)->get(j)-i)<epsilon ) {
-        if( getNumberOfArguments()==2 ) getPntrToValue()->add( i, getPntrToArgument(1)->get(j) );
-        else getPntrToValue()->add( i, 1.0 );
+        if( getNumberOfArguments()==2 ) {
+          getPntrToValue()->add( i, getPntrToArgument(1)->get(j) );
+        } else {
+          getPntrToValue()->add( i, 1.0 );
+        }
       }
     }
   }
@@ -174,9 +197,9 @@ void ClusterDistributionShortcut::registerKeywords( Keywords& keys ) {
 
 ClusterDistributionShortcut::ClusterDistributionShortcut(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::map<std::string,std::string> keymap; multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
+  ActionShortcut(ao) {
+  std::map<std::string,std::string> keymap;
+  multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
   readInputLine( getShortcutLabel() + ": CLUSTER_DISTRIBUTION_CALC " + convertInputLineToString() );
   multicolvar::MultiColvarShortcuts::expandFunctions( getShortcutLabel(),  getShortcutLabel(),  "", keymap, this );
 }
diff --git a/src/clusters/ClusterNatoms.cpp b/src/clusters/ClusterNatoms.cpp
index ebe64c7167..d1d7eca06e 100644
--- a/src/clusters/ClusterNatoms.cpp
+++ b/src/clusters/ClusterNatoms.cpp
@@ -47,13 +47,13 @@ void ClusterNatoms::registerKeywords(Keywords& keys) {
   keys.add("compulsory","CLUSTERS","the label of the action that does the clustering");
   keys.add("compulsory","CLUSTER","1","which cluster would you like to look at 1 is the largest cluster, 2 is the second largest, 3 is the the third largest and so on.");
   keys.setValueDescription("the number of atoms in the cluster");
-  keys.needsAction("CLUSTER_WEIGHTS"); keys.needsAction("SUM");
+  keys.needsAction("CLUSTER_WEIGHTS");
+  keys.needsAction("SUM");
 }
 
 ClusterNatoms::ClusterNatoms(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Create a cluster weights object
   readInputLine( getShortcutLabel() + "_weights: CLUSTER_WEIGHTS " + convertInputLineToString() );
   // Add all the weights together (weights are 1 or 0)
diff --git a/src/clusters/ClusterProperties.cpp b/src/clusters/ClusterProperties.cpp
index 3799a1bbb3..e2169be1f3 100644
--- a/src/clusters/ClusterProperties.cpp
+++ b/src/clusters/ClusterProperties.cpp
@@ -75,12 +75,13 @@ void ClusterProperties::registerKeywords(Keywords& keys) {
 
 ClusterProperties::ClusterProperties(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read the property we are interested in
-  std::string argstr; parse("ARG",argstr);
+  std::string argstr;
+  parse("ARG",argstr);
   // Read in the shortcut keywords
-  std::map<std::string,std::string> keymap; multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
+  std::map<std::string,std::string> keymap;
+  multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
   // Create a cluster weights object
   readInputLine( getShortcutLabel() + ": CLUSTER_WEIGHTS " + convertInputLineToString() );
   // Now do the multicolvar bit
diff --git a/src/clusters/ClusterWeights.cpp b/src/clusters/ClusterWeights.cpp
index e19bcd0bcb..9ff7543661 100644
--- a/src/clusters/ClusterWeights.cpp
+++ b/src/clusters/ClusterWeights.cpp
@@ -64,8 +64,10 @@ PLUMED_REGISTER_ACTION(ClusterWeights,"CLUSTER_WEIGHTS")
 
 void ClusterWeights::registerKeywords( Keywords& keys ) {
   Action::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.remove("ARG");
-  ActionWithValue::registerKeywords( keys ); keys.remove("NUMERICAL_DERIVATIVES");
+  ActionWithArguments::registerKeywords( keys );
+  keys.remove("ARG");
+  ActionWithValue::registerKeywords( keys );
+  keys.remove("NUMERICAL_DERIVATIVES");
   keys.add("compulsory","CLUSTERS","the label of the action that does the clustering");
   keys.add("compulsory","CLUSTER","1","which cluster would you like to look at 1 is the largest cluster, 2 is the second largest, 3 is the the third largest and so on.");
   keys.addFlag("LOWMEM",false,"this flag does nothing and is present only to ensure back-compatibility");
@@ -76,24 +78,38 @@ void ClusterWeights::registerKeywords( Keywords& keys ) {
 ClusterWeights::ClusterWeights(const ActionOptions&ao):
   Action(ao),
   ActionWithArguments(ao),
-  ActionWithValue(ao)
-{
-  bool lowmem; parseFlag("LOWMEM",lowmem);
-  if( lowmem ) warning("LOWMEM flag is deprecated and is no longer required for this action");
+  ActionWithValue(ao) {
+  bool lowmem;
+  parseFlag("LOWMEM",lowmem);
+  if( lowmem ) {
+    warning("LOWMEM flag is deprecated and is no longer required for this action");
+  }
   // Read in the clustering object
-  std::vector<Value*> clusters; parseArgumentList("CLUSTERS",clusters);
-  if( clusters.size()!=1 ) error("should pass only one matrix to clustering base");
+  std::vector<Value*> clusters;
+  parseArgumentList("CLUSTERS",clusters);
+  if( clusters.size()!=1 ) {
+    error("should pass only one matrix to clustering base");
+  }
   ClusteringBase* cc = dynamic_cast<ClusteringBase*>( clusters[0]->getPntrToAction() );
-  if( !cc ) error("input to CLUSTERS keyword should be a clustering action");
+  if( !cc ) {
+    error("input to CLUSTERS keyword should be a clustering action");
+  }
   // Request the arguments
   requestArguments( clusters );
   // Now create the value
-  std::vector<unsigned> shape(1); shape[0]=clusters[0]->getShape()[0];
-  addValue( shape ); setNotPeriodic(); getPntrToComponent(0)->buildDataStore();
+  std::vector<unsigned> shape(1);
+  shape[0]=clusters[0]->getShape()[0];
+  addValue( shape );
+  setNotPeriodic();
+  getPntrToComponent(0)->buildDataStore();
   // Find out which cluster we want
   parse("CLUSTER",clustr);
-  if( clustr<1 ) error("cannot look for a cluster larger than the largest cluster");
-  if( clustr>clusters[0]->getShape()[0] ) error("cluster selected is invalid - too few atoms in system");
+  if( clustr<1 ) {
+    error("cannot look for a cluster larger than the largest cluster");
+  }
+  if( clustr>clusters[0]->getShape()[0] ) {
+    error("cluster selected is invalid - too few atoms in system");
+  }
   log.printf("  atoms in %dth largest cluster calculated by %s are equal to one \n",clustr, cc->getLabel().c_str() );
 }
 
@@ -104,7 +120,9 @@ unsigned ClusterWeights::getNumberOfDerivatives() {
 void ClusterWeights::calculate() {
   plumed_assert( getPntrToArgument(0)->valueHasBeenSet() );
   for(unsigned i=0; i<getPntrToArgument(0)->getShape()[0]; ++i) {
-    if( fabs(getPntrToArgument(0)->get(i)-clustr)<epsilon ) getPntrToComponent(0)->set( i, 1.0 );
+    if( fabs(getPntrToArgument(0)->get(i)-clustr)<epsilon ) {
+      getPntrToComponent(0)->set( i, 1.0 );
+    }
   }
 }
 
diff --git a/src/clusters/ClusterWithSurface.cpp b/src/clusters/ClusterWithSurface.cpp
index 357f21fa2c..56d14546ae 100644
--- a/src/clusters/ClusterWithSurface.cpp
+++ b/src/clusters/ClusterWithSurface.cpp
@@ -50,19 +50,22 @@ void ClusterWithSurface::registerKeywords(Keywords& keys) {
   keys.add("compulsory","CLUSTERS","the label of the action that does the clustering");
   keys.add("compulsory","CLUSTER","1","which cluster would you like to look at 1 is the largest cluster, 2 is the second largest, 3 is the the third largest and so on.");
   keys.setValueDescription("a vector that is one for those atoms that are within the cluster or that are within a cetain cutoff of one of the atoms in the cluster and zero otherwise");
-  keys.needsAction("CLUSTER_WEIGHTS"); keys.needsAction("CONTACT_MATRIX");
-  keys.needsAction("OUTER_PRODUCT"); keys.needsAction("CUSTOM");
+  keys.needsAction("CLUSTER_WEIGHTS");
+  keys.needsAction("CONTACT_MATRIX");
+  keys.needsAction("OUTER_PRODUCT");
+  keys.needsAction("CUSTOM");
   keys.needsAction("DFSCLUSTERING");
 }
 
 ClusterWithSurface::ClusterWithSurface(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read atoms for contact matrix
-  std::string atdata; parse("ATOMS",atdata);
+  std::string atdata;
+  parse("ATOMS",atdata);
   // Read rcut input
-  std::string rcut_surf_str; parse("RCUT_SURF",rcut_surf_str);
+  std::string rcut_surf_str;
+  parse("RCUT_SURF",rcut_surf_str);
   // Create a cluster weights object
   readInputLine( getShortcutLabel() + "_wnosurf: CLUSTER_WEIGHTS " + convertInputLineToString() );
   // Now create a contact matrix
diff --git a/src/clusters/ClusteringBase.cpp b/src/clusters/ClusteringBase.cpp
index 5a0b6c00e6..45c995404a 100644
--- a/src/clusters/ClusteringBase.cpp
+++ b/src/clusters/ClusteringBase.cpp
@@ -26,32 +26,42 @@ namespace PLMD {
 namespace clusters {
 
 void ClusteringBase::registerKeywords( Keywords& keys ) {
-  matrixtools::MatrixOperationBase::registerKeywords( keys ); keys.use("ARG");
+  matrixtools::MatrixOperationBase::registerKeywords( keys );
+  keys.use("ARG");
   keys.setValueDescription("vector with length that is equal to the number of rows in the input matrix.  Elements of this vector are equal to the cluster that each node is a part of");
 }
 
 ClusteringBase::ClusteringBase(const ActionOptions&ao):
   Action(ao),
   matrixtools::MatrixOperationBase(ao),
-  number_of_cluster(-1)
-{
+  number_of_cluster(-1) {
   // Do some checks on the input
-  if( getPntrToArgument(0)->getShape()[0]!=getPntrToArgument(0)->getShape()[1] ) error("input matrix should be square");
+  if( getPntrToArgument(0)->getShape()[0]!=getPntrToArgument(0)->getShape()[1] ) {
+    error("input matrix should be square");
+  }
 
   // Now create a value - this holds the data on which cluster each guy is in
-  std::vector<unsigned> shape(1); shape[0]=getPntrToArgument(0)->getShape()[0];
+  std::vector<unsigned> shape(1);
+  shape[0]=getPntrToArgument(0)->getShape()[0];
   // Build the store here to make sure that next action has all data
-  addValue( shape ); setNotPeriodic(); getPntrToValue()->buildDataStore();
+  addValue( shape );
+  setNotPeriodic();
+  getPntrToValue()->buildDataStore();
   // Resize local variables
-  which_cluster.resize( getPntrToArgument(0)->getShape()[0] ); cluster_sizes.resize( getPntrToArgument(0)->getShape()[0] );
+  which_cluster.resize( getPntrToArgument(0)->getShape()[0] );
+  cluster_sizes.resize( getPntrToArgument(0)->getShape()[0] );
 }
 
 void ClusteringBase::retrieveAdjacencyLists( std::vector<unsigned>& nneigh, Matrix<unsigned>& adj_list ) {
   // Make sure we have the edges stored
-  std::vector<std::pair<unsigned,unsigned> > pairs; std::vector<double> vals;
-  unsigned nedge; getPntrToArgument(0)->retrieveEdgeList( nedge, pairs, vals );
+  std::vector<std::pair<unsigned,unsigned> > pairs;
+  std::vector<double> vals;
+  unsigned nedge;
+  getPntrToArgument(0)->retrieveEdgeList( nedge, pairs, vals );
   // Currently everything has zero neighbors
-  for(unsigned i=0; i<nneigh.size(); ++i) nneigh[i]=0;
+  for(unsigned i=0; i<nneigh.size(); ++i) {
+    nneigh[i]=0;
+  }
   // Resize the adjacency list if it is needed
   if( adj_list.ncols()!=getPntrToArgument(0)->getNumberOfColumns() ) {
     unsigned nrows = getPntrToArgument(0)->getShape()[0];
@@ -62,15 +72,22 @@ void ClusteringBase::retrieveAdjacencyLists( std::vector<unsigned>& nneigh, Matr
   for(unsigned i=0; i<nedge; ++i) {
     // Store if atoms are connected
     unsigned j=pairs[i].first, k=pairs[i].second;
-    if( j==k ) continue;
-    adj_list(j,nneigh[j])=k; nneigh[j]++;
-    adj_list(k,nneigh[k])=j; nneigh[k]++;
+    if( j==k ) {
+      continue;
+    }
+    adj_list(j,nneigh[j])=k;
+    nneigh[j]++;
+    adj_list(k,nneigh[k])=j;
+    nneigh[k]++;
   }
 }
 
 void ClusteringBase::calculate() {
   // All the clusters have zero size initially
-  for(unsigned i=0; i<cluster_sizes.size(); ++i) { cluster_sizes[i].first=0; cluster_sizes[i].second=i; }
+  for(unsigned i=0; i<cluster_sizes.size(); ++i) {
+    cluster_sizes[i].first=0;
+    cluster_sizes[i].second=i;
+  }
   // Do the clustering bit
   performClustering();
   // Order the clusters in the system by size (this returns ascending order )
@@ -79,13 +96,17 @@ void ClusteringBase::calculate() {
   for(unsigned i=0; i<cluster_sizes.size(); ++i) {
     double this_size = static_cast<double>(cluster_sizes.size()-i);
     for(unsigned j=0; j<cluster_sizes.size(); ++j) {
-      if( which_cluster[j]==cluster_sizes[i].second ) getPntrToValue()->set( j, this_size );
+      if( which_cluster[j]==cluster_sizes[i].second ) {
+        getPntrToValue()->set( j, this_size );
+      }
     }
   }
 }
 
 void ClusteringBase::apply() {
-  if( getPntrToComponent(0)->forcesWereAdded() ) error("forces on clustering actions cannot work as clustering is not differentiable");
+  if( getPntrToComponent(0)->forcesWereAdded() ) {
+    error("forces on clustering actions cannot work as clustering is not differentiable");
+  }
 }
 
 }
diff --git a/src/clusters/ClusteringBase.h b/src/clusters/ClusteringBase.h
index 65bf6d1fce..5451e7158d 100644
--- a/src/clusters/ClusteringBase.h
+++ b/src/clusters/ClusteringBase.h
@@ -46,14 +46,18 @@ class ClusteringBase : public matrixtools::MatrixOperationBase {
 /// Constructor
   explicit ClusteringBase(const ActionOptions&);
 ///
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
 ///
   void calculate() override;
 ///
   virtual void performClustering()=0;
 /// Cannot apply forces on a clustering object
   void apply() override ;
-  double getForceOnMatrixElement( const unsigned& jrow, const unsigned& krow ) const override { plumed_error(); }
+  double getForceOnMatrixElement( const unsigned& jrow, const unsigned& krow ) const override {
+    plumed_error();
+  }
 };
 
 inline
diff --git a/src/clusters/DFSClustering.cpp b/src/clusters/DFSClustering.cpp
index 85aab665f6..13215c9664 100644
--- a/src/clusters/DFSClustering.cpp
+++ b/src/clusters/DFSClustering.cpp
@@ -96,19 +96,23 @@ void DFSClustering::registerKeywords( Keywords& keys ) {
 
 DFSClustering::DFSClustering(const ActionOptions&ao):
   Action(ao),
-  ClusteringBase(ao)
-{
+  ClusteringBase(ao) {
 #ifndef __PLUMED_HAS_BOOST_GRAPH
-  nneigh.resize( getNumberOfNodes() ); color.resize(getNumberOfNodes());
+  nneigh.resize( getNumberOfNodes() );
+  color.resize(getNumberOfNodes());
 #endif
-  bool lowmem; parseFlag("LOWMEM",lowmem);
-  if( lowmem ) warning("LOWMEM flag is deprecated and is no longer required for this action");
+  bool lowmem;
+  parseFlag("LOWMEM",lowmem);
+  if( lowmem ) {
+    warning("LOWMEM flag is deprecated and is no longer required for this action");
+  }
 }
 
 void DFSClustering::performClustering() {
 #ifdef __PLUMED_HAS_BOOST_GRAPH
   // Get the list of edges
-  unsigned nedges=0; retrieveEdgeList( 0, nedges );
+  unsigned nedges=0;
+  retrieveEdgeList( 0, nedges );
 
   // Build the graph using boost
   boost::adjacency_list<boost::vecS,boost::vecS,boost::undirectedS> sg(&pairs[0],&pairs[nedges],getNumberOfNodes());
@@ -117,15 +121,21 @@ void DFSClustering::performClustering() {
   number_of_cluster=boost::connected_components(sg,&which_cluster[0]) - 1;
 
   // And work out the size of each cluster
-  for(unsigned i=0; i<which_cluster.size(); ++i) cluster_sizes[which_cluster[i]].first++;
+  for(unsigned i=0; i<which_cluster.size(); ++i) {
+    cluster_sizes[which_cluster[i]].first++;
+  }
 #else
   // Get the adjacency matrix
   retrieveAdjacencyLists( nneigh, adj_list );
 
   // Perform clustering
-  number_of_cluster=-1; color.assign(color.size(),0);
+  number_of_cluster=-1;
+  color.assign(color.size(),0);
   for(unsigned i=0; i<getNumberOfNodes(); ++i) {
-    if( color[i]==0 ) { number_of_cluster++; color[i]=explore(i); }
+    if( color[i]==0 ) {
+      number_of_cluster++;
+      color[i]=explore(i);
+    }
   }
 #endif
 }
@@ -136,7 +146,9 @@ int DFSClustering::explore( const unsigned& index ) {
   color[index]=1;
   for(unsigned i=0; i<nneigh[index]; ++i) {
     unsigned j=adj_list(index,i);
-    if( color[j]==0 ) color[j]=explore(j);
+    if( color[j]==0 ) {
+      color[j]=explore(j);
+    }
   }
 
   // Count the size of the cluster
diff --git a/src/clusters/OutputCluster.cpp b/src/clusters/OutputCluster.cpp
index 7b5ca7f584..99eb507be1 100644
--- a/src/clusters/OutputCluster.cpp
+++ b/src/clusters/OutputCluster.cpp
@@ -72,18 +72,23 @@ void OutputCluster::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","CLUSTER","1","which cluster would you like to look at 1 is the largest cluster, 2 is the second largest, 3 is the the third largest and so on");
   keys.add("compulsory","STRIDE","1","the frequency with which you would like to output the atoms in the cluster");
   keys.add("compulsory","FILE","the name of the file on which to output the details of the cluster");
-  keys.remove("HAS_VALUES"); keys.needsAction("PRINT_NDX");
+  keys.remove("HAS_VALUES");
+  keys.needsAction("PRINT_NDX");
 }
 
 OutputCluster::OutputCluster(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string id; parse("CLUSTER",id);
-  std::string stride; parse("STRIDE",stride);
-  std::string clusters; parse("CLUSTERS",clusters);
-  std::string filename; parse("FILE",filename);
-  std::string atoms; parse("ATOMS",atoms);
+  ActionShortcut(ao) {
+  std::string id;
+  parse("CLUSTER",id);
+  std::string stride;
+  parse("STRIDE",stride);
+  std::string clusters;
+  parse("CLUSTERS",clusters);
+  std::string filename;
+  parse("FILE",filename);
+  std::string atoms;
+  parse("ATOMS",atoms);
   readInputLine("PRINT_NDX ATOMS=" + atoms + " ARG=" + clusters + " FILE=" + filename + " STRIDE=" + stride + " LESS_THAN_OR_EQUAL=" + id + " GREATER_THAN_OR_EQUAL=" + id );
 }
 
diff --git a/src/colvar/Angle.cpp b/src/colvar/Angle.cpp
index 846e0432f7..2b049014ad 100644
--- a/src/colvar/Angle.cpp
+++ b/src/colvar/Angle.cpp
@@ -122,7 +122,8 @@ typedef MultiColvarTemplate<Angle> AngleMulti;
 PLUMED_REGISTER_ACTION(AngleMulti,"ANGLE_VECTOR")
 
 void Angle::registerKeywords( Keywords& keys ) {
-  Colvar::registerKeywords(keys); keys.setDisplayName("ANGLE");
+  Colvar::registerKeywords(keys);
+  keys.setDisplayName("ANGLE");
   keys.add("atoms","ATOMS","the list of atoms involved in this collective variable (either 3 or 4 atoms)");
   keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
   keys.setValueDescription("the ANGLE involving these atoms");
@@ -137,11 +138,15 @@ void Angle::parseAtomList( const int& num, std::vector<AtomNumber>& atoms, Actio
     atoms[2]=atoms[1];
   } else if(atoms.size()==4) {
     aa->log.printf("  between lines %d-%d and %d-%d\n",atoms[0].serial(),atoms[1].serial(),atoms[2].serial(),atoms[3].serial());
-  } else if( num<0 || atoms.size()>0 ) aa->error("Number of specified atoms should be either 3 or 4");
+  } else if( num<0 || atoms.size()>0 ) {
+    aa->error("Number of specified atoms should be either 3 or 4");
+  }
 }
 
 unsigned Angle::getModeAndSetupValues( ActionWithValue* av ) {
-  av->addValueWithDerivatives(); av->setNotPeriodic(); return 0;
+  av->addValueWithDerivatives();
+  av->setNotPeriodic();
+  return 0;
 }
 
 Angle::Angle(const ActionOptions&ao):
@@ -149,18 +154,22 @@ Angle::Angle(const ActionOptions&ao):
   pbc(true),
   value(1),
   derivs(1),
-  virial(1)
-{
+  virial(1) {
   derivs[0].resize(4);
-  std::vector<AtomNumber> atoms; parseAtomList( -1, atoms, this );
+  std::vector<AtomNumber> atoms;
+  parseAtomList( -1, atoms, this );
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
 
-  if(pbc) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
   requestAtoms(atoms);
   checkRead();
 }
@@ -168,10 +177,14 @@ Angle::Angle(const ActionOptions&ao):
 // calculator
 void Angle::calculate() {
 
-  if(pbc) makeWhole();
+  if(pbc) {
+    makeWhole();
+  }
   calculateCV( 0, masses, charges, getPositions(), value, derivs, virial, this );
   setValue( value[0] );
-  for(unsigned i=0; i<derivs[0].size(); ++i) setAtomsDerivatives( i, derivs[0][i] );
+  for(unsigned i=0; i<derivs[0].size(); ++i) {
+    setAtomsDerivatives( i, derivs[0][i] );
+  }
   setBoxDerivatives( virial[0] );
 }
 
@@ -181,10 +194,13 @@ void Angle::calculateCV( const unsigned& mode, const std::vector<double>& masses
   Vector dij,dik;
   dij=delta(pos[2],pos[3]);
   dik=delta(pos[1],pos[0]);
-  Vector ddij,ddik; PLMD::Angle a;
+  Vector ddij,ddik;
+  PLMD::Angle a;
   vals[0]=a.compute(dij,dik,ddij,ddik);
-  derivs[0][0]=ddik; derivs[0][1]=-ddik;
-  derivs[0][2]=-ddij; derivs[0][3]=ddij;
+  derivs[0][0]=ddik;
+  derivs[0][1]=-ddik;
+  derivs[0][2]=-ddij;
+  derivs[0][3]=ddij;
   setBoxDerivativesNoPbc( pos, derivs, virial );
 }
 
diff --git a/src/colvar/Cell.cpp b/src/colvar/Cell.cpp
index 9385e854a7..2d31f50d95 100644
--- a/src/colvar/Cell.cpp
+++ b/src/colvar/Cell.cpp
@@ -58,20 +58,37 @@ class Cell : public Colvar {
 PLUMED_REGISTER_ACTION(Cell,"CELL")
 
 Cell::Cell(const ActionOptions&ao):
-  PLUMED_COLVAR_INIT(ao)
-{
+  PLUMED_COLVAR_INIT(ao) {
   std::vector<AtomNumber> atoms;
   checkRead();
 
-  addComponentWithDerivatives("ax"); componentIsNotPeriodic("ax"); components[0][0]=getPntrToComponent("ax");
-  addComponentWithDerivatives("ay"); componentIsNotPeriodic("ay"); components[0][1]=getPntrToComponent("ay");
-  addComponentWithDerivatives("az"); componentIsNotPeriodic("az"); components[0][2]=getPntrToComponent("az");
-  addComponentWithDerivatives("bx"); componentIsNotPeriodic("bx"); components[1][0]=getPntrToComponent("bx");
-  addComponentWithDerivatives("by"); componentIsNotPeriodic("by"); components[1][1]=getPntrToComponent("by");
-  addComponentWithDerivatives("bz"); componentIsNotPeriodic("bz"); components[1][2]=getPntrToComponent("bz");
-  addComponentWithDerivatives("cx"); componentIsNotPeriodic("cx"); components[2][0]=getPntrToComponent("cx");
-  addComponentWithDerivatives("cy"); componentIsNotPeriodic("cy"); components[2][1]=getPntrToComponent("cy");
-  addComponentWithDerivatives("cz"); componentIsNotPeriodic("cz"); components[2][2]=getPntrToComponent("cz");
+  addComponentWithDerivatives("ax");
+  componentIsNotPeriodic("ax");
+  components[0][0]=getPntrToComponent("ax");
+  addComponentWithDerivatives("ay");
+  componentIsNotPeriodic("ay");
+  components[0][1]=getPntrToComponent("ay");
+  addComponentWithDerivatives("az");
+  componentIsNotPeriodic("az");
+  components[0][2]=getPntrToComponent("az");
+  addComponentWithDerivatives("bx");
+  componentIsNotPeriodic("bx");
+  components[1][0]=getPntrToComponent("bx");
+  addComponentWithDerivatives("by");
+  componentIsNotPeriodic("by");
+  components[1][1]=getPntrToComponent("by");
+  addComponentWithDerivatives("bz");
+  componentIsNotPeriodic("bz");
+  components[1][2]=getPntrToComponent("bz");
+  addComponentWithDerivatives("cx");
+  componentIsNotPeriodic("cx");
+  components[2][0]=getPntrToComponent("cx");
+  addComponentWithDerivatives("cy");
+  componentIsNotPeriodic("cy");
+  components[2][1]=getPntrToComponent("cy");
+  addComponentWithDerivatives("cz");
+  componentIsNotPeriodic("cz");
+  components[2][2]=getPntrToComponent("cz");
   requestAtoms(atoms);
 }
 
@@ -94,9 +111,16 @@ void Cell::registerKeywords( Keywords& keys ) {
 // calculator
 void Cell::calculate() {
 
-  for(int i=0; i<3; i++) for(int j=0; j<3; j++) components[i][j]->set(getBox()[i][j]);
-  for(int l=0; l<3; l++) for(int m=0; m<3; m++) {
-      Tensor der; for(int i=0; i<3; i++) der[i][m]=getBox()[l][i];
+  for(int i=0; i<3; i++)
+    for(int j=0; j<3; j++) {
+      components[i][j]->set(getBox()[i][j]);
+    }
+  for(int l=0; l<3; l++)
+    for(int m=0; m<3; m++) {
+      Tensor der;
+      for(int i=0; i<3; i++) {
+        der[i][m]=getBox()[l][i];
+      }
       setBoxDerivatives(components[l][m],-der);
     }
 }
diff --git a/src/colvar/ColvarShortcut.h b/src/colvar/ColvarShortcut.h
index 7ecd14b289..c25e9f61aa 100644
--- a/src/colvar/ColvarShortcut.h
+++ b/src/colvar/ColvarShortcut.h
@@ -36,22 +36,27 @@ class ColvarShortcut : public ActionShortcut {
 
 template <class T>
 void ColvarShortcut<T>::registerKeywords(Keywords& keys ) {
-  T::registerKeywords( keys ); keys.remove("NO_ACTION_LOG");
+  T::registerKeywords( keys );
+  keys.remove("NO_ACTION_LOG");
   unsigned nkeys = keys.size();
   for(unsigned i=0; i<nkeys; ++i) {
-    if( keys.style( keys.get(i), "atoms" ) ) keys.reset_style( keys.get(i), "numbered" );
+    if( keys.style( keys.get(i), "atoms" ) ) {
+      keys.reset_style( keys.get(i), "numbered" );
+    }
   }
-  keys.addActionNameSuffix("_SCALAR"); keys.addActionNameSuffix("_VECTOR");
+  keys.addActionNameSuffix("_SCALAR");
+  keys.addActionNameSuffix("_VECTOR");
 }
 
 template <class T>
 ColvarShortcut<T>::ColvarShortcut(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  bool scalar=true; unsigned nkeys = keywords.size();
+  ActionShortcut(ao) {
+  bool scalar=true;
+  unsigned nkeys = keywords.size();
   if( getName()=="MASS" || getName()=="CHARGE" || getName()=="POSITION" ) {
-    std::string inpt; parse("ATOMS",inpt);
+    std::string inpt;
+    parse("ATOMS",inpt);
     if( inpt.length()>0 ) {
       readInputLine( getShortcutLabel() + ": " + getName() + "_VECTOR ATOMS=" + inpt + " " + convertInputLineToString() );
       scalar=false;
@@ -59,14 +64,18 @@ ColvarShortcut<T>::ColvarShortcut(const ActionOptions&ao):
   }
   for(unsigned i=0; i<nkeys; ++i) {
     if( keywords.style( keywords.get(i), "atoms" ) ) {
-      std::string inpt; parseNumbered( keywords.get(i), 1, inpt );
+      std::string inpt;
+      parseNumbered( keywords.get(i), 1, inpt );
       if( inpt.length()>0 ) {
         readInputLine( getShortcutLabel() + ": " + getName() + "_VECTOR " + keywords.get(i) + "1=" + inpt + " " + convertInputLineToString() );
-        scalar=false; break;
+        scalar=false;
+        break;
       }
     }
   }
-  if( scalar ) readInputLine( getShortcutLabel() + ": " + getName() + "_SCALAR " + convertInputLineToString() );
+  if( scalar ) {
+    readInputLine( getShortcutLabel() + ": " + getName() + "_SCALAR " + convertInputLineToString() );
+  }
 }
 
 }
diff --git a/src/colvar/ContactMap.cpp b/src/colvar/ContactMap.cpp
index 285554dcb9..2f71032e4d 100644
--- a/src/colvar/ContactMap.cpp
+++ b/src/colvar/ContactMap.cpp
@@ -147,12 +147,13 @@ ContactMap::ContactMap(const ActionOptions&ao):
   serial(false),
   docomp(true),
   dosum(false),
-  docmdist(false)
-{
+  docmdist(false) {
   parseFlag("SERIAL",serial);
   parseFlag("SUM",dosum);
   parseFlag("CMDIST",docmdist);
-  if(docmdist==true&&dosum==true) error("You cannot use SUM and CMDIST together");
+  if(docmdist==true&&dosum==true) {
+    error("You cannot use SUM and CMDIST together");
+  }
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
@@ -161,39 +162,61 @@ ContactMap::ContactMap(const ActionOptions&ao):
   std::vector<AtomNumber> t, ga_lista, gb_lista;
   for(int i=1;; ++i ) {
     parseAtomList("ATOMS", i, t );
-    if( t.empty() ) break;
+    if( t.empty() ) {
+      break;
+    }
 
     if( t.size()!=2 ) {
-      std::string ss; Tools::convert(i,ss);
+      std::string ss;
+      Tools::convert(i,ss);
       error("ATOMS" + ss + " keyword has the wrong number of atoms");
     }
-    ga_lista.push_back(t[0]); gb_lista.push_back(t[1]);
+    ga_lista.push_back(t[0]);
+    gb_lista.push_back(t[1]);
     t.resize(0);
 
     // Add a value for this contact
-    std::string num; Tools::convert(i,num);
-    if(!dosum&&!docmdist) {addComponentWithDerivatives("contact-"+num); componentIsNotPeriodic("contact-"+num);}
+    std::string num;
+    Tools::convert(i,num);
+    if(!dosum&&!docmdist) {
+      addComponentWithDerivatives("contact-"+num);
+      componentIsNotPeriodic("contact-"+num);
+    }
   }
   // Create neighbour lists
   nl=Tools::make_unique<NeighborList>(ga_lista,gb_lista,serial,true,pbc,getPbc(),comm);
 
   // Read in switching functions
-  std::string errors; sfs.resize( ga_lista.size() ); unsigned nswitch=0;
+  std::string errors;
+  sfs.resize( ga_lista.size() );
+  unsigned nswitch=0;
   for(unsigned i=0; i<ga_lista.size(); ++i) {
-    std::string num, sw1; Tools::convert(i+1, num);
-    if( !parseNumbered( "SWITCH", i+1, sw1 ) ) break;
-    nswitch++; sfs[i].set(sw1,errors);
-    if( errors.length()!=0 ) error("problem reading SWITCH" + num + " keyword : " + errors );
+    std::string num, sw1;
+    Tools::convert(i+1, num);
+    if( !parseNumbered( "SWITCH", i+1, sw1 ) ) {
+      break;
+    }
+    nswitch++;
+    sfs[i].set(sw1,errors);
+    if( errors.length()!=0 ) {
+      error("problem reading SWITCH" + num + " keyword : " + errors );
+    }
   }
   if( nswitch==0 ) {
-    std::string sw; parse("SWITCH",sw);
-    if(sw.length()==0) error("no switching function specified use SWITCH keyword");
+    std::string sw;
+    parse("SWITCH",sw);
+    if(sw.length()==0) {
+      error("no switching function specified use SWITCH keyword");
+    }
     for(unsigned i=0; i<ga_lista.size(); ++i) {
       sfs[i].set(sw,errors);
-      if( errors.length()!=0 ) error("problem reading SWITCH keyword : " + errors );
+      if( errors.length()!=0 ) {
+        error("problem reading SWITCH keyword : " + errors );
+      }
     }
   } else if( nswitch!=sfs.size()  ) {
-    std::string num; Tools::convert(nswitch+1, num);
+    std::string num;
+    Tools::convert(nswitch+1, num);
     error("missing SWITCH" + num + " keyword");
   }
 
@@ -201,7 +224,9 @@ ContactMap::ContactMap(const ActionOptions&ao):
   nswitch=0;
   reference.resize(ga_lista.size(), 0.);
   for(unsigned i=0; i<ga_lista.size(); ++i) {
-    if( !parseNumbered( "REFERENCE", i+1, reference[i] ) ) break;
+    if( !parseNumbered( "REFERENCE", i+1, reference[i] ) ) {
+      break;
+    }
     nswitch++;
   }
   if( nswitch==0 ) {
@@ -211,13 +236,17 @@ ContactMap::ContactMap(const ActionOptions&ao):
       nswitch++;
     }
   }
-  if(nswitch == 0 && docmdist) error("with CMDIST one must use REFERENCE to setup the reference contact map");
+  if(nswitch == 0 && docmdist) {
+    error("with CMDIST one must use REFERENCE to setup the reference contact map");
+  }
 
   // Read in weight values
   nswitch=0;
   weight.resize(ga_lista.size(), 1.0);
   for(unsigned i=0; i<ga_lista.size(); ++i) {
-    if( !parseNumbered( "WEIGHT", i+1, weight[i] ) ) break;
+    if( !parseNumbered( "WEIGHT", i+1, weight[i] ) ) {
+      break;
+    }
     nswitch++;
   }
   if( nswitch==0 ) {
@@ -235,11 +264,13 @@ ContactMap::ContactMap(const ActionOptions&ao):
   }
 
   if(dosum) {
-    addValueWithDerivatives(); setNotPeriodic();
+    addValueWithDerivatives();
+    setNotPeriodic();
     log.printf("  colvar is sum of all contacts in contact map\n");
   }
   if(docmdist) {
-    addValueWithDerivatives(); setNotPeriodic();
+    addValueWithDerivatives();
+    setNotPeriodic();
     log.printf("  colvar is distance between the contact map matrix and the provided reference matrix\n");
   }
 
@@ -312,12 +343,16 @@ void ContactMap::calculate() {
 
   if(!serial) {
     comm.Sum(&ncoord,1);
-    if(!deriv.empty()) comm.Sum(&deriv[0][0],3*deriv.size());
+    if(!deriv.empty()) {
+      comm.Sum(&deriv[0][0],3*deriv.size());
+    }
     comm.Sum(&virial[0][0],9);
   }
 
   if( !docomp ) {
-    for(unsigned i=0; i<deriv.size(); ++i) setAtomsDerivatives(i,deriv[i]);
+    for(unsigned i=0; i<deriv.size(); ++i) {
+      setAtomsDerivatives(i,deriv[i]);
+    }
     setValue           (ncoord);
     setBoxDerivatives  (virial);
   }
diff --git a/src/colvar/Coordination.cpp b/src/colvar/Coordination.cpp
index 0ebd429097..d9574b6703 100644
--- a/src/colvar/Coordination.cpp
+++ b/src/colvar/Coordination.cpp
@@ -118,21 +118,24 @@ void Coordination::registerKeywords( Keywords& keys ) {
 
 Coordination::Coordination(const ActionOptions&ao):
   Action(ao),
-  CoordinationBase(ao)
-{
+  CoordinationBase(ao) {
 
   std::string sw,errors;
   parse("SWITCH",sw);
   if(sw.length()>0) {
     switchingFunction.set(sw,errors);
-    if( errors.length()!=0 ) error("problem reading SWITCH keyword : " + errors );
+    if( errors.length()!=0 ) {
+      error("problem reading SWITCH keyword : " + errors );
+    }
   } else {
     int nn=6;
     int mm=0;
     double d0=0.0;
     double r0=0.0;
     parse("R_0",r0);
-    if(r0<=0.0) error("R_0 should be explicitly specified and positive");
+    if(r0<=0.0) {
+      error("R_0 should be explicitly specified and positive");
+    }
     parse("D_0",d0);
     parse("NN",nn);
     parse("MM",mm);
diff --git a/src/colvar/CoordinationBase.cpp b/src/colvar/CoordinationBase.cpp
index e7ab51611c..e56c6fbfb0 100644
--- a/src/colvar/CoordinationBase.cpp
+++ b/src/colvar/CoordinationBase.cpp
@@ -43,8 +43,7 @@ CoordinationBase::CoordinationBase(const ActionOptions&ao):
   pbc(true),
   serial(false),
   invalidateList(true),
-  firsttime(true)
-{
+  firsttime(true) {
 
   parseFlag("SERIAL",serial);
 
@@ -67,18 +66,29 @@ CoordinationBase::CoordinationBase(const ActionOptions&ao):
   parseFlag("NLIST",doneigh);
   if(doneigh) {
     parse("NL_CUTOFF",nl_cut);
-    if(nl_cut<=0.0) error("NL_CUTOFF should be explicitly specified and positive");
+    if(nl_cut<=0.0) {
+      error("NL_CUTOFF should be explicitly specified and positive");
+    }
     parse("NL_STRIDE",nl_st);
-    if(nl_st<=0) error("NL_STRIDE should be explicitly specified and positive");
+    if(nl_st<=0) {
+      error("NL_STRIDE should be explicitly specified and positive");
+    }
   }
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
   if(gb_lista.size()>0) {
-    if(doneigh)  nl=Tools::make_unique<NeighborList>(ga_lista,gb_lista,serial,dopair,pbc,getPbc(),comm,nl_cut,nl_st);
-    else         nl=Tools::make_unique<NeighborList>(ga_lista,gb_lista,serial,dopair,pbc,getPbc(),comm);
+    if(doneigh) {
+      nl=Tools::make_unique<NeighborList>(ga_lista,gb_lista,serial,dopair,pbc,getPbc(),comm,nl_cut,nl_st);
+    } else {
+      nl=Tools::make_unique<NeighborList>(ga_lista,gb_lista,serial,dopair,pbc,getPbc(),comm);
+    }
   } else {
-    if(doneigh)  nl=Tools::make_unique<NeighborList>(ga_lista,serial,pbc,getPbc(),comm,nl_cut,nl_st);
-    else         nl=Tools::make_unique<NeighborList>(ga_lista,serial,pbc,getPbc(),comm);
+    if(doneigh) {
+      nl=Tools::make_unique<NeighborList>(ga_lista,serial,pbc,getPbc(),comm,nl_cut,nl_st);
+    } else {
+      nl=Tools::make_unique<NeighborList>(ga_lista,serial,pbc,getPbc(),comm);
+    }
   }
 
   requestAtoms(nl->getFullAtomList());
@@ -86,18 +96,27 @@ CoordinationBase::CoordinationBase(const ActionOptions&ao):
   log.printf("  between two groups of %u and %u atoms\n",static_cast<unsigned>(ga_lista.size()),static_cast<unsigned>(gb_lista.size()));
   log.printf("  first group:\n");
   for(unsigned int i=0; i<ga_lista.size(); ++i) {
-    if ( (i+1) % 25 == 0 ) log.printf("  \n");
+    if ( (i+1) % 25 == 0 ) {
+      log.printf("  \n");
+    }
     log.printf("  %d", ga_lista[i].serial());
   }
   log.printf("  \n  second group:\n");
   for(unsigned int i=0; i<gb_lista.size(); ++i) {
-    if ( (i+1) % 25 == 0 ) log.printf("  \n");
+    if ( (i+1) % 25 == 0 ) {
+      log.printf("  \n");
+    }
     log.printf("  %d", gb_lista[i].serial());
   }
   log.printf("  \n");
-  if(pbc) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  without periodic boundary conditions\n");
-  if(dopair) log.printf("  with PAIR option\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
+  if(dopair) {
+    log.printf("  with PAIR option\n");
+  }
   if(doneigh) {
     log.printf("  using neighbor lists with\n");
     log.printf("  update every %d steps and cutoff %f\n",nl_st,nl_cut);
@@ -117,15 +136,18 @@ void CoordinationBase::prepare() {
     } else {
       requestAtoms(nl->getReducedAtomList());
       invalidateList=false;
-      if(getExchangeStep()) error("Neighbor lists should be updated on exchange steps - choose a NL_STRIDE which divides the exchange stride!");
+      if(getExchangeStep()) {
+        error("Neighbor lists should be updated on exchange steps - choose a NL_STRIDE which divides the exchange stride!");
+      }
+    }
+    if(getExchangeStep()) {
+      firsttime=true;
     }
-    if(getExchangeStep()) firsttime=true;
   }
 }
 
 // calculator
-void CoordinationBase::calculate()
-{
+void CoordinationBase::calculate() {
 
   double ncoord=0.;
   Tensor virial;
@@ -147,7 +169,9 @@ void CoordinationBase::calculate()
 
   unsigned nt=OpenMP::getNumThreads();
   const unsigned nn=nl->size();
-  if(nt*stride*10>nn) nt=1;
+  if(nt*stride*10>nn) {
+    nt=1;
+  }
 
   const unsigned elementsPerRank = std::ceil(double(nn)/stride);
   const unsigned int start= rank*elementsPerRank;
@@ -165,7 +189,9 @@ void CoordinationBase::calculate()
       const unsigned i0=nl->getClosePair(i).first;
       const unsigned i1=nl->getClosePair(i).second;
 
-      if(getAbsoluteIndex(i0)==getAbsoluteIndex(i1)) continue;
+      if(getAbsoluteIndex(i0)==getAbsoluteIndex(i1)) {
+        continue;
+      }
 
       if(pbc) {
         distance=pbcDistance(getPosition(i0),getPosition(i1));
@@ -191,19 +217,24 @@ void CoordinationBase::calculate()
     }
     #pragma omp critical
     if(nt>1) {
-      for(unsigned i=0; i<getPositions().size(); i++)
+      for(unsigned i=0; i<getPositions().size(); i++) {
         deriv[i]+=omp_deriv[i];
+      }
       virial+=omp_virial;
     }
   }
 
   if(!serial) {
     comm.Sum(ncoord);
-    if(!deriv.empty()) comm.Sum(&deriv[0][0],3*deriv.size());
+    if(!deriv.empty()) {
+      comm.Sum(&deriv[0][0],3*deriv.size());
+    }
     comm.Sum(virial);
   }
 
-  for(unsigned i=0; i<deriv.size(); ++i) setAtomsDerivatives(i,deriv[i]);
+  for(unsigned i=0; i<deriv.size(); ++i) {
+    setAtomsDerivatives(i,deriv[i]);
+  }
   setValue           (ncoord);
   setBoxDerivatives  (virial);
 
diff --git a/src/colvar/DHEnergy.cpp b/src/colvar/DHEnergy.cpp
index 677fa3978d..11c10ddacc 100644
--- a/src/colvar/DHEnergy.cpp
+++ b/src/colvar/DHEnergy.cpp
@@ -108,14 +108,15 @@ DHEnergy::DHEnergy(const ActionOptions&ao):
   Action(ao),
   CoordinationBase(ao),
   k(0.0),
-  constant(0.0)
-{
+  constant(0.0) {
   double I,T;
   parse("I",I);
   parse("TEMP",T);
   parse("EPSILON",epsilon);
   checkRead();
-  if( usingNaturalUnits() ) error("DHENERGY cannot be used for calculations performed with natural units");
+  if( usingNaturalUnits() ) {
+    error("DHENERGY cannot be used for calculations performed with natural units");
+  }
   constant=138.935458111/getUnits().getEnergy()/getUnits().getLength()*getUnits().getCharge()*getUnits().getCharge();
   k=std::sqrt(I/(epsilon*T))*502.903741125*getUnits().getLength();
   checkRead();
diff --git a/src/colvar/DRMSD.cpp b/src/colvar/DRMSD.cpp
index 6c9a25bdea..7b0e48d032 100644
--- a/src/colvar/DRMSD.cpp
+++ b/src/colvar/DRMSD.cpp
@@ -126,79 +126,137 @@ void DRMSD::registerKeywords( Keywords& keys ) {
   // This is just ignored in reality which is probably bad
   keys.addFlag("NUMERICAL_DERIVATIVES",false,"calculate the derivatives for these quantities numerically");
   keys.setValueDescription("the DRMSD distance between the instantaneous structure and the reference structure");
-  keys.needsAction("SUM"); keys.needsAction("DISTANCE"); keys.needsAction("CONSTANT"); keys.needsAction("EUCLIDEAN_DISTANCE"); keys.needsAction("CUSTOM");
+  keys.needsAction("SUM");
+  keys.needsAction("DISTANCE");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("EUCLIDEAN_DISTANCE");
+  keys.needsAction("CUSTOM");
 }
 
 DRMSD::DRMSD( const ActionOptions& ao ):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in the reference configuration
-  std::string reference; parse("REFERENCE",reference);
+  std::string reference;
+  parse("REFERENCE",reference);
   // First bit of input for the instantaneous distances
-  bool numder; parseFlag("NUMERICAL_DERIVATIVES",numder); double fake_unit=0.1;
-  FILE* fp2=fopen(reference.c_str(),"r"); bool do_read=true; unsigned nframes=0;
+  bool numder;
+  parseFlag("NUMERICAL_DERIVATIVES",numder);
+  double fake_unit=0.1;
+  FILE* fp2=fopen(reference.c_str(),"r");
+  bool do_read=true;
+  unsigned nframes=0;
   while( do_read ) {
-    PDB mypdb; do_read=mypdb.readFromFilepointer(fp2,false,fake_unit);
-    if( !do_read && nframes>0 ) break ;
+    PDB mypdb;
+    do_read=mypdb.readFromFilepointer(fp2,false,fake_unit);
+    if( !do_read && nframes>0 ) {
+      break ;
+    }
     nframes++;
   }
   fclose(fp2);
 
   // Get cutoff information
-  double lcut=0; parse("LOWER_CUTOFF",lcut); std::string drmsd_type; parse("TYPE",drmsd_type);
-  double ucut=std::numeric_limits<double>::max(); parse("UPPER_CUTOFF",ucut);
-  bool nopbc; parseFlag("NOPBC",nopbc); std::string pbc_str; if(nopbc) pbc_str="NOPBC";
+  double lcut=0;
+  parse("LOWER_CUTOFF",lcut);
+  std::string drmsd_type;
+  parse("TYPE",drmsd_type);
+  double ucut=std::numeric_limits<double>::max();
+  parse("UPPER_CUTOFF",ucut);
+  bool nopbc;
+  parseFlag("NOPBC",nopbc);
+  std::string pbc_str;
+  if(nopbc) {
+    pbc_str="NOPBC";
+  }
   // Open the pdb file
-  FILE* fp=fopen(reference.c_str(),"r"); do_read=true;
-  if(!fp) error("could not open reference file " + reference ); unsigned n=0; std::string allpairs="";
-  std::vector<std::pair<unsigned,unsigned> > upairs; std::vector<std::string> refvals;
+  FILE* fp=fopen(reference.c_str(),"r");
+  do_read=true;
+  if(!fp) {
+    error("could not open reference file " + reference );
+  }
+  unsigned n=0;
+  std::string allpairs="";
+  std::vector<std::pair<unsigned,unsigned> > upairs;
+  std::vector<std::string> refvals;
   while ( do_read ) {
-    PDB mypdb; do_read=mypdb.readFromFilepointer(fp,false,fake_unit);
-    if( !do_read && n>0 ) break ;
-    std::vector<Vector> pos( mypdb.getPositions() ); unsigned nn=1;
-    if( pos.size()==0 ) error("read no atoms from file named " + reference );
+    PDB mypdb;
+    do_read=mypdb.readFromFilepointer(fp,false,fake_unit);
+    if( !do_read && n>0 ) {
+      break ;
+    }
+    std::vector<Vector> pos( mypdb.getPositions() );
+    unsigned nn=1;
+    if( pos.size()==0 ) {
+      error("read no atoms from file named " + reference );
+    }
     // This is what we do for the first frame
     if( n==0 ) {
       std::vector<AtomNumber> atoms( mypdb.getAtomNumbers() );
       if( drmsd_type=="DRMSD" ) {
         for(unsigned i=0; i<atoms.size()-1; ++i) {
-          std::string istr; Tools::convert( atoms[i].serial(), istr );
+          std::string istr;
+          Tools::convert( atoms[i].serial(), istr );
           for(unsigned j=i+1; j<atoms.size(); ++j) {
-            std::string jstr; Tools::convert( atoms[j].serial(), jstr );
+            std::string jstr;
+            Tools::convert( atoms[j].serial(), jstr );
             double distance = delta( pos[i], pos[j] ).modulo();
             if( distance < ucut && distance > lcut ) {
-              std::string num; Tools::convert( nn, num ); nn++;
+              std::string num;
+              Tools::convert( nn, num );
+              nn++;
               // Add this pair to list of pairs
               upairs.push_back( std::pair<unsigned,unsigned>(i,j) );
               // Add this distance to list of reference values
-              std::string dstr; Tools::convert( distance, dstr ); refvals.push_back( dstr );
+              std::string dstr;
+              Tools::convert( distance, dstr );
+              refvals.push_back( dstr );
               // Calculate this distance
-              if( nframes==1 ) allpairs += " ATOMS" + num + "=" + istr + "," + jstr;
-              else readInputLine( getShortcutLabel() + "_d" + num + ": DISTANCE ATOMS=" + istr + "," + jstr + " " + pbc_str );
+              if( nframes==1 ) {
+                allpairs += " ATOMS" + num + "=" + istr + "," + jstr;
+              } else {
+                readInputLine( getShortcutLabel() + "_d" + num + ": DISTANCE ATOMS=" + istr + "," + jstr + " " + pbc_str );
+              }
             }
           }
         }
       } else {
-        unsigned nblocks = mypdb.getNumberOfAtomBlocks(); std::vector<unsigned> blocks( 1 + nblocks );
-        if( nblocks==1 ) { blocks[0]=0; blocks[1]=atoms.size(); }
-        else { blocks[0]=0; for(unsigned i=0; i<nblocks; ++i) blocks[i+1]=mypdb.getAtomBlockEnds()[i]; }
+        unsigned nblocks = mypdb.getNumberOfAtomBlocks();
+        std::vector<unsigned> blocks( 1 + nblocks );
+        if( nblocks==1 ) {
+          blocks[0]=0;
+          blocks[1]=atoms.size();
+        } else {
+          blocks[0]=0;
+          for(unsigned i=0; i<nblocks; ++i) {
+            blocks[i+1]=mypdb.getAtomBlockEnds()[i];
+          }
+        }
         if( drmsd_type=="INTRA-DRMSD" ) {
           for(unsigned i=0; i<nblocks; ++i) {
             for(unsigned iatom=blocks[i]+1; iatom<blocks[i+1]; ++iatom) {
-              std::string istr; Tools::convert( atoms[iatom].serial(), istr );
+              std::string istr;
+              Tools::convert( atoms[iatom].serial(), istr );
               for(unsigned jatom=blocks[i]; jatom<iatom; ++jatom) {
-                std::string jstr; Tools::convert( atoms[jatom].serial(), jstr );
+                std::string jstr;
+                Tools::convert( atoms[jatom].serial(), jstr );
                 double distance = delta( pos[iatom], pos[jatom] ).modulo();
                 if(distance < ucut && distance > lcut ) {
-                  std::string num; Tools::convert( nn, num ); nn++;
+                  std::string num;
+                  Tools::convert( nn, num );
+                  nn++;
                   // Add this pair to list of pairs
                   upairs.push_back( std::pair<unsigned,unsigned>(iatom,jatom) );
                   // Add this distance to list of reference values
-                  std::string dstr; Tools::convert( distance, dstr ); refvals.push_back( dstr );
+                  std::string dstr;
+                  Tools::convert( distance, dstr );
+                  refvals.push_back( dstr );
                   // Calculate this distance
-                  if( nframes==1 ) allpairs += " ATOMS" + num + "=" + istr + "," + jstr;
-                  else readInputLine( getShortcutLabel() + "_d" + num + ": DISTANCE ATOMS=" + istr + "," + jstr + " " + pbc_str );
+                  if( nframes==1 ) {
+                    allpairs += " ATOMS" + num + "=" + istr + "," + jstr;
+                  } else {
+                    readInputLine( getShortcutLabel() + "_d" + num + ": DISTANCE ATOMS=" + istr + "," + jstr + " " + pbc_str );
+                  }
                 }
               }
             }
@@ -207,30 +265,42 @@ DRMSD::DRMSD( const ActionOptions& ao ):
           for(unsigned i=1; i<nblocks; ++i) {
             for(unsigned j=0; j<i; ++j) {
               for(unsigned iatom=blocks[i]; iatom<blocks[i+1]; ++iatom) {
-                std::string istr; Tools::convert( atoms[iatom].serial(), istr );
+                std::string istr;
+                Tools::convert( atoms[iatom].serial(), istr );
                 for(unsigned jatom=blocks[j]; jatom<blocks[j+1]; ++jatom) {
-                  std::string jstr; Tools::convert( atoms[jatom].serial(), jstr );
+                  std::string jstr;
+                  Tools::convert( atoms[jatom].serial(), jstr );
                   double distance = delta( pos[iatom], pos[jatom] ).modulo();
                   if(distance < ucut && distance > lcut ) {
-                    std::string num; Tools::convert( nn, num ); nn++;
+                    std::string num;
+                    Tools::convert( nn, num );
+                    nn++;
                     // Add this pair to list of pairs
                     upairs.push_back( std::pair<unsigned,unsigned>(iatom,jatom) );
                     // Add this distance to list of reference values
-                    std::string dstr; Tools::convert( distance, dstr ); refvals.push_back( dstr );
+                    std::string dstr;
+                    Tools::convert( distance, dstr );
+                    refvals.push_back( dstr );
                     // Calculate this distance
-                    if( nframes==1 ) allpairs += " ATOMS" + num + "=" + istr + "," + jstr;
-                    else readInputLine( getShortcutLabel() + "_d" + num + ": DISTANCE ATOMS=" + istr + "," + jstr + " " + pbc_str );
+                    if( nframes==1 ) {
+                      allpairs += " ATOMS" + num + "=" + istr + "," + jstr;
+                    } else {
+                      readInputLine( getShortcutLabel() + "_d" + num + ": DISTANCE ATOMS=" + istr + "," + jstr + " " + pbc_str );
+                    }
                   }
                 }
               }
             }
           }
-        } else plumed_merror( drmsd_type + " is not valid input to TYPE keyword");
+        } else {
+          plumed_merror( drmsd_type + " is not valid input to TYPE keyword");
+        }
       }
       // This is for every subsequent frame
     } else {
       for(unsigned i=0; i<refvals.size(); ++i) {
-        std::string dstr; Tools::convert( delta( pos[upairs[i].first], pos[upairs[i].second] ).modulo(), dstr );
+        std::string dstr;
+        Tools::convert( delta( pos[upairs[i].first], pos[upairs[i].second] ).modulo(), dstr );
         refvals[i] += "," + dstr;
       }
     }
@@ -241,25 +311,38 @@ DRMSD::DRMSD( const ActionOptions& ao ):
 
   if( nframes==1 ) {
     readInputLine( getShortcutLabel() + "_d: DISTANCE" + allpairs + " " + pbc_str );
-    std::string refstr = refvals[0]; for(unsigned i=1; i<refvals.size(); ++i) refstr += "," + refvals[i];
+    std::string refstr = refvals[0];
+    for(unsigned i=1; i<refvals.size(); ++i) {
+      refstr += "," + refvals[i];
+    }
     readInputLine( getShortcutLabel() + "_ref: CONSTANT VALUES="  + refstr );
     readInputLine( getShortcutLabel() + "_diffs: CUSTOM ARG=" + getShortcutLabel() + "_d," + getShortcutLabel() + "_ref FUNC=(x-y)*(x-y) PERIODIC=NO");
     readInputLine( getShortcutLabel() + "_u: SUM ARG=" + getShortcutLabel() + "_diffs PERIODIC=NO");
   } else {
     std::string arg_str1, arg_str2;
     for(unsigned i=0; i<refvals.size(); ++i ) {
-      std::string inum; Tools::convert( i+1, inum );
+      std::string inum;
+      Tools::convert( i+1, inum );
       readInputLine( getShortcutLabel() + "_ref" + inum + ": CONSTANT VALUES=" + refvals[i] );
-      if( i==0 ) { arg_str1 = getShortcutLabel() + "_d" + inum; arg_str2 = getShortcutLabel() + "_ref" + inum; }
-      else { arg_str1 += "," + getShortcutLabel() + "_d" + inum; arg_str2 += "," + getShortcutLabel() + "_ref" + inum; }
+      if( i==0 ) {
+        arg_str1 = getShortcutLabel() + "_d" + inum;
+        arg_str2 = getShortcutLabel() + "_ref" + inum;
+      } else {
+        arg_str1 += "," + getShortcutLabel() + "_d" + inum;
+        arg_str2 += "," + getShortcutLabel() + "_ref" + inum;
+      }
     }
     // And calculate the euclidean distances between the true distances and the references
     readInputLine( getShortcutLabel() + "_u: EUCLIDEAN_DISTANCE SQUARED ARG1=" + arg_str1 + " ARG2=" + arg_str2 );
   }
   // And final value
-  std::string nvals; Tools::convert( refvals.size(), nvals ); bool squared; parseFlag("SQUARED",squared);
-  if( squared ) readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_u FUNC=x/" + nvals + " PERIODIC=NO");
-  else {
+  std::string nvals;
+  Tools::convert( refvals.size(), nvals );
+  bool squared;
+  parseFlag("SQUARED",squared);
+  if( squared ) {
+    readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_u FUNC=x/" + nvals + " PERIODIC=NO");
+  } else {
     readInputLine( getShortcutLabel() + "_2: CUSTOM ARG=" + getShortcutLabel() + "_u FUNC=(x/" + nvals + ") PERIODIC=NO");
     readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_2 FUNC=sqrt(x) PERIODIC=NO");
   }
diff --git a/src/colvar/DihedralCorrelation.cpp b/src/colvar/DihedralCorrelation.cpp
index 19e08feb1b..590a62652b 100644
--- a/src/colvar/DihedralCorrelation.cpp
+++ b/src/colvar/DihedralCorrelation.cpp
@@ -85,7 +85,8 @@ typedef MultiColvarTemplate<DihedralCorrelation> DihedralCorrelationMulti;
 PLUMED_REGISTER_ACTION(DihedralCorrelationMulti,"DIHEDRAL_CORRELATION_VECTOR")
 
 void DihedralCorrelation::registerKeywords( Keywords& keys ) {
-  Colvar::registerKeywords( keys ); keys.setDisplayName("DIHEDRAL_CORRELATION");
+  Colvar::registerKeywords( keys );
+  keys.setDisplayName("DIHEDRAL_CORRELATION");
   keys.add("atoms","ATOMS","the set of 8 atoms that are being used to calculate this quantity");
   keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
   keys.setValueDescription("the DIHEDRAL_CORRELATION for these atoms");
@@ -96,23 +97,30 @@ DihedralCorrelation::DihedralCorrelation(const ActionOptions&ao):
   pbc(true),
   value(1),
   derivs(1),
-  virial(1)
-{
-  derivs[0].resize(8); std::vector<AtomNumber> atoms;
+  virial(1) {
+  derivs[0].resize(8);
+  std::vector<AtomNumber> atoms;
   parseAtomList(-1,atoms,this);
-  if( atoms.size()!=8 ) error("Number of specified atoms should be 8");
+  if( atoms.size()!=8 ) {
+    error("Number of specified atoms should be 8");
+  }
 
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
 
-  if(pbc) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
 }
 
 void DihedralCorrelation::parseAtomList( const int& num, std::vector<AtomNumber>& t, ActionAtomistic* aa ) {
   aa->parseAtomList("ATOMS",num,t);
-  if( num<0 && t.size()!=8 ) aa->error("Number of specified atoms should be 8");
+  if( num<0 && t.size()!=8 ) {
+    aa->error("Number of specified atoms should be 8");
+  }
   if( t.size()==8 ) {
     aa->log.printf("  correlation between dihedral angle for atoms %d %d %d %d and atoms %d %d %d %d\n",
                    t[0].serial(),t[1].serial(),t[2].serial(),t[3].serial(),t[4].serial(),t[5].serial(),t[6].serial(),t[7].serial());
@@ -120,15 +128,21 @@ void DihedralCorrelation::parseAtomList( const int& num, std::vector<AtomNumber>
 }
 
 unsigned DihedralCorrelation::getModeAndSetupValues( ActionWithValue* av ) {
-  av->addValueWithDerivatives(); av->setNotPeriodic(); return 0;
+  av->addValueWithDerivatives();
+  av->setNotPeriodic();
+  return 0;
 }
 
 void DihedralCorrelation::calculate() {
 
-  if(pbc) makeWhole();
+  if(pbc) {
+    makeWhole();
+  }
   calculateCV( 0, masses, charges, getPositions(), value, derivs, virial, this );
   setValue( value[0] );
-  for(unsigned i=0; i<derivs[0].size(); ++i) setAtomsDerivatives( i, derivs[0][i] );
+  for(unsigned i=0; i<derivs[0].size(); ++i) {
+    setAtomsDerivatives( i, derivs[0][i] );
+  }
   setBoxDerivatives( virial[0] );
 }
 
diff --git a/src/colvar/Dimer.cpp b/src/colvar/Dimer.cpp
index edcea7fa32..c8819091ab 100644
--- a/src/colvar/Dimer.cpp
+++ b/src/colvar/Dimer.cpp
@@ -161,8 +161,7 @@ void Dimer::registerKeywords( Keywords& keys) {
 
 
 Dimer::Dimer(const ActionOptions& ao):
-  PLUMED_COLVAR_INIT(ao)
-{
+  PLUMED_COLVAR_INIT(ao) {
 
   log<<" Bibliography "<<plumed.cite("M Nava, F. Palazzesi, C. Perego and M. Parrinello, J. Chem. Theory Comput. 13, 425(2017)")<<"\n";
   parseVector("DSIGMA",dsigmas);
@@ -179,47 +178,43 @@ Dimer::Dimer(const ActionOptions& ao):
 
   nranks=multi_sim_comm.Get_size();
   myrank=multi_sim_comm.Get_rank();
-  if(dsigmas.size()==1)
+  if(dsigmas.size()==1) {
     dsigma=dsigmas[0];
-  else
+  } else {
     dsigma=dsigmas[myrank];
+  }
 
 
 
 
-  if(useall)
-  {
+  if(useall) {
     // go with every atom in the system but not the virtuals...
     int natoms;
-    if(trimer)
+    if(trimer) {
       natoms= 2*getTotAtoms()/3;
-    else
+    } else {
       natoms=getTotAtoms()/2;
+    }
 
-    for(unsigned int i=0; i<((unsigned int)natoms); i++)
-    {
+    for(unsigned int i=0; i<((unsigned int)natoms); i++) {
       AtomNumber ati;
       ati.setIndex(i);
       atoms.push_back(ati);
     }
-  }
-  else  // serials for the first beads of each dimer are given
-  {
+  } else { // serials for the first beads of each dimer are given
     parseAtomList("ATOMS1",usedatoms1);
     parseAtomList("ATOMS2",usedatoms2);
 
     int isz1 = usedatoms1.size();
 
-    for(unsigned int i=0; i<isz1; i++)
-    {
+    for(unsigned int i=0; i<isz1; i++) {
       AtomNumber ati;
       ati.setIndex(usedatoms1[i].index());
       atoms.push_back(ati);
     }
 
     int isz2 = usedatoms2.size();
-    for(unsigned int i=0; i<isz2; i++)
-    {
+    for(unsigned int i=0; i<isz2; i++) {
       AtomNumber atip2;
       atip2.setIndex(usedatoms2[i].index());
       atoms.push_back(atip2);
@@ -235,21 +230,20 @@ Dimer::Dimer(const ActionOptions& ao):
   setNotPeriodic();
 }
 
-void Dimer::calculate()
-{
+void Dimer::calculate() {
   double cv_val=0;
   Tensor virial;
   std::vector<Vector> derivatives;
   std::vector<Vector> my_pos=getPositions();
   int atms = my_pos.size();
   std::vector<Vector> der_b2;
-  for(int i=0; i<atms/2; i++)
-  {
+  for(int i=0; i<atms/2; i++) {
     Vector dist;
     dist = pbcDistance(my_pos[i],my_pos[i+atms/2]);
     double distquad=0;
-    for(int j=0; j<3; j++)
+    for(int j=0; j<3; j++) {
       distquad += dist[j]*dist[j];
+    }
 
     double dsigquad = dsigma*dsigma;
     double fac1 = 1.0 + distquad/(2*qexp*dsigquad);
@@ -259,8 +253,7 @@ void Dimer::calculate()
     cv_val += (fac1*fac1qm1-1.0)/beta;
     Vector der_val;
     Vector mder_val;
-    for(int j=0; j<3; j++)
-    {
+    for(int j=0; j<3; j++) {
       der_val[j] = -fac1qm1*dist[j]/(dsigquad*beta);
       mder_val[j]=-der_val[j];
     }
@@ -277,8 +270,9 @@ void Dimer::calculate()
 
   derivatives.insert(derivatives.end(), der_b2.begin(), der_b2.end());
 
-  for(unsigned int i=0; i<derivatives.size(); i++)
+  for(unsigned int i=0; i<derivatives.size(); i++) {
     setAtomsDerivatives(i,derivatives[i]);
+  }
 
   setValue(cv_val);
   setBoxDerivatives(virial);
@@ -291,24 +285,28 @@ void Dimer::calculate()
 There are some conditions that a valid input should satisfy.
 These are checked here and PLUMED error handlers are (eventually) called.
 ******************/
-void Dimer::consistencyCheck()
-{
-  if(!useall && usedatoms1.size()!=usedatoms2.size())
+void Dimer::consistencyCheck() {
+  if(!useall && usedatoms1.size()!=usedatoms2.size()) {
     error("The provided atom lists are of different sizes.");
+  }
 
-  if(qexp<0.5 || qexp>1)
+  if(qexp<0.5 || qexp>1) {
     warning("Dimer CV is meant to be used with q-exponents between 0.5 and 1. We are not responsible for any black hole. :-)");
+  }
 
-  if(dsigma<0)
+  if(dsigma<0) {
     error("Please use positive sigma values for the Dimer strength constant");
+  }
 
-  if(temperature<0)
+  if(temperature<0) {
     error("Please, use a positive value for the temperature...");
+  }
 
   // if dsigmas has only one element means that either
   // you are using different plumed.x.dat files or a plumed.dat with a single replica
-  if(dsigmas.size()!=nranks && dsigmas.size()!=1)
+  if(dsigmas.size()!=nranks && dsigmas.size()!=1) {
     error("Mismatch between provided sigmas and number of replicas");
+  }
 
 }
 
diff --git a/src/colvar/Dipole.cpp b/src/colvar/Dipole.cpp
index e0a9212455..37c1bba561 100644
--- a/src/colvar/Dipole.cpp
+++ b/src/colvar/Dipole.cpp
@@ -106,7 +106,8 @@ typedef MultiColvarTemplate<Dipole> DipoleMulti;
 PLUMED_REGISTER_ACTION(DipoleMulti,"DIPOLE_VECTOR")
 
 void Dipole::registerKeywords(Keywords& keys) {
-  Colvar::registerKeywords(keys); keys.setDisplayName("DIPOLE");
+  Colvar::registerKeywords(keys);
+  keys.setDisplayName("DIPOLE");
   keys.add("atoms","GROUP","the group of atoms we are calculating the dipole moment for");
   keys.addFlag("COMPONENTS",false,"calculate the x, y and z components of the dipole separately and store them as label.x, label.y and label.z");
   keys.addOutputComponent("x","COMPONENTS","the x-component of the dipole");
@@ -121,22 +122,29 @@ Dipole::Dipole(const ActionOptions&ao):
   components(false),
   value(1),
   derivs(1),
-  virial(1)
-{
-  parseAtomList(-1,ga_lista,this); charges.resize(ga_lista.size());
+  virial(1) {
+  parseAtomList(-1,ga_lista,this);
+  charges.resize(ga_lista.size());
   components=(getModeAndSetupValues(this)==1);
   if( components ) {
-    value.resize(3); derivs.resize(3); virial.resize(3);
+    value.resize(3);
+    derivs.resize(3);
+    virial.resize(3);
     valuex=getPntrToComponent("x");
     valuey=getPntrToComponent("y");
     valuez=getPntrToComponent("z");
   }
-  for(unsigned i=0; i<derivs.size(); ++i) derivs[i].resize( ga_lista.size() );
+  for(unsigned i=0; i<derivs.size(); ++i) {
+    derivs[i].resize( ga_lista.size() );
+  }
   parseFlag("NOPBC",nopbc);
   checkRead();
 
-  if(nopbc) log.printf("  without periodic boundary conditions\n");
-  else      log.printf("  using periodic boundary conditions\n");
+  if(nopbc) {
+    log.printf("  without periodic boundary conditions\n");
+  } else {
+    log.printf("  using periodic boundary conditions\n");
+  }
 
   requestAtoms(ga_lista);
 }
@@ -153,26 +161,37 @@ void Dipole::parseAtomList( const int& num, std::vector<AtomNumber>& t, ActionAt
 }
 
 unsigned Dipole::getModeAndSetupValues( ActionWithValue* av ) {
-  bool c; av->parseFlag("COMPONENTS",c);
+  bool c;
+  av->parseFlag("COMPONENTS",c);
   if( c ) {
-    av->addComponentWithDerivatives("x"); av->componentIsNotPeriodic("x");
-    av->addComponentWithDerivatives("y"); av->componentIsNotPeriodic("y");
-    av->addComponentWithDerivatives("z"); av->componentIsNotPeriodic("z");
+    av->addComponentWithDerivatives("x");
+    av->componentIsNotPeriodic("x");
+    av->addComponentWithDerivatives("y");
+    av->componentIsNotPeriodic("y");
+    av->addComponentWithDerivatives("z");
+    av->componentIsNotPeriodic("z");
     return 1;
   }
-  av->addValueWithDerivatives(); av->setNotPeriodic(); return 0;
+  av->addValueWithDerivatives();
+  av->setNotPeriodic();
+  return 0;
 }
 
 // calculator
-void Dipole::calculate()
-{
-  if(!nopbc) makeWhole();
+void Dipole::calculate() {
+  if(!nopbc) {
+    makeWhole();
+  }
   unsigned N=getNumberOfAtoms();
-  for(unsigned i=0; i<N; ++i) charges[i]=getCharge(i);
+  for(unsigned i=0; i<N; ++i) {
+    charges[i]=getCharge(i);
+  }
 
   if(!components) {
     calculateCV( 0, masses, charges, getPositions(), value, derivs, virial, this );
-    for(unsigned i=0; i<N; i++) setAtomsDerivatives(i,derivs[0][i]);
+    for(unsigned i=0; i<N; i++) {
+      setAtomsDerivatives(i,derivs[0][i]);
+    }
     setBoxDerivatives(virial[0]);
     setValue(value[0]);
   } else {
@@ -194,13 +213,17 @@ void Dipole::calculate()
 void Dipole::calculateCV( const unsigned& mode, const std::vector<double>& masses, std::vector<double>& charges,
                           const std::vector<Vector>& pos, std::vector<double>& vals, std::vector<std::vector<Vector> >& derivs,
                           std::vector<Tensor>& virial, const ActionAtomistic* aa ) {
-  unsigned N=pos.size(); double ctot=0.;
-  for(unsigned i=0; i<N; ++i) ctot += charges[i];
+  unsigned N=pos.size();
+  double ctot=0.;
+  for(unsigned i=0; i<N; ++i) {
+    ctot += charges[i];
+  }
   ctot/=(double)N;
 
   Vector dipje;
   for(unsigned i=0; i<N; ++i) {
-    charges[i]-=ctot; dipje += charges[i]*pos[i];
+    charges[i]-=ctot;
+    dipje += charges[i]*pos[i];
   }
 
   if( mode==1 ) {
@@ -209,7 +232,9 @@ void Dipole::calculateCV( const unsigned& mode, const std::vector<double>& masse
       derivs[1][i]=charges[i]*Vector(0.0,1.0,0.0);
       derivs[2][i]=charges[i]*Vector(0.0,0.0,1.0);
     }
-    for(unsigned i=0; i<3; ++i ) vals[i] = dipje[i];
+    for(unsigned i=0; i<3; ++i ) {
+      vals[i] = dipje[i];
+    }
   } else {
     vals[0] = dipje.modulo();
     double idip = 1./vals[0];
diff --git a/src/colvar/Distance.cpp b/src/colvar/Distance.cpp
index b2d75a27fe..c0e1050581 100644
--- a/src/colvar/Distance.cpp
+++ b/src/colvar/Distance.cpp
@@ -150,7 +150,8 @@ typedef MultiColvarTemplate<Distance> DistanceMulti;
 PLUMED_REGISTER_ACTION(DistanceMulti,"DISTANCE_VECTOR")
 
 void Distance::registerKeywords( Keywords& keys ) {
-  Colvar::registerKeywords( keys ); keys.setDisplayName("DISTANCE");
+  Colvar::registerKeywords( keys );
+  keys.setDisplayName("DISTANCE");
   keys.add("atoms","ATOMS","the pair of atom that we are calculating the distance between");
   keys.addFlag("COMPONENTS",false,"calculate the x, y and z components of the distance separately and store them as label.x, label.y and label.z");
   keys.addFlag("SCALED_COMPONENTS",false,"calculate the a, b and c scaled components of the distance separately and store them as label.a, label.b and label.c");
@@ -171,60 +172,86 @@ Distance::Distance(const ActionOptions&ao):
   pbc(true),
   value(1),
   derivs(1),
-  virial(1)
-{
+  virial(1) {
   derivs[0].resize(2);
   std::vector<AtomNumber> atoms;
   parseAtomList(-1,atoms,this);
-  if(atoms.size()!=2)
+  if(atoms.size()!=2) {
     error("Number of specified atoms should be 2");
+  }
 
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
 
-  if(pbc) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
 
   unsigned mode = getModeAndSetupValues( this );
-  if(mode==1) components=true; else if(mode==2) scaled_components=true;
+  if(mode==1) {
+    components=true;
+  } else if(mode==2) {
+    scaled_components=true;
+  }
   if( components || scaled_components ) {
-    value.resize(3); derivs.resize(3); virial.resize(3);
-    for(unsigned i=0; i<3; ++i) derivs[i].resize(2);
+    value.resize(3);
+    derivs.resize(3);
+    virial.resize(3);
+    for(unsigned i=0; i<3; ++i) {
+      derivs[i].resize(2);
+    }
   }
   requestAtoms(atoms);
 }
 
 void Distance::parseAtomList( const int& num, std::vector<AtomNumber>& t, ActionAtomistic* aa ) {
   aa->parseAtomList("ATOMS",num,t);
-  if( t.size()==2 ) aa->log.printf("  between atoms %d %d\n",t[0].serial(),t[1].serial());
+  if( t.size()==2 ) {
+    aa->log.printf("  between atoms %d %d\n",t[0].serial(),t[1].serial());
+  }
 }
 
 unsigned Distance::getModeAndSetupValues( ActionWithValue* av ) {
-  bool c; av->parseFlag("COMPONENTS",c);
-  bool sc; av->parseFlag("SCALED_COMPONENTS",sc);
-  if( c && sc ) av->error("COMPONENTS and SCALED_COMPONENTS are not compatible");
+  bool c;
+  av->parseFlag("COMPONENTS",c);
+  bool sc;
+  av->parseFlag("SCALED_COMPONENTS",sc);
+  if( c && sc ) {
+    av->error("COMPONENTS and SCALED_COMPONENTS are not compatible");
+  }
 
   if(c) {
-    av->addComponentWithDerivatives("x"); av->componentIsNotPeriodic("x");
-    av->addComponentWithDerivatives("y"); av->componentIsNotPeriodic("y");
-    av->addComponentWithDerivatives("z"); av->componentIsNotPeriodic("z");
+    av->addComponentWithDerivatives("x");
+    av->componentIsNotPeriodic("x");
+    av->addComponentWithDerivatives("y");
+    av->componentIsNotPeriodic("y");
+    av->addComponentWithDerivatives("z");
+    av->componentIsNotPeriodic("z");
     av->log<<"  WARNING: components will not have the proper periodicity - see manual\n";
     return 1;
   } else if(sc) {
-    av->addComponentWithDerivatives("a"); av->componentIsPeriodic("a","-0.5","+0.5");
-    av->addComponentWithDerivatives("b"); av->componentIsPeriodic("b","-0.5","+0.5");
-    av->addComponentWithDerivatives("c"); av->componentIsPeriodic("c","-0.5","+0.5");
+    av->addComponentWithDerivatives("a");
+    av->componentIsPeriodic("a","-0.5","+0.5");
+    av->addComponentWithDerivatives("b");
+    av->componentIsPeriodic("b","-0.5","+0.5");
+    av->addComponentWithDerivatives("c");
+    av->componentIsPeriodic("c","-0.5","+0.5");
     return 2;
   }
-  av->addValueWithDerivatives(); av->setNotPeriodic();
+  av->addValueWithDerivatives();
+  av->setNotPeriodic();
   return 0;
 }
 
 // calculator
 void Distance::calculate() {
 
-  if(pbc) makeWhole();
+  if(pbc) {
+    makeWhole();
+  }
 
   if( components ) {
     calculateCV( 1, masses, charges, getPositions(), value, derivs, virial, this );
@@ -232,15 +259,21 @@ void Distance::calculate() {
     Value* valuey=getPntrToComponent("y");
     Value* valuez=getPntrToComponent("z");
 
-    for(unsigned i=0; i<2; ++i) setAtomsDerivatives(valuex,i,derivs[0][i] );
+    for(unsigned i=0; i<2; ++i) {
+      setAtomsDerivatives(valuex,i,derivs[0][i] );
+    }
     setBoxDerivatives(valuex,virial[0]);
     valuex->set(value[0]);
 
-    for(unsigned i=0; i<2; ++i) setAtomsDerivatives(valuey,i,derivs[1][i] );
+    for(unsigned i=0; i<2; ++i) {
+      setAtomsDerivatives(valuey,i,derivs[1][i] );
+    }
     setBoxDerivatives(valuey,virial[1]);
     valuey->set(value[1]);
 
-    for(unsigned i=0; i<2; ++i) setAtomsDerivatives(valuez,i,derivs[2][i] );
+    for(unsigned i=0; i<2; ++i) {
+      setAtomsDerivatives(valuez,i,derivs[2][i] );
+    }
     setBoxDerivatives(valuez,virial[2]);
     valuez->set(value[2]);
   } else if( scaled_components ) {
@@ -249,15 +282,23 @@ void Distance::calculate() {
     Value* valuea=getPntrToComponent("a");
     Value* valueb=getPntrToComponent("b");
     Value* valuec=getPntrToComponent("c");
-    for(unsigned i=0; i<2; ++i) setAtomsDerivatives(valuea,i,derivs[0][i] );
+    for(unsigned i=0; i<2; ++i) {
+      setAtomsDerivatives(valuea,i,derivs[0][i] );
+    }
     valuea->set(value[0]);
-    for(unsigned i=0; i<2; ++i) setAtomsDerivatives(valueb,i,derivs[1][i] );
+    for(unsigned i=0; i<2; ++i) {
+      setAtomsDerivatives(valueb,i,derivs[1][i] );
+    }
     valueb->set(value[1]);
-    for(unsigned i=0; i<2; ++i) setAtomsDerivatives(valuec,i,derivs[2][i] );
+    for(unsigned i=0; i<2; ++i) {
+      setAtomsDerivatives(valuec,i,derivs[2][i] );
+    }
     valuec->set(value[2]);
   } else  {
     calculateCV( 0, masses, charges, getPositions(), value, derivs, virial, this );
-    for(unsigned i=0; i<2; ++i) setAtomsDerivatives(i,derivs[0][i] );
+    for(unsigned i=0; i<2; ++i) {
+      setAtomsDerivatives(i,derivs[0][i] );
+    }
     setBoxDerivatives(virial[0]);
     setValue           (value[0]);
   }
diff --git a/src/colvar/EEFSolv.cpp b/src/colvar/EEFSolv.cpp
index 5d460ad977..08eeaa8e64 100644
--- a/src/colvar/EEFSolv.cpp
+++ b/src/colvar/EEFSolv.cpp
@@ -119,8 +119,7 @@ EEFSolv::EEFSolv(const ActionOptions&ao):
   delta_g_ref(0.),
   nl_buffer(0.1),
   nl_stride(40),
-  nl_update(0)
-{
+  nl_update(0) {
   std::vector<AtomNumber> atoms;
   parseAtomList("ATOMS", atoms);
   const unsigned size = atoms.size();
@@ -137,7 +136,8 @@ EEFSolv::EEFSolv(const ActionOptions&ao):
 
   checkRead();
 
-  log << "  Bibliography " << plumed.cite("Lazaridis T, Karplus M, Proteins Struct. Funct. Genet. 35, 133 (1999)"); log << "\n";
+  log << "  Bibliography " << plumed.cite("Lazaridis T, Karplus M, Proteins Struct. Funct. Genet. 35, 133 (1999)");
+  log << "\n";
 
   nl.resize(size);
   nlexpo.resize(size);
@@ -159,7 +159,9 @@ void EEFSolv::update_neighb() {
     const Vector posi = getPosition(i);
     // Loop through neighboring atoms, add the ones below cutoff
     for (unsigned j=i+1; j<size; j++) {
-      if(parameter[i][1]==0&&parameter[j][1]==0) continue;
+      if(parameter[i][1]==0&&parameter[j][1]==0) {
+        continue;
+      }
       const double d2 = delta(posi, getPosition(j)).modulo2();
       if (d2 < lower_c2 && j < i+14) {
         // crude approximation for i-i+1/2 interactions,
@@ -168,22 +170,32 @@ void EEFSolv::update_neighb() {
       }
       // We choose the maximum lambda value and use a more conservative cutoff
       double mlambda = 1./parameter[i][2];
-      if (1./parameter[j][2] > mlambda) mlambda = 1./parameter[j][2];
+      if (1./parameter[j][2] > mlambda) {
+        mlambda = 1./parameter[j][2];
+      }
       const double c2 = (2. * mlambda + nl_buffer) * (2. * mlambda + nl_buffer);
       if (d2 < c2 ) {
         nl[i].push_back(j);
         if(parameter[i][2] == parameter[j][2] && parameter[i][3] == parameter[j][3]) {
           nlexpo[i].push_back(true);
-        } else nlexpo[i].push_back(false);
+        } else {
+          nlexpo[i].push_back(false);
+        }
       }
     }
   }
 }
 
 void EEFSolv::calculate() {
-  if(pbc) makeWhole();
-  if(getExchangeStep()) nl_update = 0;
-  if(nl_update==0) update_neighb();
+  if(pbc) {
+    makeWhole();
+  }
+  if(getExchangeStep()) {
+    nl_update = 0;
+  }
+  if(nl_update==0) {
+    update_neighb();
+  }
 
   const unsigned size=getNumberOfAtoms();
   double bias = 0.0;
@@ -200,7 +212,9 @@ void EEFSolv::calculate() {
   }
 
   unsigned nt=OpenMP::getNumThreads();
-  if(nt*stride*10>size) nt=1;
+  if(nt*stride*10>size) {
+    nt=1;
+  }
 
   #pragma omp parallel num_threads(nt)
   {
@@ -233,8 +247,7 @@ void EEFSolv::calculate() {
         // in this case we can calculate a single exponential
         if(!nlexpo[i][i_nl]) {
           // i-j interaction
-          if(inv_rij > 0.5*inv_lambda_i && delta_g_free_i!=0.)
-          {
+          if(inv_rij > 0.5*inv_lambda_i && delta_g_free_i!=0.) {
             const double e_arg = (rij - vdw_radius_i)*inv_lambda_i;
             const double expo  = std::exp(-e_arg*e_arg);
             const double fact  = expo*fact_ij;
@@ -242,13 +255,15 @@ void EEFSolv::calculate() {
             const Vector dd    = e_deriv*dist;
             fedensity    += fact;
             deriv_i      += dd;
-            if(nt>1) deriv_omp[j] -= dd;
-            else deriv[j] -= dd;
+            if(nt>1) {
+              deriv_omp[j] -= dd;
+            } else {
+              deriv[j] -= dd;
+            }
           }
 
           // j-i interaction
-          if(inv_rij > 0.5*inv_lambda_j && delta_g_free_j!=0.)
-          {
+          if(inv_rij > 0.5*inv_lambda_j && delta_g_free_j!=0.) {
             const double e_arg = (rij - vdw_radius_j)*inv_lambda_j;
             const double expo  = std::exp(-e_arg*e_arg);
             const double fact  = expo*fact_ji;
@@ -256,13 +271,15 @@ void EEFSolv::calculate() {
             const Vector dd    = e_deriv*dist;
             fedensity    += fact;
             deriv_i      += dd;
-            if(nt>1) deriv_omp[j] -= dd;
-            else deriv[j] -= dd;
+            if(nt>1) {
+              deriv_omp[j] -= dd;
+            } else {
+              deriv[j] -= dd;
+            }
           }
         } else {
           // i-j interaction
-          if(inv_rij > 0.5*inv_lambda_i)
-          {
+          if(inv_rij > 0.5*inv_lambda_i) {
             const double e_arg = (rij - vdw_radius_i)*inv_lambda_i;
             const double expo  = std::exp(-e_arg*e_arg);
             const double fact  = expo*(fact_ij + fact_ji);
@@ -270,23 +287,34 @@ void EEFSolv::calculate() {
             const Vector dd    = e_deriv*dist;
             fedensity    += fact;
             deriv_i      += dd;
-            if(nt>1) deriv_omp[j] -= dd;
-            else deriv[j] -= dd;
+            if(nt>1) {
+              deriv_omp[j] -= dd;
+            } else {
+              deriv[j] -= dd;
+            }
           }
         }
 
       }
-      if(nt>1) deriv_omp[i] += deriv_i;
-      else deriv[i] += deriv_i;
+      if(nt>1) {
+        deriv_omp[i] += deriv_i;
+      } else {
+        deriv[i] += deriv_i;
+      }
       bias += 0.5*fedensity;
     }
     #pragma omp critical
-    if(nt>1) for(unsigned i=0; i<size; i++) deriv[i]+=deriv_omp[i];
+    if(nt>1)
+      for(unsigned i=0; i<size; i++) {
+        deriv[i]+=deriv_omp[i];
+      }
   }
 
   if(!serial) {
     comm.Sum(bias);
-    if(!deriv.empty()) comm.Sum(&deriv[0][0],3*deriv.size());
+    if(!deriv.empty()) {
+      comm.Sum(&deriv[0][0],3*deriv.size());
+    }
   }
 
   Tensor virial;
@@ -393,7 +421,9 @@ void EEFSolv::setupConstants(const std::vector<AtomNumber> &atoms, std::vector<s
   } else {
     error("MOLINFO DATA not found\n");
   }
-  for(unsigned i=0; i<atoms.size(); ++i) delta_g_ref += parameter_temp[i][1];
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    delta_g_ref += parameter_temp[i][1];
+  }
 }
 
 std::map<std::string, std::map<std::string, std::string> > EEFSolv::setupTypeMap()  {
diff --git a/src/colvar/ERMSD.cpp b/src/colvar/ERMSD.cpp
index b5027ea0a3..dc08786821 100644
--- a/src/colvar/ERMSD.cpp
+++ b/src/colvar/ERMSD.cpp
@@ -125,8 +125,7 @@ void ERMSD::registerKeywords(Keywords& keys) {
 }
 
 ERMSD::ERMSD(const ActionOptions&ao):
-  PLUMED_COLVAR_INIT(ao), pbc(true)
-{
+  PLUMED_COLVAR_INIT(ao), pbc(true) {
   std::string reference;
   parse("REFERENCE",reference);
   double cutoff=2.4;
@@ -144,11 +143,18 @@ ERMSD::ERMSD(const ActionOptions&ao):
   parseVector("PAIRS",pairs_);
   checkRead();
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
 
-  if(atoms_.size()<6) error("at least six atoms should be specified");
-  if(atoms_.size()%3!=0) error("Atoms are not multiple of 3");
-  if(pairs_.size()%2!=0) error("pairs are not multiple of 2");
+  if(atoms_.size()<6) {
+    error("at least six atoms should be specified");
+  }
+  if(atoms_.size()%3!=0) {
+    error("Atoms are not multiple of 3");
+  }
+  if(pairs_.size()%2!=0) {
+    error("pairs are not multiple of 2");
+  }
 
 
   //checkRead();
@@ -158,8 +164,9 @@ ERMSD::ERMSD(const ActionOptions&ao):
 
   // read everything in ang and transform to nm if we are not in natural units
   PDB pdb;
-  if( !pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength()) )
+  if( !pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength()) ) {
     error("missing input file " + reference );
+  }
   // store target_ distance
   std::vector <Vector> reference_positions;
   unsigned natoms = atoms_.size();
@@ -172,7 +179,9 @@ ERMSD::ERMSD(const ActionOptions&ao):
   }
 
 // shift to count from zero
-  for(unsigned i=0; i<pairs_.size(); ++i) pairs_[i]--;
+  for(unsigned i=0; i<pairs_.size(); ++i) {
+    pairs_[i]--;
+  }
 
   ermsd.setReference(reference_positions,pairs_,cutoff/getUnits().getLength());
 
@@ -205,7 +214,9 @@ void ERMSD::calculate() {
   const double scale=getUnits().getLength();
   setValue(ermsdist*scale);
 
-  for(unsigned i=0; i<derivs.size(); ++i) {setAtomsDerivatives(i,derivs[i]*scale);}
+  for(unsigned i=0; i<derivs.size(); ++i) {
+    setAtomsDerivatives(i,derivs[i]*scale);
+  }
 
   setBoxDerivativesNoPbc();
 }
diff --git a/src/colvar/Energy.cpp b/src/colvar/Energy.cpp
index 9a131d6b81..f1f2fd4c6b 100644
--- a/src/colvar/Energy.cpp
+++ b/src/colvar/Energy.cpp
@@ -81,18 +81,28 @@ PLUMED_REGISTER_ACTION(Energy,"ENERGY")
 Energy::Energy(const ActionOptions&ao):
   Action(ao),
   ActionToPutData(ao),
-  interface(NULL)
-{
-  plumed.setEnergyValue( getLabel() ); std::vector<unsigned> shape;
-  addValue( shape ); setNotPeriodic(); setUnit( "energy", "default" );
+  interface(NULL) {
+  plumed.setEnergyValue( getLabel() );
+  std::vector<unsigned> shape;
+  addValue( shape );
+  setNotPeriodic();
+  setUnit( "energy", "default" );
   ActionToPutData* px=plumed.getActionSet().selectWithLabel< ActionToPutData*>("posx");
-  plumed_assert(px); forces_to_scale.push_back(px); addDependency( px );
+  plumed_assert(px);
+  forces_to_scale.push_back(px);
+  addDependency( px );
   ActionToPutData* py=plumed.getActionSet().selectWithLabel< ActionToPutData*>("posy");
-  plumed_assert(py); forces_to_scale.push_back(py); addDependency( py );
+  plumed_assert(py);
+  forces_to_scale.push_back(py);
+  addDependency( py );
   ActionToPutData* pz=plumed.getActionSet().selectWithLabel< ActionToPutData*>("posz");
-  plumed_assert(pz); forces_to_scale.push_back(pz); addDependency( pz );
+  plumed_assert(pz);
+  forces_to_scale.push_back(pz);
+  addDependency( pz );
   ActionToPutData* bx=plumed.getActionSet().selectWithLabel< ActionToPutData*>("Box");
-  plumed_assert(bx); forces_to_scale.push_back(bx); addDependency( bx );
+  plumed_assert(bx);
+  forces_to_scale.push_back(bx);
+  addDependency( bx );
   log<<"  Bibliography ";
   log<<plumed.cite("Bartels and Karplus, J. Phys. Chem. B 102, 865 (1998)");
   log<<plumed.cite("Bonomi and Parrinello, J. Comp. Chem. 30, 1615 (2009)");
@@ -106,15 +116,22 @@ void Energy::registerKeywords( Keywords& keys ) {
 void Energy::wait() {
   if( !interface ) {
     std::vector<DomainDecomposition*> allput=plumed.getActionSet().select<DomainDecomposition*>();
-    if( allput.size()>1 ) warning("found more than one interface so don't know how to sum energy");
+    if( allput.size()>1 ) {
+      warning("found more than one interface so don't know how to sum energy");
+    }
     interface = allput[0];
   }
-  ActionToPutData::wait(); if( interface ) interface->sumOverDomains( copyOutput(0) );
+  ActionToPutData::wait();
+  if( interface ) {
+    interface->sumOverDomains( copyOutput(0) );
+  }
 }
 
 void Energy::apply() {
   if( getPntrToValue()->forcesWereAdded() ) {
-    for(unsigned i=0; i<forces_to_scale.size(); ++i) forces_to_scale[i]->rescaleForces( 1.- getPntrToValue()->getForce(0));
+    for(unsigned i=0; i<forces_to_scale.size(); ++i) {
+      forces_to_scale[i]->rescaleForces( 1.- getPntrToValue()->getForce(0));
+    }
   }
 }
 
diff --git a/src/colvar/ExtraCV.cpp b/src/colvar/ExtraCV.cpp
index 5360a0201b..ab29eb6da1 100644
--- a/src/colvar/ExtraCV.cpp
+++ b/src/colvar/ExtraCV.cpp
@@ -59,18 +59,21 @@ PLUMED_REGISTER_ACTION(ExtraCV,"EXTRACV")
 
 ExtraCV::ExtraCV(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::vector<std::string> argn(1); parse("NAME",argn[0]);
+  ActionShortcut(ao) {
+  std::vector<std::string> argn(1);
+  parse("NAME",argn[0]);
   readInputLine( argn[0] + ": PUT UNIT=number SHAPE=0 MUTABLE PERIODIC=NO");
-  if( getShortcutLabel()!=argn[0] ) readInputLine( getShortcutLabel() + ": COMBINE ARG=" + argn[0] + " PERIODIC=NO");
+  if( getShortcutLabel()!=argn[0] ) {
+    readInputLine( getShortcutLabel() + ": COMBINE ARG=" + argn[0] + " PERIODIC=NO");
+  }
 }
 
 void ExtraCV::registerKeywords( Keywords& keys ) {
   ActionShortcut::registerKeywords( keys );
   keys.add("compulsory","NAME","name of the CV as computed by the MD engine");
   keys.setValueDescription("the value of the CV that was passed from the MD code to PLUMED");
-  keys.needsAction("PUT"); keys.needsAction("COMBINE");
+  keys.needsAction("PUT");
+  keys.needsAction("COMBINE");
 }
 
 }
diff --git a/src/colvar/Fake.cpp b/src/colvar/Fake.cpp
index a799f2987f..cb1ccd3b4f 100644
--- a/src/colvar/Fake.cpp
+++ b/src/colvar/Fake.cpp
@@ -43,7 +43,9 @@ class ColvarFake : public Colvar {
 public:
   static void registerKeywords( Keywords& keys );
   explicit ColvarFake(const ActionOptions&);
-  std::string getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const override { plumed_error(); }
+  std::string getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const override {
+    plumed_error();
+  }
 // active methods:
   void calculate() override;
 };
@@ -60,8 +62,7 @@ void ColvarFake::registerKeywords( Keywords& keys ) {
 }
 
 ColvarFake::ColvarFake(const ActionOptions&ao):
-  PLUMED_COLVAR_INIT(ao)
-{
+  PLUMED_COLVAR_INIT(ao) {
   std::vector<AtomNumber> atoms;
   parseAtomList("ATOMS",atoms);
 
diff --git a/src/colvar/GHBFIX.cpp b/src/colvar/GHBFIX.cpp
index c21acf9af1..499813ecee 100644
--- a/src/colvar/GHBFIX.cpp
+++ b/src/colvar/GHBFIX.cpp
@@ -97,8 +97,7 @@ void GHBFIX::registerKeywords( Keywords& keys ) {
 
 GHBFIX::GHBFIX(const ActionOptions&ao):
   Action(ao),
-  CoordinationBase(ao)
-{
+  CoordinationBase(ao) {
   std::string types;
   std::string params;
   std::string energy_units ="plumed" ;
@@ -130,8 +129,7 @@ GHBFIX::GHBFIX(const ActionOptions&ao):
 
     if (MapTypesTable.empty()) {
       MapTypesTable.insert({itype, 0});
-    }
-    else if (MapTypesTable.count(itype) == 0) {
+    } else if (MapTypesTable.count(itype) == 0) {
       unsigned currentMax = 0;
       for(auto it = MapTypesTable.cbegin(); it != MapTypesTable.cend(); ++it ) {
         if (it ->second > currentMax) {
@@ -162,7 +160,9 @@ GHBFIX::GHBFIX(const ActionOptions&ao):
   if(energy_units!="plumed") {
     Units units;
     units.setEnergy(energy_units);
-    for(auto i=0; i<etas.size(); i++) etas[i]*=units.getEnergy()/getUnits().getEnergy();
+    for(auto i=0; i<etas.size(); i++) {
+      etas[i]*=units.getEnergy()/getUnits().getEnergy();
+    }
   }
 
 }
diff --git a/src/colvar/Gyration.cpp b/src/colvar/Gyration.cpp
index c9ad222fc1..12563b5552 100644
--- a/src/colvar/Gyration.cpp
+++ b/src/colvar/Gyration.cpp
@@ -93,7 +93,8 @@ class Gyration : public Colvar {
 PLUMED_REGISTER_ACTION(Gyration,"GYRATION_FAST")
 
 void Gyration::registerKeywords(Keywords& keys) {
-  Colvar::registerKeywords(keys); keys.setDisplayName("GYRATION");
+  Colvar::registerKeywords(keys);
+  keys.setDisplayName("GYRATION");
   keys.add("atoms","ATOMS","the group of atoms that you are calculating the Gyration Tensor for");
   keys.add("compulsory","TYPE","RADIUS","The type of calculation relative to the Gyration Tensor you want to perform");
   keys.addFlag("MASS_WEIGHTED",false,"set the masses of all the atoms equal to one");
@@ -103,49 +104,88 @@ void Gyration::registerKeywords(Keywords& keys) {
 Gyration::Gyration(const ActionOptions&ao):
   PLUMED_COLVAR_INIT(ao),
   use_masses(false),
-  nopbc(false)
-{
+  nopbc(false) {
   std::vector<AtomNumber> atoms;
   parseAtomList("ATOMS",atoms);
-  if(atoms.size()==0) error("no atoms specified");
+  if(atoms.size()==0) {
+    error("no atoms specified");
+  }
   parseFlag("MASS_WEIGHTED",use_masses);
   std::string Type;
   parse("TYPE",Type);
   parseFlag("NOPBC",nopbc);
   checkRead();
 
-  if(Type=="RADIUS") rg_type=RADIUS;
-  else if(Type=="TRACE") rg_type=TRACE;
-  else if(Type=="GTPC_1") rg_type=GTPC_1;
-  else if(Type=="GTPC_2") rg_type=GTPC_2;
-  else if(Type=="GTPC_3") rg_type=GTPC_3;
-  else if(Type=="ASPHERICITY") rg_type=ASPHERICITY;
-  else if(Type=="ACYLINDRICITY") rg_type=ACYLINDRICITY;
-  else if(Type=="KAPPA2") rg_type=KAPPA2;
-  else if(Type=="RGYR_3") rg_type=GYRATION_3;
-  else if(Type=="RGYR_2") rg_type=GYRATION_2;
-  else if(Type=="RGYR_1") rg_type=GYRATION_1;
-  else error("Unknown GYRATION type");
-
-  switch(rg_type)
-  {
-  case RADIUS:   log.printf("  GYRATION RADIUS (Rg);"); break;
-  case TRACE:  log.printf("  TRACE OF THE GYRATION TENSOR;"); break;
-  case GTPC_1: log.printf("  THE LARGEST PRINCIPAL MOMENT OF THE GYRATION TENSOR (S'_1);"); break;
-  case GTPC_2: log.printf("  THE MIDDLE PRINCIPAL MOMENT OF THE GYRATION TENSOR (S'_2);");  break;
-  case GTPC_3: log.printf("  THE SMALLEST PRINCIPAL MOMENT OF THE GYRATION TENSOR (S'_3);"); break;
-  case ASPHERICITY: log.printf("  THE ASPHERICITY (b');"); break;
-  case ACYLINDRICITY: log.printf("  THE ACYLINDRICITY (c');"); break;
-  case KAPPA2: log.printf("  THE RELATIVE SHAPE ANISOTROPY (kappa^2);"); break;
-  case GYRATION_3: log.printf("  THE SMALLEST PRINCIPAL RADIUS OF GYRATION (r_g3);"); break;
-  case GYRATION_2: log.printf("  THE MIDDLE PRINCIPAL RADIUS OF GYRATION (r_g2);"); break;
-  case GYRATION_1: log.printf("  THE LARGEST PRINCIPAL RADIUS OF GYRATION (r_g1);"); break;
+  if(Type=="RADIUS") {
+    rg_type=RADIUS;
+  } else if(Type=="TRACE") {
+    rg_type=TRACE;
+  } else if(Type=="GTPC_1") {
+    rg_type=GTPC_1;
+  } else if(Type=="GTPC_2") {
+    rg_type=GTPC_2;
+  } else if(Type=="GTPC_3") {
+    rg_type=GTPC_3;
+  } else if(Type=="ASPHERICITY") {
+    rg_type=ASPHERICITY;
+  } else if(Type=="ACYLINDRICITY") {
+    rg_type=ACYLINDRICITY;
+  } else if(Type=="KAPPA2") {
+    rg_type=KAPPA2;
+  } else if(Type=="RGYR_3") {
+    rg_type=GYRATION_3;
+  } else if(Type=="RGYR_2") {
+    rg_type=GYRATION_2;
+  } else if(Type=="RGYR_1") {
+    rg_type=GYRATION_1;
+  } else {
+    error("Unknown GYRATION type");
+  }
+
+  switch(rg_type) {
+  case RADIUS:
+    log.printf("  GYRATION RADIUS (Rg);");
+    break;
+  case TRACE:
+    log.printf("  TRACE OF THE GYRATION TENSOR;");
+    break;
+  case GTPC_1:
+    log.printf("  THE LARGEST PRINCIPAL MOMENT OF THE GYRATION TENSOR (S'_1);");
+    break;
+  case GTPC_2:
+    log.printf("  THE MIDDLE PRINCIPAL MOMENT OF THE GYRATION TENSOR (S'_2);");
+    break;
+  case GTPC_3:
+    log.printf("  THE SMALLEST PRINCIPAL MOMENT OF THE GYRATION TENSOR (S'_3);");
+    break;
+  case ASPHERICITY:
+    log.printf("  THE ASPHERICITY (b');");
+    break;
+  case ACYLINDRICITY:
+    log.printf("  THE ACYLINDRICITY (c');");
+    break;
+  case KAPPA2:
+    log.printf("  THE RELATIVE SHAPE ANISOTROPY (kappa^2);");
+    break;
+  case GYRATION_3:
+    log.printf("  THE SMALLEST PRINCIPAL RADIUS OF GYRATION (r_g3);");
+    break;
+  case GYRATION_2:
+    log.printf("  THE MIDDLE PRINCIPAL RADIUS OF GYRATION (r_g2);");
+    break;
+  case GYRATION_1:
+    log.printf("  THE LARGEST PRINCIPAL RADIUS OF GYRATION (r_g1);");
+    break;
+  }
+  if(rg_type>TRACE) {
+    log<<"  Bibliography "<<plumed.cite("Jirí Vymetal and Jirí Vondrasek, J. Phys. Chem. A 115, 11455 (2011)");
   }
-  if(rg_type>TRACE) log<<"  Bibliography "<<plumed.cite("Jirí Vymetal and Jirí Vondrasek, J. Phys. Chem. A 115, 11455 (2011)");
   log<<"\n";
 
   log.printf("  atoms involved : ");
-  for(unsigned i=0; i<atoms.size(); ++i) log.printf("%d ",atoms[i].serial());
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf("%d ",atoms[i].serial());
+  }
   log.printf("\n");
 
   if(nopbc) {
@@ -154,13 +194,16 @@ Gyration::Gyration(const ActionOptions&ao):
     log<<"  broken molecules will be rebuilt assuming atoms are in the proper order\n";
   }
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
   requestAtoms(atoms);
 }
 
 void Gyration::calculate() {
 
-  if(!nopbc) makeWhole();
+  if(!nopbc) {
+    makeWhole();
+  }
 
   Vector com;
   double totmass = 0.;
@@ -203,7 +246,9 @@ void Gyration::calculate() {
       fact = 4;
     }
     setValue(rgyr);
-    for(unsigned i=0; i<getNumberOfAtoms(); i++) setAtomsDerivatives(i,fact*derivatives[i]);
+    for(unsigned i=0; i<getNumberOfAtoms(); i++) {
+      setAtomsDerivatives(i,fact*derivatives[i]);
+    }
     setBoxDerivativesNoPbc();
     return;
   }
@@ -244,38 +289,60 @@ void Gyration::calculate() {
   transf=transpose(ttransf);
   //sort eigenvalues and eigenvectors
   if (princ_comp[0]<princ_comp[1]) {
-    double tmp=princ_comp[0]; princ_comp[0]=princ_comp[1]; princ_comp[1]=tmp;
-    for (unsigned i=0; i<3; i++) {tmp=transf[i][0]; transf[i][0]=transf[i][1]; transf[i][1]=tmp;}
+    double tmp=princ_comp[0];
+    princ_comp[0]=princ_comp[1];
+    princ_comp[1]=tmp;
+    for (unsigned i=0; i<3; i++) {
+      tmp=transf[i][0];
+      transf[i][0]=transf[i][1];
+      transf[i][1]=tmp;
+    }
   }
   if (princ_comp[1]<princ_comp[2]) {
-    double tmp=princ_comp[1]; princ_comp[1]=princ_comp[2]; princ_comp[2]=tmp;
-    for (unsigned i=0; i<3; i++) {tmp=transf[i][1]; transf[i][1]=transf[i][2]; transf[i][2]=tmp;}
+    double tmp=princ_comp[1];
+    princ_comp[1]=princ_comp[2];
+    princ_comp[2]=tmp;
+    for (unsigned i=0; i<3; i++) {
+      tmp=transf[i][1];
+      transf[i][1]=transf[i][2];
+      transf[i][2]=tmp;
+    }
   }
   if (princ_comp[0]<princ_comp[1]) {
-    double tmp=princ_comp[0]; princ_comp[0]=princ_comp[1]; princ_comp[1]=tmp;
-    for (unsigned i=0; i<3; i++) {tmp=transf[i][0]; transf[i][0]=transf[i][1]; transf[i][1]=tmp;}
+    double tmp=princ_comp[0];
+    princ_comp[0]=princ_comp[1];
+    princ_comp[1]=tmp;
+    for (unsigned i=0; i<3; i++) {
+      tmp=transf[i][0];
+      transf[i][0]=transf[i][1];
+      transf[i][1]=tmp;
+    }
   }
   //calculate determinant of transformation matrix
   double det = determinant(transf);
   // transformation matrix for rotation must have positive determinant, otherwise multiply one column by (-1)
   if(det<0) {
-    for(unsigned j=0; j<3; j++) transf[j][2]=-transf[j][2];
+    for(unsigned j=0; j<3; j++) {
+      transf[j][2]=-transf[j][2];
+    }
     det = -det;
   }
-  if(std::abs(det-1.)>0.0001) error("Plumed Error: Cannot diagonalize gyration tensor\n");
+  if(std::abs(det-1.)>0.0001) {
+    error("Plumed Error: Cannot diagonalize gyration tensor\n");
+  }
   switch(rg_type) {
   case GTPC_1:
   case GTPC_2:
-  case GTPC_3:
-  {
+  case GTPC_3: {
     int pc_index = rg_type-2; //index of principal component
     rgyr=std::sqrt(princ_comp[pc_index]/totmass);
     double rm = rgyr*totmass;
-    if(rm>1e-6) prefactor[pc_index]=1.0/rm; //some parts of derivate
+    if(rm>1e-6) {
+      prefactor[pc_index]=1.0/rm;  //some parts of derivate
+    }
     break;
   }
-  case GYRATION_3:        //the smallest principal radius of gyration
-  {
+  case GYRATION_3: {      //the smallest principal radius of gyration
     rgyr=std::sqrt((princ_comp[1]+princ_comp[2])/totmass);
     double rm = rgyr*totmass;
     if (rm>1e-6) {
@@ -284,8 +351,7 @@ void Gyration::calculate() {
     }
     break;
   }
-  case GYRATION_2:       //the midle principal radius of gyration
-  {
+  case GYRATION_2: {     //the midle principal radius of gyration
     rgyr=std::sqrt((princ_comp[0]+princ_comp[2])/totmass);
     double rm = rgyr*totmass;
     if (rm>1e-6) {
@@ -294,8 +360,7 @@ void Gyration::calculate() {
     }
     break;
   }
-  case GYRATION_1:      //the largest principal radius of gyration
-  {
+  case GYRATION_1: {    //the largest principal radius of gyration
     rgyr=std::sqrt((princ_comp[0]+princ_comp[1])/totmass);
     double rm = rgyr*totmass;
     if (rm>1e-6) {
@@ -304,8 +369,7 @@ void Gyration::calculate() {
     }
     break;
   }
-  case ASPHERICITY:
-  {
+  case ASPHERICITY: {
     rgyr=std::sqrt((princ_comp[0]-0.5*(princ_comp[1]+princ_comp[2]))/totmass);
     double rm = rgyr*totmass;
     if (rm>1e-6) {
@@ -315,8 +379,7 @@ void Gyration::calculate() {
     }
     break;
   }
-  case ACYLINDRICITY:
-  {
+  case ACYLINDRICITY: {
     rgyr=std::sqrt((princ_comp[1]-princ_comp[2])/totmass);
     double rm = rgyr*totmass;
     if (rm>1e-6) {  //avoid division by zero
@@ -325,8 +388,7 @@ void Gyration::calculate() {
     }
     break;
   }
-  case KAPPA2: // relative shape anisotropy
-  {
+  case KAPPA2: { // relative shape anisotropy
     double trace = princ_comp[0]+princ_comp[1]+princ_comp[2];
     double tmp=princ_comp[0]*princ_comp[1]+ princ_comp[1]*princ_comp[2]+ princ_comp[0]*princ_comp[2];
     rgyr=1.0-3*(tmp/(trace*trace));
@@ -344,10 +406,13 @@ void Gyration::calculate() {
       Vector tX;
       const Vector diff=delta( com,getPosition(i) );
       //project atomic postional vectors to diagonalized frame
-      for(unsigned j=0; j<3; j++) tX[j]=transf[0][j]*diff[0]+transf[1][j]*diff[1]+transf[2][j]*diff[2];
-      for(unsigned j=0; j<3; j++) derivatives[i][j]=getMass(i)*(prefactor[0]*transf[j][0]*tX[0]+
-            prefactor[1]*transf[j][1]*tX[1]+
-            prefactor[2]*transf[j][2]*tX[2]);
+      for(unsigned j=0; j<3; j++) {
+        tX[j]=transf[0][j]*diff[0]+transf[1][j]*diff[1]+transf[2][j]*diff[2];
+      }
+      for(unsigned j=0; j<3; j++)
+        derivatives[i][j]=getMass(i)*(prefactor[0]*transf[j][0]*tX[0]+
+                                      prefactor[1]*transf[j][1]*tX[1]+
+                                      prefactor[2]*transf[j][2]*tX[2]);
       setAtomsDerivatives(i,derivatives[i]);
     }
   } else {
@@ -355,10 +420,13 @@ void Gyration::calculate() {
       Vector tX;
       const Vector diff=delta( com,getPosition(i) );
       //project atomic postional vectors to diagonalized frame
-      for(unsigned j=0; j<3; j++) tX[j]=transf[0][j]*diff[0]+transf[1][j]*diff[1]+transf[2][j]*diff[2];
-      for(unsigned j=0; j<3; j++) derivatives[i][j]=prefactor[0]*transf[j][0]*tX[0]+
-            prefactor[1]*transf[j][1]*tX[1]+
-            prefactor[2]*transf[j][2]*tX[2];
+      for(unsigned j=0; j<3; j++) {
+        tX[j]=transf[0][j]*diff[0]+transf[1][j]*diff[1]+transf[2][j]*diff[2];
+      }
+      for(unsigned j=0; j<3; j++)
+        derivatives[i][j]=prefactor[0]*transf[j][0]*tX[0]+
+                          prefactor[1]*transf[j][1]*tX[1]+
+                          prefactor[2]*transf[j][2]*tX[2];
       setAtomsDerivatives(i,derivatives[i]);
     }
   }
diff --git a/src/colvar/GyrationShortcut.cpp b/src/colvar/GyrationShortcut.cpp
index de87555798..0831bda7ef 100644
--- a/src/colvar/GyrationShortcut.cpp
+++ b/src/colvar/GyrationShortcut.cpp
@@ -67,70 +67,124 @@ void GyrationShortcut::registerKeywords( Keywords& keys ) {
   keys.addFlag("MASS_WEIGHTED",false,"set the masses of all the atoms equal to one");
   keys.addFlag("UNORMALIZED",false,"do not divide by the sum of the weights");
   keys.setValueDescription("the radius that was computed from the weights");
-  keys.addActionNameSuffix("_FAST"); keys.needsAction("CENTER"); keys.needsAction("CONSTANT");
-  keys.needsAction("ONES"); keys.needsAction("MASS"); keys.needsAction("DISTANCE");
-  keys.needsAction("COVARIANCE_MATRIX"); keys.needsAction("SELECT_COMPONENTS");
-  keys.needsAction("SUM"); keys.needsAction("CUSTOM"); keys.needsAction("DIAGONALIZE");
+  keys.addActionNameSuffix("_FAST");
+  keys.needsAction("CENTER");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("ONES");
+  keys.needsAction("MASS");
+  keys.needsAction("DISTANCE");
+  keys.needsAction("COVARIANCE_MATRIX");
+  keys.needsAction("SELECT_COMPONENTS");
+  keys.needsAction("SUM");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("DIAGONALIZE");
 }
 
 GyrationShortcut::GyrationShortcut(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  bool usemass, phases; parseFlag("MASS",usemass); parseFlag("PHASES",phases);
-  std::vector<std::string> str_weights; parseVector("WEIGHTS",str_weights); std::string wflab;
+  ActionShortcut(ao) {
+  bool usemass, phases;
+  parseFlag("MASS",usemass);
+  parseFlag("PHASES",phases);
+  std::vector<std::string> str_weights;
+  parseVector("WEIGHTS",str_weights);
+  std::string wflab;
   if( !phases ) {
     if( usemass || str_weights.size()==0 || (str_weights.size()==1 && str_weights[0]=="@Masses") ) {
       std::string wt_str;
       if( str_weights.size()>0 ) {
-        wt_str="WEIGHTS=" + str_weights[0]; for(unsigned i=1; i<str_weights.size(); ++i) wt_str += "," + str_weights[i];
+        wt_str="WEIGHTS=" + str_weights[0];
+        for(unsigned i=1; i<str_weights.size(); ++i) {
+          wt_str += "," + str_weights[i];
+        }
+      }
+      if( usemass || (str_weights.size()==1 && str_weights[0]=="@Masses") ) {
+        wt_str = "MASS";
       }
-      if( usemass || (str_weights.size()==1 && str_weights[0]=="@Masses") ) wt_str = "MASS";
       readInputLine( getShortcutLabel() + ": GYRATION_FAST " + wt_str + " " + convertInputLineToString() );
       return;
     }
   }
-  if( usemass ) { str_weights.resize(1); str_weights[0]="@Masses"; }
+  if( usemass ) {
+    str_weights.resize(1);
+    str_weights[0]="@Masses";
+  }
   log<<"  Bibliography "<<plumed.cite("Jirí Vymetal and Jirí Vondrasek, J. Phys. Chem. A 115, 11455 (2011)")<<"\n";
   // Read in the atoms involved
-  std::vector<std::string> atoms; parseVector("ATOMS",atoms); Tools::interpretRanges(atoms);
-  std::string gtype, atlist=atoms[0]; for(unsigned i=1; i<atoms.size(); ++i) atlist += "," + atoms[i];
-  bool nopbc; parseFlag("NOPBC",nopbc); std::string pbcstr; if(nopbc) pbcstr = " NOPBC";
-  std::string phasestr; if(phases) phasestr = " PHASES";
+  std::vector<std::string> atoms;
+  parseVector("ATOMS",atoms);
+  Tools::interpretRanges(atoms);
+  std::string gtype, atlist=atoms[0];
+  for(unsigned i=1; i<atoms.size(); ++i) {
+    atlist += "," + atoms[i];
+  }
+  bool nopbc;
+  parseFlag("NOPBC",nopbc);
+  std::string pbcstr;
+  if(nopbc) {
+    pbcstr = " NOPBC";
+  }
+  std::string phasestr;
+  if(phases) {
+    phasestr = " PHASES";
+  }
   // Create the geometric center of the molecule
   std::string weights_str=" WEIGHTS=" + str_weights[0];
-  for(unsigned i=1; i<str_weights.size(); ++i) weights_str += "," + str_weights[i];
+  for(unsigned i=1; i<str_weights.size(); ++i) {
+    weights_str += "," + str_weights[i];
+  }
   readInputLine( getShortcutLabel() + "_cent: CENTER ATOMS=" + atlist + pbcstr + phasestr + weights_str );
   if( str_weights.size()==0 ) {
-    wflab = getShortcutLabel() + "_w"; std::string str_natoms; Tools::convert( atoms.size(), str_natoms );
+    wflab = getShortcutLabel() + "_w";
+    std::string str_natoms;
+    Tools::convert( atoms.size(), str_natoms );
     readInputLine( getShortcutLabel() + "_w: ONES SIZE=" + str_natoms );
   } else if( str_weights.size()==1 && str_weights[0]=="@Masses" ) {
     wflab = getShortcutLabel() + "_m";
     readInputLine( getShortcutLabel() + "_m: MASS ATOMS=" + atlist );
   } else if( str_weights.size()>1 ) {
-    std::string vals=str_weights[0]; for(unsigned i=1; i<str_weights.size(); ++i) vals += "," + str_weights[i];
-    readInputLine( getShortcutLabel() + "_w: CONSTANT VALUES=" + vals ); wflab=getShortcutLabel() + "_w";
+    std::string vals=str_weights[0];
+    for(unsigned i=1; i<str_weights.size(); ++i) {
+      vals += "," + str_weights[i];
+    }
+    readInputLine( getShortcutLabel() + "_w: CONSTANT VALUES=" + vals );
+    wflab=getShortcutLabel() + "_w";
   } else {
-    plumed_assert( str_weights.size()==1 ); wflab = getShortcutLabel() + "_cent_w";
+    plumed_assert( str_weights.size()==1 );
+    wflab = getShortcutLabel() + "_cent_w";
     ActionWithValue* av=plumed.getActionSet().selectWithLabel<ActionWithValue*>( wflab );
-    if( !av ) { wflab = str_weights[0]; }
+    if( !av ) {
+      wflab = str_weights[0];
+    }
   }
   // Check for normalisation
-  bool unorm; parseFlag("UNORMALIZED",unorm);
+  bool unorm;
+  parseFlag("UNORMALIZED",unorm);
   // Find out the type
   if( getName()!="GYRATION_TENSOR" ) {
     parse("TYPE",gtype);
     if( gtype!="RADIUS" && gtype!="TRACE" && gtype!="GTPC_1" && gtype!="GTPC_2" && gtype!="GTPC_3" && gtype!="ASPHERICITY" && gtype!="ACYLINDRICITY"
-        && gtype!= "KAPPA2" && gtype!="RGYR_1" && gtype!="RGYR_2" && gtype!="RGYR_3" ) error("type " + gtype + " is invalid");
+        && gtype!= "KAPPA2" && gtype!="RGYR_1" && gtype!="RGYR_2" && gtype!="RGYR_3" ) {
+      error("type " + gtype + " is invalid");
+    }
     // Check if we need to calculate the unormlised radius
-    if( gtype=="TRACE" || gtype=="KAPPA2" ) unorm=true;
+    if( gtype=="TRACE" || gtype=="KAPPA2" ) {
+      unorm=true;
+    }
   }
   // Compute all the vectors separating all the positions from the center
   std::string distance_act = getShortcutLabel() + "_dists: DISTANCE COMPONENTS" + pbcstr;
-  for(unsigned i=0; i<atoms.size(); ++i) { std::string num; Tools::convert( i+1, num ); distance_act += " ATOMS" + num + "=" + getShortcutLabel() + "_cent," + atoms[i]; }
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    std::string num;
+    Tools::convert( i+1, num );
+    distance_act += " ATOMS" + num + "=" + getShortcutLabel() + "_cent," + atoms[i];
+  }
   readInputLine( distance_act );
   // And calculate the covariance
-  std::string norm_str; if( unorm ) norm_str = " UNORMALIZED";
+  std::string norm_str;
+  if( unorm ) {
+    norm_str = " UNORMALIZED";
+  }
   if( getName()=="GYRATION_TENSOR" ) {
     readInputLine( getShortcutLabel() + ": COVARIANCE_MATRIX ARG=" + getShortcutLabel() + "_dists.x," + getShortcutLabel() + "_dists.y," + getShortcutLabel() + "_dists.z WEIGHTS=" + wflab + norm_str );
     return;
@@ -152,13 +206,23 @@ GyrationShortcut::GyrationShortcut(const ActionOptions& ao):
     // Diagonalize the gyration tensor
     readInputLine( getShortcutLabel() + "_diag: DIAGONALIZE ARG=" + getShortcutLabel() + "_tensor VECTORS=all" );
     if( gtype.find("GTPC")!=std::string::npos ) {
-      std::size_t und=gtype.find_first_of("_"); if( und==std::string::npos ) error( gtype + " is not a valid type for gyration radius");
-      std::string num = gtype.substr(und+1); if( num!="1" && num!="2" && num!="3" ) error( gtype + " is not a valid type for gyration radius");
+      std::size_t und=gtype.find_first_of("_");
+      if( und==std::string::npos ) {
+        error( gtype + " is not a valid type for gyration radius");
+      }
+      std::string num = gtype.substr(und+1);
+      if( num!="1" && num!="2" && num!="3" ) {
+        error( gtype + " is not a valid type for gyration radius");
+      }
       // Now get the appropriate eigenvalue
       readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_diag.vals-" + num + " FUNC=sqrt(x) PERIODIC=NO");
     } else if( gtype.find("RGYR")!=std::string::npos ) {
-      std::size_t und=gtype.find_first_of("_"); if( und==std::string::npos ) error( gtype + " is not a valid type for gyration radius");
-      unsigned ind; Tools::convert( gtype.substr(und+1), ind );
+      std::size_t und=gtype.find_first_of("_");
+      if( und==std::string::npos ) {
+        error( gtype + " is not a valid type for gyration radius");
+      }
+      unsigned ind;
+      Tools::convert( gtype.substr(und+1), ind );
       // Now get the appropriate quantity
       if( ind==3 ) {
         readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_diag.vals-1," + getShortcutLabel() + "_diag.vals-2 FUNC=sqrt(x+y) PERIODIC=NO");
@@ -166,7 +230,9 @@ GyrationShortcut::GyrationShortcut(const ActionOptions& ao):
         readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_diag.vals-1," + getShortcutLabel() + "_diag.vals-3 FUNC=sqrt(x+y) PERIODIC=NO");
       } else if( ind==1 ) {
         readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_diag.vals-2," + getShortcutLabel() + "_diag.vals-3 FUNC=sqrt(x+y) PERIODIC=NO");
-      } else error( gtype + " is not a valid type for gyration radius");
+      } else {
+        error( gtype + " is not a valid type for gyration radius");
+      }
     } else if( gtype=="ASPHERICITY" ) {
       readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_diag.vals-1," + getShortcutLabel() + "_diag.vals-2," + getShortcutLabel() + "_diag.vals-3 FUNC=sqrt(x-0.5*(y+z)) PERIODIC=NO" );
     } else if( gtype=="ACYLINDRICITY" ) {
@@ -175,7 +241,9 @@ GyrationShortcut::GyrationShortcut(const ActionOptions& ao):
       readInputLine( getShortcutLabel() + "_numer: CUSTOM ARG=" + getShortcutLabel() + "_diag.vals-1," + getShortcutLabel() + "_diag.vals-2," + getShortcutLabel() + "_diag.vals-3 FUNC=x*y+x*z+y*z PERIODIC=NO" );
       readInputLine( getShortcutLabel() + "_denom: CUSTOM ARG=" + getShortcutLabel() + "_diag.vals-1," + getShortcutLabel() + "_diag.vals-2," + getShortcutLabel() + "_diag.vals-3 FUNC=x+y+z PERIODIC=NO" );
       readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_numer," + getShortcutLabel() + "_denom FUNC=1-3*(x/(y*y)) PERIODIC=NO");
-    } else error( gtype + " is not a valid type for gyration radius");
+    } else {
+      error( gtype + " is not a valid type for gyration radius");
+    }
   }
 }
 
diff --git a/src/colvar/MultiColvarTemplate.h b/src/colvar/MultiColvarTemplate.h
index 3c15e05bec..49809f2883 100644
--- a/src/colvar/MultiColvarTemplate.h
+++ b/src/colvar/MultiColvarTemplate.h
@@ -54,9 +54,13 @@ void MultiColvarTemplate<T>::registerKeywords(Keywords& keys ) {
   T::registerKeywords( keys );
   unsigned nkeys = keys.size();
   for(unsigned i=0; i<nkeys; ++i) {
-    if( keys.style( keys.get(i), "atoms" ) ) keys.reset_style( keys.get(i), "numbered" );
+    if( keys.style( keys.get(i), "atoms" ) ) {
+      keys.reset_style( keys.get(i), "numbered" );
+    }
+  }
+  if( keys.outputComponentExists(".#!value") ) {
+    keys.setValueDescription("the " + keys.getDisplayName() + " for each set of specified atoms");
   }
-  if( keys.outputComponentExists(".#!value") ) keys.setValueDescription("the " + keys.getDisplayName() + " for each set of specified atoms");
 }
 
 template <class T>
@@ -65,42 +69,60 @@ MultiColvarTemplate<T>::MultiColvarTemplate(const ActionOptions&ao):
   ActionWithVector(ao),
   mode(0),
   usepbc(true),
-  wholemolecules(false)
-{
+  wholemolecules(false) {
   std::vector<AtomNumber> all_atoms;
-  if( getName()=="POSITION_VECTOR" || getName()=="MASS_VECTOR" || getName()=="CHARGE_VECTOR" ) parseAtomList( "ATOMS", all_atoms );
+  if( getName()=="POSITION_VECTOR" || getName()=="MASS_VECTOR" || getName()=="CHARGE_VECTOR" ) {
+    parseAtomList( "ATOMS", all_atoms );
+  }
   if( all_atoms.size()>0 ) {
-    ablocks.resize(1); ablocks[0].resize( all_atoms.size() );
-    for(unsigned i=0; i<all_atoms.size(); ++i) ablocks[0][i] = i;
+    ablocks.resize(1);
+    ablocks[0].resize( all_atoms.size() );
+    for(unsigned i=0; i<all_atoms.size(); ++i) {
+      ablocks[0][i] = i;
+    }
   } else {
     std::vector<AtomNumber> t;
     for(int i=1;; ++i ) {
       T::parseAtomList( i, t, this );
-      if( t.empty() ) break;
+      if( t.empty() ) {
+        break;
+      }
 
-      if( i==1 ) { ablocks.resize(t.size()); }
+      if( i==1 ) {
+        ablocks.resize(t.size());
+      }
       if( t.size()!=ablocks.size() ) {
-        std::string ss; Tools::convert(i,ss);
+        std::string ss;
+        Tools::convert(i,ss);
         error("ATOMS" + ss + " keyword has the wrong number of atoms");
       }
       for(unsigned j=0; j<ablocks.size(); ++j) {
-        ablocks[j].push_back( ablocks.size()*(i-1)+j ); all_atoms.push_back( t[j] );
+        ablocks[j].push_back( ablocks.size()*(i-1)+j );
+        all_atoms.push_back( t[j] );
       }
       t.resize(0);
     }
   }
-  if( all_atoms.size()==0 ) error("No atoms have been specified");
+  if( all_atoms.size()==0 ) {
+    error("No atoms have been specified");
+  }
   requestAtoms(all_atoms);
   if( keywords.exists("NOPBC") ) {
-    bool nopbc=!usepbc; parseFlag("NOPBC",nopbc);
+    bool nopbc=!usepbc;
+    parseFlag("NOPBC",nopbc);
     usepbc=!nopbc;
   }
   if( keywords.exists("WHOLEMOLECULES") ) {
     parseFlag("WHOLEMOLECULES",wholemolecules);
-    if( wholemolecules ) usepbc=false;
+    if( wholemolecules ) {
+      usepbc=false;
+    }
+  }
+  if( usepbc ) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
   }
-  if( usepbc ) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  without periodic boundary conditions\n");
 
   // Setup the values
   mode = T::getModeAndSetupValues( this );
@@ -118,17 +140,23 @@ void MultiColvarTemplate<T>::calculate() {
 
 template <class T>
 void MultiColvarTemplate<T>::addValueWithDerivatives( const std::vector<unsigned>& shape ) {
-  std::vector<unsigned> s(1); s[0]=ablocks[0].size(); addValue( s );
+  std::vector<unsigned> s(1);
+  s[0]=ablocks[0].size();
+  addValue( s );
 }
 
 template <class T>
 void MultiColvarTemplate<T>::addComponentWithDerivatives( const std::string& name, const std::vector<unsigned>& shape ) {
-  std::vector<unsigned> s(1); s[0]=ablocks[0].size(); addComponent( name, s );
+  std::vector<unsigned> s(1);
+  s[0]=ablocks[0].size();
+  addComponent( name, s );
 }
 
 template <class T>
 void MultiColvarTemplate<T>::setupStreamedComponents( const std::string& headstr, unsigned& nquants, unsigned& nmat, unsigned& maxcol, unsigned& nbookeeping ) {
-  if( wholemolecules ) makeWhole();
+  if( wholemolecules ) {
+    makeWhole();
+  }
   ActionWithVector::setupStreamedComponents( headstr, nquants, nmat, maxcol, nbookeeping );
 }
 
@@ -136,38 +164,60 @@ template <class T>
 void MultiColvarTemplate<T>::performTask( const unsigned& task_index, MultiValue& myvals ) const {
   // Retrieve the positions
   std::vector<Vector> & fpositions( myvals.getFirstAtomVector() );
-  if( fpositions.size()!=ablocks.size() ) fpositions.resize( ablocks.size() );
-  for(unsigned i=0; i<ablocks.size(); ++i) fpositions[i] = getPosition( ablocks[i][task_index] );
+  if( fpositions.size()!=ablocks.size() ) {
+    fpositions.resize( ablocks.size() );
+  }
+  for(unsigned i=0; i<ablocks.size(); ++i) {
+    fpositions[i] = getPosition( ablocks[i][task_index] );
+  }
   // If we are using pbc make whole
   if( usepbc ) {
     if( fpositions.size()==1 ) {
       fpositions[0]=pbcDistance(Vector(0.0,0.0,0.0),getPosition( ablocks[0][task_index] ) );
     } else {
       for(unsigned j=0; j<fpositions.size()-1; ++j) {
-        const Vector & first (fpositions[j]); Vector & second (fpositions[j+1]);
+        const Vector & first (fpositions[j]);
+        Vector & second (fpositions[j+1]);
         second=first+pbcDistance(first,second);
       }
     }
-  } else if( fpositions.size()==1 ) fpositions[0]=delta(Vector(0.0,0.0,0.0),getPosition( ablocks[0][task_index] ) );
+  } else if( fpositions.size()==1 ) {
+    fpositions[0]=delta(Vector(0.0,0.0,0.0),getPosition( ablocks[0][task_index] ) );
+  }
   // Retrieve the masses and charges
   myvals.resizeTemporyVector(2);
   std::vector<double> & mass( myvals.getTemporyVector(0) );
   std::vector<double> & charge( myvals.getTemporyVector(1) );
-  if( mass.size()!=ablocks.size() ) { mass.resize(ablocks.size()); charge.resize(ablocks.size()); }
-  for(unsigned i=0; i<ablocks.size(); ++i) { mass[i]=getMass( ablocks[i][task_index] ); charge[i]=getCharge( ablocks[i][task_index] ); }
+  if( mass.size()!=ablocks.size() ) {
+    mass.resize(ablocks.size());
+    charge.resize(ablocks.size());
+  }
+  for(unsigned i=0; i<ablocks.size(); ++i) {
+    mass[i]=getMass( ablocks[i][task_index] );
+    charge[i]=getCharge( ablocks[i][task_index] );
+  }
   // Make some space to store various things
   std::vector<double> values( getNumberOfComponents() );
   std::vector<Tensor> & virial( myvals.getFirstAtomVirialVector() );
   std::vector<std::vector<Vector> > & derivs( myvals.getFirstAtomDerivativeVector() );
-  if( derivs.size()!=values.size() ) { derivs.resize( values.size() ); virial.resize( values.size() ); }
+  if( derivs.size()!=values.size() ) {
+    derivs.resize( values.size() );
+    virial.resize( values.size() );
+  }
   for(unsigned i=0; i<derivs.size(); ++i) {
-    if( derivs[i].size()<ablocks.size() ) derivs[i].resize( ablocks.size() );
+    if( derivs[i].size()<ablocks.size() ) {
+      derivs[i].resize( ablocks.size() );
+    }
   }
   // Calculate the CVs using the method in the Colvar
   T::calculateCV( mode, mass, charge, fpositions, values, derivs, virial, this );
-  for(unsigned i=0; i<values.size(); ++i) myvals.setValue( getConstPntrToComponent(i)->getPositionInStream(), values[i] );
+  for(unsigned i=0; i<values.size(); ++i) {
+    myvals.setValue( getConstPntrToComponent(i)->getPositionInStream(), values[i] );
+  }
   // Finish if there are no derivatives
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
 
   // Now transfer the derivatives to the underlying MultiValue
   for(unsigned i=0; i<ablocks.size(); ++i) {
@@ -181,9 +231,14 @@ void MultiColvarTemplate<T>::performTask( const unsigned& task_index, MultiValue
     // Check for duplicated indices during update to avoid double counting
     bool newi=true;
     for(unsigned j=0; j<i; ++j) {
-      if( ablocks[j][task_index]==ablocks[i][task_index] ) { newi=false; break; }
+      if( ablocks[j][task_index]==ablocks[i][task_index] ) {
+        newi=false;
+        break;
+      }
+    }
+    if( !newi ) {
+      continue;
     }
-    if( !newi ) continue;
     for(int j=0; j<getNumberOfComponents(); ++j) {
       unsigned jval=getConstPntrToComponent(j)->getPositionInStream();
       myvals.updateIndex( jval, base );
diff --git a/src/colvar/MultiRMSD.cpp b/src/colvar/MultiRMSD.cpp
index f2d934e68c..f14f8a080c 100644
--- a/src/colvar/MultiRMSD.cpp
+++ b/src/colvar/MultiRMSD.cpp
@@ -59,72 +59,132 @@ void MultiRMSD::registerKeywords(Keywords& keys) {
   keys.addFlag("SQUARED",false," This should be set if you want the mean squared displacement instead of the root mean squared displacement");
   keys.addFlag("NOPBC",false,"don't use periodic boundary conditions");
   keys.setValueDescription("the sum of the multiple RMSD distances");
-  keys.needsAction("CONSTANT"); keys.needsAction("WHOLEMOLECULES"); keys.needsAction("POSITION");
-  keys.needsAction("CONCATENATE"); keys.needsAction("RMSD_VECTOR"); keys.needsAction("COMBINE"); keys.needsAction("CUSTOM");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("WHOLEMOLECULES");
+  keys.needsAction("POSITION");
+  keys.needsAction("CONCATENATE");
+  keys.needsAction("RMSD_VECTOR");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CUSTOM");
 }
 
 MultiRMSD::MultiRMSD(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   warning("this action is depracated.  look at the log to see how it is implemented using the new syntax");
-  std::string type; parse("TYPE",type); bool nopbc; parseFlag("NOPBC",nopbc);
+  std::string type;
+  parse("TYPE",type);
+  bool nopbc;
+  parseFlag("NOPBC",nopbc);
   std::size_t dash=type.find_first_of("-");
   if( dash!=std::string::npos ) {
-    if( type.substr(0,dash)=="MULTI" ) warning("MULTI is deprecated.  You can just use OPTIMAL/SIMPLE");
-    else error("cannot understand type " + type );
+    if( type.substr(0,dash)=="MULTI" ) {
+      warning("MULTI is deprecated.  You can just use OPTIMAL/SIMPLE");
+    } else {
+      error("cannot understand type " + type );
+    }
     type = type.substr(dash+1);
   }
-  std::string reference; parse("REFERENCE",reference); PDB pdb;
-  if( !pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength()) ) error("missing input file " + reference );
+  std::string reference;
+  parse("REFERENCE",reference);
+  PDB pdb;
+  if( !pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength()) ) {
+    error("missing input file " + reference );
+  }
 
   unsigned nblocks =  pdb.getNumberOfAtomBlocks();
-  if( nblocks<2 ) error("multidomain RMSD only has one block of atoms");
-  std::string num; std::vector<unsigned> blocks( nblocks+1 ); blocks[0]=0;
-  for(unsigned i=0; i<nblocks; ++i) blocks[i+1]=pdb.getAtomBlockEnds()[i];
+  if( nblocks<2 ) {
+    error("multidomain RMSD only has one block of atoms");
+  }
+  std::string num;
+  std::vector<unsigned> blocks( nblocks+1 );
+  blocks[0]=0;
+  for(unsigned i=0; i<nblocks; ++i) {
+    blocks[i+1]=pdb.getAtomBlockEnds()[i];
+  }
 
   for(unsigned i=1; i<=nblocks; ++i) {
     // Setup a constant
-    double asum=0; std::string bnum; Tools::convert( i, bnum );
-    for(unsigned j=blocks[i-1]; j<blocks[i]; ++j) asum += pdb.getOccupancy()[j];
-    Vector center; center.zero();
-    for(unsigned j=blocks[i-1]; j<blocks[i]; ++j) center += ( pdb.getOccupancy()[j] / asum )*pdb.getPositions()[j];
+    double asum=0;
+    std::string bnum;
+    Tools::convert( i, bnum );
+    for(unsigned j=blocks[i-1]; j<blocks[i]; ++j) {
+      asum += pdb.getOccupancy()[j];
+    }
+    Vector center;
+    center.zero();
+    for(unsigned j=blocks[i-1]; j<blocks[i]; ++j) {
+      center += ( pdb.getOccupancy()[j] / asum )*pdb.getPositions()[j];
+    }
     std::vector<double> vals;
     for(unsigned k=0; k<3; ++k) {
-      for(unsigned j=blocks[i-1]; j<blocks[i]; ++j) vals.push_back( pdb.getPositions()[j][k] - center[k] );
+      for(unsigned j=blocks[i-1]; j<blocks[i]; ++j) {
+        vals.push_back( pdb.getPositions()[j][k] - center[k] );
+      }
+    }
+    std::string valstr;
+    Tools::convert( vals[0], valstr );
+    for(unsigned i=1; i<vals.size(); ++i) {
+      std::string rnum;
+      Tools::convert( vals[i], rnum );
+      valstr += "," + rnum;
     }
-    std::string valstr; Tools::convert( vals[0], valstr );
-    for(unsigned i=1; i<vals.size(); ++i) { std::string rnum; Tools::convert( vals[i], rnum ); valstr += "," + rnum; }
     // Create the reference value
     readInputLine( getShortcutLabel() + "_ref" + bnum + ": CONSTANT VALUES=" + valstr );
     // Do whole molecules
     if( !nopbc ) {
-      std::string num; Tools::convert( pdb.getAtomNumbers()[blocks[i-1]].serial(), num ); std::string wm_line = "WHOLEMOLECULES ENTITY0=" + num;
-      for(unsigned j=blocks[i-1]+1; j<blocks[i]; ++j) { Tools::convert( pdb.getAtomNumbers()[j].serial(), num ); wm_line += "," + num; }
+      std::string num;
+      Tools::convert( pdb.getAtomNumbers()[blocks[i-1]].serial(), num );
+      std::string wm_line = "WHOLEMOLECULES ENTITY0=" + num;
+      for(unsigned j=blocks[i-1]+1; j<blocks[i]; ++j) {
+        Tools::convert( pdb.getAtomNumbers()[j].serial(), num );
+        wm_line += "," + num;
+      }
       readInputLine( wm_line );
     }
     // Get the positions of the atoms in this block
-    std::string num; Tools::convert( pdb.getAtomNumbers()[blocks[i-1]].serial(), num ); std::string pos_line = getShortcutLabel() + "_cpos" + bnum + ": POSITION NOPBC ATOMS=" + num;
-    for(unsigned j=blocks[i-1]+1; j<blocks[i]; ++j) { Tools::convert( pdb.getAtomNumbers()[j].serial(), num ); pos_line += "," + num; }
+    std::string num;
+    Tools::convert( pdb.getAtomNumbers()[blocks[i-1]].serial(), num );
+    std::string pos_line = getShortcutLabel() + "_cpos" + bnum + ": POSITION NOPBC ATOMS=" + num;
+    for(unsigned j=blocks[i-1]+1; j<blocks[i]; ++j) {
+      Tools::convert( pdb.getAtomNumbers()[j].serial(), num );
+      pos_line += "," + num;
+    }
     readInputLine( pos_line );
     // Concatenate the positiosn together
     readInputLine( getShortcutLabel() + "_pos" + bnum + ": CONCATENATE ARG=" + getShortcutLabel() + "_cpos" + bnum + ".x," + getShortcutLabel() + "_cpos" + bnum + ".y," + getShortcutLabel() + "_cpos" + bnum + ".z");
     // Computer the RMSD for this block
     std::string rmsd_line = getShortcutLabel() + "_rmsd" + bnum + ": RMSD_VECTOR SQUARED ARG=" + getShortcutLabel() + "_pos" + bnum + "," + getShortcutLabel() + "_ref" + bnum;
     // Now align
-    Tools::convert( pdb.getOccupancy()[blocks[i-1]], num ); rmsd_line += " ALIGN=" + num;
-    for(unsigned j=blocks[i-1]+1; j<blocks[i]; ++j) { Tools::convert( pdb.getOccupancy()[j], num ); rmsd_line += "," + num; }
+    Tools::convert( pdb.getOccupancy()[blocks[i-1]], num );
+    rmsd_line += " ALIGN=" + num;
+    for(unsigned j=blocks[i-1]+1; j<blocks[i]; ++j) {
+      Tools::convert( pdb.getOccupancy()[j], num );
+      rmsd_line += "," + num;
+    }
     // And displace
-    Tools::convert( pdb.getBeta()[blocks[i-1]], num ); rmsd_line += " DISPLACE=" + num;
-    for(unsigned j=blocks[i-1]+1; j<blocks[i]; ++j) { Tools::convert( pdb.getBeta()[j], num ); rmsd_line += "," + num; }
+    Tools::convert( pdb.getBeta()[blocks[i-1]], num );
+    rmsd_line += " DISPLACE=" + num;
+    for(unsigned j=blocks[i-1]+1; j<blocks[i]; ++j) {
+      Tools::convert( pdb.getBeta()[j], num );
+      rmsd_line += "," + num;
+    }
     readInputLine( rmsd_line + " TYPE=" + type );
   }
-  std::string argstr = getShortcutLabel() + "_rmsd1"; for(unsigned i=1; i<nblocks; ++i) { std::string bnum; Tools::convert( i+1, bnum); argstr += "," + getShortcutLabel() + "_rmsd" + bnum; }
-  bool squared; parseFlag("SQUARED",squared);
+  std::string argstr = getShortcutLabel() + "_rmsd1";
+  for(unsigned i=1; i<nblocks; ++i) {
+    std::string bnum;
+    Tools::convert( i+1, bnum);
+    argstr += "," + getShortcutLabel() + "_rmsd" + bnum;
+  }
+  bool squared;
+  parseFlag("SQUARED",squared);
   if( !squared ) {
     readInputLine( getShortcutLabel() + "_2: COMBINE ARG=" + argstr + " PERIODIC=NO");
     readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_2 FUNC=sqrt(x) PERIODIC=NO");
-  } else readInputLine( getShortcutLabel() + ": COMBINE ARG=" + argstr + " PERIODIC=NO");
+  } else {
+    readInputLine( getShortcutLabel() + ": COMBINE ARG=" + argstr + " PERIODIC=NO");
+  }
 }
 
 }
diff --git a/src/colvar/PCARMSD.cpp b/src/colvar/PCARMSD.cpp
index b2feb680c6..2e9719c2d8 100644
--- a/src/colvar/PCARMSD.cpp
+++ b/src/colvar/PCARMSD.cpp
@@ -113,48 +113,65 @@ void PCARMSD::registerKeywords(Keywords& keys) {
 PCARMSD::PCARMSD(const ActionOptions&ao):
   PLUMED_COLVAR_INIT(ao),
   squared(true),
-  nopbc(false)
-{
+  nopbc(false) {
   std::string f_average;
   parse("AVERAGE",f_average);
   std::string type;
   type.assign("OPTIMAL");
   std::string f_eigenvectors;
   parse("EIGENVECTORS",f_eigenvectors);
-  bool sq;  parseFlag("SQUARED_ROOT",sq);
-  if (sq) { squared=false; }
+  bool sq;
+  parseFlag("SQUARED_ROOT",sq);
+  if (sq) {
+    squared=false;
+  }
   parseFlag("NOPBC",nopbc);
   checkRead();
 
   PDB pdb;
 
   // read everything in ang and transform to nm if we are not in natural units
-  if( !pdb.read(f_average,usingNaturalUnits(),0.1/getUnits().getLength()) )
+  if( !pdb.read(f_average,usingNaturalUnits(),0.1/getUnits().getLength()) ) {
     error("missing input file " + f_average );
+  }
 
   rmsd=Tools::make_unique<RMSD>();
   bool remove_com=true;
   bool normalize_weights=true;
   // here align and displace are a simple vector of ones
-  std::vector<double> align; align=pdb.getOccupancy(); for(unsigned i=0; i<align.size(); i++) {align[i]=1.;} ;
-  std::vector<double> displace;  displace=pdb.getBeta(); for(unsigned i=0; i<displace.size(); i++) {displace[i]=1.;} ;
+  std::vector<double> align;
+  align=pdb.getOccupancy();
+  for(unsigned i=0; i<align.size(); i++) {
+    align[i]=1.;
+  } ;
+  std::vector<double> displace;
+  displace=pdb.getBeta();
+  for(unsigned i=0; i<displace.size(); i++) {
+    displace[i]=1.;
+  } ;
   // reset again to reimpose unifrom weights (safe to disable this)
   rmsd->set(align,displace,pdb.getPositions(),type,remove_com,normalize_weights);
   requestAtoms( pdb.getAtomNumbers() );
 
-  addComponentWithDerivatives("residual"); componentIsNotPeriodic("residual");
+  addComponentWithDerivatives("residual");
+  componentIsNotPeriodic("residual");
 
   log.printf("  average from file %s\n",f_average.c_str());
   log.printf("  which contains %d atoms\n",getNumberOfAtoms());
   log.printf("  with indices : ");
   for(unsigned i=0; i<pdb.getAtomNumbers().size(); ++i) {
-    if(i%25==0) log<<"\n";
+    if(i%25==0) {
+      log<<"\n";
+    }
     log.printf("%d ",pdb.getAtomNumbers()[i].serial());
   }
   log.printf("\n");
   log.printf("  method for alignment : %s \n",type.c_str() );
-  if(nopbc) log.printf("  without periodic boundary conditions\n");
-  else      log.printf("  using periodic boundary conditions\n");
+  if(nopbc) {
+    log.printf("  without periodic boundary conditions\n");
+  } else {
+    log.printf("  using periodic boundary conditions\n");
+  }
 
   log<<"  Bibliography "<<plumed.cite("Spiwok, Lipovova and Kralova, JPCB, 111, 3073 (2007)  ");
   log<<" "<<plumed.cite( "Sutto, D'Abramo, Gervasio, JCTC, 6, 3640 (2010)");
@@ -163,10 +180,11 @@ PCARMSD::PCARMSD(const ActionOptions&ao):
   neigenvects=0;
   // now get the eigenvectors
   // open the file
-  if (FILE* fp=this->fopen(f_eigenvectors.c_str(),"r"))
-  {
+  if (FILE* fp=this->fopen(f_eigenvectors.c_str(),"r")) {
 // call fclose when exiting this block
-    auto deleter=[this](FILE* f) { this->fclose(f); };
+    auto deleter=[this](FILE* f) {
+      this->fclose(f);
+    };
     std::unique_ptr<FILE,decltype(deleter)> fp_deleter(fp,deleter);
 
     std::vector<AtomNumber> aaa;
@@ -179,25 +197,42 @@ PCARMSD::PCARMSD(const ActionOptions&ao):
       do_read=mypdb.readFromFilepointer(fp,usingNaturalUnits(),0.1/getUnits().getLength());
       if(do_read) {
         neigenvects++;
-        if(mypdb.getAtomNumbers().size()==0) error("number of atoms in a frame should be more than zero");
-        if(nat==0) nat=mypdb.getAtomNumbers().size();
-        if(nat!=mypdb.getAtomNumbers().size()) error("frames should have the same number of atoms");
-        if(aaa.empty()) aaa=mypdb.getAtomNumbers();
-        if(aaa!=mypdb.getAtomNumbers()) error("frames should contain same atoms in same order");
+        if(mypdb.getAtomNumbers().size()==0) {
+          error("number of atoms in a frame should be more than zero");
+        }
+        if(nat==0) {
+          nat=mypdb.getAtomNumbers().size();
+        }
+        if(nat!=mypdb.getAtomNumbers().size()) {
+          error("frames should have the same number of atoms");
+        }
+        if(aaa.empty()) {
+          aaa=mypdb.getAtomNumbers();
+        }
+        if(aaa!=mypdb.getAtomNumbers()) {
+          error("frames should contain same atoms in same order");
+        }
         log<<"  Found eigenvector: "<<neigenvects<<" containing  "<<mypdb.getAtomNumbers().size()<<" atoms\n";
         pdbv.push_back(mypdb);
         eigenvectors.push_back(mypdb.getPositions());
-      } else {break ;}
+      } else {
+        break ;
+      }
     }
     log<<"  Found total "<<neigenvects<< " eigenvectors in the file "<<f_eigenvectors.c_str()<<" \n";
-    if(neigenvects==0) error("at least one eigenvector is expected");
+    if(neigenvects==0) {
+      error("at least one eigenvector is expected");
+    }
   }
   // the components
   for(unsigned i=0; i<neigenvects; i++) {
-    std::string num; Tools::convert( i, num );
-    std::string name; name=std::string("eig-")+num;
+    std::string num;
+    Tools::convert( i, num );
+    std::string name;
+    name=std::string("eig-")+num;
     pca_names.push_back(name);
-    addComponentWithDerivatives(name); componentIsNotPeriodic(name);
+    addComponentWithDerivatives(name);
+    componentIsNotPeriodic(name);
   }
   turnOnDerivatives();
 
@@ -205,7 +240,9 @@ PCARMSD::PCARMSD(const ActionOptions&ao):
 
 // calculator
 void PCARMSD::calculate() {
-  if(!nopbc) makeWhole();
+  if(!nopbc) {
+    makeWhole();
+  }
   Tensor rotation,invrotation;
   Matrix<std::vector<Vector> > drotdpos(3,3);
   std::vector<Vector> alignedpos;
@@ -227,9 +264,11 @@ void PCARMSD::calculate() {
 
   for(unsigned i=0; i<eigenvectors.size(); i++) {
     Value* value=getPntrToComponent(pca_names[i].c_str());
-    double val; val=0.;
+    double val;
+    val=0.;
     for(unsigned iat=0; iat<getNumberOfAtoms(); iat++) {
-      val+=dotProduct(alignedpos[iat]-centeredref[iat],eigenvectors[i][iat]);	der[iat].zero();
+      val+=dotProduct(alignedpos[iat]-centeredref[iat],eigenvectors[i][iat]);
+      der[iat].zero();
     }
     value->set(val);
     // here the loop is reversed to better suit the structure of the derivative of the rotation matrix
@@ -255,7 +294,9 @@ void PCARMSD::calculate() {
     }
   }
 
-  for(int i=0; i<getNumberOfComponents(); ++i) setBoxDerivativesNoPbc( getPntrToComponent(i) );
+  for(int i=0; i<getNumberOfComponents(); ++i) {
+    setBoxDerivativesNoPbc( getPntrToComponent(i) );
+  }
 
 }
 
diff --git a/src/colvar/PathMSD.cpp b/src/colvar/PathMSD.cpp
index eac2131987..8b7a5209db 100644
--- a/src/colvar/PathMSD.cpp
+++ b/src/colvar/PathMSD.cpp
@@ -104,22 +104,25 @@ void PathMSD::registerKeywords(Keywords& keys) {
 }
 
 PathMSD::PathMSD(const ActionOptions&ao):
-  Action(ao),PathMSDBase(ao)
-{
+  Action(ao),PathMSDBase(ao) {
   checkRead();
 
   log<<"  Bibliography "
      <<plumed.cite("Branduardi, Gervasio, Parrinello J. Chem. Phys. 126, 054103 (2007)")
      <<"\n";
   // no need to read anything
-  addComponentWithDerivatives("sss"); componentIsNotPeriodic("sss");
-  addComponentWithDerivatives("zzz"); componentIsNotPeriodic("zzz");
+  addComponentWithDerivatives("sss");
+  componentIsNotPeriodic("sss");
+  addComponentWithDerivatives("zzz");
+  componentIsNotPeriodic("zzz");
   requestAtoms(pdbv[0].getAtomNumbers());
 
   double i=1.;
   for(unsigned it=0 ; it<nframes ; ++it) {
-    std::vector<double> v; v.push_back(i);
-    indexvec.push_back(v); i+=1.;
+    std::vector<double> v;
+    v.push_back(i);
+    indexvec.push_back(v);
+    i+=1.;
   }
 }
 
diff --git a/src/colvar/PathMSDBase.cpp b/src/colvar/PathMSDBase.cpp
index a1a9b1af1d..65c99b78bd 100644
--- a/src/colvar/PathMSDBase.cpp
+++ b/src/colvar/PathMSDBase.cpp
@@ -51,8 +51,7 @@ PathMSDBase::PathMSDBase(const ActionOptions&ao):
   debugClose(0),
   logClose(0),
   computeRefClose(false),
-  nframes(0)
-{
+  nframes(0) {
   parse("LAMBDA",lambda);
   parse("NEIGH_SIZE",neigh_size);
   parse("NEIGH_STRIDE",neigh_stride);
@@ -63,10 +62,11 @@ PathMSDBase::PathMSDBase(const ActionOptions&ao):
   parseFlag("NOPBC",nopbc);
 
   // open the file
-  if (FILE* fp=this->fopen(reference.c_str(),"r"))
-  {
+  if (FILE* fp=this->fopen(reference.c_str(),"r")) {
 // call fclose when exiting this block
-    auto deleter=[this](FILE* f) { this->fclose(f); };
+    auto deleter=[this](FILE* f) {
+      this->fclose(f);
+    };
     std::unique_ptr<FILE,decltype(deleter)> fp_deleter(fp,deleter);
 
     std::vector<AtomNumber> aaa;
@@ -79,30 +79,44 @@ PathMSDBase::PathMSDBase(const ActionOptions&ao):
       do_read=mypdb.readFromFilepointer(fp,usingNaturalUnits(),0.1/getUnits().getLength());
       if(do_read) {
         nframes++;
-        if(mypdb.getAtomNumbers().size()==0) error("number of atoms in a frame should be more than zero");
-        if(nat==0) nat=mypdb.getAtomNumbers().size();
-        if(nat!=mypdb.getAtomNumbers().size()) error("frames should have the same number of atoms");
+        if(mypdb.getAtomNumbers().size()==0) {
+          error("number of atoms in a frame should be more than zero");
+        }
+        if(nat==0) {
+          nat=mypdb.getAtomNumbers().size();
+        }
+        if(nat!=mypdb.getAtomNumbers().size()) {
+          error("frames should have the same number of atoms");
+        }
         if(aaa.empty()) {
           aaa=mypdb.getAtomNumbers();
           log.printf("  found %zu atoms in input \n",aaa.size());
           log.printf("  with indices : ");
           for(unsigned i=0; i<aaa.size(); ++i) {
-            if(i%25==0) log<<"\n";
+            if(i%25==0) {
+              log<<"\n";
+            }
             log.printf("%d ",aaa[i].serial());
           }
           log.printf("\n");
         }
-        if(aaa!=mypdb.getAtomNumbers()) error("frames should contain same atoms in same order");
+        if(aaa!=mypdb.getAtomNumbers()) {
+          error("frames should contain same atoms in same order");
+        }
         log<<"Found PDB: "<<nframes<<" containing  "<<mypdb.getAtomNumbers().size()<<" atoms\n";
         pdbv.push_back(mypdb);
         derivs_s.resize(mypdb.getAtomNumbers().size());
         derivs_z.resize(mypdb.getAtomNumbers().size());
         mymsd.set(mypdb,"OPTIMAL");
         msdv.push_back(mymsd); // the vector that stores the frames
-      } else {break ;}
+      } else {
+        break ;
+      }
     }
     log<<"Found TOTAL "<<nframes<< " PDB in the file "<<reference.c_str()<<" \n";
-    if(nframes==0) error("at least one frame expected");
+    if(nframes==0) {
+      error("at least one frame expected");
+    }
     //set up rmsdRefClose, initialize it to the first structure loaded from reference file
     rmsdPosClose.set(pdbv[0], "OPTIMAL");
     firstPosClose = true;
@@ -121,19 +135,22 @@ PathMSDBase::PathMSDBase(const ActionOptions&ao):
   if (epsilonClose > 0) {
     log.printf(" Computing with the close structure, epsilon = %lf\n", epsilonClose);
     log << "  Bibliography " << plumed.cite("Pazurikova J, Krenek A, Spiwok V, Simkova M J. Chem. Phys. 146, 115101 (2017)") << "\n";
-  }
-  else {
+  } else {
     debugClose = 0;
     logClose = 0;
   }
-  if (debugClose)
+  if (debugClose) {
     log.printf(" Extensive debug info regarding close structure turned on\n");
+  }
 
   rotationRefClose.resize(nframes);
   savedIndices = std::vector<unsigned>(nframes);
 
-  if(nopbc) log.printf("  without periodic boundary conditions\n");
-  else      log.printf("  using periodic boundary conditions\n");
+  if(nopbc) {
+    log.printf("  without periodic boundary conditions\n");
+  } else {
+    log.printf("  using periodic boundary conditions\n");
+  }
 
 }
 
@@ -142,11 +159,15 @@ PathMSDBase::~PathMSDBase() {
 
 void PathMSDBase::calculate() {
 
-  if(neigh_size>0 && getExchangeStep()) error("Neighbor lists for this collective variable are not compatible with replica exchange, sorry for that!");
+  if(neigh_size>0 && getExchangeStep()) {
+    error("Neighbor lists for this collective variable are not compatible with replica exchange, sorry for that!");
+  }
 
   //log.printf("NOW CALCULATE! \n");
 
-  if(!nopbc) makeWhole();
+  if(!nopbc) {
+    makeWhole();
+  }
 
 
   // resize the list to full
@@ -175,8 +196,9 @@ void PathMSDBase::calculate() {
     //if we compute for the first time or the existing close structure is too far from current structure
     if (firstPosClose || (posclose > epsilonClose)) {
       //set the current structure as close one for a few next steps
-      if (logClose)
+      if (logClose) {
         log << "PLUMED_CLOSE: new close structure, rmsd pos close " << posclose << "\n";
+      }
       rmsdPosClose.clear();
       rmsdPosClose.setReference(getPositions());
       //as this is a new close structure, we need to save the rotation matrices fitted to the reference structures
@@ -188,11 +210,11 @@ void PathMSDBase::calculate() {
         imgVec[i].index=i;
       }
       firstPosClose = false;
-    }
-    else {
+    } else {
       //the current structure is pretty close to the close structure, so we use saved rotation matrices to decrease the complexity of rmsd comuptation
-      if (debugClose)
+      if (debugClose) {
         log << "PLUMED-CLOSE: old close structure, rmsd pos close " << posclose << "\n";
+      }
       computeRefClose = false;
     }
   }
@@ -210,16 +232,19 @@ void PathMSDBase::calculate() {
         tmp_distances[i] = msdv[imgVec[i].index].calc_Rot(getPositions(), tmp_derivs, tmp_rotationRefClose[imgVec[i].index], true);
         plumed_assert(tmp_derivs.size()==nat);
         #pragma omp simd
-        for(unsigned j=0; j<nat; j++) tmp_derivs2[i*nat+j]=tmp_derivs[j];
+        for(unsigned j=0; j<nat; j++) {
+          tmp_derivs2[i*nat+j]=tmp_derivs[j];
+        }
       }
-    }
-    else {
+    } else {
       //approximate distance with saved rotation matrices
       for(unsigned i=rank; i<imgVec.size(); i+=stride) {
         tmp_distances[i] = msdv[imgVec[i].index].calculateWithCloseStructure(getPositions(), tmp_derivs, rotationPosClose, rotationRefClose[imgVec[i].index], drotationPosCloseDrr01, true);
         plumed_assert(tmp_derivs.size()==nat);
         #pragma omp simd
-        for(unsigned j=0; j<nat; j++) tmp_derivs2[i*nat+j]=tmp_derivs[j];
+        for(unsigned j=0; j<nat; j++) {
+          tmp_derivs2[i*nat+j]=tmp_derivs[j];
+        }
         if (debugClose) {
           double withclose = tmp_distances[i];
           RMSD opt;
@@ -233,14 +258,15 @@ void PathMSDBase::calculate() {
         }
       }
     }
-  }
-  else {
+  } else {
     // store temporary local results
     for(unsigned i=rank; i<imgVec.size(); i+=stride) {
       tmp_distances[i]=msdv[imgVec[i].index].calculate(getPositions(),tmp_derivs,true);
       plumed_assert(tmp_derivs.size()==nat);
       #pragma omp simd
-      for(unsigned j=0; j<nat; j++) tmp_derivs2[i*nat+j]=tmp_derivs[j];
+      for(unsigned j=0; j<nat; j++) {
+        tmp_derivs2[i*nat+j]=tmp_derivs[j];
+      }
     }
   }
 
@@ -263,16 +289,23 @@ void PathMSDBase::calculate() {
 
   std::vector<Value*> val_s_path;
   if(labels.size()>0) {
-    for(unsigned i=0; i<labels.size(); i++) { val_s_path.push_back(getPntrToComponent(labels[i].c_str()));}
+    for(unsigned i=0; i<labels.size(); i++) {
+      val_s_path.push_back(getPntrToComponent(labels[i].c_str()));
+    }
   } else {
     val_s_path.push_back(getPntrToComponent("sss"));
   }
   Value* val_z_path=getPntrToComponent("zzz");
 
-  std::vector<double> s_path(val_s_path.size()); for(unsigned i=0; i<s_path.size(); i++)s_path[i]=0.;
+  std::vector<double> s_path(val_s_path.size());
+  for(unsigned i=0; i<s_path.size(); i++) {
+    s_path[i]=0.;
+  }
   double min_distance=1e10;
   for(auto & it : imgVec) {
-    if(it.distance < min_distance) min_distance=it.distance;
+    if(it.distance < min_distance) {
+      min_distance=it.distance;
+    }
   }
 
   double partition=0.;
@@ -283,7 +316,10 @@ void PathMSDBase::calculate() {
     }
     partition+=it.similarity;
   }
-  for(unsigned i=0; i<s_path.size(); i++) { s_path[i]/=partition;  val_s_path[i]->set(s_path[i]) ;}
+  for(unsigned i=0; i<s_path.size(); i++) {
+    s_path[i]/=partition;
+    val_s_path[i]->set(s_path[i]) ;
+  }
   val_z_path->set(-(1./lambda)*std::log(partition) + min_distance);
 
   // clean vector
@@ -297,18 +333,26 @@ void PathMSDBase::calculate() {
       double expval=it.similarity;
       tmp=lambda*expval*(s_path[j]-it.property[j])/partition;
       #pragma omp simd
-      for(unsigned i=0; i< derivs_s.size(); i++) { derivs_s[i]+=tmp*it.distder[i] ;}
+      for(unsigned i=0; i< derivs_s.size(); i++) {
+        derivs_s[i]+=tmp*it.distder[i] ;
+      }
       if(j==0) {
         #pragma omp simd
-        for(unsigned i=0; i< derivs_z.size(); i++) { derivs_z[i]+=it.distder[i]*expval/partition;}
+        for(unsigned i=0; i< derivs_z.size(); i++) {
+          derivs_z[i]+=it.distder[i]*expval/partition;
+        }
       }
     }
     for(unsigned i=0; i< derivs_s.size(); i++) {
       setAtomsDerivatives (val_s_path[j],i,derivs_s[i]);
-      if(j==0) {setAtomsDerivatives (val_z_path,i,derivs_z[i]);}
+      if(j==0) {
+        setAtomsDerivatives (val_z_path,i,derivs_z[i]);
+      }
     }
   }
-  for(unsigned i=0; i<val_s_path.size(); ++i) setBoxDerivativesNoPbc(val_s_path[i]);
+  for(unsigned i=0; i<val_s_path.size(); ++i) {
+    setBoxDerivativesNoPbc(val_s_path[i]);
+  }
   setBoxDerivativesNoPbc(val_z_path);
   //
   //  here set next round neighbors
diff --git a/src/colvar/Plane.cpp b/src/colvar/Plane.cpp
index 9d57a1832d..b63326ae98 100644
--- a/src/colvar/Plane.cpp
+++ b/src/colvar/Plane.cpp
@@ -84,7 +84,8 @@ typedef MultiColvarTemplate<Plane> PlaneMulti;
 PLUMED_REGISTER_ACTION(PlaneMulti,"PLANE_VECTOR")
 
 void Plane::registerKeywords( Keywords& keys ) {
-  Colvar::registerKeywords( keys ); keys.setDisplayName("PLANE");
+  Colvar::registerKeywords( keys );
+  keys.setDisplayName("PLANE");
   keys.add("atoms","ATOMS","the three or four atoms whose plane we are computing");
   keys.addOutputComponent("x","default","the x-component of the vector that is normal to the plane containing the atoms");
   keys.addOutputComponent("y","default","the y-component of the vector that is normal to the plane containing the atoms");
@@ -101,13 +102,18 @@ void Plane::parseAtomList( const int& num, std::vector<AtomNumber>& atoms, Actio
     atoms[2]=atoms[1];
   } else if(atoms.size()==4) {
     aa->log.printf("  containing lines %d-%d and %d-%d\n",atoms[0].serial(),atoms[1].serial(),atoms[2].serial(),atoms[3].serial());
-  } else if( num<0 || atoms.size()>0 ) aa->error("Number of specified atoms should be either 3 or 4");
+  } else if( num<0 || atoms.size()>0 ) {
+    aa->error("Number of specified atoms should be either 3 or 4");
+  }
 }
 
 unsigned Plane::getModeAndSetupValues( ActionWithValue* av ) {
-  av->addComponentWithDerivatives("x"); av->componentIsNotPeriodic("x");
-  av->addComponentWithDerivatives("y"); av->componentIsNotPeriodic("y");
-  av->addComponentWithDerivatives("z"); av->componentIsNotPeriodic("z");
+  av->addComponentWithDerivatives("x");
+  av->componentIsNotPeriodic("x");
+  av->addComponentWithDerivatives("y");
+  av->componentIsNotPeriodic("y");
+  av->addComponentWithDerivatives("z");
+  av->componentIsNotPeriodic("z");
   return 0;
 }
 
@@ -116,16 +122,21 @@ Plane::Plane(const ActionOptions&ao):
   pbc(true),
   value(3),
   derivs(3),
-  virial(3)
-{
-  for(unsigned i=0; i<3; ++i) derivs[i].resize(4);
-  std::vector<AtomNumber> atoms; parseAtomList(-1,atoms,this);
+  virial(3) {
+  for(unsigned i=0; i<3; ++i) {
+    derivs[i].resize(4);
+  }
+  std::vector<AtomNumber> atoms;
+  parseAtomList(-1,atoms,this);
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
 
-  if(pbc) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
 
   unsigned mode = getModeAndSetupValues( this );
   requestAtoms(atoms);
@@ -134,10 +145,14 @@ Plane::Plane(const ActionOptions&ao):
 
 void Plane::calculate() {
 
-  if(pbc) makeWhole();
+  if(pbc) {
+    makeWhole();
+  }
   calculateCV( 0, masses, charges, getPositions(), value, derivs, virial, this );
   setValue( value[0] );
-  for(unsigned i=0; i<derivs[0].size(); ++i) setAtomsDerivatives( i, derivs[0][i] );
+  for(unsigned i=0; i<derivs[0].size(); ++i) {
+    setAtomsDerivatives( i, derivs[0][i] );
+  }
   setBoxDerivatives( virial[0] );
 }
 
diff --git a/src/colvar/Position.cpp b/src/colvar/Position.cpp
index 20bdc8f234..355aa74b45 100644
--- a/src/colvar/Position.cpp
+++ b/src/colvar/Position.cpp
@@ -115,7 +115,8 @@ typedef MultiColvarTemplate<Position> PositionMulti;
 PLUMED_REGISTER_ACTION(PositionMulti,"POSITION_VECTOR")
 
 void Position::registerKeywords( Keywords& keys ) {
-  Colvar::registerKeywords( keys ); keys.setDisplayName("POSITION");
+  Colvar::registerKeywords( keys );
+  keys.setDisplayName("POSITION");
   keys.add("atoms","ATOM","the atom number");
   keys.add("atoms","ATOMS","the atom numbers that you would like to use the positions of");
   keys.addFlag("WHOLEMOLECULES",false,"if this is a vector of positions do you want to make the positions into a whole before");
@@ -135,41 +136,58 @@ Position::Position(const ActionOptions&ao):
   pbc(true),
   value(3),
   derivs(3),
-  virial(3)
-{
-  for(unsigned i=0; i<3; ++i) derivs[i].resize(1);
-  std::vector<AtomNumber> atoms; parseAtomList(-1,atoms,this);
+  virial(3) {
+  for(unsigned i=0; i<3; ++i) {
+    derivs[i].resize(1);
+  }
+  std::vector<AtomNumber> atoms;
+  parseAtomList(-1,atoms,this);
   unsigned mode=getModeAndSetupValues(this);
-  if( mode==1 ) scaled_components=true;
+  if( mode==1 ) {
+    scaled_components=true;
+  }
 
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
   checkRead();
 
-  if(pbc) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
 
   requestAtoms(atoms);
 }
 
 void Position::parseAtomList( const int& num, std::vector<AtomNumber>& t, ActionAtomistic* aa ) {
   aa->parseAtomList("ATOM",num,t);
-  if( t.size()==1 ) aa->log.printf("  for atom %d\n",t[0].serial());
-  else if( num<0 || t.size()!=0 ) aa->error("Number of specified atoms should be 1");
+  if( t.size()==1 ) {
+    aa->log.printf("  for atom %d\n",t[0].serial());
+  } else if( num<0 || t.size()!=0 ) {
+    aa->error("Number of specified atoms should be 1");
+  }
 }
 
 unsigned Position::getModeAndSetupValues( ActionWithValue* av ) {
-  bool sc; av->parseFlag("SCALED_COMPONENTS",sc);
+  bool sc;
+  av->parseFlag("SCALED_COMPONENTS",sc);
   if(sc) {
-    av->addComponentWithDerivatives("a"); av->componentIsPeriodic("a","-0.5","+0.5");
-    av->addComponentWithDerivatives("b"); av->componentIsPeriodic("b","-0.5","+0.5");
-    av->addComponentWithDerivatives("c"); av->componentIsPeriodic("c","-0.5","+0.5");
+    av->addComponentWithDerivatives("a");
+    av->componentIsPeriodic("a","-0.5","+0.5");
+    av->addComponentWithDerivatives("b");
+    av->componentIsPeriodic("b","-0.5","+0.5");
+    av->addComponentWithDerivatives("c");
+    av->componentIsPeriodic("c","-0.5","+0.5");
     return 1;
   }
-  av->addComponentWithDerivatives("x"); av->componentIsNotPeriodic("x");
-  av->addComponentWithDerivatives("y"); av->componentIsNotPeriodic("y");
-  av->addComponentWithDerivatives("z"); av->componentIsNotPeriodic("z");
+  av->addComponentWithDerivatives("x");
+  av->componentIsNotPeriodic("x");
+  av->addComponentWithDerivatives("y");
+  av->componentIsNotPeriodic("y");
+  av->addComponentWithDerivatives("z");
+  av->componentIsNotPeriodic("z");
   av->log<<"  WARNING: components will not have the proper periodicity - see manual\n";
   return 0;
 }
@@ -220,14 +238,22 @@ void Position::calculateCV( const unsigned& mode, const std::vector<double>& mas
                             std::vector<Tensor>& virial, const ActionAtomistic* aa ) {
   if( mode==1 ) {
     Vector d=aa->getPbc().realToScaled(pos[0]);
-    vals[0]=Tools::pbc(d[0]); vals[1]=Tools::pbc(d[1]); vals[2]=Tools::pbc(d[2]);
+    vals[0]=Tools::pbc(d[0]);
+    vals[1]=Tools::pbc(d[1]);
+    vals[2]=Tools::pbc(d[2]);
     derivs[0][0]=matmul(aa->getPbc().getInvBox(),Vector(+1,0,0));
     derivs[1][0]=matmul(aa->getPbc().getInvBox(),Vector(0,+1,0));
     derivs[2][0]=matmul(aa->getPbc().getInvBox(),Vector(0,0,+1));
   } else {
-    for(unsigned i=0; i<3; ++i) vals[i]=pos[0][i];
-    derivs[0][0]=Vector(+1,0,0); derivs[1][0]=Vector(0,+1,0); derivs[2][0]=Vector(0,0,+1);
-    virial[0]=Tensor(pos[0],Vector(-1,0,0)); virial[1]=Tensor(pos[0],Vector(0,-1,0)); virial[2]=Tensor(pos[0],Vector(0,0,-1));
+    for(unsigned i=0; i<3; ++i) {
+      vals[i]=pos[0][i];
+    }
+    derivs[0][0]=Vector(+1,0,0);
+    derivs[1][0]=Vector(0,+1,0);
+    derivs[2][0]=Vector(0,0,+1);
+    virial[0]=Tensor(pos[0],Vector(-1,0,0));
+    virial[1]=Tensor(pos[0],Vector(0,-1,0));
+    virial[2]=Tensor(pos[0],Vector(0,0,-1));
   }
 }
 
diff --git a/src/colvar/ProjectionOnAxis.cpp b/src/colvar/ProjectionOnAxis.cpp
index a549c0ebad..6beb44201f 100644
--- a/src/colvar/ProjectionOnAxis.cpp
+++ b/src/colvar/ProjectionOnAxis.cpp
@@ -89,26 +89,34 @@ void ProjectionOnAxis::registerKeywords( Keywords& keys ) {
 
 ProjectionOnAxis::ProjectionOnAxis(const ActionOptions&ao):
   PLUMED_COLVAR_INIT(ao),
-  pbc(true)
-{
+  pbc(true) {
   std::vector<AtomNumber> axis_atoms;
   parseAtomList("AXIS_ATOMS",axis_atoms);
-  if( axis_atoms.size()!=2 ) error("There should only be two atoms specified to AXIS_ATOMS keyword");
+  if( axis_atoms.size()!=2 ) {
+    error("There should only be two atoms specified to AXIS_ATOMS keyword");
+  }
   std::vector<AtomNumber> atom;
   parseAtomList("ATOM",atom);
-  if( atom.size()!=1 ) error("There should only be one atom specified to ATOM keyword");
+  if( atom.size()!=1 ) {
+    error("There should only be one atom specified to ATOM keyword");
+  }
   log.printf("  calculating projection of vector connecting atom %d and atom %d on vector connecting atom %d and atom %d \n",
              axis_atoms[0].serial(), atom[0].serial(), axis_atoms[0].serial(), axis_atoms[1].serial() );
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
 
-  if(pbc) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  not using periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  not using periodic boundary conditions\n");
+  }
 
   // Add values to store data
-  addComponentWithDerivatives("proj"); componentIsNotPeriodic("proj");
-  addComponentWithDerivatives("ext"); componentIsNotPeriodic("ext");
+  addComponentWithDerivatives("proj");
+  componentIsNotPeriodic("proj");
+  addComponentWithDerivatives("ext");
+  componentIsNotPeriodic("ext");
   // Get all the atom positions
   axis_atoms.push_back( atom[0] );
   requestAtoms(axis_atoms);
@@ -126,8 +134,10 @@ void ProjectionOnAxis::calculate() {
     rik = delta( getPosition(2), getPosition(0) );
     rjk = delta( getPosition(2), getPosition(1) );
   }
-  Vector rij = delta( rik, rjk ); double dij = rij.modulo();
-  Vector nij = (1.0/dij)*rij; Tensor dij_a1;
+  Vector rij = delta( rik, rjk );
+  double dij = rij.modulo();
+  Vector nij = (1.0/dij)*rij;
+  Tensor dij_a1;
   // Derivative of director connecting atom1 - atom2 wrt the position of atom 1
   dij_a1(0,0) = ( -(nij[1]*nij[1]+nij[2]*nij[2])/dij );   // dx/dx
   dij_a1(0,1) = (  nij[0]*nij[1]/dij );                   // dx/dy
@@ -144,19 +154,22 @@ void ProjectionOnAxis::calculate() {
   Vector dd1 = matmul(-rik, dij_a1) - nij;
   Vector dd2 = matmul(rik, dij_a1);
   Vector dd3 = nij;
-  Value* pval=getPntrToComponent("proj"); pval->set( d );
+  Value* pval=getPntrToComponent("proj");
+  pval->set( d );
   setAtomsDerivatives( pval, 0, dd1 );
   setAtomsDerivatives( pval, 1, dd2 );
   setAtomsDerivatives( pval, 2, dd3 );
   setBoxDerivatives( pval, -Tensor( rik, dd1 ) - Tensor( rjk, dd2 ) );
   // Calculate derivatives of perpendicular distance from axis
-  double c = std::sqrt( rik.modulo2() - d*d ); double invc = (1.0/c);
+  double c = std::sqrt( rik.modulo2() - d*d );
+  double invc = (1.0/c);
   // Calculate derivatives of the other thing
   Vector der1 = invc*(rik - d*dd1);
   Vector der2 = invc*(-d*dd2);
   Vector der3 = invc*(-rik - d*dd3);
 
-  Value* cval=getPntrToComponent("ext"); cval->set( c );
+  Value* cval=getPntrToComponent("ext");
+  cval->set( c );
   setAtomsDerivatives( cval, 0, der1 );
   setAtomsDerivatives( cval, 1, der2 );
   setAtomsDerivatives( cval, 2, der3 );
diff --git a/src/colvar/PropertyMap.cpp b/src/colvar/PropertyMap.cpp
index 347ac5a856..8b10c89392 100644
--- a/src/colvar/PropertyMap.cpp
+++ b/src/colvar/PropertyMap.cpp
@@ -106,8 +106,7 @@ void PropertyMap::registerKeywords(Keywords& keys) {
 
 PropertyMap::PropertyMap(const ActionOptions&ao):
   Action(ao),
-  PathMSDBase(ao)
-{
+  PathMSDBase(ao) {
   // this is the only additional keyword needed
   parseVector("PROPERTY",labels);
   checkRead();
@@ -122,18 +121,21 @@ PropertyMap::PropertyMap(const ActionOptions&ao):
   } else {
     for(unsigned i=0; i<labels.size(); i++) {
       log<<" found custom propety to be found in the REMARK line: "<<labels[i].c_str()<<"\n";
-      addComponentWithDerivatives(labels[i]); componentIsNotPeriodic(labels[i]);
+      addComponentWithDerivatives(labels[i]);
+      componentIsNotPeriodic(labels[i]);
     }
     // add distance anyhow
-    addComponentWithDerivatives("zzz"); componentIsNotPeriodic("zzz");
+    addComponentWithDerivatives("zzz");
+    componentIsNotPeriodic("zzz");
     //reparse the REMARK field and pick the index
     for(unsigned i=0; i<pdbv.size(); i++) {
       // now look for X=1.34555 Y=5.6677
       std::vector<double> labelvals;
       for(unsigned j=0; j<labels.size(); j++) {
         std::vector<double> val(1);
-        if( pdbv[i].getArgumentValue(labels[j],val) ) {labelvals.push_back(val[0]);}
-        else {
+        if( pdbv[i].getArgumentValue(labels[j],val) ) {
+          labelvals.push_back(val[0]);
+        } else {
           const std::size_t buflen=500;
           char buf[buflen];
           std::snprintf(buf,buflen,"PROPERTY LABEL \" %s \" NOT FOUND IN REMARK FOR FRAME %u \n",labels[j].c_str(),i);
diff --git a/src/colvar/Puckering.cpp b/src/colvar/Puckering.cpp
index 08be02dc0e..6847cd19fc 100644
--- a/src/colvar/Puckering.cpp
+++ b/src/colvar/Puckering.cpp
@@ -97,36 +97,53 @@ void Puckering::registerKeywords(Keywords& keys) {
 }
 
 Puckering::Puckering(const ActionOptions&ao):
-  PLUMED_COLVAR_INIT(ao)
-{
+  PLUMED_COLVAR_INIT(ao) {
   std::vector<AtomNumber> atoms;
   parseAtomList("ATOMS",atoms);
-  if(atoms.size()!=5 && atoms.size()!=6) error("only for 5 or 6-membered rings");
+  if(atoms.size()!=5 && atoms.size()!=6) {
+    error("only for 5 or 6-membered rings");
+  }
   checkRead();
 
   if(atoms.size()==5) {
     log.printf("  between atoms %d %d %d %d %d\n",atoms[0].serial(),atoms[1].serial(),atoms[2].serial(),atoms[3].serial(),atoms[4].serial());
   } else if(atoms.size()==6) {
     log.printf("  between atoms %d %d %d %d %d %d\n",atoms[0].serial(),atoms[1].serial(),atoms[2].serial(),atoms[3].serial(),atoms[4].serial(),atoms[5].serial());
-  } else error("ATOMS should specify 5 atoms");
+  } else {
+    error("ATOMS should specify 5 atoms");
+  }
 
   if(atoms.size()==5) {
-    addComponentWithDerivatives("phs"); componentIsPeriodic("phs","-pi","pi");
-    addComponentWithDerivatives("amp"); componentIsNotPeriodic("amp");
-    addComponentWithDerivatives("Zx"); componentIsNotPeriodic("Zx");
-    addComponentWithDerivatives("Zy"); componentIsNotPeriodic("Zy");
+    addComponentWithDerivatives("phs");
+    componentIsPeriodic("phs","-pi","pi");
+    addComponentWithDerivatives("amp");
+    componentIsNotPeriodic("amp");
+    addComponentWithDerivatives("Zx");
+    componentIsNotPeriodic("Zx");
+    addComponentWithDerivatives("Zy");
+    componentIsNotPeriodic("Zy");
   } else if(atoms.size()==6) {
-    addComponentWithDerivatives("qx"); componentIsNotPeriodic("qx");
-    addComponentWithDerivatives("qy"); componentIsNotPeriodic("qy");
-    addComponentWithDerivatives("qz"); componentIsNotPeriodic("qz");
-    addComponentWithDerivatives("phi"); componentIsPeriodic("phi","0","2pi");
-    addComponentWithDerivatives("theta"); componentIsNotPeriodic("theta");
-    addComponentWithDerivatives("amplitude"); componentIsNotPeriodic("amplitude");
+    addComponentWithDerivatives("qx");
+    componentIsNotPeriodic("qx");
+    addComponentWithDerivatives("qy");
+    componentIsNotPeriodic("qy");
+    addComponentWithDerivatives("qz");
+    componentIsNotPeriodic("qz");
+    addComponentWithDerivatives("phi");
+    componentIsPeriodic("phi","0","2pi");
+    addComponentWithDerivatives("theta");
+    componentIsNotPeriodic("theta");
+    addComponentWithDerivatives("amplitude");
+    componentIsNotPeriodic("amplitude");
   }
 
   log<<"  Bibliography ";
-  if(atoms.size()==5) log<<plumed.cite("Huang, Giese, Lee, York, J. Chem. Theory Comput. 10, 1538 (2014)");
-  if(atoms.size()==6) log<<plumed.cite("Cremer and Pople, J. Am. Chem. Soc. 97, 1354 (1975)");
+  if(atoms.size()==5) {
+    log<<plumed.cite("Huang, Giese, Lee, York, J. Chem. Theory Comput. 10, 1538 (2014)");
+  }
+  if(atoms.size()==6) {
+    log<<plumed.cite("Cremer and Pople, J. Am. Chem. Soc. 97, 1354 (1975)");
+  }
   log<<"\n";
 
   requestAtoms(atoms);
@@ -135,8 +152,11 @@ Puckering::Puckering(const ActionOptions&ao):
 // calculator
 void Puckering::calculate() {
   makeWhole();
-  if(getNumberOfAtoms()==5) calculate5m();
-  else calculate6m();
+  if(getNumberOfAtoms()==5) {
+    calculate5m();
+  } else {
+    calculate6m();
+  }
 }
 
 void Puckering::calculate5m() {
@@ -177,14 +197,22 @@ void Puckering::calculate5m() {
   dZy_dR[3]=(dd2-dd3-dd1);
   dZy_dR[4]=(dd3-dd4-dd2);
 
-  for(unsigned j=0; j<5; j++) dZx_dR[j]*=(1.0/(2.0*std::cos(4.0*pi/5.0)));
-  for(unsigned j=0; j<5; j++) dZy_dR[j]*=(1.0/(2.0*std::sin(4.0*pi/5.0)));
+  for(unsigned j=0; j<5; j++) {
+    dZx_dR[j]*=(1.0/(2.0*std::cos(4.0*pi/5.0)));
+  }
+  for(unsigned j=0; j<5; j++) {
+    dZy_dR[j]*=(1.0/(2.0*std::sin(4.0*pi/5.0)));
+  }
 
   Vector dphase_dR[5];
-  for(unsigned j=0; j<5; j++) dphase_dR[j]=(1.0/(Zx*Zx+Zy*Zy))*(-Zy*dZx_dR[j] + Zx*dZy_dR[j]);
+  for(unsigned j=0; j<5; j++) {
+    dphase_dR[j]=(1.0/(Zx*Zx+Zy*Zy))*(-Zy*dZx_dR[j] + Zx*dZy_dR[j]);
+  }
 
   Vector damplitude_dR[5];
-  for(unsigned j=0; j<5; j++) damplitude_dR[j]=(1.0/amplitude)*(Zx*dZx_dR[j] + Zy*dZy_dR[j]);
+  for(unsigned j=0; j<5; j++) {
+    damplitude_dR[j]=(1.0/amplitude)*(Zx*dZx_dR[j] + Zy*dZy_dR[j]);
+  }
 
   Value* vzx=getPntrToComponent("Zx");
   vzx->set(Zx);
@@ -229,16 +257,26 @@ void Puckering::calculate5m() {
 void Puckering::calculate6m() {
 
   std::vector<Vector> r(6);
-  for(unsigned i=0; i<6; i++) r[i]=getPosition(i);
+  for(unsigned i=0; i<6; i++) {
+    r[i]=getPosition(i);
+  }
 
   std::vector<Vector> R(6);
   Vector center;
-  for(unsigned j=0; j<6; j++) center+=r[j]/6.0;
-  for(unsigned j=0; j<6; j++) R[j]=(r[j]-center);
+  for(unsigned j=0; j<6; j++) {
+    center+=r[j]/6.0;
+  }
+  for(unsigned j=0; j<6; j++) {
+    R[j]=(r[j]-center);
+  }
 
   Vector Rp,Rpp;
-  for(unsigned j=0; j<6; j++) Rp +=R[j]*std::sin(2.0/6.0*pi*j);
-  for(unsigned j=0; j<6; j++) Rpp+=R[j]*std::cos(2.0/6.0*pi*j);
+  for(unsigned j=0; j<6; j++) {
+    Rp +=R[j]*std::sin(2.0/6.0*pi*j);
+  }
+  for(unsigned j=0; j<6; j++) {
+    Rpp+=R[j]*std::cos(2.0/6.0*pi*j);
+  }
 
   Vector n=crossProduct(Rp,Rpp);
   Vector nhat=n/modulo(n);
@@ -251,50 +289,78 @@ void Puckering::calculate6m() {
   Tensor dnhat_dRpp=matmul(dnhat_dn,dn_dRpp);
 
   std::vector<double> z(6);
-  for(unsigned j=0; j<6; j++) z[j]=dotProduct(R[j],nhat);
+  for(unsigned j=0; j<6; j++) {
+    z[j]=dotProduct(R[j],nhat);
+  }
 
   std::vector<std::vector<Vector> > dz_dR(6);
-  for(unsigned j=0; j<6; j++) dz_dR[j].resize(6);
+  for(unsigned j=0; j<6; j++) {
+    dz_dR[j].resize(6);
+  }
 
-  for(unsigned i=0; i<6; i++) for(unsigned j=0; j<6; j++) {
-      if(i==j) dz_dR[i][j]+=nhat;
+  for(unsigned i=0; i<6; i++)
+    for(unsigned j=0; j<6; j++) {
+      if(i==j) {
+        dz_dR[i][j]+=nhat;
+      }
       dz_dR[i][j]+=matmul(R[i],dnhat_dRp)*std::sin(2.0/6.0*pi*j);
       dz_dR[i][j]+=matmul(R[i],dnhat_dRpp)*std::cos(2.0/6.0*pi*j);
     }
 
   double B=0.0;
-  for(unsigned j=0; j<6; j++) B+=z[j]*std::cos(4.0/6.0*pi*j);
+  for(unsigned j=0; j<6; j++) {
+    B+=z[j]*std::cos(4.0/6.0*pi*j);
+  }
 
   std::vector<Vector> dB_dR(6);
-  for(unsigned i=0; i<6; i++) for(unsigned j=0; j<6; j++) {
+  for(unsigned i=0; i<6; i++)
+    for(unsigned j=0; j<6; j++) {
       dB_dR[i]+=dz_dR[j][i]*std::cos(4.0/6.0*pi*j);
     }
   Vector Bsum;
-  for(unsigned j=0; j<6; j++) Bsum+=dB_dR[j];
-  for(unsigned j=0; j<6; j++) dB_dR[j]-=Bsum/6.0;;
+  for(unsigned j=0; j<6; j++) {
+    Bsum+=dB_dR[j];
+  }
+  for(unsigned j=0; j<6; j++) {
+    dB_dR[j]-=Bsum/6.0;
+  };
 
   double A=0.0;
-  for(unsigned j=0; j<6; j++) A+=z[j]*std::sin(4.0/6.0*pi*j);
+  for(unsigned j=0; j<6; j++) {
+    A+=z[j]*std::sin(4.0/6.0*pi*j);
+  }
 
   std::vector<Vector> dA_dR(6);
-  for(unsigned i=0; i<6; i++) for(unsigned j=0; j<6; j++) {
+  for(unsigned i=0; i<6; i++)
+    for(unsigned j=0; j<6; j++) {
       dA_dR[i]+=dz_dR[j][i]*std::sin(4.0/6.0*pi*j);
     }
   Vector Asum;
-  for(unsigned j=0; j<6; j++) Asum+=dA_dR[j];
-  for(unsigned j=0; j<6; j++) dA_dR[j]-=Asum/6.0;;
+  for(unsigned j=0; j<6; j++) {
+    Asum+=dA_dR[j];
+  }
+  for(unsigned j=0; j<6; j++) {
+    dA_dR[j]-=Asum/6.0;
+  };
 
   double C=0.0;
-  for(unsigned j=0; j<6; j++) C+=z[j]*Tools::fastpow(-1.0,(j));
+  for(unsigned j=0; j<6; j++) {
+    C+=z[j]*Tools::fastpow(-1.0,(j));
+  }
 
   std::vector<Vector> dC_dR(6);
-  for(unsigned i=0; i<6; i++) for(unsigned j=0; j<6; j++) {
+  for(unsigned i=0; i<6; i++)
+    for(unsigned j=0; j<6; j++) {
       dC_dR[i]+=dz_dR[j][i]*Tools::fastpow(-1.0,(j));
     }
 
   Vector Csum;
-  for(unsigned j=0; j<6; j++) Csum+=dC_dR[j];
-  for(unsigned j=0; j<6; j++) dC_dR[j]-=Csum/6.0;;
+  for(unsigned j=0; j<6; j++) {
+    Csum+=dC_dR[j];
+  }
+  for(unsigned j=0; j<6; j++) {
+    dC_dR[j]-=Csum/6.0;
+  };
 
 
 // qx
diff --git a/src/colvar/RMSD.cpp b/src/colvar/RMSD.cpp
index 55ad012ebc..99716a5e1b 100644
--- a/src/colvar/RMSD.cpp
+++ b/src/colvar/RMSD.cpp
@@ -167,7 +167,8 @@ END
 PLUMED_REGISTER_ACTION(RMSD,"RMSD_SCALAR")
 
 void RMSD::registerKeywords(Keywords& keys) {
-  Colvar::registerKeywords(keys); keys.setDisplayName("RMSD");
+  Colvar::registerKeywords(keys);
+  keys.setDisplayName("RMSD");
   keys.add("compulsory","REFERENCE","a file in pdb format containing the reference structure and the atoms involved in the CV.");
   keys.add("compulsory","TYPE","SIMPLE","the manner in which RMSD alignment is performed.  Should be OPTIMAL or SIMPLE.");
   keys.addFlag("SQUARED",false," This should be set if you want mean squared displacement instead of RMSD ");
@@ -177,8 +178,7 @@ void RMSD::registerKeywords(Keywords& keys) {
 RMSD::RMSD(const ActionOptions&ao):
   PLUMED_COLVAR_INIT(ao),
   squared(false),
-  nopbc(false)
-{
+  nopbc(false) {
   std::string reference;
   parse("REFERENCE",reference);
   std::string type;
@@ -188,39 +188,53 @@ RMSD::RMSD(const ActionOptions&ao):
   parseFlag("NOPBC",nopbc);
   checkRead();
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
   PDB pdb;
 
   // read everything in ang and transform to nm if we are not in natural units
-  if( !pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength()) )
+  if( !pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength()) ) {
     error("missing input file " + reference );
+  }
   myrmsd.set( pdb, type, true, true );
 
   std::vector<AtomNumber> atoms( pdb.getAtomNumbers() );
-  requestAtoms( atoms ); der.resize( atoms.size() );
+  requestAtoms( atoms );
+  der.resize( atoms.size() );
 
   log.printf("  reference from file %s\n",reference.c_str());
   log.printf("  which contains %d atoms\n",getNumberOfAtoms());
   log.printf("  with indices : ");
   for(unsigned i=0; i<atoms.size(); ++i) {
-    if(i%25==0) log<<"\n";
+    if(i%25==0) {
+      log<<"\n";
+    }
     log.printf("%d ",atoms[i].serial());
   }
   log.printf("\n");
   log.printf("  method for alignment : %s \n",type.c_str() );
-  if(squared)log.printf("  chosen to use SQUARED option for MSD instead of RMSD\n");
-  if(nopbc) log.printf("  without periodic boundary conditions\n");
-  else      log.printf("  using periodic boundary conditions\n");
+  if(squared) {
+    log.printf("  chosen to use SQUARED option for MSD instead of RMSD\n");
+  }
+  if(nopbc) {
+    log.printf("  without periodic boundary conditions\n");
+  } else {
+    log.printf("  using periodic boundary conditions\n");
+  }
 }
 
 
 // calculator
 void RMSD::calculate() {
-  if(!nopbc) makeWhole();
+  if(!nopbc) {
+    makeWhole();
+  }
   double r=myrmsd.calculate( getPositions(), der, squared );
 
   setValue(r);
-  for(unsigned i=0; i<getNumberOfAtoms(); i++) setAtomsDerivatives( i, der[i] );
+  for(unsigned i=0; i<getNumberOfAtoms(); i++) {
+    setAtomsDerivatives( i, der[i] );
+  }
   setBoxDerivativesNoPbc();
 }
 
diff --git a/src/colvar/RMSDShortcut.cpp b/src/colvar/RMSDShortcut.cpp
index c068127b44..62c5ef6d19 100644
--- a/src/colvar/RMSDShortcut.cpp
+++ b/src/colvar/RMSDShortcut.cpp
@@ -46,61 +46,113 @@ void RMSDShortcut::registerKeywords(Keywords& keys) {
   keys.addFlag("DISPLACEMENT",false,"Calculate the vector of displacements instead of the length of this vector");
   keys.add("compulsory","NUMBER","0","if there are multiple structures in the pdb file you can specify that you want the RMSD from a specific structure by specifying its place in the file here. If NUMBER=0 then the RMSD from all structures are computed");
   keys.setValueDescription("the RMSD distance between the instaneous structure and the reference structure/s that were input");
-  keys.addActionNameSuffix("_SCALAR"); keys.addActionNameSuffix("_VECTOR");
-  keys.needsAction("PDB2CONSTANT"); keys.needsAction("WHOLEMOLECULES");
-  keys.needsAction("POSITION"); keys.needsAction("CONCATENATE");
+  keys.addActionNameSuffix("_SCALAR");
+  keys.addActionNameSuffix("_VECTOR");
+  keys.needsAction("PDB2CONSTANT");
+  keys.needsAction("WHOLEMOLECULES");
+  keys.needsAction("POSITION");
+  keys.needsAction("CONCATENATE");
 }
 
 RMSDShortcut::RMSDShortcut(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  bool disp; parseFlag("DISPLACEMENT",disp);
-  std::string reference; parse("REFERENCE",reference);
+  ActionShortcut(ao) {
+  bool disp;
+  parseFlag("DISPLACEMENT",disp);
+  std::string reference;
+  parse("REFERENCE",reference);
   // Read the reference pdb file
-  PDB pdb; if( !pdb.read(reference,plumed.usingNaturalUnits(),0.1/plumed.getUnits().getLength()) ) plumed_merror("missing file " + reference );
-  unsigned frame; parse("NUMBER",frame); unsigned nf=1;
+  PDB pdb;
+  if( !pdb.read(reference,plumed.usingNaturalUnits(),0.1/plumed.getUnits().getLength()) ) {
+    plumed_merror("missing file " + reference );
+  }
+  unsigned frame;
+  parse("NUMBER",frame);
+  unsigned nf=1;
   if( frame==0 ) {
-    FILE* fp=std::fopen(reference.c_str(),"r"); bool do_read=true; nf=0;
+    FILE* fp=std::fopen(reference.c_str(),"r");
+    bool do_read=true;
+    nf=0;
     while ( do_read ) {
-      PDB mypdb; do_read=mypdb.readFromFilepointer(fp,plumed.usingNaturalUnits(),0.1/plumed.getUnits().getLength());
-      if( !do_read && nf>0 ) break ;
+      PDB mypdb;
+      do_read=mypdb.readFromFilepointer(fp,plumed.usingNaturalUnits(),0.1/plumed.getUnits().getLength());
+      if( !do_read && nf>0 ) {
+        break ;
+      }
       nf++;
     }
   }
-  bool nopbc; parseFlag("NOPBC",nopbc);
+  bool nopbc;
+  parseFlag("NOPBC",nopbc);
   // Now create the RMSD object
   std::string rmsd_line = getShortcutLabel() + ": ";
   if( nf==1 && !disp ) {
-    rmsd_line += "RMSD_SCALAR REFERENCE=" + reference; if(nopbc) rmsd_line += " NOPBC";
+    rmsd_line += "RMSD_SCALAR REFERENCE=" + reference;
+    if(nopbc) {
+      rmsd_line += " NOPBC";
+    }
   } else {
-    std::string ffnum; Tools::convert( frame, ffnum );
+    std::string ffnum;
+    Tools::convert( frame, ffnum );
     readInputLine( getShortcutLabel() + "_ref: PDB2CONSTANT REFERENCE=" + reference + " NUMBER=" + ffnum );
     std::vector<AtomNumber> anum( pdb.getAtomNumbers() );
     if( !nopbc ) {
-      std::string num; Tools::convert( anum[0].serial(), num ); std::string wm_line = "WHOLEMOLECULES ENTITY0=" + num;
-      for(unsigned i=1; i<anum.size(); ++i) { Tools::convert( anum[i].serial(), num ); wm_line += "," + num; }
+      std::string num;
+      Tools::convert( anum[0].serial(), num );
+      std::string wm_line = "WHOLEMOLECULES ENTITY0=" + num;
+      for(unsigned i=1; i<anum.size(); ++i) {
+        Tools::convert( anum[i].serial(), num );
+        wm_line += "," + num;
+      }
       readInputLine( wm_line );
     }
-    std::string num; Tools::convert( anum[0].serial(), num ); std::string pos_line = getShortcutLabel() + "_cpos: POSITION NOPBC ATOMS=" + num;
-    for(unsigned i=1; i<anum.size(); ++i) { Tools::convert( anum[i].serial(), num ); pos_line += "," + num; }
+    std::string num;
+    Tools::convert( anum[0].serial(), num );
+    std::string pos_line = getShortcutLabel() + "_cpos: POSITION NOPBC ATOMS=" + num;
+    for(unsigned i=1; i<anum.size(); ++i) {
+      Tools::convert( anum[i].serial(), num );
+      pos_line += "," + num;
+    }
     readInputLine( pos_line );
     // Concatenate the three positions together
     readInputLine( getShortcutLabel() + "_pos: CONCATENATE ARG=" + getShortcutLabel() + "_cpos.x," + getShortcutLabel() + "_cpos.y," + getShortcutLabel() + "_cpos.z");
     rmsd_line += "RMSD_VECTOR ARG=" + getShortcutLabel() + "_pos," + getShortcutLabel() + "_ref";
-    if( disp ) rmsd_line += " DISPLACEMENT";
+    if( disp ) {
+      rmsd_line += " DISPLACEMENT";
+    }
     // Now align
-    std::vector<double> align( pdb.getOccupancy() ); Tools::convert( align[0], num ); rmsd_line += " ALIGN=" + num;
-    for(unsigned i=1; i<align.size(); ++i) { Tools::convert( align[i], num ); rmsd_line += "," + num; }
+    std::vector<double> align( pdb.getOccupancy() );
+    Tools::convert( align[0], num );
+    rmsd_line += " ALIGN=" + num;
+    for(unsigned i=1; i<align.size(); ++i) {
+      Tools::convert( align[i], num );
+      rmsd_line += "," + num;
+    }
     // And displace
-    std::vector<double> displace( pdb.getBeta() ); Tools::convert( displace[0], num ); rmsd_line += " DISPLACE=" + num;
-    for(unsigned i=1; i<displace.size(); ++i) { Tools::convert( displace[i], num ); rmsd_line += "," + num; }
+    std::vector<double> displace( pdb.getBeta() );
+    Tools::convert( displace[0], num );
+    rmsd_line += " DISPLACE=" + num;
+    for(unsigned i=1; i<displace.size(); ++i) {
+      Tools::convert( displace[i], num );
+      rmsd_line += "," + num;
+    }
   }
   // And create the RMSD object
-  bool numder; parseFlag("NUMERICAL_DERIVATIVES",numder);
-  if(numder && nf==1 && !disp ) rmsd_line += " NUMERICAL_DERIVATIVES"; else if( numder ) error("can only use NUMERICAL_DERIVATIVES flag when RMSD is calculating a single scalar value");
-  bool squared; parseFlag("SQUARED",squared); if(squared) rmsd_line += " SQUARED";
-  std::string tt; parse("TYPE",tt); readInputLine( rmsd_line + " TYPE=" + tt );
+  bool numder;
+  parseFlag("NUMERICAL_DERIVATIVES",numder);
+  if(numder && nf==1 && !disp ) {
+    rmsd_line += " NUMERICAL_DERIVATIVES";
+  } else if( numder ) {
+    error("can only use NUMERICAL_DERIVATIVES flag when RMSD is calculating a single scalar value");
+  }
+  bool squared;
+  parseFlag("SQUARED",squared);
+  if(squared) {
+    rmsd_line += " SQUARED";
+  }
+  std::string tt;
+  parse("TYPE",tt);
+  readInputLine( rmsd_line + " TYPE=" + tt );
 }
 
 }
diff --git a/src/colvar/RMSDVector.cpp b/src/colvar/RMSDVector.cpp
index b183dd5e1e..2b2e7e918e 100644
--- a/src/colvar/RMSDVector.cpp
+++ b/src/colvar/RMSDVector.cpp
@@ -40,7 +40,9 @@ namespace colvar {
 PLUMED_REGISTER_ACTION(RMSDVector,"RMSD_VECTOR")
 
 void RMSDVector::registerKeywords(Keywords& keys) {
-  ActionWithVector::registerKeywords(keys); keys.use("ARG"); keys.setDisplayName("RMSD");
+  ActionWithVector::registerKeywords(keys);
+  keys.use("ARG");
+  keys.setDisplayName("RMSD");
   keys.add("compulsory","TYPE","SIMPLE","the manner in which RMSD alignment is performed.  Should be OPTIMAL or SIMPLE.");
   keys.add("compulsory","ALIGN","1.0","the weights to use when aligning to the reference structure");
   keys.add("compulsory","DISPLACE","1.0","the weights to use when calculating the displacement from the reference structure");
@@ -55,69 +57,119 @@ void RMSDVector::registerKeywords(Keywords& keys) {
 RMSDVector::RMSDVector(const ActionOptions&ao):
   Action(ao),
   ActionWithVector(ao),
-  firststep(true)
-{
-  if( getPntrToArgument(0)->getRank()!=1 ) error("first argument should be vector");
-  if( getPntrToArgument(1)->getRank()<1 ) error("second argument should be matrix or a vector");
+  firststep(true) {
+  if( getPntrToArgument(0)->getRank()!=1 ) {
+    error("first argument should be vector");
+  }
+  if( getPntrToArgument(1)->getRank()<1 ) {
+    error("second argument should be matrix or a vector");
+  }
   if( getPntrToArgument(1)->getRank()==1 ) {
-    if( getPntrToArgument(0)->getNumberOfValues()!=getPntrToArgument(1)->getNumberOfValues() ) error("mismatch between sizes of input vectors");
+    if( getPntrToArgument(0)->getNumberOfValues()!=getPntrToArgument(1)->getNumberOfValues() ) {
+      error("mismatch between sizes of input vectors");
+    }
   } else if( getPntrToArgument(1)->getRank()==2 ) {
-    if( getPntrToArgument(0)->getNumberOfValues()!=getPntrToArgument(1)->getShape()[1] ) error("mismatch between sizes of input vectors");
+    if( getPntrToArgument(0)->getNumberOfValues()!=getPntrToArgument(1)->getShape()[1] ) {
+      error("mismatch between sizes of input vectors");
+    }
+  }
+  if( getPntrToArgument(0)->getNumberOfValues()%3!=0 ) {
+    error("number of components in input arguments should be multiple of three");
   }
-  if( getPntrToArgument(0)->getNumberOfValues()%3!=0 ) error("number of components in input arguments should be multiple of three");
 
   unsigned natoms = getPntrToArgument(0)->getNumberOfValues() / 3;
-  type.assign("SIMPLE"); parse("TYPE",type); parseFlag("SQUARED",squared);
-  align.resize( natoms ); parseVector("ALIGN",align);
-  displace.resize( natoms ); parseVector("DISPLACE",displace);
-  bool unorm=false; parseFlag("UNORMALIZED",unorm); norm_weights=!unorm;
-  double wa=0, wd=0; sqrtdisplace.resize( displace.size() );
-  for(unsigned i=0; i<align.size(); ++i) { wa+=align[i]; wd+=displace[i]; }
+  type.assign("SIMPLE");
+  parse("TYPE",type);
+  parseFlag("SQUARED",squared);
+  align.resize( natoms );
+  parseVector("ALIGN",align);
+  displace.resize( natoms );
+  parseVector("DISPLACE",displace);
+  bool unorm=false;
+  parseFlag("UNORMALIZED",unorm);
+  norm_weights=!unorm;
+  double wa=0, wd=0;
+  sqrtdisplace.resize( displace.size() );
+  for(unsigned i=0; i<align.size(); ++i) {
+    wa+=align[i];
+    wd+=displace[i];
+  }
 
   if( wa>epsilon ) {
     double iwa = 1. / wa;
-    for(unsigned i=0; i<align.size(); ++i) align[i] *= iwa;
+    for(unsigned i=0; i<align.size(); ++i) {
+      align[i] *= iwa;
+    }
   } else {
     double iwa = 1. / natoms;
-    for(unsigned i=0; i<align.size(); ++i) align[i] = iwa;
+    for(unsigned i=0; i<align.size(); ++i) {
+      align[i] = iwa;
+    }
   }
   if( wd>epsilon ) {
-    if( !norm_weights ) { wd = 1; } double iwd = 1. / wd;
-    for(unsigned i=0; i<align.size(); ++i) displace[i] *= iwd;
+    if( !norm_weights ) {
+      wd = 1;
+    }
+    double iwd = 1. / wd;
+    for(unsigned i=0; i<align.size(); ++i) {
+      displace[i] *= iwd;
+    }
   } else {
     double iwd = 1. / natoms;
-    for(unsigned i=0; i<align.size(); ++i) displace[i] = iwd;
+    for(unsigned i=0; i<align.size(); ++i) {
+      displace[i] = iwd;
+    }
+  }
+  for(unsigned i=0; i<align.size(); ++i) {
+    sqrtdisplace[i] = sqrt(displace[i]);
   }
-  for(unsigned i=0; i<align.size(); ++i) sqrtdisplace[i] = sqrt(displace[i]);
 
   parseFlag("DISPLACEMENT",displacement);
   if( displacement && (getPntrToArgument(1)->getRank()==1 || getPntrToArgument(1)->getShape()[0]<=1) ) {
-    addComponentWithDerivatives("dist"); componentIsNotPeriodic("dist");
+    addComponentWithDerivatives("dist");
+    componentIsNotPeriodic("dist");
     std::vector<unsigned> shape( 1, getPntrToArgument(0)->getNumberOfValues() );
-    addComponent( "disp", shape ); getPntrToComponent(1)->buildDataStore(); componentIsNotPeriodic("disp");
+    addComponent( "disp", shape );
+    getPntrToComponent(1)->buildDataStore();
+    componentIsNotPeriodic("disp");
   } else if( displacement ) {
     std::vector<unsigned> shape( 1, getPntrToArgument(1)->getShape()[0] );
-    addComponent( "dist", shape ); getPntrToComponent(0)->buildDataStore();
+    addComponent( "dist", shape );
+    getPntrToComponent(0)->buildDataStore();
     componentIsNotPeriodic("dist");
-    shape.resize(2); shape[0] = getPntrToArgument(1)->getShape()[0]; shape[1] = getPntrToArgument(0)->getNumberOfValues();
-    addComponent( "disp", shape ); getPntrToComponent(1)->buildDataStore(); getPntrToComponent(1)->reshapeMatrixStore( shape[1] );
+    shape.resize(2);
+    shape[0] = getPntrToArgument(1)->getShape()[0];
+    shape[1] = getPntrToArgument(0)->getNumberOfValues();
+    addComponent( "disp", shape );
+    getPntrToComponent(1)->buildDataStore();
+    getPntrToComponent(1)->reshapeMatrixStore( shape[1] );
     componentIsNotPeriodic("disp");
   } else if( (getPntrToArgument(1)->getRank()==1 || getPntrToArgument(1)->getShape()[0]==1) ) {
-    addValue(); setNotPeriodic();
+    addValue();
+    setNotPeriodic();
   } else {
     std::vector<unsigned> shape( 1, getPntrToArgument(1)->getShape()[0] );
-    addValue( shape ); setNotPeriodic();
+    addValue( shape );
+    setNotPeriodic();
+  }
+  if( getPntrToArgument(1)->getRank()==1 || getPntrToArgument(1)->getNumberOfValues()==0 ) {
+    myrmsd.resize(1);
+  } else {
+    myrmsd.resize( getPntrToArgument(1)->getShape()[0] );
   }
-  if( getPntrToArgument(1)->getRank()==1 || getPntrToArgument(1)->getNumberOfValues()==0 ) myrmsd.resize(1);
-  else myrmsd.resize( getPntrToArgument(1)->getShape()[0] );
 
-  if( getPntrToArgument(1)->getRank()==1 ) log.printf("  calculating RMSD distance between %d atoms. Distance between the avectors of atoms in %s and %s\n",
-        natoms, getPntrToArgument(0)->getName().c_str(), getPntrToArgument(1)->getName().c_str() );
-  else log.printf("  calculating RMSD distance between %d sets of %d atoms. Distance between vector %s of atoms and matrix of configurations in %s\n",
-                    getPntrToArgument(1)->getShape()[0], natoms, getPntrToArgument(0)->getName().c_str(), getPntrToArgument(1)->getName().c_str() );
+  if( getPntrToArgument(1)->getRank()==1 )
+    log.printf("  calculating RMSD distance between %d atoms. Distance between the avectors of atoms in %s and %s\n",
+               natoms, getPntrToArgument(0)->getName().c_str(), getPntrToArgument(1)->getName().c_str() );
+  else
+    log.printf("  calculating RMSD distance between %d sets of %d atoms. Distance between vector %s of atoms and matrix of configurations in %s\n",
+               getPntrToArgument(1)->getShape()[0], natoms, getPntrToArgument(0)->getName().c_str(), getPntrToArgument(1)->getName().c_str() );
   log.printf("  method for alignment : %s \n",type.c_str() );
-  if(squared)log.printf("  chosen to use SQUARED option for MSD instead of RMSD\n");
-  else      log.printf("  using periodic boundary conditions\n");
+  if(squared) {
+    log.printf("  chosen to use SQUARED option for MSD instead of RMSD\n");
+  } else {
+    log.printf("  using periodic boundary conditions\n");
+  }
 }
 
 unsigned RMSDVector::getNumberOfDerivatives() {
@@ -126,64 +178,98 @@ unsigned RMSDVector::getNumberOfDerivatives() {
 
 void RMSDVector::setReferenceConfigurations() {
   unsigned natoms = getPntrToArgument(0)->getShape()[0] / 3;
-  Vector center; std::vector<Vector> pos( natoms );
+  Vector center;
+  std::vector<Vector> pos( natoms );
   for(unsigned jconf=0; jconf<myrmsd.size(); ++jconf) {
     center.zero();
     for(unsigned i=0; i<pos.size(); ++i) {
-      for(unsigned j=0; j<3; ++j) pos[i][j] = getPntrToArgument(1)->get( (3*jconf+j)*pos.size() + i );
+      for(unsigned j=0; j<3; ++j) {
+        pos[i][j] = getPntrToArgument(1)->get( (3*jconf+j)*pos.size() + i );
+      }
       center+=pos[i]*align[i];
     }
-    for(unsigned i=0; i<pos.size(); ++i) pos[i] -= center;
-    myrmsd[jconf].clear(); myrmsd[jconf].set(align,displace,pos,type,true,norm_weights);
+    for(unsigned i=0; i<pos.size(); ++i) {
+      pos[i] -= center;
+    }
+    myrmsd[jconf].clear();
+    myrmsd[jconf].set(align,displace,pos,type,true,norm_weights);
   }
 }
 
 double RMSDVector::calculateRMSD( const unsigned& current, std::vector<Vector>& pos, std::vector<Vector>& der, std::vector<Vector>& direction ) const {
   unsigned natoms = pos.size();
   for(unsigned i=0; i<natoms; ++i) {
-    for(unsigned j=0; j<3; ++j) pos[i][j] = getPntrToArgument(0)->get( j*natoms + i );
+    for(unsigned j=0; j<3; ++j) {
+      pos[i][j] = getPntrToArgument(0)->get( j*natoms + i );
+    }
   }
 
   if( displacement && type=="SIMPLE" ) {
     const Value* myval = getConstPntrToComponent(1);
     double r = myrmsd[current].simpleAlignment( align, displace, pos, myrmsd[current].getReference(), der, direction, squared );
     if( !doNotCalculateDerivatives() && myval->forcesWereAdded() ) {
-      Vector comforce; comforce.zero();
+      Vector comforce;
+      comforce.zero();
       for(unsigned i=0; i<natoms; i++) {
-        for(unsigned k=0; k<3; ++k) comforce[k] += align[i]*myval->getForce( (3*current+k)*natoms + i);
+        for(unsigned k=0; k<3; ++k) {
+          comforce[k] += align[i]*myval->getForce( (3*current+k)*natoms + i);
+        }
       }
       for(unsigned i=0; i<natoms; i++) {
-        for(unsigned k=0; k<3; ++k) direction[i][k] = myval->getForce( (3*current+k)*natoms + i ) - comforce[k];
+        for(unsigned k=0; k<3; ++k) {
+          direction[i][k] = myval->getForce( (3*current+k)*natoms + i ) - comforce[k];
+        }
       }
     }
     return r;
   } else if( displacement ) {
     const Value* myval = getConstPntrToComponent(1);
-    Tensor rot; Matrix<std::vector<Vector> > DRotDPos(3,3); std::vector<Vector> centeredpos( natoms ), centeredreference( natoms );
-    double r = myrmsd[current].calc_PCAelements( pos, der, rot, DRotDPos, direction, centeredpos, centeredreference, squared ); std::vector<Vector> ref( myrmsd[current].getReference() );
+    Tensor rot;
+    Matrix<std::vector<Vector> > DRotDPos(3,3);
+    std::vector<Vector> centeredpos( natoms ), centeredreference( natoms );
+    double r = myrmsd[current].calc_PCAelements( pos, der, rot, DRotDPos, direction, centeredpos, centeredreference, squared );
+    std::vector<Vector> ref( myrmsd[current].getReference() );
     if( !doNotCalculateDerivatives() && myval->forcesWereAdded() ) {
-      Tensor trot=rot.transpose(); double prefactor = 1 / static_cast<double>( natoms ); Vector v1; v1.zero();
+      Tensor trot=rot.transpose();
+      double prefactor = 1 / static_cast<double>( natoms );
+      Vector v1;
+      v1.zero();
       for(unsigned n=0; n<natoms; n++) {
-        Vector ff; for(unsigned k=0; k<3; ++k ) ff[k] = myval->getForce( (3*current+k)*natoms + n );
+        Vector ff;
+        for(unsigned k=0; k<3; ++k ) {
+          ff[k] = myval->getForce( (3*current+k)*natoms + n );
+        }
         v1+=prefactor*matmul(trot,ff);
       }
       // Notice that we use centreredreference here to accumulate the true forces
       for(unsigned n=0; n<natoms; n++) {
-        Vector ff; for(unsigned k=0; k<3; ++k ) ff[k] = myval->getForce( (3*current+k)*natoms + n );
+        Vector ff;
+        for(unsigned k=0; k<3; ++k ) {
+          ff[k] = myval->getForce( (3*current+k)*natoms + n );
+        }
         centeredreference[n] = sqrtdisplace[n]*( matmul(trot,ff) - v1 );
       }
       for(unsigned a=0; a<3; a++) {
         for(unsigned b=0; b<3; b++) {
-          double tmp1=0.; for(unsigned m=0; m<natoms; m++) tmp1+=centeredpos[m][b]*myval->getForce( (3*current+a)*natoms + m );
-          for(unsigned i=0; i<natoms; i++) centeredreference[i] += sqrtdisplace[i]*tmp1*DRotDPos[a][b][i];
+          double tmp1=0.;
+          for(unsigned m=0; m<natoms; m++) {
+            tmp1+=centeredpos[m][b]*myval->getForce( (3*current+a)*natoms + m );
+          }
+          for(unsigned i=0; i<natoms; i++) {
+            centeredreference[i] += sqrtdisplace[i]*tmp1*DRotDPos[a][b][i];
+          }
         }
       }
       // Now subtract the current force and add on the true force
       for(unsigned n=0; n<natoms; n++) {
-        for(unsigned k=0; k<3; ++k) direction[n][k] = centeredreference[n][k];
+        for(unsigned k=0; k<3; ++k) {
+          direction[n][k] = centeredreference[n][k];
+        }
       }
     } else {
-      for(unsigned i=0; i<direction.size(); ++i) direction[i] = sqrtdisplace[i]*( direction[i] - ref[i] );
+      for(unsigned i=0; i<direction.size(); ++i) {
+        direction[i] = sqrtdisplace[i]*( direction[i] - ref[i] );
+      }
     }
     return r;
   }
@@ -192,7 +278,10 @@ double RMSDVector::calculateRMSD( const unsigned& current, std::vector<Vector>&
 
 // calculator
 void RMSDVector::calculate() {
-  if( firststep || !getPntrToArgument(1)->isConstant() ) { setReferenceConfigurations(); firststep=false; }
+  if( firststep || !getPntrToArgument(1)->isConstant() ) {
+    setReferenceConfigurations();
+    firststep=false;
+  }
 
   if( getPntrToComponent(0)->getRank()==0 ) {
     unsigned natoms = getPntrToArgument(0)->getShape()[0] / 3;
@@ -203,29 +292,43 @@ void RMSDVector::calculate() {
     if( getNumberOfComponents()==2 ) {
       Value* mydisp = getPntrToComponent(1);
       for(unsigned i=0; i<natoms; i++) {
-        for(unsigned j=0; j<3; ++j ) mydisp->set( j*natoms+i, direction[i][j] );
+        for(unsigned j=0; j<3; ++j ) {
+          mydisp->set( j*natoms+i, direction[i][j] );
+        }
       }
     }
-    if( doNotCalculateDerivatives() ) return;
+    if( doNotCalculateDerivatives() ) {
+      return;
+    }
 
     Value* myval = getPntrToComponent(0);
     for(unsigned i=0; i<natoms; i++) {
-      for(unsigned j=0; j<3; ++j ) myval->setDerivative( j*natoms+i, der[i][j] );
+      for(unsigned j=0; j<3; ++j ) {
+        myval->setDerivative( j*natoms+i, der[i][j] );
+      }
     }
-  } else runAllTasks();
+  } else {
+    runAllTasks();
+  }
 }
 
 bool RMSDVector::checkForTaskForce( const unsigned& itask, const Value* myval ) const {
-  if( myval->getRank()<2 ) return ActionWithVector::checkForTaskForce( itask, myval );
+  if( myval->getRank()<2 ) {
+    return ActionWithVector::checkForTaskForce( itask, myval );
+  }
   unsigned nelements = myval->getShape()[1], startr = itask*nelements;
   for(unsigned j=0; j<nelements; ++j ) {
-    if( fabs( myval->getForce( startr + j ) )>epsilon ) return true;
+    if( fabs( myval->getForce( startr + j ) )>epsilon ) {
+      return true;
+    }
   }
   return false;
 }
 
 void RMSDVector::apply() {
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
 
   if( getPntrToComponent(0)->getRank()==0 ) {
     std::vector<double> forces( getNumberOfDerivatives(), 0 );
@@ -236,50 +339,83 @@ void RMSDVector::apply() {
       std::vector<Vector> pos( natoms ), der( natoms ), direction( natoms );
       double r = calculateRMSD( 0, pos, der, direction );
       for(unsigned i=0; i<natoms; ++i) {
-        for(unsigned j=0; j<3; ++j ) forces[j*natoms+i] += direction[i][j];
+        for(unsigned j=0; j<3; ++j ) {
+          forces[j*natoms+i] += direction[i][j];
+        }
       }
       wasforced=true;
     }
-    if( wasforced ) { unsigned ss=0; addForcesOnArguments( 0, forces, ss, getLabel() ); }
-  } else ActionWithVector::apply();
+    if( wasforced ) {
+      unsigned ss=0;
+      addForcesOnArguments( 0, forces, ss, getLabel() );
+    }
+  } else {
+    ActionWithVector::apply();
+  }
 }
 
 void RMSDVector::performTask( const unsigned& current, MultiValue& myvals ) const {
   unsigned natoms = getPntrToArgument(0)->getShape()[0] / 3;
   std::vector<Vector>& pos( myvals.getFirstAtomVector() );
   std::vector<std::vector<Vector> > & allder( myvals.getFirstAtomDerivativeVector() );
-  if( allder.size()!=2 ) allder.resize(2);
-  std::vector<Vector>& der( allder[0] ); std::vector<Vector>& direction( allder[1] );
-  if( pos.size()!=natoms ) { pos.resize( natoms ); der.resize( natoms ); direction.resize( natoms ); }
+  if( allder.size()!=2 ) {
+    allder.resize(2);
+  }
+  std::vector<Vector>& der( allder[0] );
+  std::vector<Vector>& direction( allder[1] );
+  if( pos.size()!=natoms ) {
+    pos.resize( natoms );
+    der.resize( natoms );
+    direction.resize( natoms );
+  }
   for(unsigned i=0; i<pos.size(); ++i) {
-    for(unsigned j=0; j<3; ++j) pos[i][j] = getPntrToArgument(0)->get( j*natoms + i );
+    for(unsigned j=0; j<3; ++j) {
+      pos[i][j] = getPntrToArgument(0)->get( j*natoms + i );
+    }
   }
   double r = calculateRMSD( current, pos, der, direction );
   unsigned ostrn = getConstPntrToComponent(0)->getPositionInStream();
   myvals.setValue( ostrn, r );
 
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
 
   for(unsigned i=0; i<natoms; i++) {
-    for(unsigned j=0; j<3; ++j ) { myvals.addDerivative( ostrn, j*natoms+i, der[i][j] ); myvals.updateIndex( ostrn, j*natoms+i ); }
+    for(unsigned j=0; j<3; ++j ) {
+      myvals.addDerivative( ostrn, j*natoms+i, der[i][j] );
+      myvals.updateIndex( ostrn, j*natoms+i );
+    }
   }
 }
 
 void RMSDVector::gatherStoredValue( const unsigned& valindex, const unsigned& code, const MultiValue& myvals,
                                     const unsigned& bufstart, std::vector<double>& buffer ) const {
-  if( getConstPntrToComponent(valindex)->getRank()==1 ) { ActionWithVector::gatherStoredValue( valindex, code, myvals, bufstart, buffer ); return; }
+  if( getConstPntrToComponent(valindex)->getRank()==1 ) {
+    ActionWithVector::gatherStoredValue( valindex, code, myvals, bufstart, buffer );
+    return;
+  }
   const std::vector<Vector>& direction( myvals.getConstFirstAtomDerivativeVector()[1] );
-  unsigned natoms = direction.size(); unsigned vindex = bufstart + 3*code*natoms;
+  unsigned natoms = direction.size();
+  unsigned vindex = bufstart + 3*code*natoms;
   for(unsigned i=0; i<natoms; ++i) {
-    for(unsigned j=0; j<3; ++j ) buffer[vindex + j*natoms + i] += direction[i][j];
+    for(unsigned j=0; j<3; ++j ) {
+      buffer[vindex + j*natoms + i] += direction[i][j];
+    }
   }
 }
 
 void RMSDVector::gatherForcesOnStoredValue( const Value* myval, const unsigned& itask, const MultiValue& myvals, std::vector<double>& forces ) const {
-  if( myval->getRank()==1 ) { ActionWithVector::gatherForcesOnStoredValue( myval, itask, myvals, forces ); return; }
-  const std::vector<Vector>& direction( myvals.getConstFirstAtomDerivativeVector()[1] ); unsigned natoms = direction.size();
+  if( myval->getRank()==1 ) {
+    ActionWithVector::gatherForcesOnStoredValue( myval, itask, myvals, forces );
+    return;
+  }
+  const std::vector<Vector>& direction( myvals.getConstFirstAtomDerivativeVector()[1] );
+  unsigned natoms = direction.size();
   for(unsigned i=0; i<natoms; ++i) {
-    for(unsigned j=0; j<3; ++j ) forces[j*natoms+i] += direction[i][j];
+    for(unsigned j=0; j<3; ++j ) {
+      forces[j*natoms+i] += direction[i][j];
+    }
   }
 }
 
diff --git a/src/colvar/SelectMassCharge.cpp b/src/colvar/SelectMassCharge.cpp
index 4d5a4855ea..4cc6e497de 100644
--- a/src/colvar/SelectMassCharge.cpp
+++ b/src/colvar/SelectMassCharge.cpp
@@ -109,34 +109,50 @@ void SelectMassCharge::registerKeywords( Keywords& keys ) {
   keys.add("atoms","ATOM","the atom number");
   keys.add("atoms","ATOMS","the atom numbers that you would like to store the masses and charges of");
   keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
-  std::string acname = keys.getDisplayName(); std::size_t und = acname.find("_SCALAR");
-  if( und==std::string::npos ) und = acname.find("_VECTOR");
-  keys.setDisplayName( acname.substr(0,und) ); keys.setValueDescription("the " + keys.getDisplayName() + " of the atom");
+  std::string acname = keys.getDisplayName();
+  std::size_t und = acname.find("_SCALAR");
+  if( und==std::string::npos ) {
+    und = acname.find("_VECTOR");
+  }
+  keys.setDisplayName( acname.substr(0,und) );
+  keys.setValueDescription("the " + keys.getDisplayName() + " of the atom");
 }
 
 SelectMassCharge::SelectMassCharge(const ActionOptions&ao):
-  PLUMED_COLVAR_INIT(ao)
-{
-  std::vector<AtomNumber> atoms; parseAtomList(-1,atoms,this);
+  PLUMED_COLVAR_INIT(ao) {
+  std::vector<AtomNumber> atoms;
+  parseAtomList(-1,atoms,this);
   unsigned mode=getModeAndSetupValues(this);
   requestAtoms(atoms);
 }
 
 void SelectMassCharge::parseAtomList( const int& num, std::vector<AtomNumber>& t, ActionAtomistic* aa ) {
   aa->parseAtomList("ATOM",num,t);
-  if( t.size()==1 ) aa->log.printf("  for atom %d\n",t[0].serial());
-  else if( num<0 || t.size()!=0 ) aa->error("Number of specified atoms should be 1");
+  if( t.size()==1 ) {
+    aa->log.printf("  for atom %d\n",t[0].serial());
+  } else if( num<0 || t.size()!=0 ) {
+    aa->error("Number of specified atoms should be 1");
+  }
 }
 
 unsigned SelectMassCharge::getModeAndSetupValues( ActionWithValue* av ) {
-  av->addValueWithDerivatives(); av->setNotPeriodic(); bool constant=true;
-  ActionAtomistic* aa=dynamic_cast<ActionAtomistic*>( av ); plumed_assert( aa );
+  av->addValueWithDerivatives();
+  av->setNotPeriodic();
+  bool constant=true;
+  ActionAtomistic* aa=dynamic_cast<ActionAtomistic*>( av );
+  plumed_assert( aa );
   for(unsigned i=0; i<aa->getNumberOfAtoms(); ++i) {
     std::pair<std::size_t,std::size_t> p = aa->getValueIndices( aa->getAbsoluteIndex(i) );
-    if( av->getName().find("MASS")!=std::string::npos && !aa->masv[p.first]->isConstant() ) constant=false;
-    if( av->getName().find("CHARGE")!=std::string::npos && !aa->chargev[p.first]->isConstant() ) constant=false;
+    if( av->getName().find("MASS")!=std::string::npos && !aa->masv[p.first]->isConstant() ) {
+      constant=false;
+    }
+    if( av->getName().find("CHARGE")!=std::string::npos && !aa->chargev[p.first]->isConstant() ) {
+      constant=false;
+    }
+  }
+  if( !constant ) {
+    av->error("cannot deal with non-constant " + av->getName() + " values");
   }
-  if( !constant ) av->error("cannot deal with non-constant " + av->getName() + " values");
   (av->copyOutput(0))->setConstant();
   return 0;
 }
@@ -144,15 +160,21 @@ unsigned SelectMassCharge::getModeAndSetupValues( ActionWithValue* av ) {
 // calculator
 void SelectMassCharge::calculate() {
   std::vector<double> masses(1), charges(1), vals(1);
-  std::vector<Vector> pos; std::vector<std::vector<Vector> > derivs; std::vector<Tensor> virial;
-  calculateCV( 0, masses, charges, pos, vals, derivs, virial, this ); setValue( vals[0] );
+  std::vector<Vector> pos;
+  std::vector<std::vector<Vector> > derivs;
+  std::vector<Tensor> virial;
+  calculateCV( 0, masses, charges, pos, vals, derivs, virial, this );
+  setValue( vals[0] );
 }
 
 void SelectMassCharge::calculateCV( const unsigned& mode, const std::vector<double>& masses, const std::vector<double>& charges,
                                     const std::vector<Vector>& pos, std::vector<double>& vals, std::vector<std::vector<Vector> >& derivs,
                                     std::vector<Tensor>& virial, const ActionAtomistic* aa ) {
-  if( aa->getName().find("MASSES")!=std::string::npos ) vals[0]=masses[0];
-  else if( aa->chargesWereSet ) vals[0]=charges[0];
+  if( aa->getName().find("MASSES")!=std::string::npos ) {
+    vals[0]=masses[0];
+  } else if( aa->chargesWereSet ) {
+    vals[0]=charges[0];
+  }
 }
 
 }
diff --git a/src/colvar/Template.cpp b/src/colvar/Template.cpp
index c507b96b1d..16b57eca1d 100644
--- a/src/colvar/Template.cpp
+++ b/src/colvar/Template.cpp
@@ -69,22 +69,26 @@ void Template::registerKeywords(Keywords& keys) {
 
 Template::Template(const ActionOptions&ao):
   PLUMED_COLVAR_INIT(ao),
-  pbc(true)
-{
+  pbc(true) {
   std::vector<AtomNumber> atoms;
   parseAtomList("ATOMS",atoms);
-  if(atoms.size()!=2)
+  if(atoms.size()!=2) {
     error("Number of specified atoms should be 2");
+  }
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
   checkRead();
 
   log.printf("  between atoms %d %d\n",atoms[0].serial(),atoms[1].serial());
-  if(pbc) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
 
   requestAtoms(atoms);
 }
diff --git a/src/colvar/Torsion.cpp b/src/colvar/Torsion.cpp
index 710b1359eb..2da2b59ab8 100644
--- a/src/colvar/Torsion.cpp
+++ b/src/colvar/Torsion.cpp
@@ -132,7 +132,8 @@ typedef MultiColvarTemplate<Torsion> TorsionMulti;
 PLUMED_REGISTER_ACTION(TorsionMulti,"TORSION_VECTOR")
 
 void Torsion::registerKeywords(Keywords& keys) {
-  Colvar::registerKeywords( keys ); keys.setDisplayName("TORSION");
+  Colvar::registerKeywords( keys );
+  keys.setDisplayName("TORSION");
   keys.add("atoms-1","ATOMS","the four atoms involved in the torsional angle");
   keys.add("atoms-2","AXIS","two atoms that define an axis.  You can use this to find the angle in the plane perpendicular to the axis between the vectors specified using the VECTORA and VECTORB keywords.");
   keys.add("atoms-2","VECTORA","two atoms that define a vector.  You can use this in combination with VECTOR2 and AXIS");
@@ -150,14 +151,19 @@ Torsion::Torsion(const ActionOptions&ao):
   do_cosine(false),
   value(1),
   derivs(1),
-  virial(1)
-{
-  derivs[0].resize(6); std::vector<AtomNumber> atoms;
-  std::vector<AtomNumber> v1; ActionAtomistic::parseAtomList("VECTOR1",v1);
+  virial(1) {
+  derivs[0].resize(6);
+  std::vector<AtomNumber> atoms;
+  std::vector<AtomNumber> v1;
+  ActionAtomistic::parseAtomList("VECTOR1",v1);
   if( v1.size()>0 ) {
-    std::vector<AtomNumber> v2; ActionAtomistic::parseAtomList("VECTOR2",v2);
-    std::vector<AtomNumber> axis; ActionAtomistic::parseAtomList("AXIS",axis);
-    if( !(v1.size()==2 && v2.size()==2 && axis.size()==2)) error("VECTOR1, VECTOR2 and AXIS should specify 2 atoms each");
+    std::vector<AtomNumber> v2;
+    ActionAtomistic::parseAtomList("VECTOR2",v2);
+    std::vector<AtomNumber> axis;
+    ActionAtomistic::parseAtomList("AXIS",axis);
+    if( !(v1.size()==2 && v2.size()==2 && axis.size()==2)) {
+      error("VECTOR1, VECTOR2 and AXIS should specify 2 atoms each");
+    }
     atoms.resize(6);
     atoms[0]=v1[1];
     atoms[1]=v1[0];
@@ -167,17 +173,24 @@ Torsion::Torsion(const ActionOptions&ao):
     atoms[5]=v2[1];
     log.printf("  between lines %d-%d and %d-%d, projected on the plane orthogonal to line %d-%d\n",
                v1[0].serial(),v1[1].serial(),v2[0].serial(),v2[1].serial(),axis[0].serial(),axis[1].serial());
-  } else parseAtomList(-1,atoms,this);
+  } else {
+    parseAtomList(-1,atoms,this);
+  }
   unsigned mode=getModeAndSetupValues(this);
-  if( mode==1 ) do_cosine=true;
+  if( mode==1 ) {
+    do_cosine=true;
+  }
 
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
   checkRead();
 
-  if(pbc) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
   requestAtoms(atoms);
 }
 
@@ -189,8 +202,9 @@ void Torsion::parseAtomList( const int& num, std::vector<AtomNumber>& t, ActionA
   aa->parseAtomList("AXIS",num,axis);
 
   if(t.size()==4) {
-    if(!(v1.empty() && v2.empty() && axis.empty()))
+    if(!(v1.empty() && v2.empty() && axis.empty())) {
       aa->error("ATOMS keyword is not compatible with VECTORA, VECTORB and AXIS keywords");
+    }
     aa->log.printf("  between atoms %d %d %d %d\n",t[0].serial(),t[1].serial(),t[2].serial(),t[3].serial());
     t.resize(6);
     t[5]=t[3];
@@ -198,9 +212,12 @@ void Torsion::parseAtomList( const int& num, std::vector<AtomNumber>& t, ActionA
     t[3]=t[2];
     t[2]=t[1];
   } else if(t.empty()) {
-    if( num>0 && v1.empty() && v2.empty() && axis.empty() ) return;
-    if(!(v1.size()==2 && v2.size()==2 && axis.size()==2))
+    if( num>0 && v1.empty() && v2.empty() && axis.empty() ) {
+      return;
+    }
+    if(!(v1.size()==2 && v2.size()==2 && axis.size()==2)) {
       aa->error("VECTORA, VECTORB and AXIS should specify 2 atoms each");
+    }
     aa->log.printf("  between lines %d-%d and %d-%d, projected on the plane orthogonal to line %d-%d\n",
                    v1[0].serial(),v1[1].serial(),v2[0].serial(),v2[1].serial(),axis[0].serial(),axis[1].serial());
     t.resize(6);
@@ -210,25 +227,42 @@ void Torsion::parseAtomList( const int& num, std::vector<AtomNumber>& t, ActionA
     t[3]=axis[1];
     t[4]=v2[0];
     t[5]=v2[1];
-  } else if( t.size()!=4 ) aa->error("ATOMS should specify 4 atoms");
+  } else if( t.size()!=4 ) {
+    aa->error("ATOMS should specify 4 atoms");
+  }
 }
 
 unsigned Torsion::getModeAndSetupValues( ActionWithValue* av ) {
-  bool do_cos; av->parseFlag("COSINE",do_cos);
-  if(do_cos) av->log.printf("  calculating cosine instead of torsion\n");
+  bool do_cos;
+  av->parseFlag("COSINE",do_cos);
+  if(do_cos) {
+    av->log.printf("  calculating cosine instead of torsion\n");
+  }
 
   av->addValueWithDerivatives();
-  if(!do_cos) { av->setPeriodic("-pi","pi"); return 0; }
-  av->setNotPeriodic(); return 1;
+  if(!do_cos) {
+    av->setPeriodic("-pi","pi");
+    return 0;
+  }
+  av->setNotPeriodic();
+  return 1;
 }
 
 // calculator
 void Torsion::calculate() {
-  if(pbc) makeWhole();
-  if(do_cosine) calculateCV( 1, masses, charges, getPositions(), value, derivs, virial, this );
-  else calculateCV( 0, masses, charges, getPositions(), value, derivs, virial, this );
-  for(unsigned i=0; i<6; ++i) setAtomsDerivatives(i,derivs[0][i] );
-  setValue(value[0]); setBoxDerivatives( virial[0] );
+  if(pbc) {
+    makeWhole();
+  }
+  if(do_cosine) {
+    calculateCV( 1, masses, charges, getPositions(), value, derivs, virial, this );
+  } else {
+    calculateCV( 0, masses, charges, getPositions(), value, derivs, virial, this );
+  }
+  for(unsigned i=0; i<6; ++i) {
+    setAtomsDerivatives(i,derivs[0][i] );
+  }
+  setValue(value[0]);
+  setBoxDerivatives( virial[0] );
 }
 
 void Torsion::calculateCV( const unsigned& mode, const std::vector<double>& masses, const std::vector<double>& charges,
diff --git a/src/colvar/Volume.cpp b/src/colvar/Volume.cpp
index a5fc1f5d3e..7eb7377edf 100644
--- a/src/colvar/Volume.cpp
+++ b/src/colvar/Volume.cpp
@@ -54,12 +54,12 @@ class Volume : public Colvar {
 PLUMED_REGISTER_ACTION(Volume,"VOLUME")
 
 Volume::Volume(const ActionOptions&ao):
-  PLUMED_COLVAR_INIT(ao)
-{
+  PLUMED_COLVAR_INIT(ao) {
   std::vector<AtomNumber> atoms;
   checkRead();
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
   requestAtoms(atoms);
 }
 
diff --git a/src/config/Config.inc.in b/src/config/Config.inc.in
index 39ff6f0989..931ab252e8 100644
--- a/src/config/Config.inc.in
+++ b/src/config/Config.inc.in
@@ -48,11 +48,21 @@ std::string escapeForSingleQuote(const std::string& input) {
 
 // This is a fix to allow conda to correctly replace paths in binary files.
 // These functions should not be static or they will be optimized away!
-const char* plumed_root() {return "@PLUMED_ROOT@";}
-const char* plumed_soext() {return "@SOEXT@";}
-const char* plumed_htmldir() {return "@htmldir@";}
-const char* plumed_includedir() {return "@includedir@";}
-const char* plumed_program_name() {return "@program_name@";}
+const char* plumed_root() {
+  return "@PLUMED_ROOT@";
+}
+const char* plumed_soext() {
+  return "@SOEXT@";
+}
+const char* plumed_htmldir() {
+  return "@htmldir@";
+}
+const char* plumed_includedir() {
+  return "@includedir@";
+}
+const char* plumed_program_name() {
+  return "@program_name@";
+}
 
 std::string getSoExt() {
   return plumed_soext();
@@ -74,7 +84,9 @@ std::string getPlumedRoot() {
 }
 
 std::string getPlumedHtmldir() {
-  if(!isInstalled()) return getPlumedRoot();
+  if(!isInstalled()) {
+    return getPlumedRoot();
+  }
   char *env = std::getenv("PLUMED_HTMLDIR");
   std::string ss;
   if( env == NULL) {
@@ -86,7 +98,9 @@ std::string getPlumedHtmldir() {
 }
 
 std::string getPlumedIncludedir() {
-  if(!isInstalled()) return getPlumedRoot()+"/src/include";
+  if(!isInstalled()) {
+    return getPlumedRoot()+"/src/include";
+  }
   char *env = std::getenv("PLUMED_INCLUDEDIR");
   std::string ss;
   if( env == NULL) {
@@ -98,7 +112,9 @@ std::string getPlumedIncludedir() {
 }
 
 std::string getPlumedProgramName() {
-  if(!isInstalled()) return "plumed";
+  if(!isInstalled()) {
+    return "plumed";
+  }
   char *env = std::getenv("PLUMED_PROGRAM_NAME");
   std::string ss;
   if( env == NULL) {
diff --git a/src/contour/ContourFindingBase.cpp b/src/contour/ContourFindingBase.cpp
index 85fea0fa80..11944a0601 100644
--- a/src/contour/ContourFindingBase.cpp
+++ b/src/contour/ContourFindingBase.cpp
@@ -25,22 +25,25 @@ namespace PLMD {
 namespace contour {
 
 void ContourFindingBase::registerKeywords( Keywords& keys ) {
-  gridtools::ActionWithGrid::registerKeywords( keys ); keys.use("ARG");
+  gridtools::ActionWithGrid::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("compulsory","CONTOUR","the value we would like to draw the contour at in the space");
-  gridtools::EvaluateGridFunction gg; gg.registerKeywords(keys);
+  gridtools::EvaluateGridFunction gg;
+  gg.registerKeywords(keys);
 }
 
 ContourFindingBase::ContourFindingBase(const ActionOptions&ao):
   Action(ao),
   ActionWithGrid(ao),
-  mymin(this)
-{
-  parse("CONTOUR",contour); function.read( this );
+  mymin(this) {
+  parse("CONTOUR",contour);
+  function.read( this );
   log.printf("  calculating dividing surface along which function equals %f \n", contour);
 }
 
 void ContourFindingBase::setupOnFirstStep( const bool incalc ) {
-  function.setup( this ); setupValuesOnFirstStep();
+  function.setup( this );
+  setupValuesOnFirstStep();
 }
 
 }
diff --git a/src/contour/ContourFindingBase.h b/src/contour/ContourFindingBase.h
index 726d9b6285..3c2e0e3b79 100644
--- a/src/contour/ContourFindingBase.h
+++ b/src/contour/ContourFindingBase.h
@@ -58,8 +58,12 @@ void ContourFindingBase::findContour( const std::vector<double>& direction, std:
 
 inline
 double ContourFindingBase::getDifferenceFromContour( const std::vector<double>& x, std::vector<double>& der ) const {
-  std::vector<double> vals(1); Matrix<double> deriva( 1, x.size() ); function.calc( this, x, vals, deriva );
-  for(unsigned i=0; i<der.size(); ++i) der[i] = deriva(0,i);
+  std::vector<double> vals(1);
+  Matrix<double> deriva( 1, x.size() );
+  function.calc( this, x, vals, deriva );
+  for(unsigned i=0; i<der.size(); ++i) {
+    der[i] = deriva(0,i);
+  }
   return vals[0] - contour;
 }
 
diff --git a/src/contour/DistanceFromContour.cpp b/src/contour/DistanceFromContour.cpp
index 53deddeba3..46c266496b 100644
--- a/src/contour/DistanceFromContour.cpp
+++ b/src/contour/DistanceFromContour.cpp
@@ -104,43 +104,74 @@ DistanceFromContour::DistanceFromContour( const ActionOptions& ao ):
   dirv(3,0.0),
   dirv2(3,0.0),
   perp_dirs(2),
-  atom_deriv(active_list.size())
-{
+  atom_deriv(active_list.size()) {
   // Get the direction
-  std::string ldir; parse("DIR",ldir );
-  if( ldir=="x" ) { dir=0; perp_dirs[0]=1; perp_dirs[1]=2; dirv[0]=1; dirv2[0]=-1; }
-  else if( ldir=="y" ) { dir=1; perp_dirs[0]=0; perp_dirs[1]=2; dirv[1]=1; dirv2[1]=-1; }
-  else if( ldir=="z" ) { dir=2; perp_dirs[0]=0; perp_dirs[1]=1; dirv[2]=1; dirv2[2]=-1; }
-  else error(ldir + " is not a valid direction use x, y or z");
+  std::string ldir;
+  parse("DIR",ldir );
+  if( ldir=="x" ) {
+    dir=0;
+    perp_dirs[0]=1;
+    perp_dirs[1]=2;
+    dirv[0]=1;
+    dirv2[0]=-1;
+  } else if( ldir=="y" ) {
+    dir=1;
+    perp_dirs[0]=0;
+    perp_dirs[1]=2;
+    dirv[1]=1;
+    dirv2[1]=-1;
+  } else if( ldir=="z" ) {
+    dir=2;
+    perp_dirs[0]=0;
+    perp_dirs[1]=1;
+    dirv[2]=1;
+    dirv2[2]=-1;
+  } else {
+    error(ldir + " is not a valid direction use x, y or z");
+  }
 
   // Read in the tolerance for the pbc parameter
   parse("TOLERANCE",pbc_param);
 
   std::vector<unsigned> shape;
   // Create the values
-  addComponent("thickness", shape ); componentIsNotPeriodic("thickness");
-  addComponent("dist1", shape ); componentIsNotPeriodic("dist1");
-  addComponent("dist2", shape ); componentIsNotPeriodic("dist2");
-  addComponentWithDerivatives("qdist", shape ); componentIsNotPeriodic("qdist");
+  addComponent("thickness", shape );
+  componentIsNotPeriodic("thickness");
+  addComponent("dist1", shape );
+  componentIsNotPeriodic("dist1");
+  addComponent("dist2", shape );
+  componentIsNotPeriodic("dist2");
+  addComponentWithDerivatives("qdist", shape );
+  componentIsNotPeriodic("qdist");
 }
 
 void DistanceFromContour::calculate() {
   // Check box is orthorhombic
-  if( !getPbc().isOrthorombic() ) error("cell box must be orthorhombic");
+  if( !getPbc().isOrthorombic() ) {
+    error("cell box must be orthorhombic");
+  }
 
   // The nanoparticle is at the origin of our coordinate system
-  pos1[0]=pos1[1]=pos1[2]=0.0; pos2[0]=pos2[1]=pos2[2]=0.0;
+  pos1[0]=pos1[1]=pos1[2]=0.0;
+  pos2[0]=pos2[1]=pos2[2]=0.0;
 
   // Set bracket as center of mass of membrane in active region
-  Vector myvec = pbcDistance( getPosition(getNumberOfAtoms()-1), getPosition(0) ); pos2[dir]=myvec[dir];
-  nactive=1; active_list[0]=0; double d2, mindist = myvec.modulo2();
+  Vector myvec = pbcDistance( getPosition(getNumberOfAtoms()-1), getPosition(0) );
+  pos2[dir]=myvec[dir];
+  nactive=1;
+  active_list[0]=0;
+  double d2, mindist = myvec.modulo2();
   for(unsigned j=1; j<getNumberOfAtoms()-1; ++j) {
     Vector distance=pbcDistance( getPosition(getNumberOfAtoms()-1), getPosition(j) );
     if( (d2=distance[perp_dirs[0]]*distance[perp_dirs[0]])<rcut2 &&
         (d2+=distance[perp_dirs[1]]*distance[perp_dirs[1]])<rcut2 ) {
       d2+=distance[dir]*distance[dir];
-      if( d2<mindist && fabs(distance[dir])>epsilon ) { pos2[dir]=distance[dir]; mindist = d2; }
-      active_list[nactive]=j; nactive++;
+      if( d2<mindist && fabs(distance[dir])>epsilon ) {
+        pos2[dir]=distance[dir];
+        mindist = d2;
+      }
+      active_list[nactive]=j;
+      nactive++;
     }
   }
   // pos1 position of the nanoparticle, in the first time
@@ -154,8 +185,11 @@ void DistanceFromContour::calculate() {
     unsigned maxtries = std::floor( ( getBox()(dir,dir) ) / bw[dir] );
     for(unsigned i=0; i<maxtries; ++i) {
       double sign=(pos2[dir]>0)? -1 : +1; // If the nanoparticle is inside the membrane push it out
-      pos1[dir] += sign*bw[dir]; fa = getDifferenceFromContour( pos1, faked );
-      if( fa*fb<0 ) break;
+      pos1[dir] += sign*bw[dir];
+      fa = getDifferenceFromContour( pos1, faked );
+      if( fa*fb<0 ) {
+        break;
+      }
       // if fa*fb is less than zero the new pos 1 is outside the contour
     }
   }
@@ -169,8 +203,11 @@ void DistanceFromContour::calculate() {
     unsigned maxtries = std::floor( ( getBox()(dir,dir) ) / bw[dir] );
     for(unsigned i=0; i<maxtries; ++i) {
       double sign=(dirv[dir]>0)? +1 : -1;
-      pos2[dir] += sign*bw[dir]; fc = getDifferenceFromContour( pos2, faked );
-      if( fc*fb<0 ) break;
+      pos2[dir] += sign*bw[dir];
+      fc = getDifferenceFromContour( pos2, faked );
+      if( fc*fb<0 ) {
+        break;
+      }
     }
     dirv2[dir] = ( pos1[dir] + dirv[dir] ) - pos2[dir];
   }
@@ -178,11 +215,17 @@ void DistanceFromContour::calculate() {
   // Now do a search for the two contours
   findContour( dirv, pos1 );
   // Save the first value
-  Vector root1; root1.zero(); root1[dir] = pval[dir];
+  Vector root1;
+  root1.zero();
+  root1[dir] = pval[dir];
   findContour( dirv2, pos2 );
   // Calculate the separation between the two roots using PBC
-  Vector root2; root2.zero(); root2[dir] = pval[dir];
-  Vector sep = pbcDistance( root1, root2 ); double spacing = fabs( sep[dir] ); plumed_assert( spacing>epsilon );
+  Vector root2;
+  root2.zero();
+  root2[dir] = pval[dir];
+  Vector sep = pbcDistance( root1, root2 );
+  double spacing = fabs( sep[dir] );
+  plumed_assert( spacing>epsilon );
   getPntrToComponent("thickness")->set( spacing );
 
   // Make sure the sign is right
@@ -203,15 +246,22 @@ void DistanceFromContour::calculate() {
 
   // Now calculate the derivatives
   if( !doNotCalculateDerivatives() ) {
-    evaluateDerivatives( root1, root2[dir] ); evaluateDerivatives( root2, root1[dir] );
+    evaluateDerivatives( root1, root2[dir] );
+    evaluateDerivatives( root2, root1[dir] );
   }
 }
 
 void DistanceFromContour::evaluateDerivatives( const Vector& root1, const double& root2 ) {
-  if( getNumberOfArguments()>0 ) plumed_merror("derivatives for phase field distance from contour have not been implemented yet");
+  if( getNumberOfArguments()>0 ) {
+    plumed_merror("derivatives for phase field distance from contour have not been implemented yet");
+  }
 
-  Vector origind; origind.zero(); Tensor vir; vir.zero();
-  double sumd = 0; std::vector<double> pp(3), ddd(3,0);
+  Vector origind;
+  origind.zero();
+  Tensor vir;
+  vir.zero();
+  double sumd = 0;
+  std::vector<double> pp(3), ddd(3,0);
   for(unsigned i=0; i<nactive; ++i) {
     double newval = evaluateKernel( getPosition(active_list[i]), root1, ddd );
     Vector distance = pbcDistance( getPosition(getNumberOfAtoms()-1), getPosition(active_list[i]) );
@@ -219,13 +269,17 @@ void DistanceFromContour::evaluateDerivatives( const Vector& root1, const double
     if( getNumberOfArguments()==1 ) {
     } else {
       sumd += ddd[dir];
-      for(unsigned j=0; j<3; ++j) atom_deriv[i][j] = -ddd[j];
-      origind += -atom_deriv[i]; vir -= Tensor(atom_deriv[i],distance);
+      for(unsigned j=0; j<3; ++j) {
+        atom_deriv[i][j] = -ddd[j];
+      }
+      origind += -atom_deriv[i];
+      vir -= Tensor(atom_deriv[i],distance);
     }
   }
 
   // Add derivatives to atoms involved
-  Value* val=getPntrToComponent("qdist"); double prefactor =  root2 / sumd;
+  Value* val=getPntrToComponent("qdist");
+  double prefactor =  root2 / sumd;
   for(unsigned i=0; i<nactive; ++i) {
     val->addDerivative( 3*active_list[i] + 0, -prefactor*atom_deriv[i][0] );
     val->addDerivative( 3*active_list[i] + 1, -prefactor*atom_deriv[i][1] );
@@ -234,12 +288,19 @@ void DistanceFromContour::evaluateDerivatives( const Vector& root1, const double
 
   // Add derivatives to atoms at origin
   unsigned nbase = 3*(getNumberOfAtoms()-1);
-  val->addDerivative( nbase, -prefactor*origind[0] ); nbase++;
-  val->addDerivative( nbase, -prefactor*origind[1] ); nbase++;
-  val->addDerivative( nbase, -prefactor*origind[2] ); nbase++;
+  val->addDerivative( nbase, -prefactor*origind[0] );
+  nbase++;
+  val->addDerivative( nbase, -prefactor*origind[1] );
+  nbase++;
+  val->addDerivative( nbase, -prefactor*origind[2] );
+  nbase++;
 
   // Add derivatives to virial
-  for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) { val->addDerivative( nbase, -prefactor*vir(i,j) ); nbase++; }
+  for(unsigned i=0; i<3; ++i)
+    for(unsigned j=0; j<3; ++j) {
+      val->addDerivative( nbase, -prefactor*vir(i,j) );
+      nbase++;
+    }
 }
 
 }
diff --git a/src/contour/DistanceFromContourBase.cpp b/src/contour/DistanceFromContourBase.cpp
index 6444830865..c4ef6df28f 100644
--- a/src/contour/DistanceFromContourBase.cpp
+++ b/src/contour/DistanceFromContourBase.cpp
@@ -25,9 +25,12 @@ namespace PLMD {
 namespace contour {
 
 void DistanceFromContourBase::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys );
-  ActionAtomistic::registerKeywords( keys ); ActionWithArguments::registerKeywords( keys );
-  keys.remove("NUMERICAL_DERIVATIVES"); keys.use("ARG");
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionAtomistic::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  keys.remove("NUMERICAL_DERIVATIVES");
+  keys.use("ARG");
   keys.add("atoms","POSITIONS","the positions of the atoms that we are calculating the contour from");
   keys.add("atoms","ATOM","The atom whose perpendicular distance we are calculating from the contour");
   keys.add("compulsory","BANDWIDTH","the bandwidths for kernel density esimtation");
@@ -43,55 +46,92 @@ DistanceFromContourBase::DistanceFromContourBase( const ActionOptions& ao ):
   ActionAtomistic(ao),
   ActionWithArguments(ao),
   mymin(this),
-  nactive(0)
-{
-  if( getNumberOfArguments()>1 ) error("should only use one argument for this action");
+  nactive(0) {
+  if( getNumberOfArguments()>1 ) {
+    error("should only use one argument for this action");
+  }
   if( getNumberOfArguments()==1 ) {
-    if( getPntrToArgument(0)->getRank()!=1 ) error("ARG for distance from contour should be rank one");
+    if( getPntrToArgument(0)->getRank()!=1 ) {
+      error("ARG for distance from contour should be rank one");
+    }
     getPntrToArgument(0)->buildDataStore();
   }
   // Read in the multicolvar/atoms
-  std::vector<AtomNumber> atoms; parseAtomList("POSITIONS",atoms);
-  std::vector<AtomNumber> origin; parseAtomList("ATOM",origin);
-  if( origin.size()!=1 ) error("should only specify one atom for origin keyword");
+  std::vector<AtomNumber> atoms;
+  parseAtomList("POSITIONS",atoms);
+  std::vector<AtomNumber> origin;
+  parseAtomList("ATOM",origin);
+  if( origin.size()!=1 ) {
+    error("should only specify one atom for origin keyword");
+  }
   std::vector<AtomNumber> center;
   if( keywords.exists("ORIGIN") ) {
     parseAtomList("ORIGIN",center);
-    if( center.size()!=1 ) error("should only specify one atom for center keyword");
+    if( center.size()!=1 ) {
+      error("should only specify one atom for center keyword");
+    }
   }
 
-  if( center.size()==1 ) log.printf("  calculating distance between atom %d and contour along vector connecting it to atom %d \n", origin[0].serial(),center[0].serial() );
-  else log.printf("  calculating distance between atom %d and contour \n", origin[0].serial() );
+  if( center.size()==1 ) {
+    log.printf("  calculating distance between atom %d and contour along vector connecting it to atom %d \n", origin[0].serial(),center[0].serial() );
+  } else {
+    log.printf("  calculating distance between atom %d and contour \n", origin[0].serial() );
+  }
 
   log.printf("  contour is in field constructed from positions of atoms : ");
-  for(unsigned i=0; i<atoms.size(); ++i) log.printf("%d ",atoms[i].serial() );
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf("%d ",atoms[i].serial() );
+  }
   if( getNumberOfArguments()==1 ) {
-    if( getPntrToArgument(0)->getShape()[0]!=atoms.size() ) error("mismatch between number of atoms and size of vector specified using ARG keyword");
+    if( getPntrToArgument(0)->getShape()[0]!=atoms.size() ) {
+      error("mismatch between number of atoms and size of vector specified using ARG keyword");
+    }
     log.printf("\n  and weights from %s \n", getPntrToArgument(0)->getName().c_str() );
   } else {
     log.printf("\n  all weights are set equal to one \n");
   }
   // Request everything we need
   active_list.resize( atoms.size(), 0 );
-  std::vector<Value*> args( getArguments() ); atoms.push_back( origin[0] );
-  if( center.size()==1 ) atoms.push_back( center[0] );
-  requestArguments( args ); requestAtoms( atoms );
+  std::vector<Value*> args( getArguments() );
+  atoms.push_back( origin[0] );
+  if( center.size()==1 ) {
+    atoms.push_back( center[0] );
+  }
+  requestArguments( args );
+  requestAtoms( atoms );
   // Fix to request arguments
-  if( args.size()==1 ) addDependency( args[0]->getPntrToAction() );
+  if( args.size()==1 ) {
+    addDependency( args[0]->getPntrToAction() );
+  }
 
   // Read in details of phase field construction
-  parseVector("BANDWIDTH",bw); parse("KERNEL",kerneltype); parse("CONTOUR",contour);
-  std::string errors; switchingFunction.set( kerneltype + " R_0=1.0 NOSTRETCH", errors );
-  if( errors.length()!=0 ) error("problem reading switching function description " + errors);
-  double det=1; for(unsigned i=0; i<bw.size(); ++i) det*=bw[i]*bw[i];
-  gvol=1.0; if( kerneltype=="GAUSSIAN" ) gvol=pow( 2*pi, 0.5*bw.size() ) * pow( det, 0.5 );
+  parseVector("BANDWIDTH",bw);
+  parse("KERNEL",kerneltype);
+  parse("CONTOUR",contour);
+  std::string errors;
+  switchingFunction.set( kerneltype + " R_0=1.0 NOSTRETCH", errors );
+  if( errors.length()!=0 ) {
+    error("problem reading switching function description " + errors);
+  }
+  double det=1;
+  for(unsigned i=0; i<bw.size(); ++i) {
+    det*=bw[i]*bw[i];
+  }
+  gvol=1.0;
+  if( kerneltype=="GAUSSIAN" ) {
+    gvol=pow( 2*pi, 0.5*bw.size() ) * pow( det, 0.5 );
+  }
   log.printf("  constructing phase field using %s kernels with bandwidth (%f, %f, %f) \n",kerneltype.c_str(), bw[0], bw[1], bw[2] );
 
   // And a cutoff
   std::vector<double> pp( bw.size(),0 );
-  double dp2cutoff; parse("CUTOFF",dp2cutoff); double rcut =  sqrt(2*dp2cutoff)*bw[0];
+  double dp2cutoff;
+  parse("CUTOFF",dp2cutoff);
+  double rcut =  sqrt(2*dp2cutoff)*bw[0];
   for(unsigned j=1; j<bw.size(); ++j) {
-    if( sqrt(2*dp2cutoff)*bw[j]>rcut ) rcut=sqrt(2*dp2cutoff)*bw[j];
+    if( sqrt(2*dp2cutoff)*bw[j]>rcut ) {
+      rcut=sqrt(2*dp2cutoff)*bw[j];
+    }
   }
   rcut2=rcut*rcut;
 
@@ -112,33 +152,52 @@ void DistanceFromContourBase::unlockRequests() {
 double DistanceFromContourBase::evaluateKernel( const Vector& cpos, const Vector& apos, std::vector<double>& der ) const {
   Vector distance = pbcDistance( getPosition(getNumberOfAtoms()-1), cpos );
   Vector dist2 = pbcDistance( distance, apos );
-  double dval=0; for(unsigned j=0; j<3; ++j) { der[j] = dist2[j]/bw[j]; dval += der[j]*der[j]; }
+  double dval=0;
+  for(unsigned j=0; j<3; ++j) {
+    der[j] = dist2[j]/bw[j];
+    dval += der[j]*der[j];
+  }
   double dfunc, newval = switchingFunction.calculateSqr( dval, dfunc ) / gvol;
-  double tmp = dfunc / gvol; for(unsigned j=0; j<3; ++j) der[j] *= -tmp;
+  double tmp = dfunc / gvol;
+  for(unsigned j=0; j<3; ++j) {
+    der[j] *= -tmp;
+  }
   return newval;
 }
 
 double DistanceFromContourBase::getDifferenceFromContour( const std::vector<double>& x, std::vector<double>& der ) {
   // Transer the position to the local Vector
-  for(unsigned j=0; j<3; ++j) pval[j] = x[j];
+  for(unsigned j=0; j<3; ++j) {
+    pval[j] = x[j];
+  }
   // Now find the contour
-  double sumk = 0, sumd = 0; std::vector<double> pp(3), ddd(3,0);
+  double sumk = 0, sumd = 0;
+  std::vector<double> pp(3), ddd(3,0);
   for(unsigned i=0; i<nactive; ++i) {
     double newval = evaluateKernel( getPosition(active_list[i]), pval, ddd );
 
     if( getNumberOfArguments()==1 ) {
       sumk += getPntrToArgument(0)->get(active_list[i])*newval;
       sumd += newval;
-    } else sumk += newval;
+    } else {
+      sumk += newval;
+    }
+  }
+  if( getNumberOfArguments()==0 ) {
+    return sumk - contour;
+  }
+  if( fabs(sumk)<epsilon ) {
+    return -contour;
   }
-  if( getNumberOfArguments()==0 ) return sumk - contour;
-  if( fabs(sumk)<epsilon ) return -contour;
   return (sumk/sumd) - contour;
 }
 
 void DistanceFromContourBase::apply() {
-  if( !checkForForces() ) return ;
-  unsigned ind=0; setForcesOnAtoms( getForcesToApply(), ind );
+  if( !checkForForces() ) {
+    return ;
+  }
+  unsigned ind=0;
+  setForcesOnAtoms( getForcesToApply(), ind );
 }
 
 }
diff --git a/src/contour/DistanceFromContourBase.h b/src/contour/DistanceFromContourBase.h
index 74bfd78e2e..ffc4e7ddf2 100644
--- a/src/contour/DistanceFromContourBase.h
+++ b/src/contour/DistanceFromContourBase.h
@@ -34,8 +34,7 @@ namespace contour {
 class DistanceFromContourBase :
   public ActionWithValue,
   public ActionAtomistic,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
 private:
   double contour, gvol;
   RootFindingBase<DistanceFromContourBase> mymin;
@@ -58,14 +57,18 @@ class DistanceFromContourBase :
   unsigned getNumberOfDerivatives() override ;
   void lockRequests();
   void unlockRequests();
-  void calculateNumericalDerivatives( ActionWithValue* a ) { plumed_merror("numerical derivatives are not implemented for this action"); }
+  void calculateNumericalDerivatives( ActionWithValue* a ) {
+    plumed_merror("numerical derivatives are not implemented for this action");
+  }
   double getDifferenceFromContour( const std::vector<double>& x, std::vector<double>& der );
   void apply();
 };
 
 inline
 unsigned DistanceFromContourBase::getNumberOfDerivatives() {
-  if( getNumberOfArguments()==1 ) return 4*getNumberOfAtoms() + 8;  // One derivative for each weight hence four times the number of atoms - 1
+  if( getNumberOfArguments()==1 ) {
+    return 4*getNumberOfAtoms() + 8;  // One derivative for each weight hence four times the number of atoms - 1
+  }
   return 3*getNumberOfAtoms() + 9;
 }
 
diff --git a/src/contour/DistanceFromSphericalContour.cpp b/src/contour/DistanceFromSphericalContour.cpp
index 97997d80c1..83c07d6c6d 100644
--- a/src/contour/DistanceFromSphericalContour.cpp
+++ b/src/contour/DistanceFromSphericalContour.cpp
@@ -53,40 +53,59 @@ void DistanceFromSphericalContour::registerKeywords( Keywords& keys ) {
 
 DistanceFromSphericalContour::DistanceFromSphericalContour( const ActionOptions& ao ):
   Action(ao),
-  DistanceFromContourBase(ao)
-{
+  DistanceFromContourBase(ao) {
   // Create the values
   std::vector<unsigned> shape;
-  addComponentWithDerivatives("dist", shape ); componentIsNotPeriodic("dist");
-  addComponent("radius", shape ); componentIsNotPeriodic("radius");
+  addComponentWithDerivatives("dist", shape );
+  componentIsNotPeriodic("dist");
+  addComponent("radius", shape );
+  componentIsNotPeriodic("radius");
 }
 
 void DistanceFromSphericalContour::calculate() {
   // Check box is orthorhombic
-  if( !getPbc().isOrthorombic() ) error("cell box must be orthorhombic");
+  if( !getPbc().isOrthorombic() ) {
+    error("cell box must be orthorhombic");
+  }
 
   // Calculate the director of the vector connecting the center of the sphere to the molecule of interest
   Vector dirv = pbcDistance( getPosition(getNumberOfAtoms()-1), getPosition(getNumberOfAtoms()-2) );
-  double len=dirv.modulo(); dirv /= len;
+  double len=dirv.modulo();
+  dirv /= len;
   // Now work out which atoms need to be considered explicitly
   Vector myvec = pbcDistance( getPosition(getNumberOfAtoms()-1), getPosition(0) );
-  nactive=1; active_list[0]=0;
+  nactive=1;
+  active_list[0]=0;
   for(unsigned j=1; j<getNumberOfAtoms()-2; ++j) {
     if( getNumberOfArguments()==1 ) {
-      if( getPntrToArgument(0)->get(j)<epsilon ) continue;
+      if( getPntrToArgument(0)->get(j)<epsilon ) {
+        continue;
+      }
     }
-    active_list[nactive]=j; nactive++;
+    active_list[nactive]=j;
+    nactive++;
     Vector distance=pbcDistance( getPosition(getNumberOfAtoms()-1), getPosition(j) );
-    double dp = dotProduct( distance, dirv ); double cp = distance.modulo2() - dp*dp;
-    if( cp<rcut2 ) { active_list[nactive]=j; nactive++; }
+    double dp = dotProduct( distance, dirv );
+    double cp = distance.modulo2() - dp*dp;
+    if( cp<rcut2 ) {
+      active_list[nactive]=j;
+      nactive++;
+    }
   }
   // Get maximum length to fit in box
   double hbox = 0.5*getBox()(0,0);
-  if( 0.5*getBox()(1,1)<hbox ) hbox = 0.5*getBox()(1,1);
-  if( 0.5*getBox()(2,2)<hbox ) hbox = 0.5*getBox()(2,2);
+  if( 0.5*getBox()(1,1)<hbox ) {
+    hbox = 0.5*getBox()(1,1);
+  }
+  if( 0.5*getBox()(2,2)<hbox ) {
+    hbox = 0.5*getBox()(2,2);
+  }
   // Set initial guess for position of contour to position of closest molecule in region
   std::vector<double> pos1(3), dirv2(3);
-  for(unsigned k=0; k<3; ++k) { dirv2[k]=hbox*dirv[k]; pos1[k]=0; }
+  for(unsigned k=0; k<3; ++k) {
+    dirv2[k]=hbox*dirv[k];
+    pos1[k]=0;
+  }
   // Now do a search for the contours
   findContour( dirv2, pos1 );
   // Now find the distance between the center of the sphere and the contour
@@ -97,7 +116,9 @@ void DistanceFromSphericalContour::calculate() {
   getPntrToComponent("dist")->set( len - rad );
 
   // Now calculate the derivatives
-  if( !doNotCalculateDerivatives() ) plumed_merror("derivatives not implemented");
+  if( !doNotCalculateDerivatives() ) {
+    plumed_merror("derivatives not implemented");
+  }
 }
 
 void DistanceFromSphericalContour::evaluateDerivatives( const Vector& root1, const double& root2 ) {
diff --git a/src/contour/DumpContour.cpp b/src/contour/DumpContour.cpp
index 3377f38f45..60ac7b557c 100644
--- a/src/contour/DumpContour.cpp
+++ b/src/contour/DumpContour.cpp
@@ -57,7 +57,8 @@ PLUMED_REGISTER_ACTION(DumpContour,"DUMPCONTOUR")
 void DumpContour::registerKeywords( Keywords& keys ) {
   Action::registerKeywords( keys );
   ActionPilot::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.use("ARG");
+  ActionWithArguments::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("compulsory","STRIDE","1","the frequency with which the grid should be output to the file.");
   keys.add("compulsory","FILE","density","the file on which to write the grid.");
   keys.add("optional","FMT","the format that should be used to output real numbers");
@@ -67,33 +68,51 @@ DumpContour::DumpContour(const ActionOptions&ao):
   Action(ao),
   ActionWithArguments(ao),
   ActionPilot(ao),
-  fmt("%f")
-{
-  if( getNumberOfArguments()!=1 ) error("should only be one argument");
+  fmt("%f") {
+  if( getNumberOfArguments()!=1 ) {
+    error("should only be one argument");
+  }
   FindContour* fc=dynamic_cast<FindContour*>( getPntrToArgument(0)->getPntrToAction() );
-  if( !fc ) error("can only use this action to print data from FIND_CONTOUR actions");
+  if( !fc ) {
+    error("can only use this action to print data from FIND_CONTOUR actions");
+  }
 
   parse("FILE",filename);
-  if(filename.length()==0) error("name out output file was not specified");
+  if(filename.length()==0) {
+    error("name out output file was not specified");
+  }
 
   log.printf("  outputting contour with label %s to file named %s",getPntrToArgument(0)->getName().c_str(), filename.c_str() );
-  parse("FMT",fmt); log.printf(" with format %s \n", fmt.c_str() ); fmt = " " + fmt;
+  parse("FMT",fmt);
+  log.printf(" with format %s \n", fmt.c_str() );
+  fmt = " " + fmt;
 }
 
 void DumpContour::update() {
-  OFile ofile; ofile.link(*this);
+  OFile ofile;
+  ofile.link(*this);
   ofile.setBackupString("analysis");
   ofile.open( filename );
 
   FindContour* fc=dynamic_cast<FindContour*>( getPntrToArgument(0)->getPntrToAction() );
   unsigned maxp = fc->active_cells.size(), ncomp = fc->getNumberOfComponents();
-  unsigned ntasks = 0; for(unsigned i=0; i<maxp; ++i) ntasks += fc->active_cells[i];
+  unsigned ntasks = 0;
+  for(unsigned i=0; i<maxp; ++i) {
+    ntasks += fc->active_cells[i];
+  }
 
-  ofile.printf("%d\n", ntasks ); ofile.printf("Points found on isocontour\n");
+  ofile.printf("%d\n", ntasks );
+  ofile.printf("Points found on isocontour\n");
   for(unsigned i=0; i<maxp; ++i) {
-    if( fc->active_cells[i]==0 ) continue ;
-    const char* defname="X"; const char* name=defname; ofile.printf("%s", name);
-    for(unsigned j=0; j<ncomp; ++j ) ofile.printf((" " + fmt).c_str(), (fc->copyOutput(j))->get(i)  );
+    if( fc->active_cells[i]==0 ) {
+      continue ;
+    }
+    const char* defname="X";
+    const char* name=defname;
+    ofile.printf("%s", name);
+    for(unsigned j=0; j<ncomp; ++j ) {
+      ofile.printf((" " + fmt).c_str(), (fc->copyOutput(j))->get(i)  );
+    }
     ofile.printf("\n");
   }
 }
diff --git a/src/contour/FindContour.cpp b/src/contour/FindContour.cpp
index 0f5b8117e9..7aa21d551e 100644
--- a/src/contour/FindContour.cpp
+++ b/src/contour/FindContour.cpp
@@ -92,25 +92,30 @@ namespace contour {
 PLUMED_REGISTER_ACTION(FindContour,"FIND_CONTOUR")
 
 void FindContour::registerKeywords( Keywords& keys ) {
-  ContourFindingBase::registerKeywords( keys ); ActionWithValue::useCustomisableComponents(keys);
+  ContourFindingBase::registerKeywords( keys );
+  ActionWithValue::useCustomisableComponents(keys);
 // We want a better way of doing this bit
   keys.add("compulsory","BUFFER","0","number of buffer grid points around location where grid was found on last step.  If this is zero the full grid is calculated on each step");
 }
 
 FindContour::FindContour(const ActionOptions&ao):
   Action(ao),
-  ContourFindingBase(ao)
-{
+  ContourFindingBase(ao) {
   parse("BUFFER",gbuffer);
-  if( gbuffer>0 ) log.printf("  after first step a subset of only %u grid points around where the countour was found will be checked\n",gbuffer);
+  if( gbuffer>0 ) {
+    log.printf("  after first step a subset of only %u grid points around where the countour was found will be checked\n",gbuffer);
+  }
   checkRead();
 
   gridtools::ActionWithGrid* ag=dynamic_cast<gridtools::ActionWithGrid*>( getPntrToArgument(0)->getPntrToAction() );
   std::vector<std::string> argn( ag->getGridCoordinateNames() );
 
-  std::vector<unsigned> shape(1); shape[0]=0;
+  std::vector<unsigned> shape(1);
+  shape[0]=0;
   for(unsigned i=0; i<argn.size(); ++i ) {
-    addComponent( argn[i], shape ); componentIsNotPeriodic( argn[i] ); getPntrToComponent(i)->buildDataStore();
+    addComponent( argn[i], shape );
+    componentIsNotPeriodic( argn[i] );
+    getPntrToComponent(i)->buildDataStore();
   }
   // Check for task reduction
   updateTaskListReductionStatus();
@@ -121,8 +126,11 @@ std::string FindContour::getOutputComponentDescription( const std::string& cname
 }
 
 void FindContour::setupValuesOnFirstStep() {
-  std::vector<unsigned> shape(1); shape[0] = getPntrToArgument(0)->getRank()*getPntrToArgument(0)->getNumberOfValues();
-  for(unsigned i=0; i<getNumberOfComponents(); ++i) getPntrToComponent(i)->setShape( shape );
+  std::vector<unsigned> shape(1);
+  shape[0] = getPntrToArgument(0)->getRank()*getPntrToArgument(0)->getNumberOfValues();
+  for(unsigned i=0; i<getNumberOfComponents(); ++i) {
+    getPntrToComponent(i)->setShape( shape );
+  }
   active_cells.resize( shape[0] );
 }
 
@@ -142,7 +150,8 @@ void FindContour::getNumberOfTasks( unsigned& ntasks ) {
   std::vector<unsigned> ind( gval->getRank() );
   std::vector<unsigned> ones( gval->getRank(), 1 );
   std::vector<unsigned> nbin( getInputGridObject().getNbin( false ) );
-  unsigned num_neighbours; std::vector<unsigned> neighbours;
+  unsigned num_neighbours;
+  std::vector<unsigned> neighbours;
 
   std::fill( active_cells.begin(), active_cells.end(), 0 );
   for(unsigned i=0; i<npoints; ++i) {
@@ -154,19 +163,32 @@ void FindContour::getNumberOfTasks( unsigned& ntasks ) {
     bool edge=false;
     for(unsigned j=0; j<gval->getRank(); ++j) {
       // Make sure we don't search at the edge of the grid
-      if( !getInputGridObject().isPeriodic(j) && (ind[j]+1)==nbin[j] ) continue;
-      else if( (ind[j]+1)==nbin[j] ) { edge=true; ind[j]=0; }
-      else ind[j]+=1;
+      if( !getInputGridObject().isPeriodic(j) && (ind[j]+1)==nbin[j] ) {
+        continue;
+      } else if( (ind[j]+1)==nbin[j] ) {
+        edge=true;
+        ind[j]=0;
+      } else {
+        ind[j]+=1;
+      }
       double val2=gval->get( getInputGridObject().getIndex(ind) ) - contour;
-      if( val1*val2<0 ) active_cells[gval->getRank()*i + j] = 1;
-      if( getInputGridObject().isPeriodic(j) && edge ) { edge=false; ind[j]=nbin[j]-1; }
-      else ind[j]-=1;
+      if( val1*val2<0 ) {
+        active_cells[gval->getRank()*i + j] = 1;
+      }
+      if( getInputGridObject().isPeriodic(j) && edge ) {
+        edge=false;
+        ind[j]=nbin[j]-1;
+      } else {
+        ind[j]-=1;
+      }
     }
   }
 }
 
 int FindContour::checkTaskStatus( const unsigned& taskno, int& flag ) const {
-  if( active_cells[taskno]>0 ) return 1;
+  if( active_cells[taskno]>0 ) {
+    return 1;
+  }
   return 0;
 }
 
@@ -184,7 +206,9 @@ void FindContour::performTask( const unsigned& current, MultiValue& myvals ) con
   // Now find the contour
   findContour( direction, point );
   // And transfer to the store data vessel
-  for(unsigned i=0; i<getPntrToArgument(0)->getRank(); ++i) myvals.setValue( getConstPntrToComponent(i)->getPositionInStream(), point[i] );
+  for(unsigned i=0; i<getPntrToArgument(0)->getRank(); ++i) {
+    myvals.setValue( getConstPntrToComponent(i)->getPositionInStream(), point[i] );
+  }
 }
 
 }
diff --git a/src/contour/FindContour.h b/src/contour/FindContour.h
index 68f2b4f3ee..107a42cf85 100644
--- a/src/contour/FindContour.h
+++ b/src/contour/FindContour.h
@@ -41,8 +41,12 @@ class FindContour : public ContourFindingBase {
   void areAllTasksRequired( std::vector<ActionWithVector*>& task_reducing_actions ) override ;
   void getNumberOfTasks( unsigned& ntasks ) override ;
   int checkTaskStatus( const unsigned& taskno, int& flag ) const override ;
-  std::vector<std::string> getGridCoordinateNames() const override { plumed_error(); }
-  const gridtools::GridCoordinatesObject& getGridCoordinatesObject() const override { plumed_error(); }
+  std::vector<std::string> getGridCoordinateNames() const override {
+    plumed_error();
+  }
+  const gridtools::GridCoordinatesObject& getGridCoordinatesObject() const override {
+    plumed_error();
+  }
   void performTask( const unsigned& current, MultiValue& myvals ) const override;
 };
 
diff --git a/src/contour/FindContourSurface.cpp b/src/contour/FindContourSurface.cpp
index 1a1d1eb28c..4cc3f5cd47 100644
--- a/src/contour/FindContourSurface.cpp
+++ b/src/contour/FindContourSurface.cpp
@@ -116,47 +116,66 @@ void FindContourSurface::registerKeywords( Keywords& keys ) {
 FindContourSurface::FindContourSurface(const ActionOptions&ao):
   Action(ao),
   ContourFindingBase(ao),
-  ones(getPntrToArgument(0)->getRank(),1)
-{
-  if( getPntrToArgument(0)->getRank()<2 ) error("cannot find dividing surface if input grid is one dimensional");
+  ones(getPntrToArgument(0)->getRank(),1) {
+  if( getPntrToArgument(0)->getRank()<2 ) {
+    error("cannot find dividing surface if input grid is one dimensional");
+  }
 
-  std::string dir; parse("SEARCHDIR",dir);
+  std::string dir;
+  parse("SEARCHDIR",dir);
   log.printf("  calculating location of contour on %d dimensional grid \n", getPntrToArgument(0)->getRank()-1 );
   checkRead();
 
-  Value* gval=getPntrToArgument(0); unsigned n=0;
-  gdirs.resize( gval->getRank()-1 ); gnames.resize( getPntrToArgument(0)->getRank()-1 );
+  Value* gval=getPntrToArgument(0);
+  unsigned n=0;
+  gdirs.resize( gval->getRank()-1 );
+  gnames.resize( getPntrToArgument(0)->getRank()-1 );
 
   gridtools::ActionWithGrid* ag=dynamic_cast<gridtools::ActionWithGrid*>( gval->getPntrToAction() );
-  if( !ag ) error("input argument must be a grid");
-  if( getInputGridObject().getGridType()=="fibonacci") error("cannot search for contours in fibonacci grids");
+  if( !ag ) {
+    error("input argument must be a grid");
+  }
+  if( getInputGridObject().getGridType()=="fibonacci") {
+    error("cannot search for contours in fibonacci grids");
+  }
   std::vector<std::string> argn( ag->getGridCoordinateNames() );
 
   for(unsigned i=0; i<gval->getRank(); ++i) {
     if( argn[i]==dir ) {
       dir_n=i;
     } else {
-      if( n==gdirs.size() ) error("could not find " + dir + " direction in input grid");
-      gdirs[n]=i; gnames[n]=argn[i]; n++;
+      if( n==gdirs.size() ) {
+        error("could not find " + dir + " direction in input grid");
+      }
+      gdirs[n]=i;
+      gnames[n]=argn[i];
+      n++;
     }
   }
-  if( n!=(gval->getRank()-1) ) error("output of grid is not understood");
+  if( n!=(gval->getRank()-1) ) {
+    error("output of grid is not understood");
+  }
 
   std::vector<bool> ipbc( getInputGridObject().getDimension()-1 );
-  for(unsigned i=0; i<gdirs.size(); ++i) ipbc[i] = getInputGridObject().isPeriodic(gdirs[i]);
+  for(unsigned i=0; i<gdirs.size(); ++i) {
+    ipbc[i] = getInputGridObject().isPeriodic(gdirs[i]);
+  }
   gridcoords.setup( "flat", ipbc, 0, 0.0 );
 
   // Now add a value
   std::vector<unsigned> shape( getInputGridObject().getDimension()-1 );
-  addValueWithDerivatives( shape ); setNotPeriodic();
+  addValueWithDerivatives( shape );
+  setNotPeriodic();
   getPntrToComponent(0)->buildDataStore();
 }
 
 void FindContourSurface::setupValuesOnFirstStep() {
-  std::vector<double> fspacing; std::vector<unsigned> snbins( gridcoords.getDimension() );
+  std::vector<double> fspacing;
+  std::vector<unsigned> snbins( gridcoords.getDimension() );
   std::vector<std::string> smin( gridcoords.getDimension() ), smax( gridcoords.getDimension() );
   for(unsigned i=0; i<gdirs.size(); ++i) {
-    smin[i]=getInputGridObject().getMin()[gdirs[i]]; smax[i]=getInputGridObject().getMax()[gdirs[i]];
+    smin[i]=getInputGridObject().getMin()[gdirs[i]];
+    smax[i]=getInputGridObject().getMax()[gdirs[i]];
     snbins[i]=getInputGridObject().getNbin(false)[gdirs[i]];
   }
   gridcoords.setBounds( smin, smax, snbins, fspacing );
@@ -165,8 +184,11 @@ void FindContourSurface::setupValuesOnFirstStep() {
   std::vector<unsigned> find( gridcoords.getDimension() );
   std::vector<unsigned> ind( gridcoords.getDimension() );
   for(unsigned i=0; i<gridcoords.getNumberOfPoints(); ++i) {
-    find.assign( find.size(), 0 ); gridcoords.getIndices( i, ind );
-    for(unsigned j=0; j<gdirs.size(); ++j) find[gdirs[j]]=ind[j];
+    find.assign( find.size(), 0 );
+    gridcoords.getIndices( i, ind );
+    for(unsigned j=0; j<gdirs.size(); ++j) {
+      find[gdirs[j]]=ind[j];
+    }
   }
 
   // Set the direction in which to look for the contour
@@ -187,43 +209,61 @@ const gridtools::GridCoordinatesObject& FindContourSurface::getGridCoordinatesOb
 }
 
 void FindContourSurface::performTask( const unsigned& current, MultiValue& myvals ) const {
-  std::vector<unsigned> neighbours; unsigned num_neighbours; unsigned nfound=0; double minv=0, minp;
-  std::vector<unsigned> bins_n( getInputGridObject().getNbin(false) ); unsigned shiftn=current;
-  std::vector<unsigned> ind( getInputGridObject().getDimension() ); std::vector<double> point( getInputGridObject().getDimension() );
+  std::vector<unsigned> neighbours;
+  unsigned num_neighbours;
+  unsigned nfound=0;
+  double minv=0, minp;
+  std::vector<unsigned> bins_n( getInputGridObject().getNbin(false) );
+  unsigned shiftn=current;
+  std::vector<unsigned> ind( getInputGridObject().getDimension() );
+  std::vector<double> point( getInputGridObject().getDimension() );
 #ifndef DNDEBUG
-  std::vector<unsigned> oind( gridcoords.getDimension() ); gridcoords.getIndices( current, oind );
+  std::vector<unsigned> oind( gridcoords.getDimension() );
+  gridcoords.getIndices( current, oind );
 #endif
   for(unsigned i=0; i<bins_n[dir_n]; ++i) {
 #ifndef DNDEBUG
-    std::vector<unsigned> base_ind( getInputGridObject().getDimension() ); getInputGridObject().getIndices( shiftn, base_ind );
-    for(unsigned j=0; j<gdirs.size(); ++j) plumed_dbg_assert( base_ind[gdirs[j]]==oind[j] );
+    std::vector<unsigned> base_ind( getInputGridObject().getDimension() );
+    getInputGridObject().getIndices( shiftn, base_ind );
+    for(unsigned j=0; j<gdirs.size(); ++j) {
+      plumed_dbg_assert( base_ind[gdirs[j]]==oind[j] );
+    }
 #endif
     // Get the index of the current grid point
     getInputGridObject().getIndices( shiftn, ind );
     // Exit if we are at the edge of the grid
     if( !getInputGridObject().isPeriodic(dir_n) && (ind[dir_n]+1)==bins_n[dir_n] ) {
-      shiftn += getInputGridObject().getStride()[dir_n]; continue;
+      shiftn += getInputGridObject().getStride()[dir_n];
+      continue;
     }
 
     // Ensure points with inactive neighbours are ignored
     getInputGridObject().getNeighbors( ind, ones, num_neighbours, neighbours );
 
     // Now get the function value at two points
-    double val1=getPntrToArgument(0)->get( shiftn ) - contour; double val2;
-    if( (ind[dir_n]+1)==bins_n[dir_n] ) val2 = getPntrToArgument(0)->get( current ) - contour;
-    else val2=getPntrToArgument(0)->get( shiftn + getInputGridObject().getStride()[dir_n] ) - contour;
+    double val1=getPntrToArgument(0)->get( shiftn ) - contour;
+    double val2;
+    if( (ind[dir_n]+1)==bins_n[dir_n] ) {
+      val2 = getPntrToArgument(0)->get( current ) - contour;
+    } else {
+      val2=getPntrToArgument(0)->get( shiftn + getInputGridObject().getStride()[dir_n] ) - contour;
+    }
 
     // Check if the minimum is bracketed
     if( val1*val2<0 ) {
-      getInputGridObject().getGridPointCoordinates( shiftn, point ); findContour( direction, point );
-      minp=point[dir_n]; nfound++; break;
+      getInputGridObject().getGridPointCoordinates( shiftn, point );
+      findContour( direction, point );
+      minp=point[dir_n];
+      nfound++;
+      break;
     }
 
     // This moves us on to the next point
     shiftn += getInputGridObject().getStride()[dir_n];
   }
   if( nfound==0 ) {
-    std::string num; Tools::convert( getStep(), num );
+    std::string num;
+    Tools::convert( getStep(), num );
     error("On step " + num + " failed to find required grid point");
   }
   myvals.setValue( getConstPntrToComponent(0)->getPositionInStream(), minp );
@@ -231,8 +271,10 @@ void FindContourSurface::performTask( const unsigned& current, MultiValue& myval
 
 void FindContourSurface::gatherStoredValue( const unsigned& valindex, const unsigned& code, const MultiValue& myvals,
     const unsigned& bufstart, std::vector<double>& buffer ) const {
-  plumed_dbg_assert( valindex==0 ); unsigned istart = bufstart + (1+gridcoords.getDimension())*code;
-  unsigned valout = getConstPntrToComponent(0)->getPositionInStream(); buffer[istart] += myvals.get( valout );
+  plumed_dbg_assert( valindex==0 );
+  unsigned istart = bufstart + (1+gridcoords.getDimension())*code;
+  unsigned valout = getConstPntrToComponent(0)->getPositionInStream();
+  buffer[istart] += myvals.get( valout );
 }
 
 }
diff --git a/src/contour/FindSphericalContour.cpp b/src/contour/FindSphericalContour.cpp
index c4d731bae9..0514f3994e 100644
--- a/src/contour/FindSphericalContour.cpp
+++ b/src/contour/FindSphericalContour.cpp
@@ -138,20 +138,29 @@ void FindSphericalContour::registerKeywords( Keywords& keys ) {
 
 FindSphericalContour::FindSphericalContour(const ActionOptions&ao):
   Action(ao),
-  ContourFindingBase(ao)
-{
-  if( getPntrToArgument(0)->getRank()!=3 ) error("input grid must be three dimensional");
+  ContourFindingBase(ao) {
+  if( getPntrToArgument(0)->getRank()!=3 ) {
+    error("input grid must be three dimensional");
+  }
 
-  parse("NPOINTS",npoints); log.printf("  searching for %u points on dividing surface \n",npoints);
-  parse("INNER_RADIUS",min); parse("OUTER_RADIUS",max); parse("NBINS",nbins);
+  parse("NPOINTS",npoints);
+  log.printf("  searching for %u points on dividing surface \n",npoints);
+  parse("INNER_RADIUS",min);
+  parse("OUTER_RADIUS",max);
+  parse("NBINS",nbins);
   log.printf("  expecting to find dividing surface at radii between %f and %f \n",min,max);
   log.printf("  looking for contour in windows of length %f \n", (max-min)/nbins);
   // Set this here so the same set of grid points are used on every turn
-  std::vector<bool> ipbc( 3, false ); gridcoords.setup( "fibonacci", ipbc, npoints, 0.0 );
+  std::vector<bool> ipbc( 3, false );
+  gridcoords.setup( "fibonacci", ipbc, npoints, 0.0 );
   // Now create a value
-  std::vector<unsigned> shape( 3 ); shape[0]=npoints; shape[1]=shape[2]=1;
-  addValueWithDerivatives( shape ); setNotPeriodic();
-  getPntrToComponent(0)->buildDataStore(); checkRead();
+  std::vector<unsigned> shape( 3 );
+  shape[0]=npoints;
+  shape[1]=shape[2]=1;
+  addValueWithDerivatives( shape );
+  setNotPeriodic();
+  getPntrToComponent(0)->buildDataStore();
+  checkRead();
 }
 
 unsigned FindSphericalContour::getNumberOfDerivatives() {
@@ -160,7 +169,8 @@ unsigned FindSphericalContour::getNumberOfDerivatives() {
 
 std::vector<std::string> FindSphericalContour::getGridCoordinateNames() const {
   gridtools::ActionWithGrid* ag=dynamic_cast<gridtools::ActionWithGrid*>( getPntrToArgument(0)->getPntrToAction() );
-  plumed_assert( ag ); return ag->getGridCoordinateNames();
+  plumed_assert( ag );
+  return ag->getGridCoordinateNames();
 }
 
 const gridtools::GridCoordinatesObject& FindSphericalContour::getGridCoordinatesObject() const {
@@ -180,23 +190,36 @@ void FindSphericalContour::performTask( const unsigned& current, MultiValue& myv
 
   bool found=false;
   for(unsigned k=0; k<nbins; ++k) {
-    for(unsigned j=0; j<3; ++j) tmp[j] = contour_point[j] + direction[j];
+    for(unsigned j=0; j<3; ++j) {
+      tmp[j] = contour_point[j] + direction[j];
+    }
     double val1 = getDifferenceFromContour( contour_point, der );
     double val2 = getDifferenceFromContour( tmp, der );
     if( val1*val2<0 ) {
       findContour( direction, contour_point );
-      double norm=0; for(unsigned j=0; j<3; ++j) norm += contour_point[j]*contour_point[j];
-      myvals.setValue( getConstPntrToComponent(0)->getPositionInStream(), sqrt(norm) ); found=true; break;
+      double norm=0;
+      for(unsigned j=0; j<3; ++j) {
+        norm += contour_point[j]*contour_point[j];
+      }
+      myvals.setValue( getConstPntrToComponent(0)->getPositionInStream(), sqrt(norm) );
+      found=true;
+      break;
     }
-    for(unsigned j=0; j<3; ++j) contour_point[j] = tmp[j];
+    for(unsigned j=0; j<3; ++j) {
+      contour_point[j] = tmp[j];
+    }
+  }
+  if( !found ) {
+    error("range does not bracket the dividing surface");
   }
-  if( !found ) error("range does not bracket the dividing surface");
 }
 
 void FindSphericalContour::gatherStoredValue( const unsigned& valindex, const unsigned& code, const MultiValue& myvals,
     const unsigned& bufstart, std::vector<double>& buffer ) const {
-  plumed_assert( valindex==0 ); unsigned istart = bufstart + (1+gridcoords.getDimension())*code;
-  unsigned valout = getConstPntrToComponent(0)->getPositionInStream(); buffer[istart] += myvals.get( valout );
+  plumed_assert( valindex==0 );
+  unsigned istart = bufstart + (1+gridcoords.getDimension())*code;
+  unsigned valout = getConstPntrToComponent(0)->getPositionInStream();
+  buffer[istart] += myvals.get( valout );
 }
 
 }
diff --git a/src/core/Action.cpp b/src/core/Action.cpp
index 0e1e24c8a4..8a463b82e6 100644
--- a/src/core/Action.cpp
+++ b/src/core/Action.cpp
@@ -43,15 +43,13 @@ Keywords ActionOptions::emptyKeys;
 ActionOptions::ActionOptions(PlumedMain&p,const std::vector<std::string>&l):
   plumed(p),
   line(l),
-  keys(emptyKeys)
-{
+  keys(emptyKeys) {
 }
 
 ActionOptions::ActionOptions(const ActionOptions&ao,const Keywords&keys):
   plumed(ao.plumed),
   line(ao.line),
-  keys(keys)
-{
+  keys(keys) {
 }
 
 void Action::registerKeywords( Keywords& keys ) {
@@ -76,15 +74,16 @@ Action::Action(const ActionOptions&ao):
   log(plumed.getLog()),
   comm(plumed.comm),
   multi_sim_comm(plumed.multi_sim_comm),
-  keywords(ao.keys)
-{
+  keywords(ao.keys) {
   // Retrieve the timestep and save it
   resetStoredTimestep();
 
   line.erase(line.begin());
   if( !keywords.exists("NO_ACTION_LOG") ) {
     log.printf("Action %s\n",name.c_str());
-    if(ao.fullPath.length()>0) log<<"  from library: "<<ao.fullPath<<"\n";
+    if(ao.fullPath.length()>0) {
+      log<<"  from library: "<<ao.fullPath<<"\n";
+    }
   }
 
   if(comm.Get_rank()==0) {
@@ -92,32 +91,56 @@ Action::Action(const ActionOptions&ao):
   }
   comm.Bcast(replica_index,0);
 
-  if ( keywords.exists("LABEL") ) { parse("LABEL",label); }
+  if ( keywords.exists("LABEL") ) {
+    parse("LABEL",label);
+  }
   if(label.length()==0) {
-    std::string s; Tools::convert(plumed.getActionSet().size()-plumed.getActionSet().select<ActionForInterface*>().size(),s);
+    std::string s;
+    Tools::convert(plumed.getActionSet().size()-plumed.getActionSet().select<ActionForInterface*>().size(),s);
     label="@"+s;
-  } else if ( label.find(".")!=std::string::npos ) warning("using full stop in an action label should be avaoided as . has a special meaning in PLUMED action labels");
-  if( plumed.getActionSet().selectWithLabel<Action*>(label) ) error("label " + label + " has been already used");
-  if( !keywords.exists("NO_ACTION_LOG") ) log.printf("  with label %s\n",label.c_str());
-  if ( keywords.exists("UPDATE_FROM") ) parse("UPDATE_FROM",update_from);
-  if( !keywords.exists("NO_ACTION_LOG") && update_from!=std::numeric_limits<double>::max()) log.printf("  only update from time %f\n",update_from);
-  if ( keywords.exists("UPDATE_UNTIL") ) parse("UPDATE_UNTIL",update_until);
-  if( !keywords.exists("NO_ACTION_LOG") && update_until!=std::numeric_limits<double>::max()) log.printf("  only update until time %f\n",update_until);
+  } else if ( label.find(".")!=std::string::npos ) {
+    warning("using full stop in an action label should be avaoided as . has a special meaning in PLUMED action labels");
+  }
+  if( plumed.getActionSet().selectWithLabel<Action*>(label) ) {
+    error("label " + label + " has been already used");
+  }
+  if( !keywords.exists("NO_ACTION_LOG") ) {
+    log.printf("  with label %s\n",label.c_str());
+  }
+  if ( keywords.exists("UPDATE_FROM") ) {
+    parse("UPDATE_FROM",update_from);
+  }
+  if( !keywords.exists("NO_ACTION_LOG") && update_from!=std::numeric_limits<double>::max()) {
+    log.printf("  only update from time %f\n",update_from);
+  }
+  if ( keywords.exists("UPDATE_UNTIL") ) {
+    parse("UPDATE_UNTIL",update_until);
+  }
+  if( !keywords.exists("NO_ACTION_LOG") && update_until!=std::numeric_limits<double>::max()) {
+    log.printf("  only update until time %f\n",update_until);
+  }
   if ( keywords.exists("RESTART") ) {
     std::string srestart="AUTO";
     parse("RESTART",srestart);
-    if( plumed.parseOnlyMode() ) restart=false;
-    else if(srestart=="YES") restart=true;
-    else if(srestart=="NO")  restart=false;
-    else if(srestart=="AUTO") {
+    if( plumed.parseOnlyMode() ) {
+      restart=false;
+    } else if(srestart=="YES") {
+      restart=true;
+    } else if(srestart=="NO") {
+      restart=false;
+    } else if(srestart=="AUTO") {
       // do nothing, this is the default
-    } else error("RESTART should be either YES, NO, or AUTO");
+    } else {
+      error("RESTART should be either YES, NO, or AUTO");
+    }
   }
 }
 
 void Action::resetStoredTimestep() {
   ActionWithValue* ts = plumed.getActionSet().selectWithLabel<ActionWithValue*>("timestep");
-  if( ts ) timestep = (ts->copyOutput(0))->get();
+  if( ts ) {
+    timestep = (ts->copyOutput(0))->get();
+  }
 }
 
 Action::~Action() {
@@ -128,10 +151,16 @@ Action::~Action() {
 
 FILE* Action::fopen(const char *path, const char *mode) {
   bool write(false);
-  for(const char*p=mode; *p; p++) if(*p=='w' || *p=='a' || *p=='+') write=true;
+  for(const char*p=mode; *p; p++)
+    if(*p=='w' || *p=='a' || *p=='+') {
+      write=true;
+    }
   FILE* fp;
-  if(write && comm.Get_rank()!=0) fp=plumed.fopen("/dev/null",mode);
-  else      fp=plumed.fopen(path,mode);
+  if(write && comm.Get_rank()!=0) {
+    fp=plumed.fopen("/dev/null",mode);
+  } else {
+    fp=plumed.fopen(path,mode);
+  }
   files.insert(fp);
   return fp;
 }
@@ -152,11 +181,15 @@ std::string Action::getKeyword(const std::string& key) {
   plumed_massert(keywords.exists(key), "keyword " + key + " has not been registered");
 
   std::string outkey;
-  if( Tools::getKey(line,key,outkey ) ) return key + outkey;
+  if( Tools::getKey(line,key,outkey ) ) {
+    return key + outkey;
+  }
 
   if( keywords.style(key,"compulsory") ) {
     if( keywords.getDefaultValue(key,outkey) ) {
-      if( outkey.length()==0 ) error("keyword " + key + " has weird default value");
+      if( outkey.length()==0 ) {
+        error("keyword " + key + " has weird default value");
+      }
       return key + "=" +  outkey;
     } else {
       error("keyword " + key + " is compulsory for this action");
@@ -187,22 +220,33 @@ void Action::parseFlag(const std::string&key,bool & t) {
 void Action::addDependency(Action*action) {
   bool found=false;
   for(const auto & d : after ) {
-    if( action==d ) { found=true; break; }
+    if( action==d ) {
+      found=true;
+      break;
+    }
+  }
+  if( !found ) {
+    after.push_back(action);
   }
-  if( !found ) after.push_back(action);
 }
 
 bool Action::checkForDependency( Action* action ) {
   for(const auto & d : after) {
-    if( action==d ) { return true; }
-    if( d->checkForDependency(action) ) { return true; }
+    if( action==d ) {
+      return true;
+    }
+    if( d->checkForDependency(action) ) {
+      return true;
+    }
   }
   return false;
 }
 
 void Action::activate() {
 // This is set to true if actions are only need to be computed in setup (during checkRead)
-  if( never_activate ) return;
+  if( never_activate ) {
+    return;
+  }
 // preparation step is called only the first time an Action is activated.
 // since it could change its dependences (e.g. in an ActionAtomistic which is
 // accessing to a virtual atom), this is done just before dependencies are
@@ -211,15 +255,21 @@ void Action::activate() {
     this->unlockRequests();
     prepare();
     this->lockRequests();
-  } else return;
-  for(const auto & p : after) p->activate();
+  } else {
+    return;
+  }
+  for(const auto & p : after) {
+    p->activate();
+  }
   active=true;
 }
 
 void Action::setOption(const std::string &s) {
 // This overloads the action and activate some options
   options.insert(s);
-  for(const auto & p : after) p->setOption(s);
+  for(const auto & p : after) {
+    p->setOption(s);
+  }
 }
 
 void Action::clearOptions() {
@@ -236,7 +286,9 @@ void Action::checkRead() {
   if(!line.empty()) {
     std::string msg="cannot understand the following words from the input line : ";
     for(unsigned i=0; i<line.size(); i++) {
-      if(i>0) msg = msg + ", ";
+      if(i>0) {
+        msg = msg + ", ";
+      }
       msg = msg + line[i];
     }
     error(msg);
@@ -253,12 +305,17 @@ void Action::setupConstantValues( const bool& have_atoms ) {
     if( at && av ) {
       never_activate=av->getNumberOfComponents()>0;
       for(unsigned i=0; i<av->getNumberOfComponents(); ++i) {
-        if( !av->copyOutput(i)->isConstant() ) { never_activate=false; break; }
+        if( !av->copyOutput(i)->isConstant() ) {
+          never_activate=false;
+          break;
+        }
       }
     }
   }
   ActionWithArguments* aa = castToActionWithArguments();
-  if( aa && aa->getNumberOfArguments()>0 && getName()!="BIASVALUE" ) never_activate = aa->calculateConstantValues( have_atoms );
+  if( aa && aa->getNumberOfArguments()>0 && getName()!="BIASVALUE" ) {
+    never_activate = aa->calculateConstantValues( have_atoms );
+  }
 }
 
 long long int Action::getStep()const {
@@ -275,14 +332,23 @@ double Action::getTimeStep()const {
 
 double Action::getkBT() {
   double temp=-1.0;
-  if( keywords.exists("TEMP") ) parse("TEMP",temp);
-  if(temp>=0.0 && keywords.style("TEMP","optional") ) return getKBoltzmann()*temp;
+  if( keywords.exists("TEMP") ) {
+    parse("TEMP",temp);
+  }
+  if(temp>=0.0 && keywords.style("TEMP","optional") ) {
+    return getKBoltzmann()*temp;
+  }
   ActionForInterface* kb=plumed.getActionSet().selectWithLabel<ActionForInterface*>("kBT");
-  double kbt=0; if(kb) kbt=(kb->copyOutput(0))->get();
+  double kbt=0;
+  if(kb) {
+    kbt=(kb->copyOutput(0))->get();
+  }
   if( temp>=0 && keywords.style("TEMP","compulsory") ) {
     double kB=getKBoltzmann();
     if( kbt>0 && std::abs(kbt-kB*temp)>1e-4) {
-      std::string strt1, strt2; Tools::convert( temp, strt1 ); Tools::convert( kbt/kB, strt2 );
+      std::string strt1, strt2;
+      Tools::convert( temp, strt1 );
+      Tools::convert( kbt/kB, strt2 );
       warning("using TEMP=" + strt1 + " while MD engine uses " + strt2 + "\n");
     }
     kbt = kB*temp;
@@ -305,7 +371,9 @@ void Action::prepare() {
 }
 
 [[noreturn]] void Action::error( const std::string & msg ) const {
-  if( !keywords.exists("NO_ACTION_LOG") ) log.printf("ERROR in input to action %s with label %s : %s \n \n", name.c_str(), label.c_str(), msg.c_str() );
+  if( !keywords.exists("NO_ACTION_LOG") ) {
+    log.printf("ERROR in input to action %s with label %s : %s \n \n", name.c_str(), label.c_str(), msg.c_str() );
+  }
   plumed_merror("ERROR in input to action " + name + " with label " + label + " : " + msg );
 }
 
@@ -317,7 +385,10 @@ void Action::calculateFromPDB( const PDB& pdb ) {
   activate();
   for(const auto & p : after) {
     ActionWithValue*av=castToActionWithValue();
-    if(av) { av->clearInputForces(); av->clearDerivatives(); }
+    if(av) {
+      av->clearInputForces();
+      av->clearDerivatives();
+    }
     p->readAtomsFromPDB( pdb );
     p->calculate();
   }
@@ -336,8 +407,11 @@ std::string Action::cite(const std::string&s) {
 /// Check if action should be updated.
 bool Action::checkUpdate()const {
   double t=getTime();
-  if(t<update_until && (update_from==std::numeric_limits<double>::max() || t>=update_from)) return true;
-  else return false;
+  if(t<update_until && (update_from==std::numeric_limits<double>::max() || t>=update_from)) {
+    return true;
+  } else {
+    return false;
+  }
 }
 
 bool Action::getCPT() const {
@@ -353,14 +427,20 @@ bool Action::usingNaturalUnits() const {
 }
 
 double Action::getKBoltzmann() const {
-  if( usingNaturalUnits() ) return 1.0;
-  else return kBoltzmann/getUnits().getEnergy();
+  if( usingNaturalUnits() ) {
+    return 1.0;
+  } else {
+    return kBoltzmann/getUnits().getEnergy();
+  }
 }
 
 std::string Action::writeInGraph() const {
   std::string nam=getName();
-  std::size_t u=nam.find_last_of("_"); std::string sub=nam.substr(u+1);
-  if( sub=="SCALAR" || sub=="VECTOR" || sub=="GRID" ) return nam.substr(0,u);
+  std::size_t u=nam.find_last_of("_");
+  std::string sub=nam.substr(u+1);
+  if( sub=="SCALAR" || sub=="VECTOR" || sub=="GRID" ) {
+    return nam.substr(0,u);
+  }
   return nam;
 }
 
diff --git a/src/core/Action.h b/src/core/Action.h
index 08a5172190..acb9e749c8 100644
--- a/src/core/Action.h
+++ b/src/core/Action.h
@@ -292,13 +292,19 @@ class Action {
   bool isOptionOn(const std::string &s)const;
 
 /// Return dependencies
-  const Dependencies & getDependencies()const {return after;}
+  const Dependencies & getDependencies()const {
+    return after;
+  }
 
 /// Check if numerical derivatives should be performed
-  virtual bool checkNumericalDerivatives()const {return false;}
+  virtual bool checkNumericalDerivatives()const {
+    return false;
+  }
 
 /// Check if the action needs gradient
-  virtual bool checkNeedsGradients()const {return false;}
+  virtual bool checkNeedsGradients()const {
+    return false;
+  }
 
 /// Perform calculation using numerical derivatives
 /// N.B. only pass an ActionWithValue to this routine if you know exactly what you
@@ -335,16 +341,36 @@ class Action {
 /// Get the info on what to calculate
   virtual std::string writeInGraph() const ;
 /// Specialized casts, to make PlumedMain run faster
-  virtual ActionWithValue* castToActionWithValue() noexcept { return nullptr; }
-  virtual ActionWithArguments* castToActionWithArguments() noexcept { return nullptr; }
-  virtual ActionAtomistic* castToActionAtomistic() noexcept { return nullptr; }
-  virtual ActionWithVirtualAtom* castToActionWithVirtualAtom() noexcept { return nullptr; }
-  virtual PbcAction* castToPbcAction() noexcept { return nullptr; }
-  virtual ActionToPutData* castToActionToPutData() noexcept { return nullptr; }
-  virtual ActionToGetData* castToActionToGetData() noexcept { return nullptr; }
-  virtual DomainDecomposition* castToDomainDecomposition() noexcept { return nullptr; }
-  virtual ActionForInterface* castToActionForInterface() noexcept { return nullptr; }
-  virtual ActionShortcut* castToActionShortcut() noexcept { return nullptr; }
+  virtual ActionWithValue* castToActionWithValue() noexcept {
+    return nullptr;
+  }
+  virtual ActionWithArguments* castToActionWithArguments() noexcept {
+    return nullptr;
+  }
+  virtual ActionAtomistic* castToActionAtomistic() noexcept {
+    return nullptr;
+  }
+  virtual ActionWithVirtualAtom* castToActionWithVirtualAtom() noexcept {
+    return nullptr;
+  }
+  virtual PbcAction* castToPbcAction() noexcept {
+    return nullptr;
+  }
+  virtual ActionToPutData* castToActionToPutData() noexcept {
+    return nullptr;
+  }
+  virtual ActionToGetData* castToActionToGetData() noexcept {
+    return nullptr;
+  }
+  virtual DomainDecomposition* castToDomainDecomposition() noexcept {
+    return nullptr;
+  }
+  virtual ActionForInterface* castToActionForInterface() noexcept {
+    return nullptr;
+  }
+  virtual ActionShortcut* castToActionShortcut() noexcept {
+    return nullptr;
+  }
 };
 
 /////////////////////
@@ -369,7 +395,9 @@ void Action::parse(const std::string&key,T&t) {
   std::string def;
   bool present=Tools::findKeyword(line,key);
   bool found=Tools::parse(line,key,t,replica_index);
-  if(present && !found) error("keyword " + key +" could not be read correctly");
+  if(present && !found) {
+    error("keyword " + key +" could not be read correctly");
+  }
 
   // If it isn't read and it is compulsory see if a default value was specified
   if ( !found && (keywords.style(key,"compulsory") || keywords.style(key,"hidden")) ) {
@@ -388,10 +416,13 @@ template<class T>
 bool Action::parseNumbered(const std::string&key, const int no, T&t) {
   // Check keyword has been registered
   plumed_massert(keywords.exists(key),"keyword " + key + " has not been registered");
-  if( !keywords.numbered(key) ) error("numbered keywords are not allowed for " + key );
+  if( !keywords.numbered(key) ) {
+    error("numbered keywords are not allowed for " + key );
+  }
 
   // Now try to read the keyword
-  std::string num; Tools::convert(no,num);
+  std::string num;
+  Tools::convert(no,num);
   return Tools::parse(line,key+num,t,replica_index);
 }
 
@@ -399,20 +430,28 @@ template<class T>
 void Action::parseVector(const std::string&key,std::vector<T>&t) {
   // Check keyword has been registered
   plumed_massert(keywords.exists(key), "keyword " + key + " has not been registered");
-  unsigned size=t.size(); bool skipcheck=false;
-  if(size==0) skipcheck=true;
+  unsigned size=t.size();
+  bool skipcheck=false;
+  if(size==0) {
+    skipcheck=true;
+  }
 
   // Now try to read the keyword
-  std::string def; T val;
+  std::string def;
+  T val;
   bool present=Tools::findKeyword(line,key);
   bool found=Tools::parseVector(line,key,t,replica_index);
-  if(present && !found) error("keyword " + key +" could not be read correctly");
+  if(present && !found) {
+    error("keyword " + key +" could not be read correctly");
+  }
 
   // Check vectors size is correct (not if this is atoms or ARG)
   if( !keywords.style(key,"atoms") && found ) {
 //     bool skipcheck=false;
 //     if( keywords.style(key,"compulsory") ){ keywords.getDefaultValue(key,def); skipcheck=(def=="nosize"); }
-    if( !skipcheck && t.size()!=size ) error("vector read in for keyword " + key + " has the wrong size");
+    if( !skipcheck && t.size()!=size ) {
+      error("vector read in for keyword " + key + " has the wrong size");
+    }
   }
 
   // If it isn't read and it is compulsory see if a default value was specified
@@ -422,9 +461,17 @@ void Action::parseVector(const std::string&key,std::vector<T>&t) {
         plumed_error() <<"ERROR in action "<<name<<" with label "<<label<<" : keyword "<<key<<" has weird default value";
       } else {
         if(t.size()>0) {
-          for(unsigned i=0; i<t.size(); ++i) t[i]=val;
-          defaults += " " + key + "=" + def; for(unsigned i=1; i<t.size(); ++i) defaults += "," + def;
-        } else { t.push_back(val); defaults += " " + key + "=" + def; }
+          for(unsigned i=0; i<t.size(); ++i) {
+            t[i]=val;
+          }
+          defaults += " " + key + "=" + def;
+          for(unsigned i=1; i<t.size(); ++i) {
+            defaults += "," + def;
+          }
+        } else {
+          t.push_back(val);
+          defaults += " " + key + "=" + def;
+        }
       }
     } else if( keywords.style(key,"compulsory") ) {
       error("keyword " + key + " is compulsory for this action");
@@ -437,17 +484,27 @@ void Action::parseVector(const std::string&key,std::vector<T>&t) {
 template<class T>
 bool Action::parseNumberedVector(const std::string&key, const int no, std::vector<T>&t) {
   plumed_massert(keywords.exists(key),"keyword " + key + " has not been registered");
-  if( !keywords.numbered(key) ) error("numbered keywords are not allowed for " + key );
+  if( !keywords.numbered(key) ) {
+    error("numbered keywords are not allowed for " + key );
+  }
 
-  unsigned size=t.size(); bool skipcheck=false;
-  if(size==0) skipcheck=true;
-  std::string num; Tools::convert(no,num);
+  unsigned size=t.size();
+  bool skipcheck=false;
+  if(size==0) {
+    skipcheck=true;
+  }
+  std::string num;
+  Tools::convert(no,num);
   bool present=Tools::findKeyword(line,key);
   bool found=Tools::parseVector(line,key+num,t,replica_index);
-  if(present && !found) error("keyword " + key +" could not be read correctly");
+  if(present && !found) {
+    error("keyword " + key +" could not be read correctly");
+  }
 
   if(  keywords.style(key,"compulsory") ) {
-    if (!skipcheck && found && t.size()!=size ) error("vector read in for keyword " + key + num + " has the wrong size");
+    if (!skipcheck && found && t.size()!=size ) {
+      error("vector read in for keyword " + key + num + " has the wrong size");
+    }
   } else if ( !found ) {
     t.resize(0);
   }
diff --git a/src/core/ActionAnyorder.cpp b/src/core/ActionAnyorder.cpp
index b9b9991208..ed7d8a528f 100644
--- a/src/core/ActionAnyorder.cpp
+++ b/src/core/ActionAnyorder.cpp
@@ -27,8 +27,7 @@
 namespace PLMD {
 
 ActionAnyorder::ActionAnyorder(const ActionOptions&ao):
-  Action(ao)
-{
+  Action(ao) {
 }
 
 void ActionAnyorder::registerKeywords( Keywords& keys ) {
diff --git a/src/core/ActionAtomistic.cpp b/src/core/ActionAtomistic.cpp
index dfd4dda8c7..8331190433 100644
--- a/src/core/ActionAtomistic.cpp
+++ b/src/core/ActionAtomistic.cpp
@@ -48,25 +48,30 @@ ActionAtomistic::ActionAtomistic(const ActionOptions&ao):
   donotretrieve(false),
   donotforce(false),
   massesWereSet(false),
-  chargesWereSet(false)
-{
+  chargesWereSet(false) {
   ActionWithValue* bv = plumed.getActionSet().selectWithLabel<ActionWithValue*>("Box");
-  if( bv ) boxValue=bv->copyOutput(0);
+  if( bv ) {
+    boxValue=bv->copyOutput(0);
+  }
   // We now get all the information about atoms that are lying about
   getAtomValuesFromPlumedObject( plumed, xpos, ypos, zpos, masv, chargev );
-  if( xpos.size()!=ypos.size() || xpos.size()!=zpos.size() || xpos.size()!=masv.size() || xpos.size()!=chargev.size() )
+  if( xpos.size()!=ypos.size() || xpos.size()!=zpos.size() || xpos.size()!=masv.size() || xpos.size()!=chargev.size() ) {
     error("mismatch between value arrays");
+  }
 }
 
 void ActionAtomistic::getAtomValuesFromPlumedObject( const PlumedMain& plumed, std::vector<Value*>& xpos, std::vector<Value*>& ypos, std::vector<Value*>& zpos, std::vector<Value*>& masv, std::vector<Value*>& chargev ) {
-  std::vector<ActionShortcut*> shortcuts = plumed.getActionSet().select<ActionShortcut*>(); bool foundpdb=false;
+  std::vector<ActionShortcut*> shortcuts = plumed.getActionSet().select<ActionShortcut*>();
+  bool foundpdb=false;
   for(const auto & ss : shortcuts ) {
     if( ss->getName()=="READMASSCHARGE" ) {
       foundpdb=true;
       ActionWithValue* mv = plumed.getActionSet().selectWithLabel<ActionWithValue*>( ss->getShortcutLabel() + "_mass");
-      plumed_assert( mv ); masv.push_back( mv->copyOutput(0) );
+      plumed_assert( mv );
+      masv.push_back( mv->copyOutput(0) );
       ActionWithValue* qv = plumed.getActionSet().selectWithLabel<ActionWithValue*>( ss->getShortcutLabel() + "_charges");
-      plumed_assert( qv ); chargev.push_back( qv->copyOutput(0) );
+      plumed_assert( qv );
+      chargev.push_back( qv->copyOutput(0) );
     }
   }
   std::vector<ActionWithValue*> vatoms = plumed.getActionSet().select<ActionWithValue*>();
@@ -74,11 +79,21 @@ void ActionAtomistic::getAtomValuesFromPlumedObject( const PlumedMain& plumed, s
     plumed_assert(vv); // needed for following calls, see #1046
     ActionToPutData* ap = vv->castToActionToPutData();
     if( ap ) {
-      if( ap->getRole()=="x" ) xpos.push_back( ap->copyOutput(0) );
-      if( ap->getRole()=="y" ) ypos.push_back( ap->copyOutput(0) );
-      if( ap->getRole()=="z" ) zpos.push_back( ap->copyOutput(0) );
-      if( !foundpdb && ap->getRole()=="m" ) masv.push_back( ap->copyOutput(0) );
-      if( !foundpdb && ap->getRole()=="q" ) chargev.push_back( ap->copyOutput(0) );
+      if( ap->getRole()=="x" ) {
+        xpos.push_back( ap->copyOutput(0) );
+      }
+      if( ap->getRole()=="y" ) {
+        ypos.push_back( ap->copyOutput(0) );
+      }
+      if( ap->getRole()=="z" ) {
+        zpos.push_back( ap->copyOutput(0) );
+      }
+      if( !foundpdb && ap->getRole()=="m" ) {
+        masv.push_back( ap->copyOutput(0) );
+      }
+      if( !foundpdb && ap->getRole()=="q" ) {
+        chargev.push_back( ap->copyOutput(0) );
+      }
     }
     ActionWithVirtualAtom* av = vv->castToActionWithVirtualAtom();
     if( av || vv->getName()=="ARGS2VATOM" ) {
@@ -106,14 +121,27 @@ void ActionAtomistic::requestAtoms(const std::vector<AtomNumber> & a, const bool
   charges.resize(nat);
   atom_value_ind.resize( a.size() );
   int n=getTotAtoms();
-  if(clearDep) clearDependencies();
-  unique.clear(); std::vector<bool> requirements( xpos.size(), false );
-  if( boxValue ) addDependency( boxValue->getPntrToAction() );
+  if(clearDep) {
+    clearDependencies();
+  }
+  unique.clear();
+  std::vector<bool> requirements( xpos.size(), false );
+  if( boxValue ) {
+    addDependency( boxValue->getPntrToAction() );
+  }
   for(unsigned i=0; i<indexes.size(); i++) {
-    if(indexes[i].index()>=n) { std::string num; Tools::convert( indexes[i].serial(),num ); error("atom " + num + " out of range"); }
-    atom_value_ind[i] = getValueIndices( indexes[i] ); requirements[atom_value_ind[i].first] = true;
-    if( atom_value_ind[i].first==0 ) unique.push_back(indexes[i]);
-    else if( atom_value_ind[i].second>0 ) error("action atomistic is not set up to deal with multiple vectors in position input");
+    if(indexes[i].index()>=n) {
+      std::string num;
+      Tools::convert( indexes[i].serial(),num );
+      error("atom " + num + " out of range");
+    }
+    atom_value_ind[i] = getValueIndices( indexes[i] );
+    requirements[atom_value_ind[i].first] = true;
+    if( atom_value_ind[i].first==0 ) {
+      unique.push_back(indexes[i]);
+    } else if( atom_value_ind[i].second>0 ) {
+      error("action atomistic is not set up to deal with multiple vectors in position input");
+    }
   }
 
   atom_value_ind_grouped.clear();
@@ -127,16 +155,20 @@ void ActionAtomistic::requestAtoms(const std::vector<AtomNumber> & a, const bool
     for(unsigned i=1; i<atom_value_ind.size(); i++) {
       auto nn = atom_value_ind[i].first;
       auto kk = atom_value_ind[i].second;
-      if(nn!=prev_nn) atom_value_ind_grouped.push_back(std::pair<std::size_t,std::vector<std::size_t>>(nn, {}));
+      if(nn!=prev_nn)
+        atom_value_ind_grouped.push_back(std::pair<std::size_t,std::vector<std::size_t>>(nn, {}));
       atom_value_ind_grouped.back().second.push_back(kk);
       prev_nn=nn;
     }
   }
 
   // Add the dependencies to the actions that we require
-  Tools::removeDuplicates(unique); value_depends.resize(0);
+  Tools::removeDuplicates(unique);
+  value_depends.resize(0);
   for(unsigned i=0; i<requirements.size(); ++i ) {
-    if( !requirements[i] ) continue;
+    if( !requirements[i] ) {
+      continue;
+    }
     value_depends.push_back( i );
     addDependency( xpos[i]->getPntrToAction() );
     addDependency( ypos[i]->getPntrToAction() );
@@ -172,7 +204,8 @@ void ActionAtomistic::calculateAtomicNumericalDerivatives( ActionWithValue* a, c
   std::vector<Vector> savedPositions(natoms);
   const double delta=std::sqrt(epsilon);
 
-  for(int i=0; i<natoms; i++) for(int k=0; k<3; k++) {
+  for(int i=0; i<natoms; i++)
+    for(int k=0; k<3; k++) {
       savedPositions[i][k]=positions[i][k];
       positions[i][k]=positions[i][k]+delta;
       a->calculate();
@@ -182,17 +215,26 @@ void ActionAtomistic::calculateAtomicNumericalDerivatives( ActionWithValue* a, c
       }
     }
   Tensor box(pbc.getBox());
-  for(int i=0; i<3; i++) for(int k=0; k<3; k++) {
+  for(int i=0; i<3; i++)
+    for(int k=0; k<3; k++) {
       double arg0=box(i,k);
-      for(int j=0; j<natoms; j++) positions[j]=pbc.realToScaled(positions[j]);
+      for(int j=0; j<natoms; j++) {
+        positions[j]=pbc.realToScaled(positions[j]);
+      }
       box(i,k)=box(i,k)+delta;
       pbc.setBox(box);
-      for(int j=0; j<natoms; j++) positions[j]=pbc.scaledToReal(positions[j]);
+      for(int j=0; j<natoms; j++) {
+        positions[j]=pbc.scaledToReal(positions[j]);
+      }
       a->calculate();
       box(i,k)=arg0;
       pbc.setBox(box);
-      for(int j=0; j<natoms; j++) positions[j]=savedPositions[j];
-      for(int j=0; j<nval; j++) valuebox[j](i,k)=a->getOutputQuantity(j);
+      for(int j=0; j<natoms; j++) {
+        positions[j]=savedPositions[j];
+      }
+      for(int j=0; j<nval; j++) {
+        valuebox[j](i,k)=a->getOutputQuantity(j);
+      }
     }
 
   a->calculate();
@@ -201,23 +243,34 @@ void ActionAtomistic::calculateAtomicNumericalDerivatives( ActionWithValue* a, c
     Value* v=a->copyOutput(j);
     double ref=v->get();
     if(v->hasDerivatives()) {
-      for(int i=0; i<natoms; i++) for(int k=0; k<3; k++) {
+      for(int i=0; i<natoms; i++)
+        for(int k=0; k<3; k++) {
           double d=(value[j*natoms+i][k]-ref)/delta;
           v->addDerivative(startnum+3*i+k,d);
         }
       Tensor virial;
-      for(int i=0; i<3; i++) for(int k=0; k<3; k++)virial(i,k)= (valuebox[j](i,k)-ref)/delta;
+      for(int i=0; i<3; i++)
+        for(int k=0; k<3; k++) {
+          virial(i,k)= (valuebox[j](i,k)-ref)/delta;
+        }
 // BE CAREFUL WITH NON ORTHOROMBIC CELL
       virial=-matmul(box.transpose(),virial);
-      for(int i=0; i<3; i++) for(int k=0; k<3; k++) v->addDerivative(startnum+3*natoms+3*k+i,virial(k,i));
+      for(int i=0; i<3; i++)
+        for(int k=0; k<3; k++) {
+          v->addDerivative(startnum+3*natoms+3*k+i,virial(k,i));
+        }
     }
   }
 }
 
 bool ActionAtomistic::actionHasForces() {
   ActionWithValue* av = castToActionWithValue();
-  if( av ) return !av->doNotCalculateDerivatives();
-  if( indexes.size()>0 ) plumed_merror("you have to overwrite the function actionHasForce to tell plumed if you method applies forces");
+  if( av ) {
+    return !av->doNotCalculateDerivatives();
+  }
+  if( indexes.size()>0 ) {
+    plumed_merror("you have to overwrite the function actionHasForce to tell plumed if you method applies forces");
+  }
   return true;
 }
 
@@ -230,11 +283,16 @@ void ActionAtomistic::parseAtomList(const std::string&key,const int num, std::ve
   std::vector<std::string> strings;
   if( num<0 ) {
     parseVector(key,strings);
-    if(strings.empty()) return;
+    if(strings.empty()) {
+      return;
+    }
   } else {
-    if ( !parseNumberedVector(key,num,strings) ) return;
+    if ( !parseNumberedVector(key,num,strings) ) {
+      return;
+    }
   }
-  t.resize(0); interpretAtomList( strings, xpos, this, t );
+  t.resize(0);
+  interpretAtomList( strings, xpos, this, t );
 }
 
 void ActionAtomistic::interpretAtomList(std::vector<std::string>& strings, std::vector<AtomNumber> &t) {
@@ -246,18 +304,28 @@ void ActionAtomistic::interpretAtomList(std::vector<std::string>& strings, const
   for(unsigned i=0; i<strings.size(); ++i) {
     AtomNumber atom;
     bool ok=Tools::convertNoexcept(strings[i],atom); // this is converting strings to AtomNumbers
-    if(ok) t.push_back(atom);
+    if(ok) {
+      t.push_back(atom);
+    }
 // here we check if this is a special symbol for MOLINFO
     if( !ok && strings[i].compare(0,1,"@")==0 ) {
       std::string symbol=strings[i].substr(1);
       if(symbol=="allatoms") {
-        auto n=0; for(unsigned i=0; i<xpos.size(); ++i) n += xpos[i]->getNumberOfValues();
-        t.reserve(n); for(unsigned i=0; i<n; i++) t.push_back(AtomNumber::index(i));
+        auto n=0;
+        for(unsigned i=0; i<xpos.size(); ++i) {
+          n += xpos[i]->getNumberOfValues();
+        }
+        t.reserve(n);
+        for(unsigned i=0; i<n; i++) {
+          t.push_back(AtomNumber::index(i));
+        }
         ok=true;
       } else if(symbol=="mdatoms") {
         const auto n=xpos[0]->getNumberOfValues();
         t.reserve(t.size()+n);
-        for(unsigned i=0; i<n; i++) t.push_back(AtomNumber::index(i));
+        for(unsigned i=0; i<n; i++) {
+          t.push_back(AtomNumber::index(i));
+        }
         ok=true;
       } else if(Tools::startWith(symbol,"ndx:")) {
         auto words=Tools::getWords(symbol.substr(4));
@@ -267,10 +335,15 @@ void ActionAtomistic::interpretAtomList(std::vector<std::string>& strings, const
         } else if(words.size()==2) {
           ndxfile=words[0];
           ndxgroup=words[1];
-        } else plumed_error()<<"Cannot intepret selection "<<symbol;
+        } else {
+          plumed_error()<<"Cannot intepret selection "<<symbol;
+        }
 
-        if(ndxgroup.size()>0) action->log<<"  importing group '"+ndxgroup+"'";
-        else                  action->log<<"  importing first group";
+        if(ndxgroup.size()>0) {
+          action->log<<"  importing group '"+ndxgroup+"'";
+        } else {
+          action->log<<"  importing first group";
+        }
         action->log<<" from index file "<<ndxfile<<"\n";
 
         IFile ifile;
@@ -282,24 +355,36 @@ void ActionAtomistic::interpretAtomList(std::vector<std::string>& strings, const
         while(ifile.getline(line)) {
           std::vector<std::string> words=Tools::getWords(line);
           if(words.size()>=3 && words[0]=="[" && words[2]=="]") {
-            if(groupname.length()>0) firstgroup=false;
+            if(groupname.length()>0) {
+              firstgroup=false;
+            }
             groupname=words[1];
-            if(groupname==ndxgroup || ndxgroup.length()==0) groupfound=true;
+            if(groupname==ndxgroup || ndxgroup.length()==0) {
+              groupfound=true;
+            }
           } else if(groupname==ndxgroup || (firstgroup && ndxgroup.length()==0)) {
             for(unsigned i=0; i<words.size(); i++) {
-              AtomNumber at; Tools::convert(words[i],at);
+              AtomNumber at;
+              Tools::convert(words[i],at);
               t.push_back(at);
             }
           }
         }
-        if(!groupfound) plumed_error()<<"group has not been found in index file";
+        if(!groupfound) {
+          plumed_error()<<"group has not been found in index file";
+        }
         ok=true;
       } else {
         auto* moldat=action->plumed.getActionSet().selectLatest<GenericMolInfo*>(action);
         if( moldat ) {
-          std::vector<AtomNumber> atom_list; moldat->interpretSymbol( symbol, atom_list );
-          if( atom_list.size()>0 ) { ok=true; t.insert(t.end(),atom_list.begin(),atom_list.end()); }
-          else { action->error(strings[i] + " is not a label plumed knows"); }
+          std::vector<AtomNumber> atom_list;
+          moldat->interpretSymbol( symbol, atom_list );
+          if( atom_list.size()>0 ) {
+            ok=true;
+            t.insert(t.end(),atom_list.begin(),atom_list.end());
+          } else {
+            action->error(strings[i] + " is not a label plumed knows");
+          }
         } else {
           action->error("atoms specified using @ symbol but no MOLINFO was available");
         }
@@ -310,12 +395,14 @@ void ActionAtomistic::interpretAtomList(std::vector<std::string>& strings, const
       Group* mygrp=action->plumed.getActionSet().selectWithLabel<Group*>(strings[i]);
       if(mygrp) {
         std::vector<std::string> grp_str( mygrp->getGroupAtoms() );
-        interpretAtomList( grp_str, xpos, action, t ); ok=true;
+        interpretAtomList( grp_str, xpos, action, t );
+        ok=true;
       } else {
         Group* mygrp2=action->plumed.getActionSet().selectWithLabel<Group*>(strings[i]+"_grp");
         if(mygrp2) {
           std::vector<std::string> grp_str( mygrp2->getGroupAtoms() );
-          interpretAtomList( grp_str, xpos, action, t ); ok=true;
+          interpretAtomList( grp_str, xpos, action, t );
+          ok=true;
         }
       }
     }
@@ -324,12 +411,16 @@ void ActionAtomistic::interpretAtomList(std::vector<std::string>& strings, const
       unsigned ind = 0;
       for(unsigned j=0; j<xpos.size(); ++j) {
         if( xpos[j]->getPntrToAction()->getLabel()==strings[i] ) {
-          t.push_back( AtomNumber::index(ind) ); ok=true; break;
+          t.push_back( AtomNumber::index(ind) );
+          ok=true;
+          break;
         }
         ind = ind + xpos[j]->getNumberOfValues();
       }
     }
-    if(!ok) action->error("it was not possible to interpret atom name " + strings[i]);
+    if(!ok) {
+      action->error("it was not possible to interpret atom name " + strings[i]);
+    }
     // plumed_massert(ok,"it was not possible to interpret atom name " + strings[i]);
   }
 }
@@ -337,7 +428,10 @@ void ActionAtomistic::interpretAtomList(std::vector<std::string>& strings, const
 std::pair<std::size_t, std::size_t> ActionAtomistic::getValueIndices( const AtomNumber& i ) const {
   std::size_t valno=0, k = i.index();
   for(unsigned j=0; j<xpos.size(); ++j) {
-    if( k<xpos[j]->getNumberOfValues() ) { valno=j; break; }
+    if( k<xpos[j]->getNumberOfValues() ) {
+      valno=j;
+      break;
+    }
     k = k - xpos[j]->getNumberOfValues();
   }
   return std::pair<std::size_t, std::size_t>( valno, k );
@@ -348,19 +442,28 @@ void ActionAtomistic::retrieveAtoms( const bool& force ) {
     auto* ptr=boxValue->getPntrToAction();
     plumed_assert(ptr); // needed for following calls, see #1046
     PbcAction* pbca = ptr->castToPbcAction();
-    plumed_assert( pbca ); pbc=pbca->pbc;
+    plumed_assert( pbca );
+    pbc=pbca->pbc;
+  }
+  if( donotretrieve || indexes.size()==0 ) {
+    return;
   }
-  if( donotretrieve || indexes.size()==0 ) return;
   auto * mtr=masv[0]->getPntrToAction();
   plumed_assert(mtr); // needed for following calls, see #1046
   ActionToPutData* mv = mtr->castToActionToPutData();
-  if(mv) massesWereSet=mv->hasBeenSet();
-  else if( (masv[0]->getPntrToAction())->getName()=="CONSTANT" ) massesWereSet=true; // Read masses from PDB file
+  if(mv) {
+    massesWereSet=mv->hasBeenSet();
+  } else if( (masv[0]->getPntrToAction())->getName()=="CONSTANT" ) {
+    massesWereSet=true;  // Read masses from PDB file
+  }
   auto * ptr=chargev[0]->getPntrToAction();
   plumed_assert(ptr); // needed for following calls, see #1046
   ActionToPutData* cv = ptr->castToActionToPutData();
-  if(cv) chargesWereSet=cv->hasBeenSet();
-  else if( (chargev[0]->getPntrToAction())->getName()=="CONSTANT" ) chargesWereSet=true; // Read masses from PDB file
+  if(cv) {
+    chargesWereSet=cv->hasBeenSet();
+  } else if( (chargev[0]->getPntrToAction())->getName()=="CONSTANT" ) {
+    chargesWereSet=true;  // Read masses from PDB file
+  }
   unsigned j = 0;
 
 // for(const auto & a : atom_value_ind) {
@@ -393,7 +496,9 @@ void ActionAtomistic::retrieveAtoms( const bool& force ) {
 }
 
 void ActionAtomistic::setForcesOnAtoms(const std::vector<double>& forcesToApply, unsigned& ind) {
-  if( donotforce || (indexes.size()==0 && getName()!="FIXEDATOM") ) return;
+  if( donotforce || (indexes.size()==0 && getName()!="FIXEDATOM") ) {
+    return;
+  }
   for(unsigned i=0; i<value_depends.size(); ++i) {
     xpos[value_depends[i]]->hasForce = true;
     ypos[value_depends[i]]->hasForce = true;
@@ -415,9 +520,12 @@ void ActionAtomistic::setForcesOnAtoms(const std::vector<double>& forcesToApply,
     auto & yp=ypos[nn]->inputForce;
     auto & zp=zpos[nn]->inputForce;
     for(const auto & kk : a.second) {
-      xp[kk] += forcesToApply[ind]; ind++;
-      yp[kk] += forcesToApply[ind]; ind++;
-      zp[kk] += forcesToApply[ind]; ind++;
+      xp[kk] += forcesToApply[ind];
+      ind++;
+      yp[kk] += forcesToApply[ind];
+      ind++;
+      zp[kk] += forcesToApply[ind];
+      ind++;
     }
   }
 
@@ -431,29 +539,44 @@ void ActionAtomistic::setForcesOnCell(const std::vector<double>& forcesToApply,
 void ActionAtomistic::setForcesOnCell(const double* forcesToApply, std::size_t size, unsigned& ind) {
   for(unsigned i=0; i<9; ++i) {
     plumed_dbg_massert( ind<size, "problem setting forces in " + getLabel() );
-    boxValue->addForce( i, forcesToApply[ind] ); ind++;
+    boxValue->addForce( i, forcesToApply[ind] );
+    ind++;
   }
 }
 
 Tensor ActionAtomistic::getVirial() const {
-  Tensor vir; for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) vir[i][j] = boxValue->getForce(3*i+j);
+  Tensor vir;
+  for(unsigned i=0; i<3; ++i)
+    for(unsigned j=0; j<3; ++j) {
+      vir[i][j] = boxValue->getForce(3*i+j);
+    }
   return vir;
 }
 
 void ActionAtomistic::readAtomsFromPDB(const PDB& pdb) {
 
   for(unsigned j=0; j<indexes.size(); j++) {
-    if( indexes[j].index()>pdb.size() ) error("there are not enough atoms in the input pdb file");
-    if( pdb.getAtomNumbers()[j].index()!=indexes[j].index() ) error("there are atoms missing in the pdb file");
+    if( indexes[j].index()>pdb.size() ) {
+      error("there are not enough atoms in the input pdb file");
+    }
+    if( pdb.getAtomNumbers()[j].index()!=indexes[j].index() ) {
+      error("there are atoms missing in the pdb file");
+    }
     positions[j]=pdb.getPositions()[indexes[j].index()];
   }
-  for(unsigned j=0; j<indexes.size(); j++) charges[j]=pdb.getBeta()[indexes[j].index()];
-  for(unsigned j=0; j<indexes.size(); j++) masses[j]=pdb.getOccupancy()[indexes[j].index()];
+  for(unsigned j=0; j<indexes.size(); j++) {
+    charges[j]=pdb.getBeta()[indexes[j].index()];
+  }
+  for(unsigned j=0; j<indexes.size(); j++) {
+    masses[j]=pdb.getOccupancy()[indexes[j].index()];
+  }
 }
 
 unsigned ActionAtomistic::getTotAtoms()const {
   unsigned natoms = 0;
-  for(unsigned i=0; i<xpos.size(); ++i ) natoms += xpos[i]->getNumberOfValues();
+  for(unsigned i=0; i<xpos.size(); ++i ) {
+    natoms += xpos[i]->getNumberOfValues();
+  }
   return natoms;
 }
 
@@ -467,18 +590,27 @@ void ActionAtomistic::makeWhole() {
 
 void ActionAtomistic::getGradient( const unsigned& ind, Vector& deriv, std::map<AtomNumber,Vector>& gradients ) const {
   std::size_t nn = atom_value_ind[ind].first;
-  if( nn==0 ) { gradients[indexes[ind]] += deriv; return; }
+  if( nn==0 ) {
+    gradients[indexes[ind]] += deriv;
+    return;
+  }
   xpos[nn]->passGradients( deriv[0], gradients );
   ypos[nn]->passGradients( deriv[1], gradients );
   zpos[nn]->passGradients( deriv[2], gradients );
 }
 
 void ActionAtomistic::updateUniqueLocal( const bool& useunique, const std::vector<int>& g2l ) {
-  if( useunique ) { unique_local=unique; return; }
+  if( useunique ) {
+    unique_local=unique;
+    return;
+  }
   // Update unique local if it needs an update
-  unique_local_needs_update=false; unique_local.clear();
+  unique_local_needs_update=false;
+  unique_local.clear();
   for(auto pp=unique.begin(); pp!=unique.end(); ++pp) {
-    if(g2l[pp->index()]>=0) unique_local.push_back(*pp); // already sorted
+    if(g2l[pp->index()]>=0) {
+      unique_local.push_back(*pp);  // already sorted
+    }
   }
 }
 
diff --git a/src/core/ActionAtomistic.h b/src/core/ActionAtomistic.h
index 377d1c6ccb..bc49976563 100644
--- a/src/core/ActionAtomistic.h
+++ b/src/core/ActionAtomistic.h
@@ -42,8 +42,7 @@ class SelectMassCharge;
 /// \ingroup MULTIINHERIT
 /// Action used to create objects that access the positions of the atoms from the MD code
 class ActionAtomistic :
-  virtual public Action
-{
+  virtual public Action {
   friend class Group;
   friend class DomainDecomposition;
   friend class colvar::SelectMassCharge;
@@ -126,7 +125,9 @@ class ActionAtomistic :
 /// Get a reference to force on energy
   double & modifyForceOnEnergy();
 /// Get number of available atoms
-  unsigned getNumberOfAtoms()const {return indexes.size();}
+  unsigned getNumberOfAtoms()const {
+    return indexes.size();
+  }
 /// Compute the pbc distance between two positions
   Vector pbcDistance(const Vector&,const Vector&)const;
 /// Applies  PBCs to a seriens of positions or distances
@@ -160,11 +161,15 @@ class ActionAtomistic :
 /// not going to be retrieved. Can be used for optimization. Notice that
 /// calling getPosition(int) in an Action where DoNotRetrieve() was called might
 /// lead to undefined behavior.
-  void doNotRetrieve() {donotretrieve=true;}
+  void doNotRetrieve() {
+    donotretrieve=true;
+  }
 /// Skip atom forces - use with care.
 /// If this function is called during initialization, then forces are
 /// not going to be propagated. Can be used for optimization.
-  void doNotForce() {donotforce=true;}
+  void doNotForce() {
+    donotforce=true;
+  }
 /// Make atoms whole, assuming they are in the proper order
   void makeWhole();
 public:
@@ -192,7 +197,9 @@ class ActionAtomistic :
   void readAtomsFromPDB( const PDB& pdb ) override;
 /// Transfer the gradients
   void getGradient( const unsigned& ind, Vector& deriv, std::map<AtomNumber,Vector>& gradients ) const ;
-  ActionAtomistic* castToActionAtomistic() noexcept final { return this; }
+  ActionAtomistic* castToActionAtomistic() noexcept final {
+    return this;
+  }
   virtual bool actionHasForces();
 };
 
@@ -203,13 +210,17 @@ const Vector & ActionAtomistic::getPosition(int i)const {
 
 inline
 double ActionAtomistic::getMass(int i)const {
-  if( !massesWereSet ) log.printf("WARNING: masses were not passed to plumed\n");
+  if( !massesWereSet ) {
+    log.printf("WARNING: masses were not passed to plumed\n");
+  }
   return masses[i];
 }
 
 inline
 double ActionAtomistic::getCharge(int i) const {
-  if( !chargesWereSet ) error("charges were not passed to plumed");
+  if( !chargesWereSet ) {
+    error("charges were not passed to plumed");
+  }
   return charges[i];
 }
 
diff --git a/src/core/ActionForInterface.cpp b/src/core/ActionForInterface.cpp
index 6db02e8f0b..7ad5827f68 100644
--- a/src/core/ActionForInterface.cpp
+++ b/src/core/ActionForInterface.cpp
@@ -27,7 +27,8 @@
 namespace PLMD {
 
 void ActionForInterface::registerKeywords(Keywords& keys) {
-  Action::registerKeywords(keys); ActionWithValue::registerKeywords( keys );
+  Action::registerKeywords(keys);
+  ActionWithValue::registerKeywords( keys );
   keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
   keys.add("optional","ROLE","Get the role this value plays in the code can be x/y/z/m/q to signify that this is x, y, z positions of atoms or masses or charges of atoms");
 }
@@ -37,9 +38,10 @@ ActionForInterface::ActionForInterface(const ActionOptions&ao):
   ActionWithValue(ao),
   firststep(true),
   wasscaled(false),
-  wasset(false)
-{
-  if( keywords.exists("ROLE") && getName()!="DOMAIN_DECOMPOSITION") parse("ROLE",role);
+  wasset(false) {
+  if( keywords.exists("ROLE") && getName()!="DOMAIN_DECOMPOSITION") {
+    parse("ROLE",role);
+  }
 }
 
 std::string ActionForInterface::getRole() const {
diff --git a/src/core/ActionForInterface.h b/src/core/ActionForInterface.h
index 5322515534..22e56d3511 100644
--- a/src/core/ActionForInterface.h
+++ b/src/core/ActionForInterface.h
@@ -49,7 +49,9 @@ class ActionForInterface : public ActionWithValue {
 /// Check if the value has been set
   bool hasBeenSet() const ;
 /// The number of derivatives
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
 ///
   virtual void resetForStepStart() = 0;
 /// Set the start point for the memory if needed
@@ -61,7 +63,9 @@ class ActionForInterface : public ActionWithValue {
 /// Set the force to the value that contains this data
   virtual bool setForcePointer( const std::string& name, const TypesafePtr & ) = 0;
 /// This get the number of forces that need to be rescaled in rescale forces
-  virtual unsigned getNumberOfForcesToRescale() const { plumed_merror("no method for rescaling forces for this type of input"); }
+  virtual unsigned getNumberOfForcesToRescale() const {
+    plumed_merror("no method for rescaling forces for this type of input");
+  }
 /// Overriding this method from ActionWithValue ensures that taskLists that are set during share are not updated during calculate loop
 //  void setupForCalculation( const bool& force=false ) override {}
 /// Get the data
@@ -70,7 +74,10 @@ class ActionForInterface : public ActionWithValue {
 /// Get the data to share
   virtual void wait() = 0;
 /// Actually set the values for the output
-  void calculate() override { firststep=false; wasscaled=false; }
+  void calculate() override {
+    firststep=false;
+    wasscaled=false;
+  }
   virtual void reset() {}
   virtual void Set_comm(Communicator& comm) = 0;
 /// For replica exchange
@@ -78,7 +85,9 @@ class ActionForInterface : public ActionWithValue {
   virtual void readBinary(std::istream&i) = 0;
   virtual bool onStep() const = 0;
   std::string getRole() const ;
-  ActionForInterface* castToActionForInterface() noexcept final { return this; }
+  ActionForInterface* castToActionForInterface() noexcept final {
+    return this;
+  }
 };
 
 inline
diff --git a/src/core/ActionPilot.cpp b/src/core/ActionPilot.cpp
index 69643eb70a..762dda9a78 100644
--- a/src/core/ActionPilot.cpp
+++ b/src/core/ActionPilot.cpp
@@ -27,18 +27,21 @@ void ActionPilot::registerKeywords(Keywords& keys) {}
 
 ActionPilot::ActionPilot(const ActionOptions&ao):
   Action(ao),
-  stride(1)
-{
+  stride(1) {
   if( keywords.exists("STRIDE") ) {
     parse("STRIDE",stride);
-    if( !keywords.style("STRIDE","hidden") ) log.printf("  with stride %d\n",stride);
+    if( !keywords.style("STRIDE","hidden") ) {
+      log.printf("  with stride %d\n",stride);
+    }
   } else {
     stride=0;
   }
 }
 
 bool ActionPilot::onStep()const {
-  if( stride>0 ) return getStep()%stride==0;
+  if( stride>0 ) {
+    return getStep()%stride==0;
+  }
   return false;
 }
 
diff --git a/src/core/ActionPilot.h b/src/core/ActionPilot.h
index 6c6c458a90..27b9610be1 100644
--- a/src/core/ActionPilot.h
+++ b/src/core/ActionPilot.h
@@ -37,8 +37,7 @@ it in order to run.  This class is used in PLMD::Bias
  which is specified on the directive line with a STRIDE= keyword
 */
 class ActionPilot:
-  public virtual Action
-{
+  public virtual Action {
   int stride; // multiple time step
 public:
   explicit ActionPilot(const ActionOptions&);
diff --git a/src/core/ActionRegister.cpp b/src/core/ActionRegister.cpp
index 9054effa76..3004c0b48e 100644
--- a/src/core/ActionRegister.cpp
+++ b/src/core/ActionRegister.cpp
@@ -36,10 +36,13 @@ std::unique_ptr<Action> ActionRegister::create(const ActionOptions&ao) {
 }
 
 std::unique_ptr<Action> ActionRegister::create(const std::vector<void*> & images,const ActionOptions&ao) {
-  if(ao.line.size()<1)return nullptr;
+  if(ao.line.size()<1) {
+    return nullptr;
+  }
 
   auto content=get(images,ao.line[0]);
-  Keywords keys; keys.thisactname = ao.line[0];
+  Keywords keys;
+  keys.thisactname = ao.line[0];
   content.keys(keys);
   ActionOptions nao( ao,keys );
   auto fullPath=getFullPath(images,ao.line[0]);
@@ -49,9 +52,12 @@ std::unique_ptr<Action> ActionRegister::create(const std::vector<void*> & images
 
 bool ActionRegister::printManual(const std::string& action, const bool& vimout, const bool& spellout) {
   if ( check(action) ) {
-    Keywords keys; getKeywords( action, keys );
+    Keywords keys;
+    getKeywords( action, keys );
     if( vimout ) {
-      printf("%s",action.c_str()); keys.print_vim(); printf("\n");
+      printf("%s",action.c_str());
+      keys.print_vim();
+      printf("\n");
     } else if( spellout ) {
       keys.print_spelling();
     } else {
@@ -65,7 +71,8 @@ bool ActionRegister::printManual(const std::string& action, const bool& vimout,
 
 bool ActionRegister::printTemplate(const std::string& action, bool include_optional) {
   if( check(action) ) {
-    Keywords keys; keys.thisactname = action;
+    Keywords keys;
+    keys.thisactname = action;
     get(action).keys(keys);
     keys.print_template(action, include_optional);
     return true;
@@ -80,7 +87,10 @@ std::vector<std::string> ActionRegister::getActionNames() const {
 
 ActionRegister::ID ActionRegister::add(std::string key,creator_pointer cp,keywords_pointer kp) {
   // this force each action to be registered as an uppercase string
-  if ( std::any_of( std::begin( key ), std::end( key ), []( char c ) { return ( std::islower( c ) ); } ) ) plumed_error() << "Action: " + key + " cannot be registered, use only UPPERCASE characters";
+  if ( std::any_of( std::begin( key ), std::end( key ), []( char c ) {
+  return ( std::islower( c ) )
+           ;
+  } ) ) plumed_error() << "Action: " + key + " cannot be registered, use only UPPERCASE characters";
   return RegisterBase::add(key,Pointers{cp,kp});
 }
 
@@ -94,7 +104,9 @@ bool ActionRegister::getKeywords(const std::string& action, Keywords& keys) {
 }
 
 void ActionRegister::getKeywords(const std::vector<void*> & images, const std::string& action, Keywords& keys) {
-  auto content=get(images,action); keys.thisactname = action; content.keys(keys);
+  auto content=get(images,action);
+  keys.thisactname = action;
+  content.keys(keys);
 }
 
 }
diff --git a/src/core/ActionRegister.h b/src/core/ActionRegister.h
index 474505addc..dd6b0ce862 100644
--- a/src/core/ActionRegister.h
+++ b/src/core/ActionRegister.h
@@ -97,13 +97,14 @@ class ActionRegistration {
 public:
   ///On construction register the ActionClass with the wanted directive
   ActionRegistration(std::string_view directive):
-    id(actionRegister().add(directive.data(),create,ActionClass::registerKeywords))
-  {
+    id(actionRegister().add(directive.data(),create,ActionClass::registerKeywords)) {
     static_assert(isActionType<ActionClass>,
                   "ActionRegistration accepts only class that inherit from Action");
   }
   ///On destruction deregister the ActionClass (useful when you unload a shared object)
-  ~ActionRegistration() {actionRegister().remove(id);}
+  ~ActionRegistration() {
+    actionRegister().remove(id);
+  }
 };
 } //PLMD
 
diff --git a/src/core/ActionSet.cpp b/src/core/ActionSet.cpp
index 84e3c37c38..e6c16dc537 100644
--- a/src/core/ActionSet.cpp
+++ b/src/core/ActionSet.cpp
@@ -28,14 +28,17 @@ ActionSet::ActionSet(PlumedMain&p):
   (void) plumed; // to suppress warning about "unused plumed"
 }
 
-ActionSet::~ActionSet()
-{
+ActionSet::~ActionSet() {
 // required in order to deallocate in reverse order:
-  for(int i=size()-1; i>=0; i--) (*this)[i].reset();
+  for(int i=size()-1; i>=0; i--) {
+    (*this)[i].reset();
+  }
 }
 
 void ActionSet::clearDelete() {
-  for(int i=size()-1; i>=0; i--) (*this)[i].reset();
+  for(int i=size()-1; i>=0; i--) {
+    (*this)[i].reset();
+  }
   clear();
 }
 
@@ -43,9 +46,13 @@ ActionShortcut* ActionSet::getShortcutActionWithLabel( const std::string& s ) co
   ActionShortcut* scf = NULL;
   for(const auto & p : (*this)) {
     ActionShortcut* sc=dynamic_cast<ActionShortcut*>(p.get());
-    if( sc && sc->shortcutlabel==s ) scf = sc;
+    if( sc && sc->shortcutlabel==s ) {
+      scf = sc;
+    }
+  }
+  if( scf ) {
+    return scf;
   }
-  if( scf ) return scf;
   return NULL;
 }
 
diff --git a/src/core/ActionSet.h b/src/core/ActionSet.h
index 77c706ecf1..52d2951515 100644
--- a/src/core/ActionSet.h
+++ b/src/core/ActionSet.h
@@ -38,8 +38,7 @@ class PlumedMain;
 /// Finally, since it holds pointers, there is a clearDelete() function
 /// which deletes the pointers before deleting the vector
 class ActionSet:
-  public std::vector<std::unique_ptr<Action>>
-{
+  public std::vector<std::unique_ptr<Action>> {
   PlumedMain& plumed;
 public:
   explicit ActionSet(PlumedMain&p);
@@ -88,7 +87,9 @@ std::vector<T> ActionSet::select()const {
   std::vector<T> ret;
   for(const auto & p : (*this)) {
     T t=dynamic_cast<T>(p.get());
-    if(t) ret.push_back(t);
+    if(t) {
+      ret.push_back(t);
+    }
   };
   return ret;
 }
@@ -97,7 +98,9 @@ template <class T>
 T ActionSet::selectWithLabel(const std::string&s)const {
   for(const auto & p : (*this)) {
     T t=dynamic_cast<T>(p.get());
-    if(t && t->getLabel()==s) return t;
+    if(t && t->getLabel()==s) {
+      return t;
+    }
   };
   return NULL;
 }
@@ -107,7 +110,9 @@ std::vector<Action*> ActionSet::selectNot()const {
   std::vector<Action*> ret;
   for(const auto & p : (*this)) {
     T t=dynamic_cast<T>(p);
-    if(!t) ret.push_back(p.get());
+    if(!t) {
+      ret.push_back(p.get());
+    }
   };
   return ret;
 }
@@ -116,7 +121,9 @@ template <class T>
 std::string ActionSet::getLabelList() const {
   std::string outlist;
   for(const auto & p : (*this)) {
-    if(dynamic_cast<T>(p.get())) outlist+=p->getLabel()+" ";
+    if(dynamic_cast<T>(p.get())) {
+      outlist+=p->getLabel()+" ";
+    }
   };
   return  outlist;
 }
@@ -126,7 +133,9 @@ template <class T>
 std::vector<std::string> ActionSet::getLabelVector() const {
   std::vector<std::string> outlist;
   for(const auto & p : (*this)) {
-    if(dynamic_cast<T>(p.get())) outlist.push_back(p->getLabel());
+    if(dynamic_cast<T>(p.get())) {
+      outlist.push_back(p->getLabel());
+    }
   };
   return  outlist;
 }
@@ -135,9 +144,13 @@ template <class T>
 T ActionSet::selectLatest(const Action*action) const {
   T t=nullptr;
   for(const auto & p : (*this)) {
-    if(p.get()==action) return t;
+    if(p.get()==action) {
+      return t;
+    }
     T r=dynamic_cast<T>(p.get());
-    if(r) t=r;
+    if(r) {
+      t=r;
+    }
   }
   return t;
 }
diff --git a/src/core/ActionSetup.cpp b/src/core/ActionSetup.cpp
index b70515b3a7..a7e16faa3d 100644
--- a/src/core/ActionSetup.cpp
+++ b/src/core/ActionSetup.cpp
@@ -29,8 +29,7 @@
 namespace PLMD {
 
 ActionSetup::ActionSetup(const ActionOptions&ao):
-  Action(ao)
-{
+  Action(ao) {
   const ActionSet& actionset(plumed.getActionSet());
   for(const auto & p : actionset) {
     // check that all the preceding actions are ActionSetup
diff --git a/src/core/ActionShortcut.cpp b/src/core/ActionShortcut.cpp
index 29e5658155..f165db0af5 100644
--- a/src/core/ActionShortcut.cpp
+++ b/src/core/ActionShortcut.cpp
@@ -42,75 +42,112 @@ void ActionShortcut::readShortcutKeywords( const Keywords& keys, std::map<std::s
         keymap.insert(std::pair<std::string,std::string>(keyname,t));
       } else if( keys.numbered( keyname ) ) {
         for(unsigned i=1;; ++i) {
-          std::string istr; Tools::convert( i, istr );
-          if( !parseNumbered(keyname,i,t) ) break ;
+          std::string istr;
+          Tools::convert( i, istr );
+          if( !parseNumbered(keyname,i,t) ) {
+            break ;
+          }
           keymap.insert(std::pair<std::string,std::string>(keyname + istr,t));
         }
       }
     } else if( keys.style( keyname, "flag") ) {
-      bool found=false; parseFlag(keyname,found);
-      if( found ) keymap.insert(std::pair<std::string,std::string>(keyname,""));
-    } else plumed_merror("shortcut keywords should be optional, compulsory or flags");
+      bool found=false;
+      parseFlag(keyname,found);
+      if( found ) {
+        keymap.insert(std::pair<std::string,std::string>(keyname,""));
+      }
+    } else {
+      plumed_merror("shortcut keywords should be optional, compulsory or flags");
+    }
   }
 }
 
 ActionShortcut::ActionShortcut(const ActionOptions&ao):
   Action(ao),
-  shortcutlabel(label)
-{
-  std::string s; Tools::convert(plumed.getActionSet().size(),s);
+  shortcutlabel(label) {
+  std::string s;
+  Tools::convert(plumed.getActionSet().size(),s);
   if( shortcutlabel==("@" + s) ) {
-    std::string t; Tools::convert(plumed.getActionSet().size(),t);
+    std::string t;
+    Tools::convert(plumed.getActionSet().size(),t);
     shortcutlabel="@" + t;
-  } else label = ("@s" + s);
+  } else {
+    label = ("@s" + s);
+  }
 }
 
 void ActionShortcut::readInputLine( const std::string& input, bool saveline ) {
-  std::vector<std::string> words=Tools::getWords(input); Tools::interpretLabel(words);
+  std::vector<std::string> words=Tools::getWords(input);
+  Tools::interpretLabel(words);
   // Check if this action name has been registered
   bool founds=false, found = std::find(keywords.neededActions.begin(), keywords.neededActions.end(), words[0] )!=keywords.neededActions.end();
   // Check if we are just calling something like SUM_VECTOR using just SUM.
   if( !found && words[0].find(getName())!=std::string::npos ) {
     for(unsigned j=0 ; j<keywords.actionNameSuffixes.size(); ++j) {
-      if( (getName() + keywords.actionNameSuffixes[j])==words[0] ) { found=true; break; }
+      if( (getName() + keywords.actionNameSuffixes[j])==words[0] ) {
+        found=true;
+        break;
+      }
     }
     founds=true;
   }
   if( found ) {
-    std::string f_input = input; if( !founds && saveline ) addToSavedInputLines( input );
+    std::string f_input = input;
+    if( !founds && saveline ) {
+      addToSavedInputLines( input );
+    }
     if( keywords.exists("RESTART") ) {
-      if( restart ) f_input += " RESTART=YES";
-      if( !restart ) f_input += " RESTART=NO";
+      if( restart ) {
+        f_input += " RESTART=YES";
+      }
+      if( !restart ) {
+        f_input += " RESTART=NO";
+      }
     }
     plumed.readInputLine( f_input );
     if( !founds ) {
       ActionWithValue* av=NULL;
       for(auto pp=plumed.getActionSet().rbegin(); pp!=plumed.getActionSet().rend(); ++pp) {
         av = pp->get()->castToActionWithValue();
-        if( !av ) continue ;
-        if( std::find(savedOutputs.begin(), savedOutputs.end(), av->getLabel() )!=savedOutputs.end() ) av=NULL;
+        if( !av ) {
+          continue ;
+        }
+        if( std::find(savedOutputs.begin(), savedOutputs.end(), av->getLabel() )!=savedOutputs.end() ) {
+          av=NULL;
+        }
         break;
       }
       if( av ) {
         std::string av_label = av->getLabel();
-        if( av_label == getShortcutLabel() ) savedOutputs.push_back( av_label );
-        else {
+        if( av_label == getShortcutLabel() ) {
+          savedOutputs.push_back( av_label );
+        } else {
           for(unsigned i=0; i<keywords.cnames.size(); ++i) {
-            if( av_label == getShortcutLabel() + "_" + keywords.cnames[i] ) savedOutputs.push_back( av_label );
-            else if( keywords.getOutputComponentFlag(keywords.cnames[i])!="default" ) {
+            if( av_label == getShortcutLabel() + "_" + keywords.cnames[i] ) {
+              savedOutputs.push_back( av_label );
+            } else if( keywords.getOutputComponentFlag(keywords.cnames[i])!="default" ) {
               std::string thisflag = keywords.getOutputComponentFlag(keywords.cnames[i]);
-              if( keywords.numbered(thisflag) && av_label.find(getShortcutLabel() + "_" + keywords.cnames[i])!=std::string::npos ) savedOutputs.push_back( av_label );
+              if( keywords.numbered(thisflag) && av_label.find(getShortcutLabel() + "_" + keywords.cnames[i])!=std::string::npos ) {
+                savedOutputs.push_back( av_label );
+              }
             }
           }
         }
       }
     } else {
       ActionWithValue* av = plumed.getActionSet()[plumed.getActionSet().size()-1]->castToActionWithValue();
-      if( !av ) error("shortcut is using suffix but action created is not ActionWithValue");
-      Keywords thiskeys; actionRegister().getKeywords( av->getName(), thiskeys );
-      if( thiskeys.getDisplayName()!=getName() ) error("mismatch between display name of hidden action " + thiskeys.getDisplayName() + " and shortcut that creates it " + getName() );
+      if( !av ) {
+        error("shortcut is using suffix but action created is not ActionWithValue");
+      }
+      Keywords thiskeys;
+      actionRegister().getKeywords( av->getName(), thiskeys );
+      if( thiskeys.getDisplayName()!=getName() ) {
+        error("mismatch between display name of hidden action " + thiskeys.getDisplayName() + " and shortcut that creates it " + getName() );
+      }
     }
-  } else error("requirement for action " + words[0] + " should be registered in registerKeywords function for shortcut action using keys.useAction");
+  } else {
+    error("requirement for action " + words[0] + " should be registered in registerKeywords function for shortcut action using keys.useAction");
+  }
 }
 
 void ActionShortcut::addCommentToShortcutOutput( const std::string& input ) {
@@ -120,59 +157,93 @@ void ActionShortcut::addCommentToShortcutOutput( const std::string& input ) {
 std::string ActionShortcut::getUpdateLimits() const {
   std::string f_input="";
   if( update_from!=std::numeric_limits<double>::max() ) {
-    std::string ufrom; Tools::convert( update_from, ufrom ); f_input += " UPDATE_FROM=" + ufrom;
+    std::string ufrom;
+    Tools::convert( update_from, ufrom );
+    f_input += " UPDATE_FROM=" + ufrom;
   }
   if( update_until!=std::numeric_limits<double>::max() ) {
-    std::string util; Tools::convert( update_until, util ); f_input += " UPDATE_UNTIL=" + util;
+    std::string util;
+    Tools::convert( update_until, util );
+    f_input += " UPDATE_UNTIL=" + util;
   }
   return f_input;
 }
 
 void ActionShortcut::addToSavedInputLines( const std::string& line ) {
-  std::vector<std::string> words = Tools::getWords(line); std::string actname;
-  if( words[0].find_first_of(":")!=std::string::npos) actname = words[1]; else actname = words[0];
-  if( !actionRegister().check(actname) ) error("found no action with name " + actname + " to create shortcut");
-  Keywords thiskeys; actionRegister().getKeywords( actname, thiskeys ); std::vector<std::string> numberedkeys;
+  std::vector<std::string> words = Tools::getWords(line);
+  std::string actname;
+  if( words[0].find_first_of(":")!=std::string::npos) {
+    actname = words[1];
+  } else {
+    actname = words[0];
+  }
+  if( !actionRegister().check(actname) ) {
+    error("found no action with name " + actname + " to create shortcut");
+  }
+  Keywords thiskeys;
+  actionRegister().getKeywords( actname, thiskeys );
+  std::vector<std::string> numberedkeys;
   for(unsigned i=0; i<thiskeys.size(); ++i ) {
-    if( thiskeys.numbered( thiskeys.getKeyword(i) ) ) numberedkeys.push_back( thiskeys.getKeyword(i) );
+    if( thiskeys.numbered( thiskeys.getKeyword(i) ) ) {
+      numberedkeys.push_back( thiskeys.getKeyword(i) );
+    }
   }
   if( numberedkeys.size()>0 && actname!="CONCATENATE" ) {
     std::string reducedline;
     for(unsigned i=0; i<words.size(); ++i) {
       bool notnumbered=true;
       for(unsigned j=0; j<numberedkeys.size(); ++j) {
-        if( words[i].find(numberedkeys[j])!=std::string::npos && words[i].substr(0,numberedkeys[j].length()+1)!=numberedkeys[j]+"=" ) { notnumbered=false; break; }
+        if( words[i].find(numberedkeys[j])!=std::string::npos && words[i].substr(0,numberedkeys[j].length()+1)!=numberedkeys[j]+"=" ) {
+          notnumbered=false;
+          break;
+        }
       }
       if( notnumbered || words[i]==actname ) {
         if( words[i].find(" ")!=std::string::npos) {
           std::size_t eq=words[i].find_first_of("=");
           reducedline += words[i].substr(0,eq) + "={" + words[i].substr(eq+1) + "} ";
-        } else reducedline += words[i] + " ";
+        } else {
+          reducedline += words[i] + " ";
+        }
       }
     }
     std::vector<unsigned> ninstances( numberedkeys.size(), 0 );
     for(unsigned j=0; j<numberedkeys.size(); ++j) {
       for(unsigned i=1;; ++i) {
-        std::string num, val; Tools::convert(i, num);
+        std::string num, val;
+        Tools::convert(i, num);
         bool found = Tools::parse(words, numberedkeys[j] + num, val );
-        if( !found) break ;
-        if( i<6 ) reducedline += numberedkeys[j] + num + "=" + val + " ";
-        else ninstances[j]++;
+        if( !found) {
+          break ;
+        }
+        if( i<6 ) {
+          reducedline += numberedkeys[j] + num + "=" + val + " ";
+        } else {
+          ninstances[j]++;
+        }
       }
     }
     bool outputcomment=false;
     for(unsigned j=0; j<numberedkeys.size(); ++j) {
-      if( ninstances[j]>0 ) { outputcomment=true; break; }
+      if( ninstances[j]>0 ) {
+        outputcomment=true;
+        break;
+      }
     }
     if( outputcomment ) {
       reducedline += "    # Action input conctinues with ";
       for(unsigned  j=0; j<numberedkeys.size(); ++j) {
-        std::string num; Tools::convert( ninstances[j], num );
-        if( ninstances[j]>0 ) reducedline += num + " further " + numberedkeys[j] + "n keywords, ";
+        std::string num;
+        Tools::convert( ninstances[j], num );
+        if( ninstances[j]>0 ) {
+          reducedline += num + " further " + numberedkeys[j] + "n keywords, ";
+        }
       }
     }
     savedInputLines.push_back( reducedline );
-  } else savedInputLines.push_back( line );
+  } else {
+    savedInputLines.push_back( line );
+  }
 }
 
 const std::string & ActionShortcut::getShortcutLabel() const {
@@ -193,15 +264,21 @@ std::string ActionShortcut::convertInputLineToString() {
     if( (*p).find(" " )!=std::string::npos ) {
       std::size_t eq = (*p).find_first_of("=");
       output += " " + (*p).substr(0,eq) + "={" + (*p).substr(eq+1) + "}";
-    } else output += " " + (*p);
+    } else {
+      output += " " + (*p);
+    }
   }
-  line.resize(0); return output;
+  line.resize(0);
+  return output;
 }
 
 void ActionShortcut::interpretDataLabel( const std::string& mystr, Action* myuser, std::vector<Value*>& arg ) const {
-  std::size_t dot=mystr.find_first_of('.'); std::string a=mystr.substr(0,dot); std::string name=mystr.substr(dot+1);
+  std::size_t dot=mystr.find_first_of('.');
+  std::string a=mystr.substr(0,dot);
+  std::string name=mystr.substr(dot+1);
   // Retrieve the keywords for the shortcut
-  Keywords skeys; actionRegister().getKeywords( getName(), skeys );
+  Keywords skeys;
+  actionRegister().getKeywords( getName(), skeys );
   std::vector<std::string> out_comps( skeys.getOutputComponents() );
   // Now get the output components
   if( name=="*" ) {
@@ -209,21 +286,30 @@ void ActionShortcut::interpretDataLabel( const std::string& mystr, Action* myuse
       if( out_comps[k]=="" ) {
         ActionWithValue* action=plumed.getActionSet().selectWithLabel<ActionWithValue*>( a );
         if( action ) {
-          if( action->getNumberOfComponents()!=1 ) myuser->error("action named " + a + " has more than one component");
+          if( action->getNumberOfComponents()!=1 ) {
+            myuser->error("action named " + a + " has more than one component");
+          }
           arg.push_back(action->copyOutput(0));
         }
       } else {
         ActionWithValue* action=plumed.getActionSet().selectWithLabel<ActionWithValue*>( a + "_" + out_comps[k] );
         if( action ) {
-          if( action->getNumberOfComponents()!=1 ) myuser->error("action named " + a + "_" + out_comps[k] + " has more than one component");
+          if( action->getNumberOfComponents()!=1 ) {
+            myuser->error("action named " + a + "_" + out_comps[k] + " has more than one component");
+          }
           arg.push_back(action->copyOutput(0));
         } else {
           for(unsigned j=1;; ++j) {
-            std::string numstr; Tools::convert( j, numstr );
+            std::string numstr;
+            Tools::convert( j, numstr );
             ActionWithValue* act=plumed.getActionSet().selectWithLabel<ActionWithValue*>( a + "_" + out_comps[k] + "-" + numstr );
             if( act ) {
-              for(unsigned n=0; n<act->getNumberOfComponents(); ++n ) arg.push_back(act->copyOutput(n));
-            } else if( j>1 ) break;    // This ensures that * syntax works with moments, which normally start from 2
+              for(unsigned n=0; n<act->getNumberOfComponents(); ++n ) {
+                arg.push_back(act->copyOutput(n));
+              }
+            } else if( j>1 ) {
+              break;  // This ensures that * syntax works with moments, which normally start from 2
+            }
           }
         }
       }
@@ -231,12 +317,16 @@ void ActionShortcut::interpretDataLabel( const std::string& mystr, Action* myuse
   } else {
     // Check for an action that has action.component
     ActionWithValue* act=plumed.getActionSet().selectWithLabel<ActionWithValue*>( a );
-    if( act && act->exists(mystr) ) return;
+    if( act && act->exists(mystr) ) {
+      return;
+    }
     // Get components that are actually actions
     for(unsigned k=0; k<out_comps.size(); ++k) {
       if(name.find_first_of(out_comps[k])!=std::string::npos ) {
         ActionWithValue* action=plumed.getActionSet().selectWithLabel<ActionWithValue*>( a + "_" + name );
-        if( action ) arg.push_back(action->copyOutput(a+"_"+name));
+        if( action ) {
+          arg.push_back(action->copyOutput(a+"_"+name));
+        }
         break;
       }
     }
diff --git a/src/core/ActionShortcut.h b/src/core/ActionShortcut.h
index be4ef136bb..b83907574a 100644
--- a/src/core/ActionShortcut.h
+++ b/src/core/ActionShortcut.h
@@ -63,7 +63,9 @@ class ActionShortcut :
   std::string convertInputLineToString();
 /// This sorts out the reading of arguments from shortcuts
   void interpretDataLabel( const std::string& mystr, Action* myuser, std::vector<Value*>& args ) const ;
-  ActionShortcut* castToActionShortcut() noexcept final { return this; }
+  ActionShortcut* castToActionShortcut() noexcept final {
+    return this;
+  }
 };
 
 }
diff --git a/src/core/ActionToGetData.cpp b/src/core/ActionToGetData.cpp
index 8c363b1e61..6f16d36f5e 100644
--- a/src/core/ActionToGetData.cpp
+++ b/src/core/ActionToGetData.cpp
@@ -37,7 +37,9 @@ namespace PLMD {
 PLUMED_REGISTER_ACTION(ActionToGetData,"GET")
 
 void ActionToGetData::registerKeywords(Keywords& keys) {
-  Action::registerKeywords(keys); ActionPilot::registerKeywords(keys); ActionWithArguments::registerKeywords(keys);
+  Action::registerKeywords(keys);
+  ActionPilot::registerKeywords(keys);
+  ActionWithArguments::registerKeywords(keys);
   keys.add("compulsory","STRIDE","1","the frequency with which the quantities of interest should be stored");
   keys.add("compulsory","TYPE","value","what do you want to collect for the value can be derivative/force");
   keys.use("ARG");
@@ -48,30 +50,50 @@ ActionToGetData::ActionToGetData(const ActionOptions&ao):
   Action(ao),
   ActionPilot(ao),
   ActionWithArguments(ao),
-  mydata(DataPassingObject::create(plumed.getRealPrecision()))
-{
-  std::string type; parse("TYPE",type);
-  if( type=="value" ) gtype=val;
-  else if( type=="derivatives" ) gtype=deriv;
-  else if( type=="forces" ) gtype=force;
-  else plumed_merror("cannot get " + type + " for value TYPE should be value/derivative/force");
-
-  if( gtype!=val ) error("not implemented functionality to pass derviatives or forces to python.  Email gareth.tribello@gmail.com if you want this.");
-
-  if( getNumberOfArguments()!=1 ) error("python interface works best when you ask for one argument at a time");
-  if( getPntrToArgument(0)->getNumberOfValues()==0 ) error("cannot get data as shape of value " + getPntrToArgument(0)->getName() + " has not been set");
-  getPntrToArgument(0)->buildDataStore(); data.resize( getPntrToArgument(0)->getNumberOfValues() );
+  mydata(DataPassingObject::create(plumed.getRealPrecision())) {
+  std::string type;
+  parse("TYPE",type);
+  if( type=="value" ) {
+    gtype=val;
+  } else if( type=="derivatives" ) {
+    gtype=deriv;
+  } else if( type=="forces" ) {
+    gtype=force;
+  } else {
+    plumed_merror("cannot get " + type + " for value TYPE should be value/derivative/force");
+  }
+
+  if( gtype!=val ) {
+    error("not implemented functionality to pass derviatives or forces to python.  Email gareth.tribello@gmail.com if you want this.");
+  }
+
+  if( getNumberOfArguments()!=1 ) {
+    error("python interface works best when you ask for one argument at a time");
+  }
+  if( getPntrToArgument(0)->getNumberOfValues()==0 ) {
+    error("cannot get data as shape of value " + getPntrToArgument(0)->getName() + " has not been set");
+  }
+  getPntrToArgument(0)->buildDataStore();
+  data.resize( getPntrToArgument(0)->getNumberOfValues() );
 }
 
 void ActionToGetData::get_rank( const TypesafePtr & dims ) {
-  if( getPntrToArgument(0)->getRank()==0 ) { dims.set(long(1)); return; }
+  if( getPntrToArgument(0)->getRank()==0 ) {
+    dims.set(long(1));
+    return;
+  }
   dims.set(long(getPntrToArgument(0)->getRank()));
 }
 
 void ActionToGetData::get_shape( const TypesafePtr & dims ) {
-  if( getPntrToArgument(0)->getRank()==0 ) { dims.set(long(1)); return; }
+  if( getPntrToArgument(0)->getRank()==0 ) {
+    dims.set(long(1));
+    return;
+  }
   auto dims_=dims.get<long*>( { getPntrToArgument(0)->getRank() } );
-  for(unsigned j=0; j<getPntrToArgument(0)->getRank(); ++j) dims_[j] = getPntrToArgument(0)->getShape()[j];
+  for(unsigned j=0; j<getPntrToArgument(0)->getRank(); ++j) {
+    dims_[j] = getPntrToArgument(0)->getShape()[j];
+  }
 }
 
 void ActionToGetData::set_memory( const TypesafePtr & val ) {
@@ -79,7 +101,8 @@ void ActionToGetData::set_memory( const TypesafePtr & val ) {
 }
 
 void ActionToGetData::calculate() {
-  plumed_assert( gtype==val ); mydata->setData( getPntrToArgument(0) );
+  plumed_assert( gtype==val );
+  mydata->setData( getPntrToArgument(0) );
 }
 
 }
diff --git a/src/core/ActionToGetData.h b/src/core/ActionToGetData.h
index a6afbde6a0..04e285d4ca 100644
--- a/src/core/ActionToGetData.h
+++ b/src/core/ActionToGetData.h
@@ -30,8 +30,7 @@ namespace PLMD {
 
 class ActionToGetData :
   public ActionPilot,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
 private:
 /// What do you want to collect to pass back to python
   enum {val,deriv,force} gtype;
@@ -51,7 +50,9 @@ class ActionToGetData :
 /// Actually set the values for the output
   void calculate();
   void apply() {}
-  ActionToGetData* castToActionToGetData() noexcept final { return this; }
+  ActionToGetData* castToActionToGetData() noexcept final {
+    return this;
+  }
 };
 
 }
diff --git a/src/core/ActionToPutData.cpp b/src/core/ActionToPutData.cpp
index 06d75abf61..24b52e0d22 100644
--- a/src/core/ActionToPutData.cpp
+++ b/src/core/ActionToPutData.cpp
@@ -60,87 +60,150 @@ ActionToPutData::ActionToPutData(const ActionOptions&ao):
   resetable(false),
   dataCanBeSet(true),
   unit(n),
-  mydata(DataPassingObject::create(plumed.getRealPrecision()))
-{
+  mydata(DataPassingObject::create(plumed.getRealPrecision())) {
   if( getName()!="ENERGY" && getName()!="PBC" ) {
-    std::vector<unsigned> shape; parseVector("SHAPE",shape);
-    if( shape.size()==1 && shape[0]==0 ) { shape.resize(0); addValue( shape ); }
-    else { addValue( shape ); }
-
-    std::string unitstr, funitstr; parse("UNIT",unitstr);
-    parse("FORCE_UNIT",funitstr); setUnit( unitstr, funitstr );
+    std::vector<unsigned> shape;
+    parseVector("SHAPE",shape);
+    if( shape.size()==1 && shape[0]==0 ) {
+      shape.resize(0);
+      addValue( shape );
+    } else {
+      addValue( shape );
+    }
+
+    std::string unitstr, funitstr;
+    parse("UNIT",unitstr);
+    parse("FORCE_UNIT",funitstr);
+    setUnit( unitstr, funitstr );
 
     // Now sort out period
-    std::vector<std::string> period; parseVector("PERIODIC",period);
+    std::vector<std::string> period;
+    parseVector("PERIODIC",period);
     if( period.size()==1 ) {
-      if( period[0]!="NO") error("input to PERIODIC keyword does not make sense");
+      if( period[0]!="NO") {
+        error("input to PERIODIC keyword does not make sense");
+      }
       setNotPeriodic();
-    } else if( period.size()==2 ) setPeriodic( period[0], period[1] );
-    else  error("input to PERIODIC keyword does not make sense");
-
-    parseFlag("CONSTANT",fixed); if( fixed ) { noforce=true; copyOutput(0)->setConstant(); }
-    parseFlag("FROM_DOMAINS",from_domains); parseFlag("MUTABLE",resetable);
+    } else if( period.size()==2 ) {
+      setPeriodic( period[0], period[1] );
+    } else {
+      error("input to PERIODIC keyword does not make sense");
+    }
+
+    parseFlag("CONSTANT",fixed);
+    if( fixed ) {
+      noforce=true;
+      copyOutput(0)->setConstant();
+    }
+    parseFlag("FROM_DOMAINS",from_domains);
+    parseFlag("MUTABLE",resetable);
   }
 }
 
 void ActionToPutData::setUnit( const std::string& unitstr, const std::string& funitstr ) {
-  if( unitstr=="number" ) unit=n;
-  else if( unitstr=="energy" ) unit=e;
-  else if( unitstr=="length" ) unit=l;
-  else if( unitstr=="mass" ) unit=m;
-  else if( unitstr=="charge" ) unit=q;
-  else if( unitstr=="time" ) unit=t;
-  else error( unitstr + " is not a valid input unit");
+  if( unitstr=="number" ) {
+    unit=n;
+  } else if( unitstr=="energy" ) {
+    unit=e;
+  } else if( unitstr=="length" ) {
+    unit=l;
+  } else if( unitstr=="mass" ) {
+    unit=m;
+  } else if( unitstr=="charge" ) {
+    unit=q;
+  } else if( unitstr=="time" ) {
+    unit=t;
+  } else {
+    error( unitstr + " is not a valid input unit");
+  }
   // Set the force units
-  if( funitstr=="default" ) funit=d;
-  else if( funitstr=="energy" ) funit=eng;
-  else error( funitstr + " is not a valid input force unit");
+  if( funitstr=="default" ) {
+    funit=d;
+  } else if( funitstr=="energy" ) {
+    funit=eng;
+  } else {
+    error( funitstr + " is not a valid input force unit");
+  }
 }
 
 std::string ActionToPutData::getUnitName() const {
-  if( unit==e ) return "energy";
-  if( unit==l ) return "length";
-  if( unit==m ) return "mass";
-  if( unit==q ) return "charge";
-  if( unit==t ) return "time";
+  if( unit==e ) {
+    return "energy";
+  }
+  if( unit==l ) {
+    return "length";
+  }
+  if( unit==m ) {
+    return "mass";
+  }
+  if( unit==q ) {
+    return "charge";
+  }
+  if( unit==t ) {
+    return "time";
+  }
   plumed_error();
 }
 
 void ActionToPutData::setStart( const std::string& name, const unsigned& sss) {
-  plumed_assert( name==getLabel() ); mydata->setStart(sss);
+  plumed_assert( name==getLabel() );
+  mydata->setStart(sss);
 }
 
 void ActionToPutData::setStride( const std::string& name, const unsigned& sss ) {
-  plumed_assert( name==getLabel() ); mydata->setStride(sss);
+  plumed_assert( name==getLabel() );
+  mydata->setStride(sss);
 }
 
 void ActionToPutData::updateUnits( DataPassingTools* passtools ) {
   // Don't need to do anythign if this is just a number
-  if( unit==n ) return ;
+  if( unit==n ) {
+    return ;
+  }
 
   double vunits=passtools->getUnitConversion( getUnitName() );
-  mydata->setUnit(vunits); if( fixed && wasset ) mydata->share_data( 0, getPntrToValue()->getNumberOfValues(), getPntrToValue() );
-  if( funit==eng ) mydata->setForceUnit( 1/passtools->getUnitConversion("energy"));
-  else if( funit==d ) mydata->setForceUnit(1/passtools->getUnitConversion("energy")*vunits);
+  mydata->setUnit(vunits);
+  if( fixed && wasset ) {
+    mydata->share_data( 0, getPntrToValue()->getNumberOfValues(), getPntrToValue() );
+  }
+  if( funit==eng ) {
+    mydata->setForceUnit( 1/passtools->getUnitConversion("energy"));
+  } else if( funit==d ) {
+    mydata->setForceUnit(1/passtools->getUnitConversion("energy")*vunits);
+  }
 }
 
 bool ActionToPutData::setValuePointer( const std::string& name, const TypesafePtr & val ) {
-  if( name!=getLabel() ) return false;
-  wasset=true; plumed_massert( dataCanBeSet, "set " + getLabel() + " cannot be set at this time");
+  if( name!=getLabel() ) {
+    return false;
+  }
+  wasset=true;
+  plumed_massert( dataCanBeSet, "set " + getLabel() + " cannot be set at this time");
   if( !from_domains ) {
     if( !resetable && getPntrToComponent(0)->getRank()==0 ) {
       mydata->saveValueAsDouble( val );
-      if( fixed ) mydata->share_data( 0, getPntrToValue()->getNumberOfValues(), getPntrToValue() );
-    } else mydata->setValuePointer(val,getPntrToComponent(0)->getShape(), !resetable);
-  } else mydata->setValuePointer(val,std::vector<unsigned>(), !resetable);
+      if( fixed ) {
+        mydata->share_data( 0, getPntrToValue()->getNumberOfValues(), getPntrToValue() );
+      }
+    } else {
+      mydata->setValuePointer(val,getPntrToComponent(0)->getShape(), !resetable);
+    }
+  } else {
+    mydata->setValuePointer(val,std::vector<unsigned>(), !resetable);
+  }
   return true;
 }
 
 bool ActionToPutData::setForcePointer( const std::string& name, const TypesafePtr & val ) {
-  if( name!=getLabel() ) return false;
+  if( name!=getLabel() ) {
+    return false;
+  }
   plumed_massert( dataCanBeSet, "force on " + getLabel() + " cannot be set at this time");
-  if( !from_domains ) mydata->setForcePointer(val,getPntrToComponent(0)->getShape());
-  else mydata->setForcePointer(val,std::vector<unsigned>());
+  if( !from_domains ) {
+    mydata->setForcePointer(val,getPntrToComponent(0)->getShape());
+  } else {
+    mydata->setForcePointer(val,std::vector<unsigned>());
+  }
   return true;
 }
 
@@ -149,18 +212,26 @@ void ActionToPutData::getLocalValues( std::vector<double>& vals ) const {
 }
 
 void ActionToPutData::wait() {
-  dataCanBeSet=false; if( fixed || !wasset ) { return; } plumed_assert( wasset );
+  dataCanBeSet=false;
+  if( fixed || !wasset ) {
+    return;
+  }
+  plumed_assert( wasset );
   mydata->share_data( 0, getPntrToValue()->getNumberOfValues(), getPntrToValue() );
 }
 
 void ActionToPutData::apply() {
   if( getPntrToValue()->forcesWereAdded() && !noforce ) {
-    if( getName()=="ENERGY" || getDependencies().size()==0 ) mydata->add_force( getPntrToValue() );
+    if( getName()=="ENERGY" || getDependencies().size()==0 ) {
+      mydata->add_force( getPntrToValue() );
+    }
   }
 }
 
 unsigned ActionToPutData::getNumberOfForcesToRescale() const {
-  if( getName()!="ENERGY" || getDependencies().size()>0 ) return copyOutput(0)->getNumberOfValues();
+  if( getName()!="ENERGY" || getDependencies().size()>0 ) {
+    return copyOutput(0)->getNumberOfValues();
+  }
   plumed_assert( getDependencies().size()==1 );
   plumed_assert(getDependencies()[0]); // needed for following calls, see #1046
   ActionForInterface* ai = getDependencies()[0]->castToActionForInterface();
@@ -168,17 +239,24 @@ unsigned ActionToPutData::getNumberOfForcesToRescale() const {
 }
 
 void ActionToPutData::rescaleForces( const double& alpha ) {
-  if( noforce ) return; wasscaled=true;
+  if( noforce ) {
+    return;
+  }
+  wasscaled=true;
   mydata->rescale_force( getNumberOfForcesToRescale(), alpha, getPntrToValue() );
 
 }
 
 void ActionToPutData::writeBinary(std::ostream&o) {
-  if(!fixed) getPntrToValue()->writeBinary(o);
+  if(!fixed) {
+    getPntrToValue()->writeBinary(o);
+  }
 }
 
 void ActionToPutData::readBinary(std::istream&i) {
-  if(!fixed) getPntrToValue()->readBinary(i);
+  if(!fixed) {
+    getPntrToValue()->readBinary(i);
+  }
 }
 
 }
diff --git a/src/core/ActionToPutData.h b/src/core/ActionToPutData.h
index dbbf96008d..6efe24cee4 100644
--- a/src/core/ActionToPutData.h
+++ b/src/core/ActionToPutData.h
@@ -30,8 +30,7 @@
 namespace PLMD {
 
 class ActionToPutData :
-  public ActionForInterface
-{
+  public ActionForInterface {
   friend class PlumedMain;
   friend class TimeStep;
   friend class DomainDecomposition;
@@ -67,7 +66,9 @@ class ActionToPutData :
 /// Update the units on the input data
   void updateUnits( DataPassingTools* passtools );
 /// This is called at the start of the step
-  void resetForStepStart() override { dataCanBeSet = true; }
+  void resetForStepStart() override {
+    dataCanBeSet = true;
+  }
 /// These are the actions that set the pointers to the approrpiate values
   virtual bool setValuePointer( const std::string& name, const TypesafePtr & val ) override ;
   bool setForcePointer( const std::string& name, const TypesafePtr & val ) override ;
@@ -88,8 +89,12 @@ class ActionToPutData :
 /// For replica exchange
   void writeBinary(std::ostream&o) override;
   virtual void readBinary(std::istream&i) override;
-  bool onStep() const override { return false; }
-  ActionToPutData* castToActionToPutData() noexcept final { return this; }
+  bool onStep() const override {
+    return false;
+  }
+  ActionToPutData* castToActionToPutData() noexcept final {
+    return this;
+  }
 };
 
 }
diff --git a/src/core/ActionWithArguments.cpp b/src/core/ActionWithArguments.cpp
index a1b9208e6a..3bb5f61d52 100644
--- a/src/core/ActionWithArguments.cpp
+++ b/src/core/ActionWithArguments.cpp
@@ -48,10 +48,16 @@ void ActionWithArguments::registerKeywords(Keywords& keys) {
 }
 
 void ActionWithArguments::parseArgumentList(const std::string&key,std::vector<Value*>&arg) {
-  std::string def; std::vector<std::string> c; arg.clear(); parseVector(key,c);
+  std::string def;
+  std::vector<std::string> c;
+  arg.clear();
+  parseVector(key,c);
   if( c.size()==0 && (keywords.style(key,"compulsory") || keywords.style(key,"hidden")) ) {
-    if( keywords.getDefaultValue(key,def) ) c.push_back( def );
-    else return;
+    if( keywords.getDefaultValue(key,def) ) {
+      c.push_back( def );
+    } else {
+      return;
+    }
   }
   interpretArgumentList(c,plumed.getActionSet(),this,arg);
 }
@@ -62,7 +68,9 @@ bool ActionWithArguments::parseArgumentList(const std::string&key,int i,std::vec
   if(parseNumberedVector(key,i,c)) {
     interpretArgumentList(c,plumed.getActionSet(),this,arg);
     return true;
-  } else return false;
+  } else {
+    return false;
+  }
 }
 
 void ActionWithArguments::interpretArgumentList(const std::vector<std::string>& c, const ActionSet& as, Action* readact, std::vector<Value*>&arg) {
@@ -76,7 +84,9 @@ void ActionWithArguments::interpretArgumentList(const std::vector<std::string>&
         // take the string enclosed in quotes and put in round brackets
         std::string myregex=c[i];
         std::vector<ActionWithValue*> all=as.select<ActionWithValue*>();
-        if( all.empty() ) readact->error("your input file is not telling plumed to calculate anything");
+        if( all.empty() ) {
+          readact->error("your input file is not telling plumed to calculate anything");
+        }
 
         try {
           std::regex txt_regex(myregex,std::regex::extended);
@@ -93,7 +103,9 @@ void ActionWithArguments::interpretArgumentList(const std::vector<std::string>&
         } catch(std::regex_error & e) {
           plumed_error()<<"Error parsing regular expression: "<<e.what();
         }
-        if(!found_something) plumed_error()<<"There isn't any action matching your regex " << myregex;
+        if(!found_something) {
+          plumed_error()<<"There isn't any action matching your regex " << myregex;
+        }
       } else {
         plumed_merror("did you want to use regexp to input arguments? enclose it between two round braces (...) with no spaces!");
       }
@@ -105,17 +117,26 @@ void ActionWithArguments::interpretArgumentList(const std::vector<std::string>&
         if(a=="*" && name=="*") {
           // Take all values from all actions
           std::vector<ActionWithValue*> all=as.select<ActionWithValue*>();
-          if( all.empty() ) readact->error("your input file is not telling plumed to calculate anything");
+          if( all.empty() ) {
+            readact->error("your input file is not telling plumed to calculate anything");
+          }
           for(unsigned j=0; j<all.size(); j++) {
             plumed_assert(all[j]); // needed for following calls, see #1046
-            ActionForInterface* ap=all[j]->castToActionForInterface(); if( ap ) continue;
-            for(int k=0; k<all[j]->getNumberOfComponents(); ++k) arg.push_back(all[j]->copyOutput(k));
+            ActionForInterface* ap=all[j]->castToActionForInterface();
+            if( ap ) {
+              continue;
+            }
+            for(int k=0; k<all[j]->getNumberOfComponents(); ++k) {
+              arg.push_back(all[j]->copyOutput(k));
+            }
           }
         } else if ( name=="*") {
           unsigned carg=arg.size();
           // Take all the values from an action with a specific name
           ActionShortcut* shortcut=as.getShortcutActionWithLabel(a);
-          if( shortcut ) shortcut->interpretDataLabel( a + "." + name, readact, arg );
+          if( shortcut ) {
+            shortcut->interpretDataLabel( a + "." + name, readact, arg );
+          }
           if( arg.size()==carg ) {
             // Take all the values from an action with a specific name
             ActionWithValue* action=as.selectWithLabel<ActionWithValue*>(a);
@@ -124,24 +145,36 @@ void ActionWithArguments::interpretArgumentList(const std::vector<std::string>&
               str+=as.getLabelList<ActionWithValue*>()+")";
               readact->error("cannot find action named " + a + str);
             }
-            if( action->getNumberOfComponents()==0 ) readact->error("found " + a +".* indicating use all components calculated by action with label " + a + " but this action has no components");
-            for(int k=0; k<action->getNumberOfComponents(); ++k) arg.push_back(action->copyOutput(k));
+            if( action->getNumberOfComponents()==0 ) {
+              readact->error("found " + a +".* indicating use all components calculated by action with label " + a + " but this action has no components");
+            }
+            for(int k=0; k<action->getNumberOfComponents(); ++k) {
+              arg.push_back(action->copyOutput(k));
+            }
           }
         } else if ( a=="*" ) {
           std::vector<ActionShortcut*> shortcuts=as.select<ActionShortcut*>();
           // Take components from all actions with a specific name
           std::vector<ActionWithValue*> all=as.select<ActionWithValue*>();
-          if( all.empty() ) readact->error("your input file is not telling plumed to calculate anything");
+          if( all.empty() ) {
+            readact->error("your input file is not telling plumed to calculate anything");
+          }
           unsigned carg=arg.size();
           for(unsigned j=0; j<shortcuts.size(); ++j) {
             shortcuts[j]->interpretDataLabel( shortcuts[j]->getShortcutLabel() + "." + name, readact, arg );
           }
           unsigned nval=0;
           for(unsigned j=0; j<all.size(); j++) {
-            std::string flab; flab=all[j]->getLabel() + "." + name;
-            if( all[j]->exists(flab) ) { arg.push_back(all[j]->copyOutput(flab)); nval++; }
+            std::string flab;
+            flab=all[j]->getLabel() + "." + name;
+            if( all[j]->exists(flab) ) {
+              arg.push_back(all[j]->copyOutput(flab));
+              nval++;
+            }
+          }
+          if(nval==0 && arg.size()==carg) {
+            readact->error("found no actions with a component called " + name );
           }
-          if(nval==0 && arg.size()==carg) readact->error("found no actions with a component called " + name );
         } else {
           // Take values with a specific name
           ActionWithValue* action=as.selectWithLabel<ActionWithValue*>(a);
@@ -153,8 +186,11 @@ void ActionWithArguments::interpretArgumentList(const std::vector<std::string>&
           } else if( action && action->exists(c[i]) ) {
             arg.push_back(action->copyOutput(c[i]));
           } else if( shortcut ) {
-            unsigned narg=arg.size(); shortcut->interpretDataLabel( a + "." + name, readact, arg );
-            if( arg.size()==narg ) readact->error("found no element in " + a + " with label " + name );
+            unsigned narg=arg.size();
+            shortcut->interpretDataLabel( a + "." + name, readact, arg );
+            if( arg.size()==narg ) {
+              readact->error("found no element in " + a + " with label " + name );
+            }
           } else {
             std::string str=" (hint! the components in this actions are: ";
             str+=action->getComponentsList()+")";
@@ -165,12 +201,22 @@ void ActionWithArguments::interpretArgumentList(const std::vector<std::string>&
         if(c[i]=="*") {
           // Take all values from all actions
           std::vector<ActionWithValue*> all=as.select<ActionWithValue*>();
-          if( all.empty() ) readact->error("your input file is not telling plumed to calculate anything");
+          if( all.empty() ) {
+            readact->error("your input file is not telling plumed to calculate anything");
+          }
           for(unsigned j=0; j<all.size(); j++) {
             plumed_assert(all[j]); // needed for following calls, see #1046
-            ActionWithVirtualAtom* av=all[j]->castToActionWithVirtualAtom(); if( av ) continue;
-            ActionForInterface* ap=all[j]->castToActionForInterface(); if( ap && all[j]->getName()!="ENERGY" ) continue;
-            for(int k=0; k<all[j]->getNumberOfComponents(); ++k) arg.push_back(all[j]->copyOutput(k));
+            ActionWithVirtualAtom* av=all[j]->castToActionWithVirtualAtom();
+            if( av ) {
+              continue;
+            }
+            ActionForInterface* ap=all[j]->castToActionForInterface();
+            if( ap && all[j]->getName()!="ENERGY" ) {
+              continue;
+            }
+            for(int k=0; k<all[j]->getNumberOfComponents(); ++k) {
+              arg.push_back(all[j]->copyOutput(k));
+            }
           }
         } else {
           ActionWithValue* action=as.selectWithLabel<ActionWithValue*>(c[i]);
@@ -218,7 +264,9 @@ void ActionWithArguments::requestArguments(const std::vector<Value*> &arg) {
     addDependency(action);
   }
   ActionWithValue* av=dynamic_cast<ActionWithValue*>(this);
-  if(av) av->firststep=true;
+  if(av) {
+    av->firststep=true;
+  }
 }
 
 void ActionWithArguments::requestExtraDependencies(const std::vector<Value*> &extra) {
@@ -241,8 +289,7 @@ void ActionWithArguments::requestExtraDependencies(const std::vector<Value*> &ex
 
 ActionWithArguments::ActionWithArguments(const ActionOptions&ao):
   Action(ao),
-  lockRequestArguments(false)
-{
+  lockRequestArguments(false) {
   if( keywords.exists("ARG") ) {
     std::vector<Value*> arg;
     parseArgumentList("ARG",arg);
@@ -250,11 +297,17 @@ ActionWithArguments::ActionWithArguments(const ActionOptions&ao):
     if(!arg.empty()) {
       log.printf("  with arguments : \n");
       for(unsigned i=0; i<arg.size(); i++) {
-        if( arg[i]->hasDerivatives() && arg[i]->getRank()>0 ) log.printf(" function on grid with label %s \n",arg[i]->getName().c_str());
-        else if( arg[i]->getRank()==2 ) log.printf("   matrix with label %s \n",arg[i]->getName().c_str());
-        else if( arg[i]->getRank()==1 ) log.printf("   vector with label %s \n",arg[i]->getName().c_str());
-        else if( arg[i]->getRank()==0 ) log.printf("   scalar with label %s \n",arg[i]->getName().c_str());
-        else error("type of argument does not make sense");
+        if( arg[i]->hasDerivatives() && arg[i]->getRank()>0 ) {
+          log.printf(" function on grid with label %s \n",arg[i]->getName().c_str());
+        } else if( arg[i]->getRank()==2 ) {
+          log.printf("   matrix with label %s \n",arg[i]->getName().c_str());
+        } else if( arg[i]->getRank()==1 ) {
+          log.printf("   vector with label %s \n",arg[i]->getName().c_str());
+        } else if( arg[i]->getRank()==0 ) {
+          log.printf("   scalar with label %s \n",arg[i]->getName().c_str());
+        } else {
+          error("type of argument does not make sense");
+        }
       }
     }
     requestArguments(arg);
@@ -283,7 +336,10 @@ void ActionWithArguments::calculateNumericalDerivatives( ActionWithValue* a ) {
   a->clearDerivatives();
   for(int j=0; j<nval; j++) {
     Value* v=a->copyOutput(j);
-    if( v->hasDerivatives() ) for(int i=0; i<npar; i++) v->addDerivative(i,(value[i*nval+j]-a->getOutputQuantity(j))/std::sqrt(epsilon));
+    if( v->hasDerivatives() )
+      for(int i=0; i<npar; i++) {
+        v->addDerivative(i,(value[i*nval+j]-a->getOutputQuantity(j))/std::sqrt(epsilon));
+      }
   }
 }
 
@@ -297,36 +353,57 @@ double ActionWithArguments::getProjection(unsigned i,unsigned j)const {
 
 void ActionWithArguments::addForcesOnArguments( const unsigned& argstart, const std::vector<double>& forces, unsigned& ind, const std::string& c  ) {
   for(unsigned i=0; i<arguments.size(); ++i) {
-    if( i==0 && getName().find("EVALUATE_FUNCTION_FROM_GRID")!=std::string::npos ) continue ;
+    if( i==0 && getName().find("EVALUATE_FUNCTION_FROM_GRID")!=std::string::npos ) {
+      continue ;
+    }
     if( !arguments[i]->ignoreStoredValue(c) || arguments[i]->getRank()==0 || (arguments[i]->getRank()>0 && arguments[i]->hasDerivatives()) ) {
       unsigned nvals = arguments[i]->getNumberOfStoredValues();
-      for(unsigned j=0; j<nvals; ++j) { arguments[i]->addForce( j, forces[ind], false ); ind++; }
+      for(unsigned j=0; j<nvals; ++j) {
+        arguments[i]->addForce( j, forces[ind], false );
+        ind++;
+      }
     }
   }
 }
 
 void ActionWithArguments::setGradients( Value* myval, unsigned& start ) const {
-  if( !myval->hasDeriv ) return; plumed_assert( myval->getRank()==0 );
+  if( !myval->hasDeriv ) {
+    return;
+  }
+  plumed_assert( myval->getRank()==0 );
 
   bool scalar=true;
   for(unsigned i=0; i<arguments.size(); ++i ) {
-    if( arguments[i]->getRank()!=0 ) { scalar=false; break; }
+    if( arguments[i]->getRank()!=0 ) {
+      scalar=false;
+      break;
+    }
   }
   if( !scalar ) {
     bool constant=true;
     for(unsigned i=0; i<arguments.size(); ++i ) {
-      if( !arguments[i]->isConstant() ) { constant=false; break; }
-      else start += arguments[i]->getNumberOfValues();
+      if( !arguments[i]->isConstant() ) {
+        constant=false;
+        break;
+      } else {
+        start += arguments[i]->getNumberOfValues();
+      }
+    }
+    if( !constant ) {
+      error("cannot set gradient as unable to handle non-constant actions that take vectors/matrices/grids in input");
     }
-    if( !constant ) error("cannot set gradient as unable to handle non-constant actions that take vectors/matrices/grids in input");
   }
   // Now pass the gradients
-  for(unsigned i=0; i<arguments.size(); ++i ) arguments[i]->passGradients( myval->getDerivative(i), myval->gradients );
+  for(unsigned i=0; i<arguments.size(); ++i ) {
+    arguments[i]->passGradients( myval->getDerivative(i), myval->gradients );
+  }
 }
 
 bool ActionWithArguments::calculateConstantValues( const bool& haveatoms ) {
   ActionWithValue* av = castToActionWithValue();
-  if( !av || arguments.size()==0 ) return false;
+  if( !av || arguments.size()==0 ) {
+    return false;
+  }
   bool constant = true, atoms=false;
   for(unsigned i=0; i<arguments.size(); ++i) {
     auto * ptr=arguments[i]->getPntrToAction();
@@ -334,23 +411,39 @@ bool ActionWithArguments::calculateConstantValues( const bool& haveatoms ) {
     ActionAtomistic* aa=ptr->castToActionAtomistic();
     if( aa ) {
       ActionWithVector* av=dynamic_cast<ActionWithVector*>( arguments[i]->getPntrToAction() );
-      if( !av || aa->getNumberOfAtoms()>0 ) atoms=true;
+      if( !av || aa->getNumberOfAtoms()>0 ) {
+        atoms=true;
+      }
+    }
+    if( !arguments[i]->isConstant() ) {
+      constant=false;
+      break;
     }
-    if( !arguments[i]->isConstant() ) { constant=false; break; }
   }
   if( constant ) {
     // Set everything constant first as we need to set the shape
-    for(unsigned i=0; i<av->getNumberOfComponents(); ++i) (av->copyOutput(i))->setConstant();
-    if( !haveatoms ) log.printf("  values stored by this action are computed during startup and stay fixed during the simulation\n");
-    if( atoms ) return haveatoms;
+    for(unsigned i=0; i<av->getNumberOfComponents(); ++i) {
+      (av->copyOutput(i))->setConstant();
+    }
+    if( !haveatoms ) {
+      log.printf("  values stored by this action are computed during startup and stay fixed during the simulation\n");
+    }
+    if( atoms ) {
+      return haveatoms;
+    }
   }
   // Now do the calculation and store the values if we don't need anything from the atoms
   if( constant && !haveatoms ) {
-    plumed_assert( !atoms ); activate(); calculate(); deactivate();
+    plumed_assert( !atoms );
+    activate();
+    calculate();
+    deactivate();
     for(unsigned i=0; i<av->getNumberOfComponents(); ++i) {
       unsigned nv = av->copyOutput(i)->getNumberOfValues();
       log.printf("  %d values stored in component labelled %s are : ", nv, (av->copyOutput(i))->getName().c_str() );
-      for(unsigned j=0; j<nv; ++j) log.printf(" %f", (av->copyOutput(i))->get(j) );
+      for(unsigned j=0; j<nv; ++j) {
+        log.printf(" %f", (av->copyOutput(i))->get(j) );
+      }
       log.printf("\n");
     }
   }
diff --git a/src/core/ActionWithArguments.h b/src/core/ActionWithArguments.h
index 21725fba6b..ef6bf26093 100644
--- a/src/core/ActionWithArguments.h
+++ b/src/core/ActionWithArguments.h
@@ -42,8 +42,7 @@ This is used in PLMD::Function and PLMD::Bias
 class ActionSet;
 
 class ActionWithArguments:
-  public virtual Action
-{
+  public virtual Action {
   std::vector<Value*> arguments;
   bool lockRequestArguments;
 protected:
@@ -90,7 +89,9 @@ class ActionWithArguments:
   virtual bool calculateConstantValues( const bool& have_atoms );
 /// Get the gradient for this action
   void setGradients( Value* myval, unsigned& start ) const ;
-  ActionWithArguments* castToActionWithArguments() noexcept final { return this; }
+  ActionWithArguments* castToActionWithArguments() noexcept final {
+    return this;
+  }
 };
 
 
diff --git a/src/core/ActionWithMatrix.cpp b/src/core/ActionWithMatrix.cpp
index bc0609f41b..77ea78f3ea 100644
--- a/src/core/ActionWithMatrix.cpp
+++ b/src/core/ActionWithMatrix.cpp
@@ -25,7 +25,8 @@
 namespace PLMD {
 
 void ActionWithMatrix::registerKeywords( Keywords& keys ) {
-  ActionWithVector::registerKeywords( keys ); keys.use("ARG");
+  ActionWithVector::registerKeywords( keys );
+  keys.use("ARG");
 }
 
 ActionWithMatrix::ActionWithMatrix(const ActionOptions&ao):
@@ -34,21 +35,29 @@ ActionWithMatrix::ActionWithMatrix(const ActionOptions&ao):
   next_action_in_chain(NULL),
   matrix_to_do_before(NULL),
   matrix_to_do_after(NULL),
-  clearOnEachCycle(true)
-{
+  clearOnEachCycle(true) {
 }
 
 ActionWithMatrix::~ActionWithMatrix() {
-  if( matrix_to_do_before ) { matrix_to_do_before->matrix_to_do_after=NULL; matrix_to_do_before->next_action_in_chain=NULL; }
+  if( matrix_to_do_before ) {
+    matrix_to_do_before->matrix_to_do_after=NULL;
+    matrix_to_do_before->next_action_in_chain=NULL;
+  }
 }
 
 void ActionWithMatrix::getAllActionLabelsInMatrixChain( std::vector<std::string>& mylabels ) const {
   bool found=false;
   for(unsigned i=0; i<mylabels.size(); ++i) {
-    if( getLabel()==mylabels[i] ) { found=true; }
+    if( getLabel()==mylabels[i] ) {
+      found=true;
+    }
+  }
+  if( !found ) {
+    mylabels.push_back( getLabel() );
+  }
+  if( matrix_to_do_after ) {
+    matrix_to_do_after->getAllActionLabelsInMatrixChain( mylabels );
   }
-  if( !found ) mylabels.push_back( getLabel() );
-  if( matrix_to_do_after ) matrix_to_do_after->getAllActionLabelsInMatrixChain( mylabels );
 }
 
 void ActionWithMatrix::setupStreamedComponents( const std::string& headstr, unsigned& nquants, unsigned& nmat, unsigned& maxcol, unsigned& nbookeeping ) {
@@ -56,10 +65,17 @@ void ActionWithMatrix::setupStreamedComponents( const std::string& headstr, unsi
 
   for(int i=0; i<getNumberOfComponents(); ++i) {
     Value* myval=getPntrToComponent(i);
-    if( myval->getRank()!=2 || myval->hasDerivatives() ) continue;
-    myval->setPositionInMatrixStash(nmat); nmat++;
-    if( !myval->valueIsStored() ) continue;
-    if( myval->getShape()[1]>maxcol ) maxcol=myval->getShape()[1];
+    if( myval->getRank()!=2 || myval->hasDerivatives() ) {
+      continue;
+    }
+    myval->setPositionInMatrixStash(nmat);
+    nmat++;
+    if( !myval->valueIsStored() ) {
+      continue;
+    }
+    if( myval->getShape()[1]>maxcol ) {
+      maxcol=myval->getShape()[1];
+    }
     myval->setMatrixBookeepingStart(nbookeeping);
     nbookeeping += myval->getShape()[0]*( 1 + myval->getNumberOfColumns() );
   }
@@ -67,47 +83,70 @@ void ActionWithMatrix::setupStreamedComponents( const std::string& headstr, unsi
   clearOnEachCycle = false;
   for(int i=0; i<getNumberOfComponents(); ++i) {
     const Value* myval=getConstPntrToComponent(i);
-    if( myval->getRank()==2 && !myval->hasDerivatives() ) { clearOnEachCycle = true; break; }
+    if( myval->getRank()==2 && !myval->hasDerivatives() ) {
+      clearOnEachCycle = true;
+      break;
+    }
   }
   // Turn off clearing of derivatives if we have only the values of adjacency matrices
-  if( doNotCalculateDerivatives() && isAdjacencyMatrix() ) clearOnEachCycle = false;
+  if( doNotCalculateDerivatives() && isAdjacencyMatrix() ) {
+    clearOnEachCycle = false;
+  }
 }
 
 void ActionWithMatrix::finishChainBuild( ActionWithVector* act ) {
-  ActionWithMatrix* am=dynamic_cast<ActionWithMatrix*>(act); if( !am || act==this ) return;
+  ActionWithMatrix* am=dynamic_cast<ActionWithMatrix*>(act);
+  if( !am || act==this ) {
+    return;
+  }
   // Build the list that contains everything we are going to loop over in getTotalMatrixBookeepgin and updateAllNeighbourLists
-  if( next_action_in_chain ) next_action_in_chain->finishChainBuild( act );
-  else {
+  if( next_action_in_chain ) {
+    next_action_in_chain->finishChainBuild( act );
+  } else {
     next_action_in_chain=am;
     // Build the list of things we are going to loop over in runTask
-    if( am->isAdjacencyMatrix() || act->getName()=="VSTACK" ) return ;
+    if( am->isAdjacencyMatrix() || act->getName()=="VSTACK" ) {
+      return ;
+    }
     plumed_massert( !matrix_to_do_after, "cannot add " + act->getLabel() + " in " + getLabel() + " as have already added " + matrix_to_do_after->getLabel() );
-    matrix_to_do_after=am; am->matrix_to_do_before=this;
+    matrix_to_do_after=am;
+    am->matrix_to_do_before=this;
   }
 }
 
 const ActionWithMatrix* ActionWithMatrix::getFirstMatrixInChain() const {
-  if( !actionInChain() ) return this;
+  if( !actionInChain() ) {
+    return this;
+  }
   return matrix_to_do_before->getFirstMatrixInChain();
 }
 
 void ActionWithMatrix::getTotalMatrixBookeeping( unsigned& nbookeeping ) {
   for(int i=0; i<getNumberOfComponents(); ++i) {
     Value* myval=getPntrToComponent(i);
-    if( myval->getRank()!=2 || myval->hasDerivatives() || !myval->valueIsStored() ) continue;
+    if( myval->getRank()!=2 || myval->hasDerivatives() || !myval->valueIsStored() ) {
+      continue;
+    }
     myval->reshapeMatrixStore( getNumberOfColumns() );
     nbookeeping += myval->getShape()[0]*( 1 + myval->getNumberOfColumns() );
   }
-  if( next_action_in_chain ) next_action_in_chain->getTotalMatrixBookeeping( nbookeeping );
+  if( next_action_in_chain ) {
+    next_action_in_chain->getTotalMatrixBookeeping( nbookeeping );
+  }
 }
 
 void ActionWithMatrix::calculate() {
-  if( actionInChain() ) return ;
+  if( actionInChain() ) {
+    return ;
+  }
   // Update all the neighbour lists
   updateAllNeighbourLists();
   // Setup the matrix indices
-  unsigned nbookeeping=0; getTotalMatrixBookeeping( nbookeeping );
-  if( matrix_bookeeping.size()!=nbookeeping ) matrix_bookeeping.resize( nbookeeping );
+  unsigned nbookeeping=0;
+  getTotalMatrixBookeeping( nbookeeping );
+  if( matrix_bookeeping.size()!=nbookeeping ) {
+    matrix_bookeeping.resize( nbookeeping );
+  }
   std::fill( matrix_bookeeping.begin(), matrix_bookeeping.end(), 0 );
   // And run all the tasks
   runAllTasks();
@@ -115,7 +154,9 @@ void ActionWithMatrix::calculate() {
 
 void ActionWithMatrix::updateAllNeighbourLists() {
   updateNeighbourList();
-  if( next_action_in_chain ) next_action_in_chain->updateAllNeighbourLists();
+  if( next_action_in_chain ) {
+    next_action_in_chain->updateAllNeighbourLists();
+  }
 }
 
 void ActionWithMatrix::performTask( const unsigned& task_index, MultiValue& myvals ) const {
@@ -140,64 +181,97 @@ void ActionWithMatrix::performTask( const unsigned& task_index, MultiValue& myva
 }
 
 void ActionWithMatrix::runTask( const std::string& controller, const unsigned& current, const unsigned colno, MultiValue& myvals ) const {
-  double outval=0; myvals.setTaskIndex(current); myvals.setSecondTaskIndex( colno );
-  if( isActive() ) performTask( controller, current, colno, myvals );
+  double outval=0;
+  myvals.setTaskIndex(current);
+  myvals.setSecondTaskIndex( colno );
+  if( isActive() ) {
+    performTask( controller, current, colno, myvals );
+  }
   bool hasval = !isAdjacencyMatrix();
   for(int i=0; i<getNumberOfComponents(); ++i) {
-    if( fabs(myvals.get( getConstPntrToComponent(i)->getPositionInStream()) )>0 ) { hasval=true; break; }
+    if( fabs(myvals.get( getConstPntrToComponent(i)->getPositionInStream()) )>0 ) {
+      hasval=true;
+      break;
+    }
   }
 
   if( hasval ) {
     for(int i=0; i<getNumberOfComponents(); ++i) {
       const Value* myval=getConstPntrToComponent(i);
-      if( myval->getRank()!=2 || myval->hasDerivatives() || !myval->valueIsStored() ) continue;
+      if( myval->getRank()!=2 || myval->hasDerivatives() || !myval->valueIsStored() ) {
+        continue;
+      }
       unsigned matindex = myval->getPositionInMatrixStash(), matbook_start = myval->getMatrixBookeepingStart(), col_stash_index = colno;
-      if( colno>=myval->getShape()[0] ) col_stash_index = colno - myval->getShape()[0];
+      if( colno>=myval->getShape()[0] ) {
+        col_stash_index = colno - myval->getShape()[0];
+      }
       unsigned rowstart = matbook_start+current*(1+myval->getNumberOfColumns());
       if( myval->forcesWereAdded() ) {
         unsigned sind = myval->getPositionInStream(), find = myvals.getMatrixBookeeping()[rowstart];
         double fforce = myval->getForce( myvals.getTaskIndex()*myval->getNumberOfColumns() + find );
-        if( getNumberOfColumns()>=myval->getShape()[1] ) fforce = myval->getForce( myvals.getTaskIndex()*myval->getShape()[1] + col_stash_index );
+        if( getNumberOfColumns()>=myval->getShape()[1] ) {
+          fforce = myval->getForce( myvals.getTaskIndex()*myval->getShape()[1] + col_stash_index );
+        }
         for(unsigned j=0; j<myvals.getNumberActive(sind); ++j) {
-          unsigned kindex = myvals.getActiveIndex(sind,j); myvals.addMatrixForce( matindex, kindex, fforce*myvals.getDerivative(sind,kindex ) );
+          unsigned kindex = myvals.getActiveIndex(sind,j);
+          myvals.addMatrixForce( matindex, kindex, fforce*myvals.getDerivative(sind,kindex ) );
         }
       }
       double finalval = myvals.get( myval->getPositionInStream() );
-      if( fabs(finalval)>0 ) myvals.stashMatrixElement( matindex, rowstart, col_stash_index, finalval );
+      if( fabs(finalval)>0 ) {
+        myvals.stashMatrixElement( matindex, rowstart, col_stash_index, finalval );
+      }
     }
   }
-  if( matrix_to_do_after ) matrix_to_do_after->runTask( controller, current, colno, myvals );
+  if( matrix_to_do_after ) {
+    matrix_to_do_after->runTask( controller, current, colno, myvals );
+  }
 }
 
 void ActionWithMatrix::gatherThreads( const unsigned& nt, const unsigned& bufsize, const std::vector<double>& omp_buffer, std::vector<double>& buffer, MultiValue& myvals ) {
   ActionWithVector::gatherThreads( nt, bufsize, omp_buffer, buffer, myvals );
-  for(unsigned i=0; i<matrix_bookeeping.size(); ++i) matrix_bookeeping[i] += myvals.getMatrixBookeeping()[i];
+  for(unsigned i=0; i<matrix_bookeeping.size(); ++i) {
+    matrix_bookeeping[i] += myvals.getMatrixBookeeping()[i];
+  }
 }
 
 void ActionWithMatrix::gatherProcesses( std::vector<double>& buffer ) {
   ActionWithVector::gatherProcesses( buffer );
-  if( matrix_bookeeping.size()>0 && !runInSerial() ) comm.Sum( matrix_bookeeping );
-  unsigned nval=0; transferNonZeroMatrixElementsToValues( nval, matrix_bookeeping );
+  if( matrix_bookeeping.size()>0 && !runInSerial() ) {
+    comm.Sum( matrix_bookeeping );
+  }
+  unsigned nval=0;
+  transferNonZeroMatrixElementsToValues( nval, matrix_bookeeping );
 }
 
 void ActionWithMatrix::transferNonZeroMatrixElementsToValues( unsigned& nval, const std::vector<unsigned>& matbook ) {
   for(int i=0; i<getNumberOfComponents(); ++i) {
     Value* myval=getPntrToComponent(i);
-    if( myval->getRank()!=2 || myval->hasDerivatives() || !myval->valueIsStored() || getNumberOfColumns()>=myval->getShape()[1] ) continue;
+    if( myval->getRank()!=2 || myval->hasDerivatives() || !myval->valueIsStored() || getNumberOfColumns()>=myval->getShape()[1] ) {
+      continue;
+    }
     unsigned nelements = myval->getShape()[0]*( 1 + myval->getNumberOfColumns() );
-    for(unsigned j=0; j<nelements; ++j) myval->setMatrixBookeepingElement( j, matbook[nval+j] );
+    for(unsigned j=0; j<nelements; ++j) {
+      myval->setMatrixBookeepingElement( j, matbook[nval+j] );
+    }
     nval += nelements;
   }
-  if( next_action_in_chain ) next_action_in_chain->transferNonZeroMatrixElementsToValues( nval, matbook );
+  if( next_action_in_chain ) {
+    next_action_in_chain->transferNonZeroMatrixElementsToValues( nval, matbook );
+  }
 }
 
 void ActionWithMatrix::gatherStoredValue( const unsigned& valindex, const unsigned& code, const MultiValue& myvals,
     const unsigned& bufstart, std::vector<double>& buffer ) const {
-  if( getConstPntrToComponent(valindex)->getRank()==1 ) { ActionWithVector::gatherStoredValue( valindex, code, myvals, bufstart, buffer ); return; }
+  if( getConstPntrToComponent(valindex)->getRank()==1 ) {
+    ActionWithVector::gatherStoredValue( valindex, code, myvals, bufstart, buffer );
+    return;
+  }
   const Value* myval=getConstPntrToComponent(valindex);
   unsigned ncols = myval->getNumberOfColumns(), matind = myval->getPositionInMatrixStash();
   unsigned matbook_start = myval->getMatrixBookeepingStart(), vindex = bufstart + code*myval->getNumberOfColumns();
-  const std::vector<unsigned> & matbook( myvals.getMatrixBookeeping() ); unsigned nelements = matbook[matbook_start+code*(1+ncols)];
+  const std::vector<unsigned> & matbook( myvals.getMatrixBookeeping() );
+  unsigned nelements = matbook[matbook_start+code*(1+ncols)];
   if( ncols>=myval->getShape()[1] ) {
     // In this case we store the full matrix
     for(unsigned j=0; j<nelements; ++j) {
@@ -216,28 +290,41 @@ void ActionWithMatrix::gatherStoredValue( const unsigned& valindex, const unsign
 }
 
 bool ActionWithMatrix::checkForTaskForce( const unsigned& itask, const Value* myval ) const {
-  if( myval->getRank()<2 ) return ActionWithVector::checkForTaskForce( itask, myval );
+  if( myval->getRank()<2 ) {
+    return ActionWithVector::checkForTaskForce( itask, myval );
+  }
   unsigned nelements = myval->getRowLength(itask), startr = itask*myval->getNumberOfColumns();
   for(unsigned j=0; j<nelements; ++j ) {
-    if( fabs( myval->getForce( startr + j ) )>epsilon ) return true;
+    if( fabs( myval->getForce( startr + j ) )>epsilon ) {
+      return true;
+    }
   }
   return false;
 }
 
 void ActionWithMatrix::gatherForcesOnStoredValue( const Value* myval, const unsigned& itask, const MultiValue& myvals, std::vector<double>& forces ) const {
-  if( myval->getRank()==1 ) { ActionWithVector::gatherForcesOnStoredValue( myval, itask, myvals, forces ); return; }
+  if( myval->getRank()==1 ) {
+    ActionWithVector::gatherForcesOnStoredValue( myval, itask, myvals, forces );
+    return;
+  }
   unsigned matind = myval->getPositionInMatrixStash();
-  for(unsigned j=0; j<forces.size(); ++j) forces[j] += myvals.getStashedMatrixForce( matind, j );
+  for(unsigned j=0; j<forces.size(); ++j) {
+    forces[j] += myvals.getStashedMatrixForce( matind, j );
+  }
 }
 
 void ActionWithMatrix::clearMatrixElements( MultiValue& myvals ) const {
   if( isActive() && clearOnEachCycle ) {
     for(int i=0; i<getNumberOfComponents(); ++i) {
       const Value* myval=getConstPntrToComponent(i);
-      if( myval->getRank()==2 && !myval->hasDerivatives() ) myvals.clearDerivatives( myval->getPositionInStream() );
+      if( myval->getRank()==2 && !myval->hasDerivatives() ) {
+        myvals.clearDerivatives( myval->getPositionInStream() );
+      }
     }
   }
-  if( matrix_to_do_after ) matrix_to_do_after->clearMatrixElements( myvals );
+  if( matrix_to_do_after ) {
+    matrix_to_do_after->clearMatrixElements( myvals );
+  }
 }
 
 }
diff --git a/src/core/ActionWithMatrix.h b/src/core/ActionWithMatrix.h
index 4cc4de4ee3..52d1e20674 100644
--- a/src/core/ActionWithMatrix.h
+++ b/src/core/ActionWithMatrix.h
@@ -61,7 +61,9 @@ class ActionWithMatrix : public ActionWithVector {
   explicit ActionWithMatrix(const ActionOptions&);
   virtual ~ActionWithMatrix();
 ///
-  virtual bool isAdjacencyMatrix() const { return false; }
+  virtual bool isAdjacencyMatrix() const {
+    return false;
+  }
 ///
   void getAllActionLabelsInMatrixChain( std::vector<std::string>& mylabels ) const override ;
 /// Get the first matrix in this chain
@@ -103,14 +105,18 @@ bool ActionWithMatrix::matrixChainContinues() const {
 
 inline
 double ActionWithMatrix::getArgumentElement( const unsigned& ic, const unsigned& jelem, const MultiValue& myvals ) const {
-  if( !getPntrToArgument(ic)->valueHasBeenSet() ) return myvals.get( getPntrToArgument(ic)->getPositionInStream() );
+  if( !getPntrToArgument(ic)->valueHasBeenSet() ) {
+    return myvals.get( getPntrToArgument(ic)->getPositionInStream() );
+  }
   return getPntrToArgument(ic)->get( jelem );
 }
 
 inline
 double ActionWithMatrix::getElementOfMatrixArgument( const unsigned& imat, const unsigned& irow, const unsigned& jcol, const MultiValue& myvals ) const {
   plumed_dbg_assert( imat<getNumberOfArguments() && getPntrToArgument(imat)->getRank()==2 && !getPntrToArgument(imat)->hasDerivatives() );
-  if( !getPntrToArgument(imat)->valueHasBeenSet() ) return myvals.get( getPntrToArgument(imat)->getPositionInStream() );
+  if( !getPntrToArgument(imat)->valueHasBeenSet() ) {
+    return myvals.get( getPntrToArgument(imat)->getPositionInStream() );
+  }
   return getArgumentElement( imat, irow*getPntrToArgument(imat)->getShape()[1] + jcol, myvals );
 }
 
@@ -119,7 +125,8 @@ void ActionWithMatrix::addDerivativeOnVectorArgument( const bool& inchain, const
   plumed_dbg_massert( jarg<getNumberOfArguments() && getPntrToArgument(jarg)->getRank()<2, "failing in action " + getName() + " with label " + getLabel() );
   unsigned ostrn = getConstPntrToComponent(ival)->getPositionInStream(), vstart=arg_deriv_starts[jarg];
   if( !inchain ) {
-    myvals.addDerivative( ostrn, vstart + jelem, der ); myvals.updateIndex( ostrn, vstart + jelem );
+    myvals.addDerivative( ostrn, vstart + jelem, der );
+    myvals.updateIndex( ostrn, vstart + jelem );
   } else {
     unsigned istrn = getPntrToArgument(jarg)->getPositionInStream();
     for(unsigned k=0; k<myvals.getNumberActive(istrn); ++k) {
@@ -136,7 +143,8 @@ void ActionWithMatrix::addDerivativeOnMatrixArgument( const bool& inchain, const
   unsigned ostrn = getConstPntrToComponent(ival)->getPositionInStream(), vstart=arg_deriv_starts[jarg];
   if( !inchain ) {
     unsigned dloc = vstart + irow*getPntrToArgument(jarg)->getNumberOfColumns() + jcol;
-    myvals.addDerivative( ostrn, dloc, der ); myvals.updateIndex( ostrn, dloc );
+    myvals.addDerivative( ostrn, dloc, der );
+    myvals.updateIndex( ostrn, dloc );
   } else {
     unsigned istrn = getPntrToArgument(jarg)->getPositionInStream();
     for(unsigned k=0; k<myvals.getNumberActive(istrn); ++k) {
diff --git a/src/core/ActionWithValue.cpp b/src/core/ActionWithValue.cpp
index 320450ae63..f431d9ff32 100644
--- a/src/core/ActionWithValue.cpp
+++ b/src/core/ActionWithValue.cpp
@@ -45,7 +45,9 @@ void ActionWithValue::noAnalyticalDerivatives(Keywords& keys) {
 }
 
 void ActionWithValue::useCustomisableComponents(Keywords& keys) {
-  if( !keys.outputComponentExists(".#!custom") ) keys.addOutputComponent(".#!custom","default","the names of the output components for this action depend on the actions input file see the example inputs below for details");
+  if( !keys.outputComponentExists(".#!custom") ) {
+    keys.addOutputComponent(".#!custom","default","the names of the output components for this action depend on the actions input file see the example inputs below for details");
+  }
   keys.setComponentsIntroduction("The names of the components in this action can be customized by the user in the "
                                  "actions input file.  However, in addition to the components that can be customized the "
                                  "following quantities will always be output");
@@ -55,10 +57,13 @@ ActionWithValue::ActionWithValue(const ActionOptions&ao):
   Action(ao),
   firststep(true),
   noderiv(true),
-  numericalDerivatives(false)
-{
-  if( keywords.exists("NUMERICAL_DERIVATIVES") ) parseFlag("NUMERICAL_DERIVATIVES",numericalDerivatives);
-  if(!keywords.exists("NO_ACTION_LOG") && numericalDerivatives) log.printf("  using numerical derivatives\n");
+  numericalDerivatives(false) {
+  if( keywords.exists("NUMERICAL_DERIVATIVES") ) {
+    parseFlag("NUMERICAL_DERIVATIVES",numericalDerivatives);
+  }
+  if(!keywords.exists("NO_ACTION_LOG") && numericalDerivatives) {
+    log.printf("  using numerical derivatives\n");
+  }
 }
 
 ActionWithValue::~ActionWithValue() {
@@ -66,7 +71,9 @@ ActionWithValue::~ActionWithValue() {
 }
 
 void ActionWithValue::clearInputForces( const bool& force ) {
-  for(unsigned i=0; i<values.size(); i++) values[i]->clearInputForce();
+  for(unsigned i=0; i<values.size(); i++) {
+    values[i]->clearInputForce();
+  }
 }
 
 void ActionWithValue::clearDerivatives( const bool& force ) {
@@ -74,7 +81,9 @@ void ActionWithValue::clearDerivatives( const bool& force ) {
   #pragma omp parallel num_threads(nt)
   {
     #pragma omp for
-    for(unsigned i=0; i<values.size(); i++) values[i]->clearDerivatives();
+    for(unsigned i=0; i<values.size(); i++) {
+      values[i]->clearDerivatives();
+    }
   }
 }
 
@@ -82,20 +91,29 @@ void ActionWithValue::clearDerivatives( const bool& force ) {
 
 bool ActionWithValue::exists( const std::string& name ) const {
   for(unsigned i=0; i<values.size(); ++i) {
-    if (values[i]->name==name) return true;
+    if (values[i]->name==name) {
+      return true;
+    }
   }
   return false;
 }
 
 void ActionWithValue::getMatrixColumnTitles( std::vector<std::string>& argnames ) const {
   plumed_assert( getNumberOfComponents()==1 && getConstPntrToComponent(0)->getRank()==2 );
-  unsigned nargs = getConstPntrToComponent(0)->getShape()[1]; std::string aname = getConstPntrToComponent(0)->getName();
-  for(unsigned j=0; j<nargs; ++j) { std::string nn; Tools::convert( j+1, nn ); argnames.push_back( aname + "." + nn ); }
+  unsigned nargs = getConstPntrToComponent(0)->getShape()[1];
+  std::string aname = getConstPntrToComponent(0)->getName();
+  for(unsigned j=0; j<nargs; ++j) {
+    std::string nn;
+    Tools::convert( j+1, nn );
+    argnames.push_back( aname + "." + nn );
+  }
 }
 
 Value* ActionWithValue::copyOutput( const std::string& name ) const {
   for(unsigned i=0; i<values.size(); ++i) {
-    if (values[i]->name==name) return values[i].get();
+    if (values[i]->name==name) {
+      return values[i].get();
+    }
   }
   plumed_merror("there is no pointer with name " + name);
 }
@@ -108,13 +126,17 @@ Value* ActionWithValue::copyOutput( const unsigned& n ) const {
 // -- HERE WE HAVE THE STUFF FOR THE DEFAULT VALUE -- //
 
 void ActionWithValue::addValue( const std::vector<unsigned>& shape ) {
-  if( !keywords.outputComponentExists(".#!value") ) warning("documentation for the value calculated by this action has not been included");
+  if( !keywords.outputComponentExists(".#!value") ) {
+    warning("documentation for the value calculated by this action has not been included");
+  }
   plumed_massert(values.empty(),"You have already added the default value for this action");
   values.emplace_back(Tools::make_unique<Value>(this,getLabel(), false, shape ) );
 }
 
 void ActionWithValue::addValueWithDerivatives( const std::vector<unsigned>& shape ) {
-  if( !keywords.outputComponentExists(".#!value") ) warning("documentation for the value calculated by this action has not been included");
+  if( !keywords.outputComponentExists(".#!value") ) {
+    warning("documentation for the value calculated by this action has not been included");
+  }
   plumed_massert(values.empty(),"You have already added the default value for this action");
   values.emplace_back(Tools::make_unique<Value>(this,getLabel(), true, shape ) );
 }
@@ -122,7 +144,8 @@ void ActionWithValue::addValueWithDerivatives( const std::vector<unsigned>& shap
 void ActionWithValue::setNotPeriodic() {
   plumed_massert(values.size()==1,"The number of components is not equal to one");
   plumed_massert(values[0]->name==getLabel(), "The value you are trying to set is not the default");
-  values[0]->min=0; values[0]->max=0;
+  values[0]->min=0;
+  values[0]->max=0;
   values[0]->setupPeriodicity();
 }
 
@@ -139,7 +162,8 @@ void ActionWithValue::addComponent( const std::string& name, const std::vector<u
     plumed_merror("a description of component " + name + " has not been added to the manual. Components should be registered like keywords in "
                   "registerKeywords as described in the developer docs.");
   }
-  std::string thename; thename=getLabel() + "." + name;
+  std::string thename;
+  thename=getLabel() + "." + name;
   for(unsigned i=0; i<values.size(); ++i) {
     plumed_massert(values[i]->name!=getLabel(),"Cannot mix single values with components");
     plumed_massert(values[i]->name!=thename,"there is already a value with this name: "+thename);
@@ -156,7 +180,8 @@ void ActionWithValue::addComponentWithDerivatives( const std::string& name, cons
     plumed_merror("a description of component " + name + " has not been added to the manual. Components should be registered like keywords in "
                   "registerKeywords as described in the developer doc.");
   }
-  std::string thename; thename=getLabel() + "." + name;
+  std::string thename;
+  thename=getLabel() + "." + name;
   for(unsigned i=0; i<values.size(); ++i) {
     plumed_massert(values[i]->name!=getLabel(),"Cannot mix single values with components");
     plumed_massert(values[i]->name!=thename,"there is already a value with this name: "+thename);
@@ -169,19 +194,29 @@ void ActionWithValue::addComponentWithDerivatives( const std::string& name, cons
 }
 
 std::string ActionWithValue::getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const {
-  if( keys.outputComponentExists(".#!custom") ) return "a quantity calculated by the action " + getName() + " with label " + getLabel();
-  std::size_t und=cname.find_last_of("_"); std::size_t hyph=cname.find_first_of("-");
-  if( und!=std::string::npos ) return keys.getOutputComponentDescription(cname.substr(und)) + " This particular component measures this quantity for the input CV named " + cname.substr(0,und);
-  if( hyph!=std::string::npos ) return keys.getOutputComponentDescription(cname.substr(0,hyph)) + "  This is the " + cname.substr(hyph+1) + "th of these quantities";
+  if( keys.outputComponentExists(".#!custom") ) {
+    return "a quantity calculated by the action " + getName() + " with label " + getLabel();
+  }
+  std::size_t und=cname.find_last_of("_");
+  std::size_t hyph=cname.find_first_of("-");
+  if( und!=std::string::npos ) {
+    return keys.getOutputComponentDescription(cname.substr(und)) + " This particular component measures this quantity for the input CV named " + cname.substr(0,und);
+  }
+  if( hyph!=std::string::npos ) {
+    return keys.getOutputComponentDescription(cname.substr(0,hyph)) + "  This is the " + cname.substr(hyph+1) + "th of these quantities";
+  }
   plumed_massert( keys.outputComponentExists(cname), "component " + cname + " does not exist in " + keys.getDisplayName() + " if the component names are customizable then you should override this function" );
   return keys.getOutputComponentDescription( cname );
 }
 
 int ActionWithValue::getComponent( const std::string& name ) const {
   plumed_massert( !exists( getLabel() ), "You should not be calling this routine if you are using a value");
-  std::string thename; thename=getLabel() + "." + name;
+  std::string thename;
+  thename=getLabel() + "." + name;
   for(unsigned i=0; i<values.size(); ++i) {
-    if (values[i]->name==thename) return i;
+    if (values[i]->name==thename) {
+      return i;
+    }
   }
   plumed_merror("there is no component with name " + name);
 }
@@ -204,7 +239,8 @@ std::vector<std::string> ActionWithValue::getComponentsVector( ) const {
 
 void ActionWithValue::componentIsNotPeriodic( const std::string& name ) {
   int kk=getComponent(name);
-  values[kk]->min=0; values[kk]->max=0;
+  values[kk]->min=0;
+  values[kk]->max=0;
   values[kk]->setupPeriodicity();
 }
 
@@ -217,11 +253,21 @@ void ActionWithValue::setGradientsIfNeeded() {
   if(isOptionOn("GRADIENTS")) {
     ActionAtomistic* aa=castToActionAtomistic();
     if(aa) {
-      for(unsigned i=0; i<values.size(); i++) { unsigned start=0; values[i]->gradients.clear(); values[i]->setGradients( aa, start ); }
+      for(unsigned i=0; i<values.size(); i++) {
+        unsigned start=0;
+        values[i]->gradients.clear();
+        values[i]->setGradients( aa, start );
+      }
     } else {
       ActionWithArguments* aarg = castToActionWithArguments();
-      if( !aarg ) plumed_merror( "failing in " + getLabel() );
-      for(unsigned i=0; i<values.size(); i++) { unsigned start=0; values[i]->gradients.clear(); aarg->setGradients( values[i].get(), start ); }
+      if( !aarg ) {
+        plumed_merror( "failing in " + getLabel() );
+      }
+      for(unsigned i=0; i<values.size(); i++) {
+        unsigned start=0;
+        values[i]->gradients.clear();
+        aarg->setGradients( values[i].get(), start );
+      }
     }
   }
 }
@@ -230,11 +276,15 @@ void ActionWithValue::turnOnDerivatives() {
   // Turn on the derivatives
   noderiv=false;
   // Resize the derivatives
-  for(unsigned i=0; i<values.size(); ++i) values[i]->resizeDerivatives( getNumberOfDerivatives() );
+  for(unsigned i=0; i<values.size(); ++i) {
+    values[i]->resizeDerivatives( getNumberOfDerivatives() );
+  }
   // And turn on the derivatives in all actions on which we are dependent
   for(unsigned i=0; i<getDependencies().size(); ++i) {
     ActionWithValue* vv=getDependencies()[i]->castToActionWithValue();
-    if(vv) vv->turnOnDerivatives();
+    if(vv) {
+      vv->turnOnDerivatives();
+    }
   }
 }
 
@@ -260,7 +310,9 @@ bool ActionWithValue::calculateOnUpdate() {
       const std::vector<Value*> & args(aa->getArguments());
       for(const auto & p : args ) {
         if( p->calculateOnUpdate() ) {
-          for(unsigned i=0; i<values.size(); ++i) values[i]->setValType("calcFromAverage");
+          for(unsigned i=0; i<values.size(); ++i) {
+            values[i]->setValType("calcFromAverage");
+          }
           break;
         }
       }
@@ -268,7 +320,9 @@ bool ActionWithValue::calculateOnUpdate() {
     firststep=false;
   }
   for(unsigned i=0; i<values.size(); ++i) {
-    if( values[i]->calculateOnUpdate() ) return true;
+    if( values[i]->calculateOnUpdate() ) {
+      return true;
+    }
   }
   return false;
 }
@@ -276,19 +330,26 @@ bool ActionWithValue::calculateOnUpdate() {
 bool ActionWithValue::checkForForces() {
   const unsigned    ncp=getNumberOfComponents();
   unsigned    nder=getNumberOfDerivatives();
-  if( ncp==0 || nder==0 ) return false;
+  if( ncp==0 || nder==0 ) {
+    return false;
+  }
 
   unsigned nvalsWithForce=0;
   valsToForce.resize(ncp);
   for(unsigned i=0; i<ncp; ++i) {
     if( values[i]->hasForce && !values[i]->isConstant() ) {
-      valsToForce[nvalsWithForce]=i; nvalsWithForce++;
+      valsToForce[nvalsWithForce]=i;
+      nvalsWithForce++;
     }
   }
-  if( nvalsWithForce==0 ) return false;
+  if( nvalsWithForce==0 ) {
+    return false;
+  }
 
   // Make sure forces to apply is empty of forces
-  if( forcesForApply.size()!=nder ) forcesForApply.resize( nder );
+  if( forcesForApply.size()!=nder ) {
+    forcesForApply.resize( nder );
+  }
   std::fill(forcesForApply.begin(),forcesForApply.end(),0);
 
   unsigned stride=1;
@@ -299,12 +360,16 @@ bool ActionWithValue::checkForForces() {
   }
 
   unsigned nt=OpenMP::getNumThreads();
-  if(nt>ncp/(4*stride)) nt=1;
+  if(nt>ncp/(4*stride)) {
+    nt=1;
+  }
 
   #pragma omp parallel num_threads(nt)
   {
     std::vector<double> omp_f;
-    if( nt>1 ) omp_f.resize(nder,0);
+    if( nt>1 ) {
+      omp_f.resize(nder,0);
+    }
     #pragma omp for
     for(unsigned i=rank; i<nvalsWithForce; i+=stride) {
       double ff=values[valsToForce[i]]->inputForce[0];
@@ -312,8 +377,11 @@ bool ActionWithValue::checkForForces() {
       int nn=nder;
       int one1=1;
       int one2=1;
-      if( nt>1 ) plumed_blas_daxpy(&nn,&ff,thisderiv.data()+1,&one1,omp_f.data(),&one2);
-      else       plumed_blas_daxpy(&nn,&ff,thisderiv.data()+1,&one1,forcesForApply.data(),&one2);
+      if( nt>1 ) {
+        plumed_blas_daxpy(&nn,&ff,thisderiv.data()+1,&one1,omp_f.data(),&one2);
+      } else {
+        plumed_blas_daxpy(&nn,&ff,thisderiv.data()+1,&one1,forcesForApply.data(),&one2);
+      }
       // if( nt>1 ) for(unsigned j=0; j<nder; ++j) omp_f[j] += ff*thisderiv[1+j];
       //else for(unsigned j=0; j<nder; ++j) forcesForApply[j] += ff*thisderiv[1+j];
     }
@@ -332,7 +400,9 @@ bool ActionWithValue::checkForForces() {
     }
   }
 
-  if(ncp>4*comm.Get_size()) comm.Sum(&forcesForApply[0],nder);
+  if(ncp>4*comm.Get_size()) {
+    comm.Sum(&forcesForApply[0],nder);
+  }
   return true;
 }
 
diff --git a/src/core/ActionWithValue.h b/src/core/ActionWithValue.h
index 343115fb85..a6f52bfde3 100644
--- a/src/core/ActionWithValue.h
+++ b/src/core/ActionWithValue.h
@@ -65,8 +65,7 @@ PLMD::Action you should use <b> the routines with the word component in the name
 */
 
 class ActionWithValue :
-  public virtual Action
-{
+  public virtual Action {
   friend class ActionWithVector;
   friend class ActionWithArguments;
 private:
@@ -178,7 +177,9 @@ class ActionWithValue :
 /// This forces the class to use numerical derivatives
   void useNumericalDerivatives();
 // These are things for using vectors of values as fields
-  virtual void checkFieldsAllowed() { error("cannot use this action as a field"); }
+  virtual void checkFieldsAllowed() {
+    error("cannot use this action as a field");
+  }
   virtual unsigned getNumberOfDerivatives()=0;
 /// Activate the calculation of derivatives
   virtual void turnOnDerivatives();
@@ -186,7 +187,9 @@ class ActionWithValue :
   virtual void getMatrixColumnTitles( std::vector<std::string>& argnames ) const ;
 /// This is used to check if we run calculate during the update step
   virtual bool calculateOnUpdate();
-  ActionWithValue* castToActionWithValue() noexcept final { return this; }
+  ActionWithValue* castToActionWithValue() noexcept final {
+    return this;
+  }
 };
 
 inline
@@ -202,7 +205,9 @@ double ActionWithValue::getOutputQuantity( const std::string& name ) const {
     const std::string & valname=values[i]->name;
     if(valname.size()>offset+1 && valname[offset]=='.' ) {
       plumed_dbg_assert(Tools::startWith(valname,getLabel()));
-      if(!std::strcmp(valname.c_str()+offset+1,name.c_str())) return values[i]->get();
+      if(!std::strcmp(valname.c_str()+offset+1,name.c_str())) {
+        return values[i]->get();
+      }
     }
   }
   return 0.0;
diff --git a/src/core/ActionWithVector.cpp b/src/core/ActionWithVector.cpp
index 8dbb9ecedd..670297a560 100644
--- a/src/core/ActionWithVector.cpp
+++ b/src/core/ActionWithVector.cpp
@@ -30,7 +30,8 @@ namespace PLMD {
 void ActionWithVector::registerKeywords( Keywords& keys ) {
   Action::registerKeywords( keys );
   ActionAtomistic::registerKeywords( keys );
-  ActionWithValue::registerKeywords( keys ); keys.remove("NUMERICAL_DERIVATIVES");
+  ActionWithValue::registerKeywords( keys );
+  keys.remove("NUMERICAL_DERIVATIVES");
   ActionWithArguments::registerKeywords( keys );
   keys.addFlag("SERIAL",false,"do the calculation in serial.  Do not parallelize");
 }
@@ -46,13 +47,16 @@ ActionWithVector::ActionWithVector(const ActionOptions&ao):
   never_reduce_tasks(false),
   reduce_tasks(false),
   atomsWereRetrieved(false),
-  done_in_chain(false)
-{
-  if( keywords.exists("SERIAL") ) parseFlag("SERIAL",serial);
+  done_in_chain(false) {
+  if( keywords.exists("SERIAL") ) {
+    parseFlag("SERIAL",serial);
+  }
 }
 
 ActionWithVector::~ActionWithVector() {
-  if( action_to_do_before ) action_to_do_before->action_to_do_after=NULL;
+  if( action_to_do_before ) {
+    action_to_do_before->action_to_do_after=NULL;
+  }
 }
 
 void ActionWithVector::lockRequests() {
@@ -70,47 +74,70 @@ void ActionWithVector::calculateNumericalDerivatives(ActionWithValue* av) {
 }
 
 void ActionWithVector::clearDerivatives( const bool& force ) {
-  if( !force && actionInChain() ) return;
+  if( !force && actionInChain() ) {
+    return;
+  }
   ActionWithValue::clearDerivatives();
-  if( action_to_do_after ) action_to_do_after->clearDerivatives( true );
+  if( action_to_do_after ) {
+    action_to_do_after->clearDerivatives( true );
+  }
 }
 
 void ActionWithVector::clearInputForces( const bool& force ) {
-  if( !force && actionInChain() ) return;
+  if( !force && actionInChain() ) {
+    return;
+  }
   ActionWithValue::clearInputForces();
-  if( action_to_do_after ) action_to_do_after->clearInputForces( true );
+  if( action_to_do_after ) {
+    action_to_do_after->clearInputForces( true );
+  }
 }
 
 const ActionWithVector* ActionWithVector::getFirstActionInChain() const {
-  if( !actionInChain() ) return this;
+  if( !actionInChain() ) {
+    return this;
+  }
   return action_to_do_before->getFirstActionInChain();
 }
 
 ActionWithVector* ActionWithVector::getFirstActionInChain() {
-  if( !actionInChain() ) return this;
+  if( !actionInChain() ) {
+    return this;
+  }
   return action_to_do_before->getFirstActionInChain();
 }
 
 void ActionWithVector::retrieveAtoms( const bool& force ) {
-  if( !force && actionInChain() || atomsWereRetrieved ) return;
-  ActionAtomistic::retrieveAtoms(); atomsWereRetrieved = !actionInChain();
-  if( action_to_do_after ) action_to_do_after->retrieveAtoms( true );
+  if( !force && actionInChain() || atomsWereRetrieved ) {
+    return;
+  }
+  ActionAtomistic::retrieveAtoms();
+  atomsWereRetrieved = !actionInChain();
+  if( action_to_do_after ) {
+    action_to_do_after->retrieveAtoms( true );
+  }
 }
 
 bool ActionWithVector::hasStoredArguments() const {
   std::string headstr=getFirstActionInChain()->getLabel();
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( !getPntrToArgument(i)->ignoreStoredValue(headstr) ) return true;
+    if( !getPntrToArgument(i)->ignoreStoredValue(headstr) ) {
+      return true;
+    }
   }
   return false;
 }
 
 bool ActionWithVector::argumentDependsOn( const std::string& headstr, ActionWithVector* faction, Value* thearg ) {
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( this!=faction && thearg==getPntrToArgument(i) ) return true;
+    if( this!=faction && thearg==getPntrToArgument(i) ) {
+      return true;
+    }
     ActionWithVector* av = dynamic_cast<ActionWithVector*>( getPntrToArgument(i)->getPntrToAction() );
     if( av && (av->getFirstActionInChain())->getLabel()==headstr ) {
-      if( av->argumentDependsOn( headstr, faction, thearg ) ) return true;;
+      if( av->argumentDependsOn( headstr, faction, thearg ) ) {
+        return true;
+      };
     }
   }
   return false;
@@ -119,42 +146,72 @@ bool ActionWithVector::argumentDependsOn( const std::string& headstr, ActionWith
 unsigned ActionWithVector::buildArgumentStore( const unsigned& argstart ) {
   // Don't use chains for grids
   for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->isConstant() ) continue;
+    if( getPntrToArgument(i)->isConstant() ) {
+      continue;
+    }
     ActionWithVector* av=dynamic_cast<ActionWithVector*>(getPntrToArgument(i)->getPntrToAction());
-    if( !av || getPntrToArgument(i)->getRank()>0 && getPntrToArgument(i)->hasDerivatives() ) { done_in_chain=false; break; }
+    if( !av || getPntrToArgument(i)->getRank()>0 && getPntrToArgument(i)->hasDerivatives() ) {
+      done_in_chain=false;
+      break;
+    }
   }
   if( done_in_chain ) {
-    std::vector<std::string> alabels; std::vector<ActionWithVector*> f_actions;
+    std::vector<std::string> alabels;
+    std::vector<ActionWithVector*> f_actions;
     for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-      bool found=false; std::string mylab = (getPntrToArgument(i)->getPntrToAction())->getLabel();
+      bool found=false;
+      std::string mylab = (getPntrToArgument(i)->getPntrToAction())->getLabel();
       for(unsigned j=0; j<alabels.size(); ++j) {
-        if( alabels[j]==mylab ) { found=true; break; }
+        if( alabels[j]==mylab ) {
+          found=true;
+          break;
+        }
+      }
+      if( !found ) {
+        alabels.push_back( mylab );
       }
-      if( !found ) alabels.push_back( mylab );
 
       // If this is calculated in setup we never need to add to chain
-      if( getPntrToArgument(i)->isConstant() ) continue;
+      if( getPntrToArgument(i)->isConstant() ) {
+        continue;
+      }
       // Find the chain we need to add this to from the arguments
-      ActionWithVector* av=dynamic_cast<ActionWithVector*>(getPntrToArgument(i)->getPntrToAction()); plumed_assert( av );
-      found=false; ActionWithVector* myact = av->getFirstActionInChain();
+      ActionWithVector* av=dynamic_cast<ActionWithVector*>(getPntrToArgument(i)->getPntrToAction());
+      plumed_assert( av );
+      found=false;
+      ActionWithVector* myact = av->getFirstActionInChain();
       if( getPntrToArgument(i)->getRank()==1 && getPntrToArgument(i)->storedata ) {
         for(unsigned j=argstart; j<getNumberOfArguments(); ++j) {
           ActionWithArguments* aarg=dynamic_cast<ActionWithArguments*>( getPntrToArgument(j)->getPntrToAction() );
-          if( !aarg || i==j ) continue;
+          if( !aarg || i==j ) {
+            continue;
+          }
           for(unsigned k=0; k<aarg->getNumberOfArguments(); ++k) {
-            if( aarg->getPntrToArgument(k)==getPntrToArgument(i) ) { done_in_chain=false; return reallyBuildArgumentStore( argstart ); }
+            if( aarg->getPntrToArgument(k)==getPntrToArgument(i) ) {
+              done_in_chain=false;
+              return reallyBuildArgumentStore( argstart );
+            }
           }
         }
       }
       for(unsigned j=0; j<f_actions.size(); ++j) {
-        if( f_actions[j]==myact ) { found=true; break; }
+        if( f_actions[j]==myact ) {
+          found=true;
+          break;
+        }
       }
       if( !found ) {
         if( f_actions.size()>0 ) {
-          if( f_actions[0]->checkForDependency(myact) ) getPntrToArgument(i)->buildDataStore();
-          if( myact->checkForDependency(f_actions[0]) ) error("cannot deal with arguments in this order. Try swapping argument order");
+          if( f_actions[0]->checkForDependency(myact) ) {
+            getPntrToArgument(i)->buildDataStore();
+          }
+          if( myact->checkForDependency(f_actions[0]) ) {
+            error("cannot deal with arguments in this order. Try swapping argument order");
+          }
+        }
+        if( !getPntrToArgument(i)->storedata && getPntrToArgument(i)->getRank()>0 ) {
+          f_actions.push_back( myact );
         }
-        if( !getPntrToArgument(i)->storedata && getPntrToArgument(i)->getRank()>0 ) f_actions.push_back( myact );
       }
     }
     // Now make sure that everything we need is in the chain
@@ -162,24 +219,42 @@ unsigned ActionWithVector::buildArgumentStore( const unsigned& argstart ) {
       // Check everything for later f_actions is done before f_actions[0]
       for(unsigned i=1; i<f_actions.size(); ++i) {
         ActionWithArguments* aarg = dynamic_cast<ActionWithArguments*>( f_actions[i] );
-        if( !aarg || aarg->getNumberOfArguments()==0 ) continue;
+        if( !aarg || aarg->getNumberOfArguments()==0 ) {
+          continue;
+        }
         for(unsigned j=0; j<aarg->getNumberOfArguments(); ++j) {
-          if( (aarg->getPntrToArgument(j))->isConstant() ) continue ;
-          bool found=false; std::string dep_argname = (aarg->getPntrToArgument(j))->getPntrToAction()->getLabel();
+          if( (aarg->getPntrToArgument(j))->isConstant() ) {
+            continue ;
+          }
+          bool found=false;
+          std::string dep_argname = (aarg->getPntrToArgument(j))->getPntrToAction()->getLabel();
           for(const auto & pp : plumed.getActionSet()) {
             Action* p(pp.get());
             // Check if this is the dependency
-            if( p->getLabel()==dep_argname ) { found=true; break; }
+            if( p->getLabel()==dep_argname ) {
+              found=true;
+              break;
+            }
             // Check if this is the first of the arguments that will appear in this chain
-            else if( p->getLabel()==f_actions[0]->getLabel() ) break;
+            else if( p->getLabel()==f_actions[0]->getLabel() ) {
+              break;
+            }
+          }
+          if( !found ) {
+            done_in_chain=false;
+            break;
           }
-          if( !found ) { done_in_chain=false; break; }
         }
         // Stop trying to add things in the chain if we cannot
-        if( !done_in_chain ) return reallyBuildArgumentStore( argstart );
+        if( !done_in_chain ) {
+          return reallyBuildArgumentStore( argstart );
+        }
+      }
+      std::vector<std::string> empty(1);
+      empty[0] = f_actions[0]->getLabel();
+      for(unsigned i=1; i<f_actions.size(); ++i) {
+        f_actions[0]->addActionToChain( empty, f_actions[i] );
       }
-      std::vector<std::string> empty(1); empty[0] = f_actions[0]->getLabel();
-      for(unsigned i=1; i<f_actions.size(); ++i) f_actions[0]->addActionToChain( empty, f_actions[i] );
     }
     // Now add this argument to the chain
     bool added=false;
@@ -187,34 +262,52 @@ unsigned ActionWithVector::buildArgumentStore( const unsigned& argstart ) {
       // Add this function to jobs to do in recursive loop in previous action
       if( getPntrToArgument(i)->getRank()>0 && !getPntrToArgument(i)->isConstant() ) {
         ActionWithVector* av=dynamic_cast<ActionWithVector*>( getPntrToArgument(i)->getPntrToAction() );
-        if( av && av->addActionToChain( alabels, this ) ) { added=true; break; }
+        if( av && av->addActionToChain( alabels, this ) ) {
+          added=true;
+          break;
+        }
       }
     }
     plumed_massert(added, "could not add action " + getLabel() + " to chain of any of its arguments");
     // And get the number of derivatives
     ActionWithVector* head=getFirstActionInChain();
-    unsigned nder=0; arg_deriv_starts.resize( getNumberOfArguments() );
+    unsigned nder=0;
+    arg_deriv_starts.resize( getNumberOfArguments() );
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
       // Ensures that we ignore the grid (first argument) if we are evaluating a function on a grid
-      if( i==0 && getName().find("EVALUATE_FUNCTION_FROM_GRID")!=std::string::npos ) continue ;
+      if( i==0 && getName().find("EVALUATE_FUNCTION_FROM_GRID")!=std::string::npos ) {
+        continue ;
+      }
       ActionWithVector* iaction=dynamic_cast<ActionWithVector*>(getPntrToArgument(i)->getPntrToAction());
       if( actionInChain() && !getPntrToArgument(i)->ignoreStoredValue(head->getLabel()) ) {
-        arg_deriv_starts[i] = 0; head->getNumberOfStreamedDerivatives( arg_deriv_starts[i], getPntrToArgument(i) );
+        arg_deriv_starts[i] = 0;
+        head->getNumberOfStreamedDerivatives( arg_deriv_starts[i], getPntrToArgument(i) );
       } else if( iaction && iaction->isInSubChain(nder) ) {
         arg_deriv_starts[i] = nder;
         // Add the total number of derivatives that we have by this point in the chain to nder
-        if( iaction ) { nder=0; head->getNumberOfStreamedDerivatives( nder, getPntrToArgument(i) ); }
+        if( iaction ) {
+          nder=0;
+          head->getNumberOfStreamedDerivatives( nder, getPntrToArgument(i) );
+        }
       } else {
         // Check if we have already found this action
         int k=-1;
         if( iaction ) {
           ActionWithVector* ider_action=iaction->getActionWithDerivatives( iaction );
           for(unsigned j=0; j<i; ++j) {
-            if( j==0 && getName().find("EVALUATE_FUNCTION_FROM_GRID")!=std::string::npos ) continue ;
+            if( j==0 && getName().find("EVALUATE_FUNCTION_FROM_GRID")!=std::string::npos ) {
+              continue ;
+            }
             ActionWithVector* jaction=dynamic_cast<ActionWithVector*>(getPntrToArgument(j)->getPntrToAction());
-            if( jaction->getActionWithDerivatives(jaction)==ider_action || jaction->checkForDependency(ider_action) ) { k=j; break; }
+            if( jaction->getActionWithDerivatives(jaction)==ider_action || jaction->checkForDependency(ider_action) ) {
+              k=j;
+              break;
+            }
+          }
+          if( k>=0 ) {
+            arg_deriv_starts[i] = arg_deriv_starts[k];
+            continue;
           }
-          if( k>=0 ) { arg_deriv_starts[i] = arg_deriv_starts[k]; continue; }
         }
 
         if( i>0 ) {
@@ -229,8 +322,12 @@ unsigned ActionWithVector::buildArgumentStore( const unsigned& argstart ) {
           // mder is equal to the number of derivatives by the time you get to f minus the number of derivatives for c
           unsigned mder=0;
           ActionWithVector* jaction=dynamic_cast<ActionWithVector*>(getPntrToArgument(i-1)->getPntrToAction());
-          if( jaction->action_to_do_after && !(jaction->action_to_do_after)->getNumberOfStoredValues( getPntrToArgument(i-1), mder, i, getArguments() ) ) mder=0;
-          if( mder>0 ) nder = nder + mder;
+          if( jaction->action_to_do_after && !(jaction->action_to_do_after)->getNumberOfStoredValues( getPntrToArgument(i-1), mder, i, getArguments() ) ) {
+            mder=0;
+          }
+          if( mder>0 ) {
+            nder = nder + mder;
+          }
         }
 
         arg_deriv_starts[i] = nder;
@@ -242,29 +339,44 @@ unsigned ActionWithVector::buildArgumentStore( const unsigned& argstart ) {
             plumed_assert( aarg && aarg->getNumberOfArguments()==2 );
             head->getNumberOfStreamedDerivatives( nder, aarg->getPntrToArgument(0) );
             nder += (aarg->getPntrToArgument(1))->getNumberOfValues();
-          } else head->getNumberOfStreamedDerivatives( nder, getPntrToArgument(i) );
+          } else {
+            head->getNumberOfStreamedDerivatives( nder, getPntrToArgument(i) );
+          }
         }
       }
     }
-    nder=0; head->getNumberOfStreamedDerivatives( nder, NULL );
+    nder=0;
+    head->getNumberOfStreamedDerivatives( nder, NULL );
     return nder;
   }
   return reallyBuildArgumentStore( argstart );
 }
 
 unsigned ActionWithVector::reallyBuildArgumentStore( const unsigned& argstart ) {
-  for(unsigned i=argstart; i<getNumberOfArguments(); ++i) { if( getPntrToArgument(i)->getRank()>0 ) getPntrToArgument(i)->buildDataStore(); }
-  unsigned nder=0; arg_deriv_starts.resize( getNumberOfArguments() );
-  for(unsigned i=0; i<getNumberOfArguments(); ++i) { arg_deriv_starts[i] = nder; nder += getPntrToArgument(i)->getNumberOfValues(); }
+  for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
+    if( getPntrToArgument(i)->getRank()>0 ) {
+      getPntrToArgument(i)->buildDataStore();
+    }
+  }
+  unsigned nder=0;
+  arg_deriv_starts.resize( getNumberOfArguments() );
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    arg_deriv_starts[i] = nder;
+    nder += getPntrToArgument(i)->getNumberOfValues();
+  }
   return nder;
 }
 
 ActionWithVector* ActionWithVector::getActionWithDerivatives( ActionWithVector* depaction ) {
   if( depaction==this || depaction->checkForDependency(this) ) {
-    if( getNumberOfAtoms()>0 ) return this;
+    if( getNumberOfAtoms()>0 ) {
+      return this;
+    }
     std::string c=getFirstActionInChain()->getLabel();
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-      if( !getPntrToArgument(i)->ignoreStoredValue(c) && !getPntrToArgument(i)->isConstant() ) return this;
+      if( !getPntrToArgument(i)->ignoreStoredValue(c) && !getPntrToArgument(i)->isConstant() ) {
+        return this;
+      }
     }
   }
   plumed_assert( action_to_do_before );
@@ -272,47 +384,70 @@ ActionWithVector* ActionWithVector::getActionWithDerivatives( ActionWithVector*
 }
 
 bool ActionWithVector::addActionToChain( const std::vector<std::string>& alabels, ActionWithVector* act ) {
-  if( action_to_do_after ) { bool state=action_to_do_after->addActionToChain( alabels, act ); return state; }
+  if( action_to_do_after ) {
+    bool state=action_to_do_after->addActionToChain( alabels, act );
+    return state;
+  }
   // Check action is not already in chain
-  std::vector<std::string> mylabels; getFirstActionInChain()->getAllActionLabelsInChain( mylabels );
+  std::vector<std::string> mylabels;
+  getFirstActionInChain()->getAllActionLabelsInChain( mylabels );
   for(unsigned i=0; i<mylabels.size(); ++i) {
-    if( act->getLabel()==mylabels[i] ) return true;
+    if( act->getLabel()==mylabels[i] ) {
+      return true;
+    }
   }
 
   // Check that everything that is required has been calculated
   for(unsigned i=0; i<alabels.size(); ++i) {
     bool found=false;
     for(unsigned j=0; j<mylabels.size(); ++j) {
-      if( alabels[i]==mylabels[j] ) { found=true; break; }
+      if( alabels[i]==mylabels[j] ) {
+        found=true;
+        break;
+      }
     }
     if( !found ) {
       ActionWithValue* av=plumed.getActionSet().selectWithLabel<ActionWithValue*>( alabels[i] );
-      plumed_massert( av, "could not cast " + alabels[i] ); bool storingall=true;
+      plumed_massert( av, "could not cast " + alabels[i] );
+      bool storingall=true;
       for(int j=0; j<av->getNumberOfComponents(); ++j) {
-        if( !(av->getPntrToComponent(j))->storedata ) storingall=false;
+        if( !(av->getPntrToComponent(j))->storedata ) {
+          storingall=false;
+        }
+      }
+      if( !storingall ) {
+        return false;
       }
-      if( !storingall ) return false;
     }
   }
   // This checks that there is nothing that will cause problems in the chain
-  mylabels.resize(0); getFirstActionInChain()->getAllActionLabelsInChain( mylabels );
+  mylabels.resize(0);
+  getFirstActionInChain()->getAllActionLabelsInChain( mylabels );
   for(unsigned i=0; i<mylabels.size(); ++i) {
     ActionWithVector* av1=plumed.getActionSet().selectWithLabel<ActionWithVector*>( mylabels[i] );
     for(unsigned j=0; j<i; ++j) {
       ActionWithVector* av2=plumed.getActionSet().selectWithLabel<ActionWithVector*>( mylabels[j] );
-      if( !av1->canBeAfterInChain( av2 ) ) error("must calculate " + mylabels[j] + " before " + mylabels[i] );
+      if( !av1->canBeAfterInChain( av2 ) ) {
+        error("must calculate " + mylabels[j] + " before " + mylabels[i] );
+      }
     }
   }
-  action_to_do_after=act; act->action_to_do_before=this; updateTaskListReductionStatus();
+  action_to_do_after=act;
+  act->action_to_do_before=this;
+  updateTaskListReductionStatus();
   ActionWithVector* head = getFirstActionInChain();
-  head->broadcastThatTasksAreReduced( head ); head->finishChainBuild( act );
+  head->broadcastThatTasksAreReduced( head );
+  head->finishChainBuild( act );
   return true;
 }
 
 void ActionWithVector::updateTaskListReductionStatus() {
   ActionWithVector* head = getFirstActionInChain();
-  std::vector<ActionWithVector*> task_reducing_actions; head->canReduceTasks( task_reducing_actions );
-  if( task_reducing_actions.size()>0 ) head->reduce_tasks=true;
+  std::vector<ActionWithVector*> task_reducing_actions;
+  head->canReduceTasks( task_reducing_actions );
+  if( task_reducing_actions.size()>0 ) {
+    head->reduce_tasks=true;
+  }
 }
 
 void ActionWithVector::broadcastThatTasksAreReduced( ActionWithVector* aselect ) {
@@ -324,15 +459,23 @@ void ActionWithVector::broadcastThatTasksAreReduced( ActionWithVector* aselect )
         bool found=false;
         ActionWithVector* av_head = av->getFirstActionInChain();
         for(unsigned i=0; i<av_head->task_control_list.size(); ++i) {
-          if( aselect==av_head->task_control_list[i] ) { found=true; break; }
+          if( aselect==av_head->task_control_list[i] ) {
+            found=true;
+            break;
+          }
+        }
+        if( !found ) {
+          av_head->task_control_list.insert( av_head->task_control_list.begin(), aselect );
         }
-        if( !found ) av_head->task_control_list.insert( av_head->task_control_list.begin(), aselect );
 
-        av_head->reduce_tasks=true; av_head->updateTaskReductionFlag( av_head->reduce_tasks );
+        av_head->reduce_tasks=true;
+        av_head->updateTaskReductionFlag( av_head->reduce_tasks );
       }
     }
   }
-  if( action_to_do_after ) action_to_do_after->broadcastThatTasksAreReduced( aselect );
+  if( action_to_do_after ) {
+    action_to_do_after->broadcastThatTasksAreReduced( aselect );
+  }
 }
 
 void ActionWithVector::updateTaskReductionFlag( bool& head_reduce_tasks ) {
@@ -340,56 +483,87 @@ void ActionWithVector::updateTaskReductionFlag( bool& head_reduce_tasks ) {
     plumed_assert( task_control_list.size()==0 );
   } else {
     for(unsigned i=0; i<task_control_list.size(); ++i) {
-      if( !(task_control_list[i]->getFirstActionInChain())->reduce_tasks ) head_reduce_tasks=false;
+      if( !(task_control_list[i]->getFirstActionInChain())->reduce_tasks ) {
+        head_reduce_tasks=false;
+      }
     }
   }
   broadcastThatTasksAreReduced( getFirstActionInChain() );
-  if( action_to_do_after ) action_to_do_after->updateTaskReductionFlag( head_reduce_tasks );
+  if( action_to_do_after ) {
+    action_to_do_after->updateTaskReductionFlag( head_reduce_tasks );
+  }
 }
 
 void ActionWithVector::canReduceTasks( std::vector<ActionWithVector*>& task_reducing_actions ) {
   areAllTasksRequired( task_reducing_actions );
-  if( action_to_do_after ) action_to_do_after->canReduceTasks( task_reducing_actions );
+  if( action_to_do_after ) {
+    action_to_do_after->canReduceTasks( task_reducing_actions );
+  }
 }
 
 void ActionWithVector::finishChainBuild( ActionWithVector* act ) {
-  if( action_to_do_after ) action_to_do_after->finishChainBuild( act );
+  if( action_to_do_after ) {
+    action_to_do_after->finishChainBuild( act );
+  }
 }
 
 void ActionWithVector::getAllActionLabelsInChain( std::vector<std::string>& mylabels ) const {
   bool found = false ;
   for(unsigned i=0; i<mylabels.size(); ++i) {
-    if( getLabel()==mylabels[i] ) { found=true; }
+    if( getLabel()==mylabels[i] ) {
+      found=true;
+    }
+  }
+  if( !found ) {
+    mylabels.push_back( getLabel() );
+  }
+  if( action_to_do_after ) {
+    action_to_do_after->getAllActionLabelsInChain( mylabels );
   }
-  if( !found ) mylabels.push_back( getLabel() );
-  if( action_to_do_after ) action_to_do_after->getAllActionLabelsInChain( mylabels );
 }
 
 void ActionWithVector::taskIsActive( const unsigned& current, int& flag ) const {
-  if( isActive() ) flag = checkTaskStatus( current, flag );
-  if( flag<=0 && action_to_do_after ) action_to_do_after->taskIsActive( current, flag );
+  if( isActive() ) {
+    flag = checkTaskStatus( current, flag );
+  }
+  if( flag<=0 && action_to_do_after ) {
+    action_to_do_after->taskIsActive( current, flag );
+  }
 }
 
 void ActionWithVector::getAdditionalTasksRequired( ActionWithVector* action, std::vector<unsigned>& atasks ) {
-  for(unsigned i=0; i<task_control_list.size(); ++i ) task_control_list[i]->getAdditionalTasksRequired( action, atasks );
+  for(unsigned i=0; i<task_control_list.size(); ++i ) {
+    task_control_list[i]->getAdditionalTasksRequired( action, atasks );
+  }
 }
 
 void ActionWithVector::prepare() {
-  active_tasks.resize(0); atomsWereRetrieved=false;
+  active_tasks.resize(0);
+  atomsWereRetrieved=false;
 }
 
 std::vector<unsigned>& ActionWithVector::getListOfActiveTasks( ActionWithVector* action ) {
-  if( active_tasks.size()>0 ) return active_tasks;
-  unsigned ntasks=0; getNumberOfTasks( ntasks );
+  if( active_tasks.size()>0 ) {
+    return active_tasks;
+  }
+  unsigned ntasks=0;
+  getNumberOfTasks( ntasks );
 
   unsigned stride=comm.Get_size();
   unsigned rank=comm.Get_rank();
-  if(serial) { stride=1; rank=0; }
+  if(serial) {
+    stride=1;
+    rank=0;
+  }
 
   // Get number of threads for OpenMP
   unsigned nt=OpenMP::getNumThreads();
-  if( nt*stride*10>ntasks ) nt=ntasks/stride/10;
-  if( nt==0 ) nt=1;
+  if( nt*stride*10>ntasks ) {
+    nt=ntasks/stride/10;
+  }
+  if( nt==0 ) {
+    nt=1;
+  }
 
   if( !never_reduce_tasks && reduce_tasks ) {
     if( task_control_list.size()>0 ) {
@@ -410,33 +584,50 @@ std::vector<unsigned>& ActionWithVector::getListOfActiveTasks( ActionWithVector*
           taskIsActive( i, taskFlags[i] );
         }
       }
-      for(unsigned i=0; i<ntasks; ++i) taskFlags[i] = std::abs( taskFlags[i] );
-      if( !serial ) comm.Sum( taskFlags );
+      for(unsigned i=0; i<ntasks; ++i) {
+        taskFlags[i] = std::abs( taskFlags[i] );
+      }
+      if( !serial ) {
+        comm.Sum( taskFlags );
+      }
 
       unsigned nt=0;
       for(unsigned i=0; i<ntasks; ++i) {
-        if( taskFlags[i]>=stride ) nt++;
+        if( taskFlags[i]>=stride ) {
+          nt++;
+        }
       }
-      active_tasks.resize(nt); nt=0;
+      active_tasks.resize(nt);
+      nt=0;
       for(unsigned i=0; i<ntasks; ++i) {
-        if( taskFlags[i]>=stride ) { active_tasks[nt]=i; nt++; }
+        if( taskFlags[i]>=stride ) {
+          active_tasks[nt]=i;
+          nt++;
+        }
       }
       getAdditionalTasksRequired( this, active_tasks );
     }
   } else {
     active_tasks.resize( ntasks );
-    for(unsigned i=0; i<ntasks; ++i) active_tasks[i]=i;
+    for(unsigned i=0; i<ntasks; ++i) {
+      active_tasks[i]=i;
+    }
   }
   return active_tasks;
 }
 
 void ActionWithVector::runAllTasks() {
 // Skip this if this is done elsewhere
-  if( action_to_do_before ) return;
+  if( action_to_do_before ) {
+    return;
+  }
 
   unsigned stride=comm.Get_size();
   unsigned rank=comm.Get_rank();
-  if(serial) { stride=1; rank=0; }
+  if(serial) {
+    stride=1;
+    rank=0;
+  }
 
   // Get the list of active tasks
   std::vector<unsigned> & partialTaskList( getListOfActiveTasks( this ) );
@@ -444,8 +635,12 @@ void ActionWithVector::runAllTasks() {
 
   // Get number of threads for OpenMP
   unsigned nt=OpenMP::getNumThreads();
-  if( nt*stride*10>nactive_tasks ) nt=nactive_tasks/stride/10;
-  if( nt==0 ) nt=1;
+  if( nt*stride*10>nactive_tasks ) {
+    nt=nactive_tasks/stride/10;
+  }
+  if( nt==0 ) {
+    nt=1;
+  }
 
   // Now do all preparations required to run all the tasks
   // prepareForTaskLoop();
@@ -454,19 +649,27 @@ void ActionWithVector::runAllTasks() {
   unsigned nquants=0, nmatrices=0, maxcol=0, nbooks=0;
   getNumberOfStreamedQuantities( getLabel(), nquants, nmatrices, maxcol, nbooks );
   // Get size for buffer
-  unsigned bufsize=0; getSizeOfBuffer( nactive_tasks, bufsize );
-  if( buffer.size()!=bufsize ) buffer.resize( bufsize );
+  unsigned bufsize=0;
+  getSizeOfBuffer( nactive_tasks, bufsize );
+  if( buffer.size()!=bufsize ) {
+    buffer.resize( bufsize );
+  }
   // Clear buffer
   buffer.assign( buffer.size(), 0.0 );
 
   // Recover the number of derivatives we require
-  unsigned nderivatives = 0; bool gridsInStream=checkForGrids(nderivatives);
-  if( !doNotCalculateDerivatives() && !gridsInStream ) getNumberOfStreamedDerivatives( nderivatives, NULL );
+  unsigned nderivatives = 0;
+  bool gridsInStream=checkForGrids(nderivatives);
+  if( !doNotCalculateDerivatives() && !gridsInStream ) {
+    getNumberOfStreamedDerivatives( nderivatives, NULL );
+  }
 
   #pragma omp parallel num_threads(nt)
   {
     std::vector<double> omp_buffer;
-    if( nt>1 ) omp_buffer.resize( bufsize, 0.0 );
+    if( nt>1 ) {
+      omp_buffer.resize( bufsize, 0.0 );
+    }
     MultiValue myvals( nquants, nderivatives, nmatrices, maxcol, nbooks );
     myvals.clearAll();
 
@@ -476,8 +679,11 @@ void ActionWithVector::runAllTasks() {
       runTask( partialTaskList[i], myvals );
 
       // Now transfer the data to the actions that accumulate values from the calculated quantities
-      if( nt>1 ) gatherAccumulators( partialTaskList[i], myvals, omp_buffer );
-      else gatherAccumulators( partialTaskList[i], myvals, buffer );
+      if( nt>1 ) {
+        gatherAccumulators( partialTaskList[i], myvals, omp_buffer );
+      } else {
+        gatherAccumulators( partialTaskList[i], myvals, buffer );
+      }
 
       // Clear the value
       myvals.clearAll();
@@ -487,12 +693,17 @@ void ActionWithVector::runAllTasks() {
   }
 
   // MPI Gather everything
-  if( !serial && buffer.size()>0 ) gatherProcesses( buffer );
+  if( !serial && buffer.size()>0 ) {
+    gatherProcesses( buffer );
+  }
   finishComputations( buffer );
 }
 
 void ActionWithVector::gatherThreads( const unsigned& nt, const unsigned& bufsize, const std::vector<double>& omp_buffer, std::vector<double>& buffer, MultiValue& myvals ) {
-  if( nt>1 ) for(unsigned i=0; i<bufsize; ++i) buffer[i]+=omp_buffer[i];
+  if( nt>1 )
+    for(unsigned i=0; i<bufsize; ++i) {
+      buffer[i]+=omp_buffer[i];
+    }
 }
 
 void ActionWithVector::gatherProcesses( std::vector<double>& buffer ) {
@@ -502,92 +713,144 @@ void ActionWithVector::gatherProcesses( std::vector<double>& buffer ) {
 bool ActionWithVector::checkForGrids( unsigned& nder ) const {
   for(int i=0; i<getNumberOfComponents(); ++i) {
     if( getConstPntrToComponent(i)->getRank()>0 && getConstPntrToComponent(i)->hasDerivatives() ) {
-      nder=getConstPntrToComponent(i)->getNumberOfGridDerivatives(); return true;
+      nder=getConstPntrToComponent(i)->getNumberOfGridDerivatives();
+      return true;
     }
   }
-  if( action_to_do_after ) return action_to_do_after->checkForGrids(nder);
+  if( action_to_do_after ) {
+    return action_to_do_after->checkForGrids(nder);
+  }
   return false;
 }
 
 void ActionWithVector::getNumberOfTasks( unsigned& ntasks ) {
   if( ntasks==0 ) {
     if( getNumberOfArguments()==1 && getNumberOfComponents()==1 && getPntrToComponent(0)->getRank()==0 ) {
-      if( !getPntrToArgument(0)->hasDerivatives() && getPntrToArgument(0)->getRank()==2 ) ntasks = getPntrToArgument(0)->getShape()[0];
-      else ntasks = getPntrToArgument(0)->getNumberOfValues();
+      if( !getPntrToArgument(0)->hasDerivatives() && getPntrToArgument(0)->getRank()==2 ) {
+        ntasks = getPntrToArgument(0)->getShape()[0];
+      } else {
+        ntasks = getPntrToArgument(0)->getNumberOfValues();
+      }
     } else {
       plumed_assert( getNumberOfComponents()>0 && getPntrToComponent(0)->getRank()>0 );
-      if( getPntrToComponent(0)->hasDerivatives() ) ntasks = getPntrToComponent(0)->getNumberOfValues();
-      else ntasks = getPntrToComponent(0)->getShape()[0];
+      if( getPntrToComponent(0)->hasDerivatives() ) {
+        ntasks = getPntrToComponent(0)->getNumberOfValues();
+      } else {
+        ntasks = getPntrToComponent(0)->getShape()[0];
+      }
     }
   }
   for(int i=0; i<getNumberOfComponents(); ++i) {
     if( getPntrToComponent(i)->getRank()==0 ) {
-      if( getNumberOfArguments()!=1 ) error("mismatched numbers of tasks in streamed quantities");
-      if( getPntrToArgument(0)->hasDerivatives() && ntasks!=getPntrToArgument(0)->getNumberOfValues() ) error("mismatched numbers of tasks in streamed quantities");
-      else if ( !getPntrToArgument(0)->hasDerivatives() && ntasks!=getPntrToArgument(0)->getShape()[0] ) error("mismatched numbers of tasks in streamed quantities");
-    } else if( getPntrToComponent(i)->hasDerivatives() && ntasks!=getPntrToComponent(i)->getNumberOfValues() ) error("mismatched numbers of tasks in streamed quantities");
-    else if( !getPntrToComponent(i)->hasDerivatives() && ntasks!=getPntrToComponent(i)->getShape()[0] ) error("mismatched numbers of tasks in streamed quantities");
+      if( getNumberOfArguments()!=1 ) {
+        error("mismatched numbers of tasks in streamed quantities");
+      }
+      if( getPntrToArgument(0)->hasDerivatives() && ntasks!=getPntrToArgument(0)->getNumberOfValues() ) {
+        error("mismatched numbers of tasks in streamed quantities");
+      } else if ( !getPntrToArgument(0)->hasDerivatives() && ntasks!=getPntrToArgument(0)->getShape()[0] ) {
+        error("mismatched numbers of tasks in streamed quantities");
+      }
+    } else if( getPntrToComponent(i)->hasDerivatives() && ntasks!=getPntrToComponent(i)->getNumberOfValues() ) {
+      error("mismatched numbers of tasks in streamed quantities");
+    } else if( !getPntrToComponent(i)->hasDerivatives() && ntasks!=getPntrToComponent(i)->getShape()[0] ) {
+      error("mismatched numbers of tasks in streamed quantities");
+    }
+  }
+  if( action_to_do_after ) {
+    action_to_do_after->getNumberOfTasks( ntasks );
   }
-  if( action_to_do_after ) action_to_do_after->getNumberOfTasks( ntasks );
 }
 
 void ActionWithVector::setupStreamedComponents( const std::string& headstr, unsigned& nquants, unsigned& nmat, unsigned& maxcol, unsigned& nbookeeping ) {
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( !getPntrToArgument(i)->ignoreStoredValue(headstr) ) { getPntrToArgument(i)->streampos=nquants; nquants++; }
+    if( !getPntrToArgument(i)->ignoreStoredValue(headstr) ) {
+      getPntrToArgument(i)->streampos=nquants;
+      nquants++;
+    }
+  }
+  for(int i=0; i<getNumberOfComponents(); ++i) {
+    getPntrToComponent(i)->streampos=nquants;
+    nquants++;
   }
-  for(int i=0; i<getNumberOfComponents(); ++i) { getPntrToComponent(i)->streampos=nquants; nquants++; }
 }
 
 void ActionWithVector::getNumberOfStreamedQuantities( const std::string& headstr, unsigned& nquants, unsigned& nmat, unsigned& maxcol, unsigned& nbookeeping ) {
   setupStreamedComponents( headstr, nquants, nmat, maxcol, nbookeeping );
-  if( action_to_do_after ) action_to_do_after->getNumberOfStreamedQuantities( headstr, nquants, nmat, maxcol, nbookeeping );
+  if( action_to_do_after ) {
+    action_to_do_after->getNumberOfStreamedQuantities( headstr, nquants, nmat, maxcol, nbookeeping );
+  }
 }
 
 void ActionWithVector::getSizeOfBuffer( const unsigned& nactive_tasks, unsigned& bufsize ) {
-  for(int i=0; i<getNumberOfComponents(); ++i) { getPntrToComponent(i)->bufstart=bufsize; bufsize += getPntrToComponent(i)->data.size(); }
-  if( action_to_do_after ) action_to_do_after->getSizeOfBuffer( nactive_tasks, bufsize );
+  for(int i=0; i<getNumberOfComponents(); ++i) {
+    getPntrToComponent(i)->bufstart=bufsize;
+    bufsize += getPntrToComponent(i)->data.size();
+  }
+  if( action_to_do_after ) {
+    action_to_do_after->getSizeOfBuffer( nactive_tasks, bufsize );
+  }
 }
 
 void ActionWithVector::getNumberOfStreamedDerivatives( unsigned& nderivatives, Value* stopat ) {
   std::string c=getFirstActionInChain()->getLabel();
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
     if( !getPntrToArgument(i)->ignoreStoredValue(c) ) {
-      if( getPntrToArgument(i)==stopat ) return;
+      if( getPntrToArgument(i)==stopat ) {
+        return;
+      }
       nderivatives += getPntrToArgument(i)->getNumberOfValues();
     }
   }
-  if( getNumberOfAtoms()>0 ) nderivatives += 3*getNumberOfAtoms() + 9;
+  if( getNumberOfAtoms()>0 ) {
+    nderivatives += 3*getNumberOfAtoms() + 9;
+  }
   // Don't do the whole chain if we have been told to stop early
-  if( stopat && stopat->getPntrToAction()==this ) return;
+  if( stopat && stopat->getPntrToAction()==this ) {
+    return;
+  }
 
-  if( action_to_do_after ) action_to_do_after->getNumberOfStreamedDerivatives( nderivatives, stopat );
+  if( action_to_do_after ) {
+    action_to_do_after->getNumberOfStreamedDerivatives( nderivatives, stopat );
+  }
 }
 
 bool ActionWithVector::getNumberOfStoredValues( Value* startat, unsigned& nvals, const unsigned& astart, const std::vector<Value*>& stopat ) {
   for(unsigned j=astart; j<stopat.size(); ++j) {
-    if( stopat[j] && (stopat[j]->getPntrToAction()==this || (stopat[j]->getPntrToAction())->checkForDependency(this)) ) return true;
+    if( stopat[j] && (stopat[j]->getPntrToAction()==this || (stopat[j]->getPntrToAction())->checkForDependency(this)) ) {
+      return true;
+    }
   }
 
   std::string c=getFirstActionInChain()->getLabel();
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
     if( !getPntrToArgument(i)->ignoreStoredValue(c) ) {
       for(unsigned j=astart; j<stopat.size(); ++j) {
-        if( getPntrToArgument(i)==stopat[j] ) return true;
+        if( getPntrToArgument(i)==stopat[j] ) {
+          return true;
+        }
       }
       nvals += getPntrToArgument(i)->getNumberOfValues();
     }
   }
-  if( startat->getPntrToAction()!=this && getNumberOfAtoms()>0 ) return false;
+  if( startat->getPntrToAction()!=this && getNumberOfAtoms()>0 ) {
+    return false;
+  }
 
-  if( action_to_do_after ) return action_to_do_after->getNumberOfStoredValues( startat, nvals, astart, stopat );
+  if( action_to_do_after ) {
+    return action_to_do_after->getNumberOfStoredValues( startat, nvals, astart, stopat );
+  }
   return false;
 }
 
 void ActionWithVector::runTask( const unsigned& current, MultiValue& myvals ) const {
   if( isActive() ) {
-    myvals.setTaskIndex(current); myvals.vector_call=true; performTask( current, myvals );
+    myvals.setTaskIndex(current);
+    myvals.vector_call=true;
+    performTask( current, myvals );
+  }
+  if( action_to_do_after ) {
+    action_to_do_after->runTask( current, myvals );
   }
-  if( action_to_do_after ) action_to_do_after->runTask( current, myvals );
 }
 
 void ActionWithVector::gatherAccumulators( const unsigned& taskCode, const MultiValue& myvals, std::vector<double>& buffer ) const {
@@ -597,7 +860,8 @@ void ActionWithVector::gatherAccumulators( const unsigned& taskCode, const Multi
       // This looks after storing of scalars that are summed from vectors/matrices
       if( getConstPntrToComponent(i)->getRank()==0 ) {
         plumed_dbg_massert( bufstart<buffer.size(), "problem in " + getLabel() );
-        unsigned sind = getConstPntrToComponent(i)->streampos; buffer[bufstart] += myvals.get(sind);
+        unsigned sind = getConstPntrToComponent(i)->streampos;
+        buffer[bufstart] += myvals.get(sind);
         if( getConstPntrToComponent(i)->hasDerivatives() ) {
           for(unsigned k=0; k<myvals.getNumberActive(sind); ++k) {
             unsigned kindex = myvals.getActiveIndex(sind,k);
@@ -606,16 +870,21 @@ void ActionWithVector::gatherAccumulators( const unsigned& taskCode, const Multi
           }
         }
         // This looks after storing of vectors
-      } else if( getConstPntrToComponent(i)->storedata ) gatherStoredValue( i, taskCode, myvals, bufstart, buffer );
+      } else if( getConstPntrToComponent(i)->storedata ) {
+        gatherStoredValue( i, taskCode, myvals, bufstart, buffer );
+      }
     }
   }
-  if( action_to_do_after ) action_to_do_after->gatherAccumulators( taskCode, myvals, buffer );
+  if( action_to_do_after ) {
+    action_to_do_after->gatherAccumulators( taskCode, myvals, buffer );
+  }
 }
 
 void ActionWithVector::gatherStoredValue( const unsigned& valindex, const unsigned& taskCode, const MultiValue& myvals,
     const unsigned& bufstart, std::vector<double>& buffer ) const {
   plumed_dbg_assert( getConstPntrToComponent(valindex)->getRank()==1 && !getConstPntrToComponent(valindex)->hasDeriv );
-  unsigned vindex = getConstPntrToComponent(valindex)->bufstart + taskCode; plumed_dbg_massert( vindex<buffer.size(), "failing in " + getLabel() );
+  unsigned vindex = getConstPntrToComponent(valindex)->bufstart + taskCode;
+  plumed_dbg_massert( vindex<buffer.size(), "failing in " + getLabel() );
   buffer[vindex] += myvals.get(getConstPntrToComponent(valindex)->streampos);
 }
 
@@ -632,58 +901,87 @@ void ActionWithVector::finishComputations( const std::vector<double>& buf ) {
           getPntrToComponent(i)->add( j, buf[bufstart+j] );
         }
         // Make sure single values are set
-      } else if( getPntrToComponent(i)->getRank()==0 ) getPntrToComponent(i)->set( buf[bufstart] );
+      } else if( getPntrToComponent(i)->getRank()==0 ) {
+        getPntrToComponent(i)->set( buf[bufstart] );
+      }
       // This gathers derivatives of scalars
       if( !doNotCalculateDerivatives() && getPntrToComponent(i)->hasDeriv && getPntrToComponent(i)->getRank()==0 ) {
-        for(unsigned j=0; j<getPntrToComponent(i)->getNumberOfDerivatives(); ++j) getPntrToComponent(i)->setDerivative( j, buf[bufstart+1+j] );
+        for(unsigned j=0; j<getPntrToComponent(i)->getNumberOfDerivatives(); ++j) {
+          getPntrToComponent(i)->setDerivative( j, buf[bufstart+1+j] );
+        }
       }
     }
   }
-  if( action_to_do_after ) action_to_do_after->finishComputations( buf );
+  if( action_to_do_after ) {
+    action_to_do_after->finishComputations( buf );
+  }
 }
 
 bool ActionWithVector::checkChainForNonScalarForces() const {
   for(unsigned i=0; i<getNumberOfComponents(); ++i) {
-    if( getConstPntrToComponent(i)->getRank()>0 && getConstPntrToComponent(i)->forcesWereAdded() ) return true;
+    if( getConstPntrToComponent(i)->getRank()>0 && getConstPntrToComponent(i)->forcesWereAdded() ) {
+      return true;
+    }
+  }
+  if( action_to_do_after ) {
+    return action_to_do_after->checkChainForNonScalarForces();
   }
-  if( action_to_do_after ) return action_to_do_after->checkChainForNonScalarForces();
   return false;
 }
 
 bool ActionWithVector::checkForForces() {
-  if( getPntrToComponent(0)->getRank()==0 ) return ActionWithValue::checkForForces();
-  else if( actionInChain() ) return false;
+  if( getPntrToComponent(0)->getRank()==0 ) {
+    return ActionWithValue::checkForForces();
+  } else if( actionInChain() ) {
+    return false;
+  }
 
   // Check if there are any forces
-  if( !checkChainForNonScalarForces() ) return false;
+  if( !checkChainForNonScalarForces() ) {
+    return false;
+  }
 
   // Setup MPI parallel loop
   unsigned stride=comm.Get_size();
   unsigned rank=comm.Get_rank();
-  if(serial) { stride=1; rank=0; }
+  if(serial) {
+    stride=1;
+    rank=0;
+  }
 
   // Get the number of tasks
-  std::vector<unsigned> force_tasks; getForceTasks( force_tasks );
-  Tools::removeDuplicates(force_tasks); unsigned nf_tasks=force_tasks.size();
+  std::vector<unsigned> force_tasks;
+  getForceTasks( force_tasks );
+  Tools::removeDuplicates(force_tasks);
+  unsigned nf_tasks=force_tasks.size();
 
   // Get number of threads for OpenMP
   unsigned nt=OpenMP::getNumThreads();
-  if( nt*stride*10>nf_tasks ) nt=nf_tasks/stride/10;
-  if( nt==0 ) nt=1;
+  if( nt*stride*10>nf_tasks ) {
+    nt=nf_tasks/stride/10;
+  }
+  if( nt==0 ) {
+    nt=1;
+  }
 
   // Now determine how big the multivalue needs to be
   unsigned nquants=0, nmatrices=0, maxcol=0, nbooks=0;
   getNumberOfStreamedQuantities( getLabel(), nquants, nmatrices, maxcol, nbooks );
   // Recover the number of derivatives we require (this should be equal to the number of forces)
-  unsigned nderiv=0; getNumberOfStreamedDerivatives( nderiv, NULL );
-  if( forcesForApply.size()!=nderiv ) forcesForApply.resize( nderiv );
+  unsigned nderiv=0;
+  getNumberOfStreamedDerivatives( nderiv, NULL );
+  if( forcesForApply.size()!=nderiv ) {
+    forcesForApply.resize( nderiv );
+  }
   // Clear force buffer
   forcesForApply.assign( forcesForApply.size(), 0.0 );
 
   #pragma omp parallel num_threads(nt)
   {
     std::vector<double> omp_forces;
-    if( nt>1 ) omp_forces.resize( forcesForApply.size(), 0.0 );
+    if( nt>1 ) {
+      omp_forces.resize( forcesForApply.size(), 0.0 );
+    }
     MultiValue myvals( nquants, nderiv, nmatrices, maxcol, nbooks );
     myvals.clearAll();
 
@@ -692,22 +990,32 @@ bool ActionWithVector::checkForForces() {
       runTask( force_tasks[i], myvals );
 
       // Now get the forces
-      if( nt>1 ) gatherForces( force_tasks[i], myvals, omp_forces );
-      else gatherForces( force_tasks[i], myvals, forcesForApply );
+      if( nt>1 ) {
+        gatherForces( force_tasks[i], myvals, omp_forces );
+      } else {
+        gatherForces( force_tasks[i], myvals, forcesForApply );
+      }
 
       myvals.clearAll();
     }
     #pragma omp critical
-    if(nt>1) for(unsigned i=0; i<forcesForApply.size(); ++i) forcesForApply[i]+=omp_forces[i];
+    if(nt>1)
+      for(unsigned i=0; i<forcesForApply.size(); ++i) {
+        forcesForApply[i]+=omp_forces[i];
+      }
   }
   // MPI Gather on forces
-  if( !serial ) comm.Sum( forcesForApply );
+  if( !serial ) {
+    comm.Sum( forcesForApply );
+  }
   return true;
 }
 
 bool ActionWithVector::checkComponentsForForce() const {
   for(unsigned i=0; i<values.size(); ++i) {
-    if( getConstPntrToComponent(i)->forcesWereAdded() ) return true;
+    if( getConstPntrToComponent(i)->forcesWereAdded() ) {
+      return true;
+    }
   }
   return false;
 }
@@ -720,9 +1028,13 @@ bool ActionWithVector::checkForTaskForce( const unsigned& itask, const Value* my
 void ActionWithVector::updateForceTasksFromValue( const Value* myval, std::vector<unsigned>& force_tasks ) const {
   if( myval->getRank()>0 && myval->forcesWereAdded() ) {
     unsigned nt = myval->getNumberOfValues();
-    if( !myval->hasDerivatives() ) nt = myval->getShape()[0];
+    if( !myval->hasDerivatives() ) {
+      nt = myval->getShape()[0];
+    }
     for(unsigned i=0; i<nt; ++i) {
-      if( checkForTaskForce(i, myval) ) force_tasks.push_back( i );
+      if( checkForTaskForce(i, myval) ) {
+        force_tasks.push_back( i );
+      }
     }
   }
 }
@@ -733,7 +1045,9 @@ void ActionWithVector::getForceTasks( std::vector<unsigned>& force_tasks ) const
       updateForceTasksFromValue( getConstPntrToComponent(k), force_tasks );
     }
   }
-  if( action_to_do_after ) action_to_do_after->getForceTasks( force_tasks );
+  if( action_to_do_after ) {
+    action_to_do_after->getForceTasks( force_tasks );
+  }
 }
 
 void ActionWithVector::gatherForcesOnStoredValue( const Value* myval, const unsigned& itask, const MultiValue& myvals, std::vector<double>& forces ) const {
@@ -741,7 +1055,8 @@ void ActionWithVector::gatherForcesOnStoredValue( const Value* myval, const unsi
   double fforce = myval->getForce(itask);
   unsigned sspos = myval->getPositionInStream();
   for(unsigned j=0; j<myvals.getNumberActive(sspos); ++j) {
-    unsigned jder=myvals.getActiveIndex(sspos, j); plumed_dbg_assert( jder<forces.size() );
+    unsigned jder=myvals.getActiveIndex(sspos, j);
+    plumed_dbg_assert( jder<forces.size() );
     forces[jder] += fforce*myvals.getDerivative( sspos, jder );
   }
 }
@@ -750,22 +1065,34 @@ void ActionWithVector::gatherForces( const unsigned& itask, const MultiValue& my
   if( isActive() && checkComponentsForForce() ) {
     for(unsigned k=0; k<getNumberOfComponents(); ++k) {
       const Value* myval=getConstPntrToComponent(k);
-      if( myval->getRank()>0 && myval->forcesWereAdded() ) gatherForcesOnStoredValue( myval, itask, myvals, forces );
+      if( myval->getRank()>0 && myval->forcesWereAdded() ) {
+        gatherForcesOnStoredValue( myval, itask, myvals, forces );
+      }
     }
   }
-  if( action_to_do_after ) action_to_do_after->gatherForces( itask, myvals, forces );
+  if( action_to_do_after ) {
+    action_to_do_after->gatherForces( itask, myvals, forces );
+  }
 }
 
 void ActionWithVector::apply() {
-  if( !checkForForces() ) return;
+  if( !checkForForces() ) {
+    return;
+  }
   // Find the top of the chain and add forces
-  unsigned ind=0; getFirstActionInChain()->addForcesToInput( getForcesToApply(), ind );
+  unsigned ind=0;
+  getFirstActionInChain()->addForcesToInput( getForcesToApply(), ind );
 }
 
 void ActionWithVector::addForcesToInput( const std::vector<double>& forcesToApply, unsigned& ind ) {
-  if( ind>=forcesToApply.size() ) return;
-  addForcesOnArguments( 0, forcesToApply, ind, getFirstActionInChain()->getLabel() ); setForcesOnAtoms( forcesToApply, ind );
-  if( action_to_do_after ) action_to_do_after->addForcesToInput( forcesToApply, ind );
+  if( ind>=forcesToApply.size() ) {
+    return;
+  }
+  addForcesOnArguments( 0, forcesToApply, ind, getFirstActionInChain()->getLabel() );
+  setForcesOnAtoms( forcesToApply, ind );
+  if( action_to_do_after ) {
+    action_to_do_after->addForcesToInput( forcesToApply, ind );
+  }
 }
 
 }
diff --git a/src/core/ActionWithVector.h b/src/core/ActionWithVector.h
index c72e7d09bb..876b8643b8 100644
--- a/src/core/ActionWithVector.h
+++ b/src/core/ActionWithVector.h
@@ -33,8 +33,7 @@ namespace PLMD {
 class ActionWithVector:
   public ActionAtomistic,
   public ActionWithValue,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
   friend class Value;
 private:
 /// Is the calculation to be done in serial
@@ -139,15 +138,21 @@ class ActionWithVector:
 /// We override clearDerivatives here to prevent data in streams from being deleted
   void clearDerivatives( const bool& force=false ) override;
 /// Check if we can be after another ActionWithVector
-  virtual bool canBeAfterInChain( ActionWithVector* av ) { return true; }
+  virtual bool canBeAfterInChain( ActionWithVector* av ) {
+    return true;
+  }
 /// Do we always need to do all the tasks for this action
   virtual void areAllTasksRequired( std::vector<ActionWithVector*>& task_reducing_actions ) {}
 /// Find out how many tasks we need to perform in this loop
   virtual void getNumberOfTasks( unsigned& ntasks );
 /// Check the status of the ith task
-  virtual int checkTaskStatus( const unsigned& taskno, int& flag ) const { return flag; }
+  virtual int checkTaskStatus( const unsigned& taskno, int& flag ) const {
+    return flag;
+  }
 /// Check if we are in a subchain
-  virtual bool isInSubChain( unsigned& nder ) { return false; }
+  virtual bool isInSubChain( unsigned& nder ) {
+    return false;
+  }
 /// Get the additional tasks that are required here
   virtual void getAdditionalTasksRequired( ActionWithVector* action, std::vector<unsigned>& atasks );
 /// setup the streamed quantities
diff --git a/src/core/ActionWithVirtualAtom.cpp b/src/core/ActionWithVirtualAtom.cpp
index afd1a6e156..741e02cceb 100644
--- a/src/core/ActionWithVirtualAtom.cpp
+++ b/src/core/ActionWithVirtualAtom.cpp
@@ -39,29 +39,46 @@ void ActionWithVirtualAtom::registerKeywords(Keywords& keys) {
 ActionWithVirtualAtom::ActionWithVirtualAtom(const ActionOptions&ao):
   Action(ao),
   ActionAtomistic(ao),
-  ActionWithValue(ao)
-{
-  addComponentWithDerivatives("x"); componentIsNotPeriodic("x");
-  addComponentWithDerivatives("y"); componentIsNotPeriodic("y");
-  addComponentWithDerivatives("z"); componentIsNotPeriodic("z");
+  ActionWithValue(ao) {
+  addComponentWithDerivatives("x");
+  componentIsNotPeriodic("x");
+  addComponentWithDerivatives("y");
+  componentIsNotPeriodic("y");
+  addComponentWithDerivatives("z");
+  componentIsNotPeriodic("z");
   // Store the derivatives with respect to the virial only even if there are no atoms
-  for(unsigned i=0; i<3; ++i) getPntrToComponent(i)->resizeDerivatives(9);
-  addComponent("mass"); componentIsNotPeriodic("mass"); getPntrToComponent("mass")->isConstant();
-  addComponent("charge"); componentIsNotPeriodic("charge"); getPntrToComponent("charge")->isConstant();
+  for(unsigned i=0; i<3; ++i) {
+    getPntrToComponent(i)->resizeDerivatives(9);
+  }
+  addComponent("mass");
+  componentIsNotPeriodic("mass");
+  getPntrToComponent("mass")->isConstant();
+  addComponent("charge");
+  componentIsNotPeriodic("charge");
+  getPntrToComponent("charge")->isConstant();
 }
 
 void ActionWithVirtualAtom::requestAtoms(const std::vector<AtomNumber> & a) {
-  ActionAtomistic::requestAtoms(a); for(unsigned i=0; i<3; ++i) getPntrToComponent(i)->resizeDerivatives(3*a.size()+9);
+  ActionAtomistic::requestAtoms(a);
+  for(unsigned i=0; i<3; ++i) {
+    getPntrToComponent(i)->resizeDerivatives(3*a.size()+9);
+  }
 }
 
 void ActionWithVirtualAtom::apply() {
-  if( !checkForForces() ) return ;
+  if( !checkForForces() ) {
+    return ;
+  }
 
   Value* xval=getPntrToComponent(0);
   Value* yval=getPntrToComponent(1);
   Value* zval=getPntrToComponent(2);
-  if( !xval->forcesWereAdded() && !yval->forcesWereAdded() && !zval->forcesWereAdded() ) return ;
-  if( xval->isConstant() && yval->isConstant() && zval->isConstant() ) return;
+  if( !xval->forcesWereAdded() && !yval->forcesWereAdded() && !zval->forcesWereAdded() ) {
+    return ;
+  }
+  if( xval->isConstant() && yval->isConstant() && zval->isConstant() ) {
+    return;
+  }
 
   for(unsigned i=0; i<value_depends.size(); ++i) {
     xpos[value_depends[i]]->hasForce = true;
@@ -84,15 +101,22 @@ void ActionWithVirtualAtom::apply() {
     auto & yp=ypos[nn]->inputForce;
     auto & zp=zpos[nn]->inputForce;
     for(const auto & kk : a.second) {
-      xp[kk] += xf*xval->data[1+k] + yf*yval->data[1+k] + zf*zval->data[1+k]; k++;
-      yp[kk] += xf*xval->data[1+k] + yf*yval->data[1+k] + zf*zval->data[1+k]; k++;
-      zp[kk] += xf*xval->data[1+k] + yf*yval->data[1+k] + zf*zval->data[1+k]; k++;
+      xp[kk] += xf*xval->data[1+k] + yf*yval->data[1+k] + zf*zval->data[1+k];
+      k++;
+      yp[kk] += xf*xval->data[1+k] + yf*yval->data[1+k] + zf*zval->data[1+k];
+      k++;
+      zp[kk] += xf*xval->data[1+k] + yf*yval->data[1+k] + zf*zval->data[1+k];
+      k++;
     }
   }
 
   std::array<double,9> virial;
-  for(unsigned i=0; i<9; ++i) { virial[i] = xf*xval->data[1+k] + yf*yval->data[1+k] + zf*zval->data[1+k]; k++; }
-  unsigned ind = 0; setForcesOnCell( virial.data(), virial.size(), ind );
+  for(unsigned i=0; i<9; ++i) {
+    virial[i] = xf*xval->data[1+k] + yf*yval->data[1+k] + zf*zval->data[1+k];
+    k++;
+  }
+  unsigned ind = 0;
+  setForcesOnCell( virial.data(), virial.size(), ind );
   // The above can be achieved using the two functions below.  The code above that is specialised for the ActionWithVirtualAtom
   // class runs faster than the general code below.
   // if( !checkForForces() ) return ;
@@ -100,23 +124,34 @@ void ActionWithVirtualAtom::apply() {
 }
 
 void ActionWithVirtualAtom::setBoxDerivatives(const std::vector<Tensor> &d) {
-  plumed_assert(d.size()==3); unsigned nbase = 3*getNumberOfAtoms();
+  plumed_assert(d.size()==3);
+  unsigned nbase = 3*getNumberOfAtoms();
   for(unsigned i=0; i<3; ++i) {
     Value* myval = getPntrToComponent(i);
     for(unsigned j=0; j<3; ++j) {
-      for(unsigned k=0; k<3; ++k) myval->setDerivative( nbase + 3*j + k, d[i][j][k] );
+      for(unsigned k=0; k<3; ++k) {
+        myval->setDerivative( nbase + 3*j + k, d[i][j][k] );
+      }
     }
   }
 // Subtract the trivial part coming from a distorsion applied to the ghost atom first.
 // Notice that this part alone should exactly cancel the already accumulated virial
 // due to forces on this atom.
-  Vector pos; for(unsigned i=0; i<3; ++i) pos[i] = getPntrToComponent(i)->get();
-  for(unsigned i=0; i<3; i++) for(unsigned j=0; j<3; j++) getPntrToComponent(j)->addDerivative( nbase + 3*i + j, pos[i] );
+  Vector pos;
+  for(unsigned i=0; i<3; ++i) {
+    pos[i] = getPntrToComponent(i)->get();
+  }
+  for(unsigned i=0; i<3; i++)
+    for(unsigned j=0; j<3; j++) {
+      getPntrToComponent(j)->addDerivative( nbase + 3*i + j, pos[i] );
+    }
 }
 
 void ActionWithVirtualAtom::setBoxDerivativesNoPbc() {
   std::vector<Tensor> bd(3);
-  for(unsigned i=0; i<3; i++) for(unsigned j=0; j<3; j++) for(unsigned k=0; k<3; k++) {
+  for(unsigned i=0; i<3; i++)
+    for(unsigned j=0; j<3; j++)
+      for(unsigned k=0; k<3; k++) {
 // Notice that this expression is very similar to the one used in Colvar::setBoxDerivativesNoPbc().
 // Indeed, we have the negative of a sum over dependent atoms (l) of the external product between positions
 // and derivatives. Notice that this only works only when Pbc have not been used to compute
diff --git a/src/core/ActionWithVirtualAtom.h b/src/core/ActionWithVirtualAtom.h
index 4075a24bc8..9ea8027116 100644
--- a/src/core/ActionWithVirtualAtom.h
+++ b/src/core/ActionWithVirtualAtom.h
@@ -39,8 +39,7 @@ Inherit from here if you are calculating the position of a virtual atom (eg a ce
 /// (it might be extended to add multiple virtual atoms).
 class ActionWithVirtualAtom:
   public ActionAtomistic,
-  public ActionWithValue
-{
+  public ActionWithValue {
 protected:
 /// Set position of the virtual atom
   void setPosition(const Vector &);
@@ -76,7 +75,9 @@ class ActionWithVirtualAtom:
   static void registerKeywords(Keywords& keys);
   virtual unsigned getNumberOfDerivatives();
   virtual void apply();
-  ActionWithVirtualAtom* castToActionWithVirtualAtom() noexcept final { return this; }
+  ActionWithVirtualAtom* castToActionWithVirtualAtom() noexcept final {
+    return this;
+  }
 };
 
 inline
@@ -86,7 +87,9 @@ unsigned ActionWithVirtualAtom::getNumberOfDerivatives() {
 
 inline
 void ActionWithVirtualAtom::setPosition(const Vector & pos) {
-  for(unsigned i=0; i<3; ++i) getPntrToComponent(i)->set(pos[i]);
+  for(unsigned i=0; i<3; ++i) {
+    getPntrToComponent(i)->set(pos[i]);
+  }
 }
 
 inline
diff --git a/src/core/CLTool.cpp b/src/core/CLTool.cpp
index 1527cac7f4..b2ab576ffd 100644
--- a/src/core/CLTool.cpp
+++ b/src/core/CLTool.cpp
@@ -27,14 +27,12 @@ Keywords CLToolOptions::emptyKeys;
 
 CLToolOptions::CLToolOptions(const std::string &name):
   line(1,name),
-  keys(emptyKeys)
-{
+  keys(emptyKeys) {
 }
 
 CLToolOptions::CLToolOptions(const CLToolOptions& co, const Keywords& k):
   line(co.line),
-  keys(k)
-{
+  keys(k) {
 }
 
 void CLTool::registerKeywords( Keywords& keys ) {
@@ -44,17 +42,20 @@ void CLTool::registerKeywords( Keywords& keys ) {
 CLTool::CLTool(const CLToolOptions& co ):
   name(co.line[0]),
   keywords(co.keys),
-  inputdata(unset)
-{
+  inputdata(unset) {
 }
 
 void CLTool::parseFlag( const std::string&key, bool&t ) {
   plumed_massert(keywords.exists(key),"keyword " + key + " has not been registered");
   plumed_massert(keywords.style(key,"flag"),"keyword " + key + " has not been registered as a flag");
   plumed_assert(inputData.count(key)>0);
-  if( inputData[key]=="true") t=true;
-  else if( inputData[key]=="false") t=false;
-  else plumed_error();
+  if( inputData[key]=="true") {
+    t=true;
+  } else if( inputData[key]=="false") {
+    t=false;
+  } else {
+    plumed_error();
+  }
 }
 
 bool CLTool::readInput( int argc, char**argv, FILE* in, FILE*out ) {
@@ -62,8 +63,12 @@ bool CLTool::readInput( int argc, char**argv, FILE* in, FILE*out ) {
                   "If it is from the command line (like driver) add inputdata=commandline to the "
                   "tools constructor. If it reads everything from an input file (like simplemd) "
                   "add inputdata=ifile to the tools constructor");
-  if(inputdata==commandline) return readCommandLineArgs( argc, argv, out );
-  if(inputdata==ifile) return readInputFile( argc, argv, in, out );
+  if(inputdata==commandline) {
+    return readCommandLineArgs( argc, argv, out );
+  }
+  if(inputdata==ifile) {
+    return readInputFile( argc, argv, in, out );
+  }
   return true;
 }
 
@@ -74,14 +79,18 @@ bool CLTool::readCommandLineArgs( int argc, char**argv, FILE*out ) {
   // Set all flags to default false
   for(unsigned k=0; k<keywords.size(); ++k) {
     thiskey=keywords.get(k);
-    if( keywords.style(thiskey,"flag") ) inputData.insert(std::pair<std::string,std::string>(thiskey,"false"));
+    if( keywords.style(thiskey,"flag") ) {
+      inputData.insert(std::pair<std::string,std::string>(thiskey,"false"));
+    }
   }
 
   // Read command line arguments
   bool printhelp=false;
   for(int i=1; i<argc; i++) {
     a=prefix+argv[i];
-    if(a.length()==0) continue;
+    if(a.length()==0) {
+      continue;
+    }
     if(a=="-h" || a=="--help") {
       printhelp=true;
     } else {
@@ -89,13 +98,19 @@ bool CLTool::readCommandLineArgs( int argc, char**argv, FILE*out ) {
       for(unsigned k=0; k<keywords.size(); ++k) {
         thiskey=keywords.get(k);
         if( keywords.style(thiskey,"flag") ) {
-          if( a==thiskey ) { found=true; inputData[thiskey]="true"; }
+          if( a==thiskey ) {
+            found=true;
+            inputData[thiskey]="true";
+          }
         } else {
           if( a==thiskey ) {
-            prefix=thiskey+"="; found=true;
+            prefix=thiskey+"=";
+            found=true;
             inputData.insert(std::pair<std::string,std::string>(thiskey,""));
           } else if(Tools::startWith(a,thiskey+"=")) {
-            a.erase(0,a.find("=")+1); prefix=""; found=true;
+            a.erase(0,a.find("=")+1);
+            prefix="";
+            found=true;
             if(inputData.count(thiskey)==0) {
               inputData.insert(std::pair<std::string,std::string>(thiskey,a));
             } else {
@@ -112,10 +127,14 @@ bool CLTool::readCommandLineArgs( int argc, char**argv, FILE*out ) {
         printhelp=true;
       }
     }
-    if(printhelp) break;
+    if(printhelp) {
+      break;
+    }
   }
 
-  if(!printhelp) setRemainingToDefault(out);
+  if(!printhelp) {
+    setRemainingToDefault(out);
+  }
 
   if(printhelp) {
     std::fprintf(out,"Usage: %s [options] \n\n", name.c_str() );
@@ -150,7 +169,9 @@ bool CLTool::readInputFile( int argc, char**argv, FILE* in, FILE*out ) {
   std::string a;
   for(int i=1; i<argc; i++) {
     a=argv[i];
-    if(a.length()==0) continue;
+    if(a.length()==0) {
+      continue;
+    }
     if(a=="-h" || a=="--help") {
       std::fprintf(out,"Usage: %s < inputFile \n", name.c_str() );
       std::fprintf(out,"inputFile should contain one directive per line.  The directives should come from amongst the following\n\n");
@@ -161,7 +182,9 @@ bool CLTool::readInputFile( int argc, char**argv, FILE* in, FILE*out ) {
 
   FILE* mystdin=in;
 // call fclose when fp_deleter goes out of scope
-  auto deleter=[](auto f) { std::fclose(f); };
+  auto deleter=[](auto f) {
+    std::fclose(f);
+  };
   std::unique_ptr<FILE,decltype(deleter)> fp_deleter(nullptr,deleter);
 
   if(argc==2) {
@@ -178,14 +201,22 @@ bool CLTool::readInputFile( int argc, char**argv, FILE* in, FILE*out ) {
 
   plumed_assert(mystdin);
 
-  char buffer[256]; std::string line; line.resize(256);
+  char buffer[256];
+  std::string line;
+  line.resize(256);
   while(fgets(buffer,256,mystdin)) {
     line=buffer;
-    for(unsigned i=0; i<line.length(); ++i) if(line[i]=='#' || line[i]=='\n') line.erase(i);
+    for(unsigned i=0; i<line.length(); ++i)
+      if(line[i]=='#' || line[i]=='\n') {
+        line.erase(i);
+      }
     Tools::stripLeadingAndTrailingBlanks( line );
-    if(line.length()==0) continue;
+    if(line.length()==0) {
+      continue;
+    }
     std::sscanf(line.c_str(),"%255s",buffer);
-    std::string keyword=buffer; bool found=false;
+    std::string keyword=buffer;
+    bool found=false;
     for(unsigned i=0; i<keywords.size(); ++i) {
       std::string thiskey=keywords.get(i);
       if(thiskey==keyword) {
diff --git a/src/core/CLTool.h b/src/core/CLTool.h
index 0b3e99c93b..b66759157b 100644
--- a/src/core/CLTool.h
+++ b/src/core/CLTool.h
@@ -94,7 +94,9 @@ class CLTool {
 /// virtual function mapping to the specific main for each tool
   virtual int main( FILE* in, FILE*out, Communicator&pc )=0;
 /// virtual function returning a one-line descriptor for the tool
-  virtual std::string description()const {return "(no description available)";}
+  virtual std::string description()const {
+    return "(no description available)";
+  }
 /// virtual destructor to allow inheritance
   virtual ~CLTool() {}
 };
@@ -103,12 +105,18 @@ template<class T>
 bool CLTool::parse(const std::string&key,T&t) {
   plumed_massert(keywords.exists(key),"keyword " + key + " has not been registered");
   if(keywords.style(key,"compulsory") ) {
-    if(inputData.count(key)==0) error("missing data for keyword " + key);
+    if(inputData.count(key)==0) {
+      error("missing data for keyword " + key);
+    }
     bool check=Tools::convertNoexcept(inputData[key],t);
-    if(!check) error("data input for keyword " + key + " has wrong type");
+    if(!check) {
+      error("data input for keyword " + key + " has wrong type");
+    }
     return true;
   }
-  if( inputData.count(key)==0 ) return false;
+  if( inputData.count(key)==0 ) {
+    return false;
+  }
   Tools::convert(inputData[key],t);
   return true;
 }
@@ -121,14 +129,18 @@ bool CLTool::parseVector(const std::string&key,std::vector<T>&t) {
   // initial size
   unsigned size=t.size();
   bool skipcheck=false;
-  if(size==0) skipcheck=true; // if the vector in input has size zero, skip the check if size of input vector is the same of argument read
+  if(size==0) {
+    skipcheck=true;  // if the vector in input has size zero, skip the check if size of input vector is the same of argument read
+  }
 
   // check if there is some value
 
   plumed_massert(inputData[key]!="false","compulsory keyword "+std::string(key)+"has no data");
   std::vector<std::string> words=Tools::getWords(inputData[key],"\t\n ,");
   t.resize(0);
-  if(words.size()==0)return false;
+  if(words.size()==0) {
+    return false;
+  }
 
   for(unsigned i=0; i<words.size(); ++i) {
     T v;
diff --git a/src/core/CLToolMain.cpp b/src/core/CLToolMain.cpp
index 885160e018..edf2687dd2 100644
--- a/src/core/CLToolMain.cpp
+++ b/src/core/CLToolMain.cpp
@@ -40,8 +40,7 @@ namespace PLMD {
 CLToolMain::CLToolMain():
   argc(0),
   in(stdin),
-  out(stdout)
-{
+  out(stdout) {
 }
 
 CLToolMain::~CLToolMain() {
@@ -72,7 +71,9 @@ void CLToolMain::cmd(std::string_view word,const TypesafePtr & val) {
     const char*const*v;
     const char*vv;
     const auto it=word_map.find(words[0]);
-    if(it!=word_map.end()) iword=it->second;
+    if(it!=word_map.end()) {
+      iword=it->second;
+    }
     switch(iword) {
     case cmd_setArgc:
       CHECK_NULL(val,word);
@@ -81,7 +82,9 @@ void CLToolMain::cmd(std::string_view word,const TypesafePtr & val) {
     case cmd_setArgv:
       CHECK_NULL(val,word);
       v=val.get<const char*const*>({argc});
-      for(int i=0; i<argc; ++i) argv.push_back(std::string(v[i]));
+      for(int i=0; i<argc; ++i) {
+        argv.push_back(std::string(v[i]));
+      }
       break;
     case cmd_setArgvLine:
       CHECK_NULL(val,word);
@@ -106,16 +109,21 @@ void CLToolMain::cmd(std::string_view word,const TypesafePtr & val) {
       CHECK_NULL(val,word);
       argc=argv.size();
       {
-        int n=0; for(int i=0; i<argc; ++i) n+=argv[i].length()+1;
+        int n=0;
+        for(int i=0; i<argc; ++i) {
+          n+=argv[i].length()+1;
+        }
         std::vector<char> args(n);
         std::vector<char*> vvv(argc);
         char* ptr=&args[0];
         for(int i=0; i<argc; ++i) {
           vvv[i]=ptr;
           for(unsigned c=0; c<argv[i].length(); ++c) {
-            *ptr=argv[i][c]; ptr++;
+            *ptr=argv[i][c];
+            ptr++;
           }
-          *ptr=0; ptr++;
+          *ptr=0;
+          ptr++;
         }
         val.set(int(run(argc,&vvv[0],in,out,comm)));
       }
@@ -147,13 +155,18 @@ int CLToolMain::run(int argc, char **argv,FILE*in,FILE*out,Communicator& pc) {
   std::string a("");
   for(i=1; i<argc; i++) {
     a=prefix+argv[i];
-    if(a.length()==0) continue;
+    if(a.length()==0) {
+      continue;
+    }
     if(a=="help" || a=="-h" || a=="--help") {
       printhelp=true;
       break;
     } else if(a=="--has-mpi") {
-      if(Communicator::initialized()) return 0;
-      else return 1;
+      if(Communicator::initialized()) {
+        return 0;
+      } else {
+        return 1;
+      }
     } else if(a=="--has-cregex") {
       return (config::hasCregex()?0:1);
     } else if(a=="--has-dlopen") {
@@ -186,7 +199,9 @@ int CLToolMain::run(int argc, char **argv,FILE*in,FILE*out,Communicator& pc) {
       std::string msg="ERROR: Unknown option " +a;
       std::fprintf(stderr,"%s\n",msg.c_str());
       return 1;
-    } else break;
+    } else {
+      break;
+    }
   }
 
 // Check if plumedRoot/patches/ directory exists (as a further check)
@@ -208,10 +223,16 @@ int CLToolMain::run(int argc, char **argv,FILE*in,FILE*out,Communicator& pc) {
     tmp=Tools::ls(std::string(root+"/scripts"));
     for(unsigned j=0; j<tmp.size(); ++j) {
       size_t ff=tmp[j].find(".sh");
-      if(ff==std::string::npos) tmp[j].erase();
-      else                 tmp[j].erase(ff);
+      if(ff==std::string::npos) {
+        tmp[j].erase();
+      } else {
+        tmp[j].erase(ff);
+      }
     }
-    for(unsigned j=0; j<tmp.size(); ++j) if(tmp[j].length()>0) availableShell.push_back(tmp[j]);
+    for(unsigned j=0; j<tmp.size(); ++j)
+      if(tmp[j].length()>0) {
+        availableShell.push_back(tmp[j]);
+      }
   }
 
   if(printhelp) {
@@ -261,7 +282,9 @@ int CLToolMain::run(int argc, char **argv,FILE*in,FILE*out,Communicator& pc) {
     auto cl=cltoolRegister().create(dlloader.getHandles(),CLToolOptions(command));
     plumed_assert(cl);
     // Read the command line options (returns false if we are just printing help)
-    if( !cl->readInput( argc-i,&argv[i],in,out ) ) { return 0; }
+    if( !cl->readInput( argc-i,&argv[i],in,out ) ) {
+      return 0;
+    }
     int ret=cl->main(in,out,pc);
     return ret;
   }
@@ -270,13 +293,18 @@ int CLToolMain::run(int argc, char **argv,FILE*in,FILE*out,Communicator& pc) {
     plumed_massert(in==stdin,"shell tools can only work on stdin");
     plumed_massert(out==stdout,"shell tools can only work on stdin");
     std::string cmd=config::getEnvCommand()+" \""+root+"/scripts/"+command+".sh\"";
-    for(int j=i+1; j<argc; j++) cmd+=std::string(" ")+argv[j];
+    for(int j=i+1; j<argc; j++) {
+      cmd+=std::string(" ")+argv[j];
+    }
     int r=std::system(cmd.c_str());
 // this is necessary since system seems to return numbers which are multiple
 // of 256. this would make the interpretation by the shell wrong
 // I just return 1 in case of failure and 0 in case of success
-    if(r!=0) return 1;
-    else return 0;
+    if(r!=0) {
+      return 1;
+    } else {
+      return 0;
+    }
   }
 
   std::string msg="ERROR: unknown command " + command + ". Use 'plumed help' for help";
diff --git a/src/core/CLToolMain.h b/src/core/CLToolMain.h
index 962e5358d7..849a12bae3 100644
--- a/src/core/CLToolMain.h
+++ b/src/core/CLToolMain.h
@@ -77,8 +77,7 @@ See the file \ref main.cpp for a similar example.
 
 */
 class CLToolMain:
-  public WithCmd
-{
+  public WithCmd {
 /// arguments for command-line mode:
   int argc;
 /// arguments for command-line mode:
diff --git a/src/core/CLToolRegister.cpp b/src/core/CLToolRegister.cpp
index 3361149776..5c515dcf67 100644
--- a/src/core/CLToolRegister.cpp
+++ b/src/core/CLToolRegister.cpp
@@ -39,7 +39,9 @@ std::unique_ptr<CLTool> CLToolRegister::create(const CLToolOptions&ao) {
 }
 
 std::unique_ptr<CLTool> CLToolRegister::create(const std::vector<void*> & images,const CLToolOptions&ao) {
-  if(ao.line.size()<1)return nullptr;
+  if(ao.line.size()<1) {
+    return nullptr;
+  }
   auto & content=get(images,ao.line[0]);
   CLToolOptions nao( ao,content.keys );
   return content.create(nao);
@@ -47,9 +49,13 @@ std::unique_ptr<CLTool> CLToolRegister::create(const std::vector<void*> & images
 
 CLToolRegister::ID CLToolRegister::add(std::string key,creator_pointer cp,keywords_pointer kp) {
   // this force each action to be registered as an uppercase string
-  if ( std::any_of( std::begin( key ), std::end( key ), []( char c ) { return ( std::isupper( c ) ); } ) ) plumed_error() << "CLTool: " + key + " cannot be registered, use only LOWERCASE characters";
+  if ( std::any_of( std::begin( key ), std::end( key ), []( char c ) {
+  return ( std::isupper( c ) )
+           ;
+  } ) ) plumed_error() << "CLTool: " + key + " cannot be registered, use only LOWERCASE characters";
 
-  Keywords keys; kp(keys);
+  Keywords keys;
+  kp(keys);
   return RegisterBase::add(key,Pointers{cp,keys});
 }
 
@@ -72,7 +78,9 @@ std::vector<std::string> CLToolRegister::getKeys(const std::string& cltool)const
     auto cl=get(cltool);
     auto k=cl.keys.getKeys();
     std::cerr<<k.size()<<"\n";
-    for(unsigned i=0; i<k.size(); i++) std::cerr<<k[i]<<"\n";
+    for(unsigned i=0; i<k.size(); i++) {
+      std::cerr<<k[i]<<"\n";
+    }
     return k;
   } else {
     std::vector<std::string> empty;
diff --git a/src/core/Colvar.cpp b/src/core/Colvar.cpp
index da28e9d4bb..f90ac70511 100644
--- a/src/core/Colvar.cpp
+++ b/src/core/Colvar.cpp
@@ -29,8 +29,7 @@ namespace PLMD {
 Colvar::Colvar(const ActionOptions&ao):
   Action(ao),
   ActionAtomistic(ao),
-  ActionWithValue(ao)
-{
+  ActionWithValue(ao) {
 }
 
 void Colvar::registerKeywords( Keywords& keys ) {
@@ -44,30 +43,41 @@ void Colvar::requestAtoms(const std::vector<AtomNumber> & a) {
 // Tell actionAtomistic what atoms we are getting
   ActionAtomistic::requestAtoms(a);
 // Resize the derivatives of all atoms
-  for(int i=0; i<getNumberOfComponents(); ++i) getPntrToComponent(i)->resizeDerivatives(3*a.size()+9);
+  for(int i=0; i<getNumberOfComponents(); ++i) {
+    getPntrToComponent(i)->resizeDerivatives(3*a.size()+9);
+  }
 }
 
 void Colvar::apply() {
-  if( !checkForForces() ) return ;
+  if( !checkForForces() ) {
+    return ;
+  }
   unsigned ind=0;
-  if( getNumberOfAtoms()>0 ) setForcesOnAtoms( getForcesToApply(), ind );
-  else setForcesOnCell( getForcesToApply(), ind );
+  if( getNumberOfAtoms()>0 ) {
+    setForcesOnAtoms( getForcesToApply(), ind );
+  } else {
+    setForcesOnCell( getForcesToApply(), ind );
+  }
 }
 
 void Colvar::setBoxDerivativesNoPbc( const std::vector<Vector>& pos, std::vector<std::vector<Vector> >& derivs, std::vector<Tensor>& virial ) {
   unsigned nat=pos.size();
   for(unsigned i=0; i<virial.size(); ++i) {
-    virial[i].zero(); for(unsigned j=0; j<nat; j++) virial[i]-=Tensor(pos[j],derivs[i][j]);
+    virial[i].zero();
+    for(unsigned j=0; j<nat; j++) {
+      virial[i]-=Tensor(pos[j],derivs[i][j]);
+    }
   }
 }
 
 void Colvar::setBoxDerivativesNoPbc(Value* v) {
   Tensor virial;
   unsigned nat=getNumberOfAtoms();
-  for(unsigned i=0; i<nat; i++) virial-=Tensor(getPosition(i),
-                                          Vector(v->getDerivative(3*i+0),
-                                              v->getDerivative(3*i+1),
-                                              v->getDerivative(3*i+2)));
+  for(unsigned i=0; i<nat; i++)
+    virial-=Tensor(getPosition(i),
+                   Vector(v->getDerivative(3*i+0),
+                          v->getDerivative(3*i+1),
+                          v->getDerivative(3*i+2)));
   setBoxDerivatives(v,virial);
 }
 }
diff --git a/src/core/Colvar.h b/src/core/Colvar.h
index ddf048b953..1d0533e34f 100644
--- a/src/core/Colvar.h
+++ b/src/core/Colvar.h
@@ -38,8 +38,7 @@ This is the abstract base class to use for implementing new collective variables
 
 class Colvar :
   public ActionAtomistic,
-  public ActionWithValue
-{
+  public ActionWithValue {
 private:
 protected:
   void requestAtoms(const std::vector<AtomNumber> & a);
diff --git a/src/core/DataPassingObject.cpp b/src/core/DataPassingObject.cpp
index d682d974b0..a92202004b 100644
--- a/src/core/DataPassingObject.cpp
+++ b/src/core/DataPassingObject.cpp
@@ -27,9 +27,14 @@ namespace PLMD {
 
 template<typename T>
 static void getPointer(const TypesafePtr & p, const std::vector<unsigned>& shape, const unsigned& start, const unsigned& stride, T*&pp ) {
-  if( shape.size()==1 && stride==1 ) { pp=p.get<T*>( {shape[0]} );  }
-  else if( shape.size()==1 ) { auto p_=p.get<T*>( {shape[0],stride} ); pp = p_+start; }
-  else if( shape.size()==2 ) { pp=p.get<T*>( {shape[0],shape[1]} ); }
+  if( shape.size()==1 && stride==1 ) {
+    pp=p.get<T*>( {shape[0]} );
+  } else if( shape.size()==1 ) {
+    auto p_=p.get<T*>( {shape[0],stride} );
+    pp = p_+start;
+  } else if( shape.size()==2 ) {
+    pp=p.get<T*>( {shape[0],shape[1]} );
+  }
 }
 
 template <class T>
@@ -71,117 +76,184 @@ std::unique_ptr<DataPassingObject> DataPassingObject::create(unsigned n) {
   } else  if(n==sizeof(float)) {
     return std::make_unique<DataPassingObjectTyped<float>>();
   }
-  std::string pp; Tools::convert(n,pp);
+  std::string pp;
+  Tools::convert(n,pp);
   plumed_merror("cannot create an MD interface with sizeof(real)=="+ pp);
   return NULL;
 }
 
 template <class T>
 double DataPassingObjectTyped<T>::MD2double(const TypesafePtr & m) const {
-  double d=double(m.template get<T>()); return d;
+  double d=double(m.template get<T>());
+  return d;
 }
 
 template <class T>
 void DataPassingObjectTyped<T>::saveValueAsDouble( const TypesafePtr & val ) {
-  hasbackup=true; bvalue=double(val.template get<T>());
+  hasbackup=true;
+  bvalue=double(val.template get<T>());
 }
 
 template <class T>
 void DataPassingObjectTyped<T>::setValuePointer( const TypesafePtr & val, const std::vector<unsigned>& shape, const bool& isconst ) {
   if( shape.size()==0 ) {
-    if( isconst ) val.get<const T*>(); else val.get<T*>();  // just check type and discard pointer
+    if( isconst ) {
+      val.get<const T*>();
+    } else {
+      val.get<T*>();  // just check type and discard pointer
+    }
   } else if( shape.size()==1 ) {
-    if( isconst ) val.get<const T*>({shape[0]}); else val.get<T*>({shape[0]});  // just check type and discard pointer
+    if( isconst )
+      val.get<const T*>({shape[0]});
+    else
+      val.get<T*>({shape[0]});  // just check type and discard pointer
   } else if( shape.size()==2 ) {
-    if( isconst ) val.get<const T*>({shape[0],shape[1]}); else val.get<T*>({shape[0],shape[1]});  // just check type and discard pointer
+    if( isconst )
+      val.get<const T*>({shape[0],shape[1]});
+    else
+      val.get<T*>({shape[0],shape[1]});  // just check type and discard pointer
   }
   v=val.copy();
 }
 
 template <class T>
 void DataPassingObjectTyped<T>::setForcePointer( const TypesafePtr & val, const std::vector<unsigned>& shape ) {
-  if( shape.size()==0 ) val.get<T*>();  // just check type and discard pointer
-  else if( shape.size()==1 ) val.get<T*>({shape[0]});   // just check type and discard pointer
-  else if( shape.size()==2 ) val.get<T*>({shape[0],shape[1]});   // just check type and discard pointer
+  if( shape.size()==0 ) {
+    val.get<T*>();  // just check type and discard pointer
+  } else if( shape.size()==1 )
+    val.get<T*>({shape[0]});   // just check type and discard pointer
+  else if( shape.size()==2 )
+    val.get<T*>({shape[0],shape[1]});   // just check type and discard pointer
   f=val.copy();
 }
 
 template <class T>
 void DataPassingObjectTyped<T>::setData( Value* value ) {
-  if( value->getRank()==0 ) { *v.template get<T*>() = static_cast<T>(value->get()) / unit; return; }
-  T* pp; getPointer( v, value->getShape(), start, stride, pp ); unsigned nvals=value->getNumberOfValues();
-  for(unsigned i=0; i<nvals; ++i) pp[i] = T( value->get(i) );
+  if( value->getRank()==0 ) {
+    *v.template get<T*>() = static_cast<T>(value->get()) / unit;
+    return;
+  }
+  T* pp;
+  getPointer( v, value->getShape(), start, stride, pp );
+  unsigned nvals=value->getNumberOfValues();
+  for(unsigned i=0; i<nvals; ++i) {
+    pp[i] = T( value->get(i) );
+  }
 }
 
 template <class T>
 void DataPassingObjectTyped<T>::share_data( const unsigned& j, const unsigned& k, Value* value ) {
   if( value->getRank()==0 ) {
-    if( hasbackup ) value->set( unit*bvalue );
-    else value->set( unit*double(v.template get<T>()) );
+    if( hasbackup ) {
+      value->set( unit*bvalue );
+    } else {
+      value->set( unit*double(v.template get<T>()) );
+    }
     return;
   }
-  std::vector<unsigned> s(value->getShape()); if( s.size()==1 ) s[0]=k-j;
-  const T* pp; getPointer( v, s, start, stride, pp );
+  std::vector<unsigned> s(value->getShape());
+  if( s.size()==1 ) {
+    s[0]=k-j;
+  }
+  const T* pp;
+  getPointer( v, s, start, stride, pp );
   std::vector<double> & d=value->data;
   #pragma omp parallel for num_threads(value->getGoodNumThreads(j,k))
-  for(unsigned i=j; i<k; ++i) d[i]=unit*pp[i*stride];
+  for(unsigned i=j; i<k; ++i) {
+    d[i]=unit*pp[i*stride];
+  }
 }
 
 template <class T>
 void DataPassingObjectTyped<T>::share_data( std::vector<double>& values ) const {
-  std::vector<unsigned> maxel(1,values.size()); const T* pp; getPointer( v, maxel, start, stride, pp );
+  std::vector<unsigned> maxel(1,values.size());
+  const T* pp;
+  getPointer( v, maxel, start, stride, pp );
   #pragma omp parallel for num_threads(OpenMP::getGoodNumThreads(values))
-  for(unsigned i=0; i<values.size(); ++i) values[i]=unit*pp[i*stride];
+  for(unsigned i=0; i<values.size(); ++i) {
+    values[i]=unit*pp[i*stride];
+  }
 }
 
 template <class T>
 void DataPassingObjectTyped<T>::share_data( const std::vector<AtomNumber>&index, const std::vector<unsigned>& i, Value* value ) {
-  plumed_dbg_assert( value->getRank()==1 ); std::vector<unsigned> maxel(1,index.size());
+  plumed_dbg_assert( value->getRank()==1 );
+  std::vector<unsigned> maxel(1,index.size());
 #ifndef NDEBUG
 // bounds are only checked in debug mode since they require this extra step that is potentially expensive
   maxel[0]=(i.size()>0?*std::max_element(i.begin(),i.end())+1:0);
 #else
   maxel[0]=0;
 #endif
-  const T* pp; getPointer( v, maxel, start, stride, pp );
+  const T* pp;
+  getPointer( v, maxel, start, stride, pp );
   // cannot be parallelized with omp because access to data is not ordered
-  unsigned k=0; for(const auto & p : index) { value->data[p.index()]=unit*pp[i[k]*stride]; k++; }
+  unsigned k=0;
+  for(const auto & p : index) {
+    value->data[p.index()]=unit*pp[i[k]*stride];
+    k++;
+  }
 }
 
 template <class T>
 void DataPassingObjectTyped<T>::add_force( Value* value ) {
-  if( value->getRank()==0 ) { *f.template get<T*>() += funit*static_cast<T>(value->getForce(0)); return; }
-  T* pp; getPointer( f, value->getShape(), start, stride, pp ); unsigned nvals=value->getNumberOfValues();
+  if( value->getRank()==0 ) {
+    *f.template get<T*>() += funit*static_cast<T>(value->getForce(0));
+    return;
+  }
+  T* pp;
+  getPointer( f, value->getShape(), start, stride, pp );
+  unsigned nvals=value->getNumberOfValues();
   #pragma omp parallel for num_threads(OpenMP::getGoodNumThreads(pp,nvals))
-  for(unsigned i=0; i<nvals; ++i) pp[i*stride] += funit*T(value->getForce(i));
+  for(unsigned i=0; i<nvals; ++i) {
+    pp[i*stride] += funit*T(value->getForce(i));
+  }
 }
 
 template <class T>
 void DataPassingObjectTyped<T>::add_force( const std::vector<int>& index, Value* value ) {
-  plumed_assert( value->getRank()==1 ); std::vector<unsigned> s(1,index.size()); T* pp; getPointer( f, s, start, stride, pp );
+  plumed_assert( value->getRank()==1 );
+  std::vector<unsigned> s(1,index.size());
+  T* pp;
+  getPointer( f, s, start, stride, pp );
   #pragma omp parallel for num_threads(OpenMP::getGoodNumThreads(pp,index.size()))
-  for(unsigned i=0; i<index.size(); ++i) pp[i*stride] += funit*T(value->getForce(index[i]));
+  for(unsigned i=0; i<index.size(); ++i) {
+    pp[i*stride] += funit*T(value->getForce(index[i]));
+  }
 }
 
 template <class T>
 void DataPassingObjectTyped<T>::add_force( const std::vector<AtomNumber>& index, const std::vector<unsigned>& i, Value* value ) {
-  plumed_dbg_assert( value->getRank()==1 ); std::vector<unsigned> maxel(1,index.size());
+  plumed_dbg_assert( value->getRank()==1 );
+  std::vector<unsigned> maxel(1,index.size());
 #ifndef NDEBUG
 // bounds are only checked in debug mode since they require this extra step that is potentially expensive
   maxel[0]=(i.size()>0?*std::max_element(i.begin(),i.end())+1:0);
 #else
   maxel[0]=0;
 #endif
-  T* pp; getPointer( f, maxel, start, stride, pp );
-  unsigned k=0; for(const auto & p : index) { pp[stride*i[k]] += funit*T(value->getForce(p.index())); k++; }
+  T* pp;
+  getPointer( f, maxel, start, stride, pp );
+  unsigned k=0;
+  for(const auto & p : index) {
+    pp[stride*i[k]] += funit*T(value->getForce(p.index()));
+    k++;
+  }
 }
 
 template <class T>
 void DataPassingObjectTyped<T>::rescale_force( const unsigned& n, const double& factor, Value* value ) {
-  plumed_assert( value->getRank()>0 ); std::vector<unsigned> s( value->getShape() ); if( s.size()==1 ) s[0] = n;
-  T* pp; getPointer( f, s, start, stride, pp );
+  plumed_assert( value->getRank()>0 );
+  std::vector<unsigned> s( value->getShape() );
+  if( s.size()==1 ) {
+    s[0] = n;
+  }
+  T* pp;
+  getPointer( f, s, start, stride, pp );
   #pragma omp parallel for num_threads(OpenMP::getGoodNumThreads(pp,n))
-  for(unsigned i=0; i<n; ++i) pp[i*stride] *= T(factor);
+  for(unsigned i=0; i<n; ++i) {
+    pp[i*stride] *= T(factor);
+  }
 }
 
 }
diff --git a/src/core/DataPassingObject.h b/src/core/DataPassingObject.h
index eb0a83e5f2..248a253605 100644
--- a/src/core/DataPassingObject.h
+++ b/src/core/DataPassingObject.h
@@ -52,13 +52,21 @@ class DataPassingObject {
 /// Convert what comes from the MD code to a double
   virtual double MD2double(const TypesafePtr & m) const=0;
 ///
-  void setStart( const unsigned& s ) { start=s; }
+  void setStart( const unsigned& s ) {
+    start=s;
+  }
 /// Set the stride to use when getting data from the input array
-  void setStride( const unsigned& s ) { stride=s; }
+  void setStride( const unsigned& s ) {
+    stride=s;
+  }
 /// Set the unit for the value
-  void setUnit( const double& u ) { unit=u; }
+  void setUnit( const double& u ) {
+    unit=u;
+  }
 /// Set the unit for the force
-  void setForceUnit( const double& u ) { funit=u; }
+  void setForceUnit( const double& u ) {
+    funit=u;
+  }
 /// This is used when you want to save the passed object to a double variable in PLUMED rather than the pointer
 /// this can be used even when you don't pass a pointer from the MD code
   virtual void saveValueAsDouble( const TypesafePtr & val )=0;
diff --git a/src/core/DataPassingTools.cpp b/src/core/DataPassingTools.cpp
index 2a06631109..c51675326f 100644
--- a/src/core/DataPassingTools.cpp
+++ b/src/core/DataPassingTools.cpp
@@ -26,12 +26,24 @@
 namespace PLMD {
 
 double DataPassingTools::getUnitConversion( const std::string& unit ) const {
-  if( unit=="energy" ) return MDUnits.getEnergy()/units.getEnergy();
-  if( unit=="length" ) return MDUnits.getLength()/units.getLength();
-  if( unit=="mass" ) return  MDUnits.getMass()/units.getMass();
-  if( unit=="charge" ) return MDUnits.getCharge()/units.getCharge();
-  if( unit=="time" ) return MDUnits.getTime()/units.getTime();
-  if( unit=="number" ) return 1;
+  if( unit=="energy" ) {
+    return MDUnits.getEnergy()/units.getEnergy();
+  }
+  if( unit=="length" ) {
+    return MDUnits.getLength()/units.getLength();
+  }
+  if( unit=="mass" ) {
+    return  MDUnits.getMass()/units.getMass();
+  }
+  if( unit=="charge" ) {
+    return MDUnits.getCharge()/units.getCharge();
+  }
+  if( unit=="time" ) {
+    return MDUnits.getTime()/units.getTime();
+  }
+  if( unit=="number" ) {
+    return 1;
+  }
   plumed_error();
 }
 
@@ -49,7 +61,8 @@ std::unique_ptr<DataPassingTools> DataPassingTools::create(unsigned n) {
   } else  if(n==sizeof(float)) {
     return std::make_unique<DataPassingToolsTyped<float>>();
   }
-  std::string pp; Tools::convert(n,pp);
+  std::string pp;
+  Tools::convert(n,pp);
   plumed_merror("cannot create an MD interface with sizeof(real)=="+ pp);
   return NULL;
 }
diff --git a/src/core/DomainDecomposition.cpp b/src/core/DomainDecomposition.cpp
index f1916a68b2..a9a4de4e2f 100644
--- a/src/core/DomainDecomposition.cpp
+++ b/src/core/DomainDecomposition.cpp
@@ -45,10 +45,18 @@ namespace {
 enum class Option {automatic, no, yes };
 
 Option interpretEnvString(const char* env,const char* str) {
-  if(!str) return Option::automatic;
-  if(!std::strcmp(str,"yes"))return Option::yes;
-  if(!std::strcmp(str,"no"))return Option::no;
-  if(!std::strcmp(str,"auto"))return Option::automatic;
+  if(!str) {
+    return Option::automatic;
+  }
+  if(!std::strcmp(str,"yes")) {
+    return Option::yes;
+  }
+  if(!std::strcmp(str,"no")) {
+    return Option::no;
+  }
+  if(!std::strcmp(str,"auto")) {
+    return Option::automatic;
+  }
   plumed_error()<<"Cannot understand env var "<<env<<"\nPossible values: yes/no/auto\nActual value: "<<str;
 }
 
@@ -77,14 +85,19 @@ void DomainDecomposition::DomainComms::enable(Communicator& c) {
   async=Get_size()<10;
   if(std::getenv("PLUMED_ASYNC_SHARE")) {
     std::string s(std::getenv("PLUMED_ASYNC_SHARE"));
-    if(s=="yes") async=true;
-    else if(s=="no") async=false;
-    else plumed_merror("PLUMED_ASYNC_SHARE variable is set to " + s + "; should be yes or no");
+    if(s=="yes") {
+      async=true;
+    } else if(s=="no") {
+      async=false;
+    } else {
+      plumed_merror("PLUMED_ASYNC_SHARE variable is set to " + s + "; should be yes or no");
+    }
   }
 }
 
 void DomainDecomposition::registerKeywords(Keywords& keys) {
-  ActionForInterface::registerKeywords( keys ); keys.remove("ROLE");
+  ActionForInterface::registerKeywords( keys );
+  keys.remove("ROLE");
   keys.add("compulsory","NATOMS","the number of atoms across all the domains");
   keys.add("numbered","VALUE","value to create for the domain decomposition");
   keys.add("numbered","UNIT","unit of the ith value that is being passed through the domain decomposition");
@@ -103,58 +116,91 @@ DomainDecomposition::DomainDecomposition(const ActionOptions&ao):
   ddStep(0),
   shuffledAtoms(0),
   asyncSent(false),
-  unique_serial(false)
-{
+  unique_serial(false) {
   // Read in the number of atoms
-  int natoms; parse("NATOMS",natoms);
-  std::string str_natoms; Tools::convert( natoms, str_natoms );
+  int natoms;
+  parse("NATOMS",natoms);
+  std::string str_natoms;
+  Tools::convert( natoms, str_natoms );
   // Setup the gat index
-  gatindex.resize(natoms); for(unsigned i=0; i<gatindex.size(); i++) gatindex[i]=i;
+  gatindex.resize(natoms);
+  for(unsigned i=0; i<gatindex.size(); i++) {
+    gatindex[i]=i;
+  }
   // Now read in the values we are creating here
   for(unsigned i=1;; ++i) {
     std::string valname;
-    if( !parseNumbered("VALUE",i,valname) ) break;
-    std::string unit; parseNumbered("UNIT",i,unit);
-    std::string constant; parseNumbered("CONSTANT",i,constant);
-    std::string period; parseNumbered("PERIODIC",i,period);
-    std::string role; parseNumbered("ROLE",i,role);
-    if( constant=="True") plumed.readInputLine( valname + ": PUT FROM_DOMAINS CONSTANT SHAPE=" + str_natoms + " UNIT=" + unit + " PERIODIC=" + period + " ROLE=" + role, true );
-    else if( constant=="False") plumed.readInputLine( valname + ": PUT FROM_DOMAINS SHAPE=" + str_natoms + " UNIT=" + unit + " PERIODIC=" + period + " ROLE=" + role, true );
-    else plumed_merror("missing information on whether value is constant");
+    if( !parseNumbered("VALUE",i,valname) ) {
+      break;
+    }
+    std::string unit;
+    parseNumbered("UNIT",i,unit);
+    std::string constant;
+    parseNumbered("CONSTANT",i,constant);
+    std::string period;
+    parseNumbered("PERIODIC",i,period);
+    std::string role;
+    parseNumbered("ROLE",i,role);
+    if( constant=="True") {
+      plumed.readInputLine( valname + ": PUT FROM_DOMAINS CONSTANT SHAPE=" + str_natoms + " UNIT=" + unit + " PERIODIC=" + period + " ROLE=" + role, true );
+    } else if( constant=="False") {
+      plumed.readInputLine( valname + ": PUT FROM_DOMAINS SHAPE=" + str_natoms + " UNIT=" + unit + " PERIODIC=" + period + " ROLE=" + role, true );
+    } else {
+      plumed_merror("missing information on whether value is constant");
+    }
     // And save the list of values that are set from here
-    ActionToPutData* ap=plumed.getActionSet().selectWithLabel<ActionToPutData*>(valname); ap->addDependency( this ); inputs.push_back( ap );
+    ActionToPutData* ap=plumed.getActionSet().selectWithLabel<ActionToPutData*>(valname);
+    ap->addDependency( this );
+    inputs.push_back( ap );
   }
-  std::string pbclabel; parse("PBCLABEL",pbclabel); plumed.readInputLine(pbclabel + ": PBC",true);
+  std::string pbclabel;
+  parse("PBCLABEL",pbclabel);
+  plumed.readInputLine(pbclabel + ": PBC",true);
   // Turn on the domain decomposition
-  if( Communicator::initialized() ) Set_comm(comm);
+  if( Communicator::initialized() ) {
+    Set_comm(comm);
+  }
 }
 
 void DomainDecomposition::Set_comm(Communicator& comm) {
-  dd.enable(comm); setAtomsNlocal(getNumberOfAtoms()); setAtomsContiguous(0);
+  dd.enable(comm);
+  setAtomsNlocal(getNumberOfAtoms());
+  setAtomsContiguous(0);
   if( dd.Get_rank()!=0 ) {
-    ActionToPutData* ap=plumed.getActionSet().selectWithLabel<ActionToPutData*>("Box"); ap->noforce=true;
+    ActionToPutData* ap=plumed.getActionSet().selectWithLabel<ActionToPutData*>("Box");
+    ap->noforce=true;
   }
 }
 
 unsigned DomainDecomposition::getNumberOfAtoms() const {
-  if( inputs.size()==0 ) return 0;
+  if( inputs.size()==0 ) {
+    return 0;
+  }
   return (inputs[0]->getPntrToValue())->getShape()[0];
 }
 
 void DomainDecomposition::resetForStepStart() {
-  for(const auto & pp : inputs) pp->resetForStepStart();
+  for(const auto & pp : inputs) {
+    pp->resetForStepStart();
+  }
 }
 
 void DomainDecomposition::setStart( const std::string& name, const unsigned& sss) {
   for(const auto & pp : inputs) {
-    if( pp->getLabel()==name ) { pp->setStart(name, sss); return; }
+    if( pp->getLabel()==name ) {
+      pp->setStart(name, sss);
+      return;
+    }
   }
   plumed_error();
 }
 
 void DomainDecomposition::setStride( const std::string& name, const unsigned& sss) {
   for(const auto & pp : inputs) {
-    if( pp->getLabel()==name ) { pp->setStride(name, sss); return; }
+    if( pp->getLabel()==name ) {
+      pp->setStride(name, sss);
+      return;
+    }
   }
   plumed_error();
 }
@@ -162,14 +208,18 @@ void DomainDecomposition::setStride( const std::string& name, const unsigned& ss
 bool DomainDecomposition::setValuePointer( const std::string& name, const TypesafePtr & val ) {
   wasset=true;  // Once the domain decomposition stuff is transferred moved the setting of this to where the g2l vector is setup
   for(const auto & pp : inputs) {
-    if( pp->setValuePointer( name, val ) ) return true;
+    if( pp->setValuePointer( name, val ) ) {
+      return true;
+    }
   }
   return false;
 }
 
 bool DomainDecomposition::setForcePointer( const std::string& name, const TypesafePtr & val ) {
   for(const auto & pp : inputs) {
-    if( pp->setForcePointer( name, val ) ) return true;
+    if( pp->setForcePointer( name, val ) ) {
+      return true;
+    }
   }
   return false;
 }
@@ -182,7 +232,9 @@ void DomainDecomposition::setAtomsNlocal(int n) {
 // &dd.positionsToBeSent[0]
 // we make sure they are non-zero-sized so as to
 // avoid errors when doing boundary check
-    if(n==0) n++;
+    if(n==0) {
+      n++;
+    }
     std::size_t nvals = inputs.size(), natoms = getNumberOfAtoms();
     dd.positionsToBeSent.resize(n*nvals,0.0);
     dd.positionsToBeReceived.resize(natoms*nvals,0.0);
@@ -196,59 +248,99 @@ void DomainDecomposition::setAtomsGatindex(const TypesafePtr & g,bool fortran) {
   auto gg=g.get<const int*>({gatindex.size()});
   ddStep=getStep();
   if(fortran) {
-    for(unsigned i=0; i<gatindex.size(); i++) gatindex[i]=gg[i]-1;
+    for(unsigned i=0; i<gatindex.size(); i++) {
+      gatindex[i]=gg[i]-1;
+    }
   } else {
-    for(unsigned i=0; i<gatindex.size(); i++) gatindex[i]=gg[i];
+    for(unsigned i=0; i<gatindex.size(); i++) {
+      gatindex[i]=gg[i];
+    }
+  }
+  for(unsigned i=0; i<g2l.size(); i++) {
+    g2l[i]=-1;
   }
-  for(unsigned i=0; i<g2l.size(); i++) g2l[i]=-1;
   if( gatindex.size()==getNumberOfAtoms() ) {
     shuffledAtoms=0;
     for(unsigned i=0; i<gatindex.size(); i++) {
-      if( gatindex[i]!=i ) { shuffledAtoms=1; break; }
+      if( gatindex[i]!=i ) {
+        shuffledAtoms=1;
+        break;
+      }
     }
   } else {
     shuffledAtoms=1;
   }
-  if(dd) dd.Sum(shuffledAtoms);
-  for(unsigned i=0; i<gatindex.size(); i++) g2l[gatindex[i]]=i;
+  if(dd) {
+    dd.Sum(shuffledAtoms);
+  }
+  for(unsigned i=0; i<gatindex.size(); i++) {
+    g2l[gatindex[i]]=i;
+  }
   // keep in unique only those atoms that are local
-  for(unsigned i=0; i<actions.size(); i++) actions[i]->unique_local_needs_update=true;
-  unique.clear(); forced_unique.clear();
+  for(unsigned i=0; i<actions.size(); i++) {
+    actions[i]->unique_local_needs_update=true;
+  }
+  unique.clear();
+  forced_unique.clear();
 }
 
 void DomainDecomposition::setAtomsContiguous(int start) {
   ddStep=plumed.getStep();
-  for(unsigned i=0; i<gatindex.size(); i++) gatindex[i]=start+i;
-  for(unsigned i=0; i<g2l.size(); i++) g2l[i]=-1;
-  for(unsigned i=0; i<gatindex.size(); i++) g2l[gatindex[i]]=i;
-  if(gatindex.size()<getNumberOfAtoms()) shuffledAtoms=1;
+  for(unsigned i=0; i<gatindex.size(); i++) {
+    gatindex[i]=start+i;
+  }
+  for(unsigned i=0; i<g2l.size(); i++) {
+    g2l[i]=-1;
+  }
+  for(unsigned i=0; i<gatindex.size(); i++) {
+    g2l[gatindex[i]]=i;
+  }
+  if(gatindex.size()<getNumberOfAtoms()) {
+    shuffledAtoms=1;
+  }
   // keep in unique only those atoms that are local
-  for(unsigned i=0; i<actions.size(); i++) actions[i]->unique_local_needs_update=true;
-  unique.clear(); forced_unique.clear();
+  for(unsigned i=0; i<actions.size(); i++) {
+    actions[i]->unique_local_needs_update=true;
+  }
+  unique.clear();
+  forced_unique.clear();
 }
 
 void DomainDecomposition::shareAll() {
-  unique.clear(); forced_unique.clear(); int natoms = getNumberOfAtoms();
+  unique.clear();
+  forced_unique.clear();
+  int natoms = getNumberOfAtoms();
   if( dd && shuffledAtoms>0 ) {
-    for(int i=0; i<natoms; ++i) if( g2l[i]>=0 ) unique.push_back( AtomNumber::index(i) );
+    for(int i=0; i<natoms; ++i)
+      if( g2l[i]>=0 ) {
+        unique.push_back( AtomNumber::index(i) );
+      }
   } else {
     unique.resize(natoms);
-    for(int i=0; i<natoms; i++) unique[i]=AtomNumber::index(i);
+    for(int i=0; i<natoms; i++) {
+      unique[i]=AtomNumber::index(i);
+    }
   }
   forced_unique.resize( unique.size() );
-  for(unsigned i=0; i<unique.size(); ++i) forced_unique[i] = unique[i];
+  for(unsigned i=0; i<unique.size(); ++i) {
+    forced_unique[i] = unique[i];
+  }
   share(unique);
 }
 
 void DomainDecomposition::share() {
   // We can no longer set the pointers after the share
-  bool atomsNeeded=false; for(const auto & pp : inputs) pp->share();
+  bool atomsNeeded=false;
+  for(const auto & pp : inputs) {
+    pp->share();
+  }
   // At first step I scatter all the atoms so as to store their mass and charge
   // Notice that this works with the assumption that charges and masses are
   // not changing during the simulation!
   if( firststep ) {
     actions = plumed.getActionSet().select<ActionAtomistic*>();
-    shareAll(); return;
+    shareAll();
+    return;
   }
 
   if(getenvForceUnique()==Option::automatic) {
@@ -256,11 +348,16 @@ void DomainDecomposition::share() {
     for(unsigned i=0; i<actions.size(); i++) {
       if(actions[i]->isActive()) {
         auto l=actions[i]->getUnique().size();
-        if(l>largest) largest=l;
+        if(l>largest) {
+          largest=l;
+        }
       }
     }
-    if(largest*2<getNumberOfAtoms()) unique_serial=true;
-    else unique_serial=false;
+    if(largest*2<getNumberOfAtoms()) {
+      unique_serial=true;
+    } else {
+      unique_serial=false;
+    }
   } else if(getenvForceUnique()==Option::yes) {
     unique_serial=true;
   } else if(getenvForceUnique()==Option::no) {
@@ -271,24 +368,33 @@ void DomainDecomposition::share() {
 
   if(unique_serial || !(int(gatindex.size())==getNumberOfAtoms() && shuffledAtoms==0)) {
     for(unsigned i=0; i<actions.size(); i++) {
-      if( actions[i]->unique_local_needs_update ) actions[i]->updateUniqueLocal( !(dd && shuffledAtoms>0), g2l );
+      if( actions[i]->unique_local_needs_update ) {
+        actions[i]->updateUniqueLocal( !(dd && shuffledAtoms>0), g2l );
+      }
     }
     // Now reset unique for the new step
     gch::small_vector<const std::vector<AtomNumber>*,32> forced_vectors;
     gch::small_vector<const std::vector<AtomNumber>*,32> nonforced_vectors;
-    forced_vectors.reserve(actions.size()); nonforced_vectors.reserve(actions.size());
+    forced_vectors.reserve(actions.size());
+    nonforced_vectors.reserve(actions.size());
     for(unsigned i=0; i<actions.size(); i++) {
       if(actions[i]->isActive()) {
         if(!actions[i]->getUnique().empty()) {
           // unique are the local atoms
-          if( actions[i]->actionHasForces() ) forced_vectors.push_back(&actions[i]->getUniqueLocal());
-          else nonforced_vectors.push_back(&actions[i]->getUniqueLocal());
+          if( actions[i]->actionHasForces() ) {
+            forced_vectors.push_back(&actions[i]->getUniqueLocal());
+          } else {
+            nonforced_vectors.push_back(&actions[i]->getUniqueLocal());
+          }
         }
       }
     }
-    if( !(forced_vectors.empty() && nonforced_vectors.empty()) ) atomsNeeded=true;
+    if( !(forced_vectors.empty() && nonforced_vectors.empty()) ) {
+      atomsNeeded=true;
+    }
     // Merge the atoms from the atoms that have a force on
-    unique.clear(); forced_unique.clear();
+    unique.clear();
+    forced_unique.clear();
     mergeVectorTools::mergeSortedVectors(forced_vectors,forced_unique);
     // Merge all the atoms
     nonforced_vectors.push_back( &forced_unique );
@@ -296,46 +402,72 @@ void DomainDecomposition::share() {
   } else {
     for(unsigned i=0; i<actions.size(); i++) {
       if(actions[i]->isActive()) {
-        if(!actions[i]->getUnique().empty()) { atomsNeeded=true; }
+        if(!actions[i]->getUnique().empty()) {
+          atomsNeeded=true;
+        }
       }
     }
   }
 
   // Now we retrieve the atom numbers we need
-  if( atomsNeeded ) share( unique );
+  if( atomsNeeded ) {
+    share( unique );
+  }
 }
 
 void DomainDecomposition::share(const std::vector<AtomNumber>& unique) {
   // This retrieves what values we need to get
-  int ndata=0; std::vector<Value*> values_to_get;
+  int ndata=0;
+  std::vector<Value*> values_to_get;
   if(!(int(gatindex.size())==getNumberOfAtoms() && shuffledAtoms==0)) {
     uniq_index.resize(unique.size());
-    for(unsigned i=0; i<unique.size(); i++) uniq_index[i]=g2l[unique[i].index()];
+    for(unsigned i=0; i<unique.size(); i++) {
+      uniq_index[i]=g2l[unique[i].index()];
+    }
     for(const auto & ip : inputs) {
-      if( (!ip->fixed || firststep) && ip->wasset ) { (ip->mydata)->share_data( unique, uniq_index, ip->copyOutput(0) ); values_to_get.push_back(ip->copyOutput(0)); ndata++; }
+      if( (!ip->fixed || firststep) && ip->wasset ) {
+        (ip->mydata)->share_data( unique, uniq_index, ip->copyOutput(0) );
+        values_to_get.push_back(ip->copyOutput(0));
+        ndata++;
+      }
     }
   } else if( unique_serial) {
     uniq_index.resize(unique.size());
-    for(unsigned i=0; i<unique.size(); i++) uniq_index[i]=unique[i].index();
+    for(unsigned i=0; i<unique.size(); i++) {
+      uniq_index[i]=unique[i].index();
+    }
     for(const auto & ip : inputs) {
-      if( (!ip->fixed || firststep) && ip->wasset ) { (ip->mydata)->share_data( unique, uniq_index, ip->copyOutput(0) ); values_to_get.push_back(ip->copyOutput(0)); ndata++; }
+      if( (!ip->fixed || firststep) && ip->wasset ) {
+        (ip->mydata)->share_data( unique, uniq_index, ip->copyOutput(0) );
+        values_to_get.push_back(ip->copyOutput(0));
+        ndata++;
+      }
     }
   } else {
 // faster version, which retrieves all atoms
     for(const auto & ip : inputs) {
-      if( (!ip->fixed || firststep) && ip->wasset ) { (ip->mydata)->share_data( 0, getNumberOfAtoms(), ip->copyOutput(0) ); values_to_get.push_back(ip->copyOutput(0)); ndata++; }
+      if( (!ip->fixed || firststep) && ip->wasset ) {
+        (ip->mydata)->share_data( 0, getNumberOfAtoms(), ip->copyOutput(0) );
+        values_to_get.push_back(ip->copyOutput(0));
+        ndata++;
+      }
     }
   }
 
   if(dd && shuffledAtoms>0) {
     if(dd.async) {
-      for(unsigned i=0; i<dd.mpi_request_positions.size(); i++) dd.mpi_request_positions[i].wait();
-      for(unsigned i=0; i<dd.mpi_request_index.size(); i++)     dd.mpi_request_index[i].wait();
+      for(unsigned i=0; i<dd.mpi_request_positions.size(); i++) {
+        dd.mpi_request_positions[i].wait();
+      }
+      for(unsigned i=0; i<dd.mpi_request_index.size(); i++) {
+        dd.mpi_request_index[i].wait();
+      }
     }
 
     int count=0;
     for(const auto & p : unique) {
-      dd.indexToBeSent[count]=p.index(); int dpoint=0;
+      dd.indexToBeSent[count]=p.index();
+      int dpoint=0;
       for(unsigned i=0; i<values_to_get.size(); ++i) {
         dd.positionsToBeSent[ndata*count+dpoint]=values_to_get[i]->get(p.index());
         dpoint++;
@@ -359,16 +491,23 @@ void DomainDecomposition::share(const std::vector<AtomNumber>& unique) {
       std::vector<int> displ5(n);
       dd.Allgather(count,counts);
       displ[0]=0;
-      for(int i=1; i<n; ++i) displ[i]=displ[i-1]+counts[i-1];
-      for(int i=0; i<n; ++i) counts5[i]=counts[i]*ndata;
-      for(int i=0; i<n; ++i) displ5[i]=displ[i]*ndata;
+      for(int i=1; i<n; ++i) {
+        displ[i]=displ[i-1]+counts[i-1];
+      }
+      for(int i=0; i<n; ++i) {
+        counts5[i]=counts[i]*ndata;
+      }
+      for(int i=0; i<n; ++i) {
+        displ5[i]=displ[i]*ndata;
+      }
       dd.Allgatherv(&dd.indexToBeSent[0],count,&dd.indexToBeReceived[0],&counts[0],&displ[0]);
       dd.Allgatherv(&dd.positionsToBeSent[0],ndata*count,&dd.positionsToBeReceived[0],&counts5[0],&displ5[0]);
       int tot=displ[n-1]+counts[n-1];
       for(int i=0; i<tot; i++) {
         int dpoint=0;
         for(unsigned j=0; j<values_to_get.size(); ++j) {
-          values_to_get[j]->data[dd.indexToBeReceived[i]] = dd.positionsToBeReceived[ndata*i+dpoint]; dpoint++;
+          values_to_get[j]->data[dd.indexToBeReceived[i]] = dd.positionsToBeReceived[ndata*i+dpoint];
+          dpoint++;
         }
       }
     }
@@ -376,12 +515,18 @@ void DomainDecomposition::share(const std::vector<AtomNumber>& unique) {
 }
 
 void DomainDecomposition::wait() {
-  for(const auto & ip : inputs) ip->dataCanBeSet=false;
+  for(const auto & ip : inputs) {
+    ip->dataCanBeSet=false;
+  }
 
   if(dd && shuffledAtoms>0) {
-    int ndata=0; std::vector<Value*> values_to_set;
+    int ndata=0;
+    std::vector<Value*> values_to_set;
     for(const auto & ip : inputs) {
-      if( (!ip->fixed || firststep) && ip->wasset ) { values_to_set.push_back(ip->copyOutput(0)); ndata++; }
+      if( (!ip->fixed || firststep) && ip->wasset ) {
+        values_to_set.push_back(ip->copyOutput(0));
+        ndata++;
+      }
     }
 
 // receive toBeReceived
@@ -413,41 +558,61 @@ unsigned DomainDecomposition::getNumberOfForcesToRescale() const {
 void DomainDecomposition::apply() {
   std::vector<unsigned> forced_uniq_index(forced_unique.size());
   if(!(int(gatindex.size())==getNumberOfAtoms() && shuffledAtoms==0)) {
-    for(unsigned i=0; i<forced_unique.size(); i++) forced_uniq_index[i]=g2l[forced_unique[i].index()];
+    for(unsigned i=0; i<forced_unique.size(); i++) {
+      forced_uniq_index[i]=g2l[forced_unique[i].index()];
+    }
   } else {
-    for(unsigned i=0; i<forced_unique.size(); i++) forced_uniq_index[i]=forced_unique[i].index();
+    for(unsigned i=0; i<forced_unique.size(); i++) {
+      forced_uniq_index[i]=forced_unique[i].index();
+    }
   }
   for(const auto & ip : inputs) {
     if( !(ip->getPntrToValue())->forcesWereAdded() || ip->noforce ) {
       continue;
     } else if( ip->wasscaled || (!unique_serial && int(gatindex.size())==getNumberOfAtoms() && shuffledAtoms==0) ) {
       (ip->mydata)->add_force( gatindex, ip->getPntrToValue() );
-    } else { (ip->mydata)->add_force( forced_unique, forced_uniq_index, ip->getPntrToValue() ); }
+    } else {
+      (ip->mydata)->add_force( forced_unique, forced_uniq_index, ip->getPntrToValue() );
+    }
   }
 }
 
 void DomainDecomposition::reset() {
-  if( !unique_serial && int(gatindex.size())==getNumberOfAtoms() && shuffledAtoms==0 ) return;
+  if( !unique_serial && int(gatindex.size())==getNumberOfAtoms() && shuffledAtoms==0 ) {
+    return;
+  }
   // This is an optimisation to ensure that we don't call std::fill over the whole forces
   // array if there are a small number of atoms passed between the MD code and PLUMED
-  if( dd && shuffledAtoms>0 ) getAllActiveAtoms( unique );
-  for(const auto & ip : inputs) (ip->copyOutput(0))->clearInputForce( unique );
+  if( dd && shuffledAtoms>0 ) {
+    getAllActiveAtoms( unique );
+  }
+  for(const auto & ip : inputs) {
+    (ip->copyOutput(0))->clearInputForce( unique );
+  }
 }
 
 void DomainDecomposition::writeBinary(std::ostream&o) {
-  for(const auto & ip : inputs) ip->writeBinary(o);
+  for(const auto & ip : inputs) {
+    ip->writeBinary(o);
+  }
 }
 
 void DomainDecomposition::readBinary(std::istream&i) {
-  for(const auto & ip : inputs) ip->readBinary(i);
+  for(const auto & ip : inputs) {
+    ip->readBinary(i);
+  }
 }
 
 void DomainDecomposition::broadcastToDomains( Value* val ) {
-  if( dd ) dd.Bcast( val->data, 0 );
+  if( dd ) {
+    dd.Bcast( val->data, 0 );
+  }
 }
 
 void DomainDecomposition::sumOverDomains( Value* val ) {
-  if( dd && shuffledAtoms>0 ) dd.Sum( val->data );
+  if( dd && shuffledAtoms>0 ) {
+    dd.Sum( val->data );
+  }
 }
 
 const long int& DomainDecomposition::getDdStep() const {
@@ -476,23 +641,32 @@ void DomainDecomposition::getAllActiveAtoms( std::vector<AtomNumber>& u ) {
 void DomainDecomposition::createFullList(const TypesafePtr & n) {
   if( firststep ) {
     int natoms = getNumberOfAtoms();
-    n.set(int(natoms)); fullList.resize(natoms);
-    for(unsigned i=0; i<natoms; i++) fullList[i]=i;
+    n.set(int(natoms));
+    fullList.resize(natoms);
+    for(unsigned i=0; i<natoms; i++) {
+      fullList[i]=i;
+    }
   } else {
 // We update here the unique list defined at Atoms::unique.
 // This is not very clear, and probably should be coded differently.
 // Hopefully this fix the longstanding issue with NAMD.
     getAllActiveAtoms( unique );
-    fullList.clear(); fullList.reserve(unique.size());
-    for(const auto & p : unique) fullList.push_back(p.index());
+    fullList.clear();
+    fullList.reserve(unique.size());
+    for(const auto & p : unique) {
+      fullList.push_back(p.index());
+    }
     n.set(int(fullList.size()));
   }
 }
 
 void DomainDecomposition::getFullList(const TypesafePtr & x) {
   auto xx=x.template get<const int**>();
-  if(!fullList.empty()) *xx=&fullList[0];
-  else *xx=NULL;
+  if(!fullList.empty()) {
+    *xx=&fullList[0];
+  } else {
+    *xx=NULL;
+  }
 }
 
 void DomainDecomposition::clearFullList() {
diff --git a/src/core/DomainDecomposition.h b/src/core/DomainDecomposition.h
index d9df5b8849..647d06b874 100644
--- a/src/core/DomainDecomposition.h
+++ b/src/core/DomainDecomposition.h
@@ -44,7 +44,9 @@ class DomainDecomposition : public ActionForInterface {
     std::vector<double> positionsToBeReceived;
     std::vector<int>    indexToBeSent;
     std::vector<int>    indexToBeReceived;
-    operator bool() const {return on;}
+    operator bool() const {
+      return on;
+    }
     DomainComms(): on(false), async(false) {}
     void enable(Communicator& c);
   };
@@ -105,9 +107,13 @@ class DomainDecomposition : public ActionForInterface {
   void createFullList(const TypesafePtr & x);
   void getFullList(const TypesafePtr & x);
   void clearFullList();
-  bool onStep() const override { return getNumberOfAtoms()>0; }
+  bool onStep() const override {
+    return getNumberOfAtoms()>0;
+  }
   unsigned getNumberOfAtoms() const;
-  DomainDecomposition* castToDomainDecomposition() noexcept final { return this; }
+  DomainDecomposition* castToDomainDecomposition() noexcept final {
+    return this;
+  }
 };
 
 }
diff --git a/src/core/ExchangePatterns.cpp b/src/core/ExchangePatterns.cpp
index ee5af5993c..c39e07b8e6 100644
--- a/src/core/ExchangePatterns.cpp
+++ b/src/core/ExchangePatterns.cpp
@@ -43,28 +43,30 @@ void ExchangePatterns::getFlag(int &flag) {
   flag=PatternFlag;
 }
 
-void ExchangePatterns::setSeed(const int seed)
-{
+void ExchangePatterns::setSeed(const int seed) {
   random.setSeed(seed);
 }
 
-void ExchangePatterns::getList(const TypesafePtr & ind)
-{
+void ExchangePatterns::getList(const TypesafePtr & ind) {
   auto iind=ind.get<int*>({NumberOfReplicas});
-  switch(PatternFlag)
-  {
+  switch(PatternFlag) {
   case RANDOM:
     for(int i=0; i<NumberOfReplicas; i++) {
       int stat=1;
       while(stat) {
         stat=0;
         iind[i] = (int) (random.U01()*NumberOfReplicas);
-        for(int j=0; j<i; j++) if(iind[i]==iind[j]) stat=1;
+        for(int j=0; j<i; j++)
+          if(iind[i]==iind[j]) {
+            stat=1;
+          }
       }
     }
     break;
   case NEIGHBOR:
-    for(int i=0; i<NumberOfReplicas; i++) iind[i]=i;
+    for(int i=0; i<NumberOfReplicas; i++) {
+      iind[i]=i;
+    }
     break;
   }
 }
diff --git a/src/core/FlexibleBin.cpp b/src/core/FlexibleBin.cpp
index 7be201915b..8fac4c5f76 100644
--- a/src/core/FlexibleBin.cpp
+++ b/src/core/FlexibleBin.cpp
@@ -34,8 +34,7 @@ FlexibleBin::FlexibleBin(int type, ActionWithArguments *paction, double const &d
   paction(paction),
   sigma(d),
   sigmamin(smin),
-  sigmamax(smax)
-{
+  sigmamax(smax) {
   // initialize the averages and the variance matrices
   if(type==diffusion) {
     unsigned ncv=paction->getNumberOfArguments();
@@ -69,8 +68,7 @@ FlexibleBin::FlexibleBin(int type, ActionWithArguments *paction, double const &d
 /// Constructure for 1D FB for PBMETAD
 FlexibleBin::FlexibleBin(int type, ActionWithArguments *paction, unsigned iarg,
                          double const &d, std::vector<double> &smin, const std::vector<double> &smax):
-  type(type),paction(paction),sigma(d),sigmamin(smin),sigmamax(smax)
-{
+  type(type),paction(paction),sigma(d),sigmamin(smin),sigmamax(smax) {
   // initialize the averages and the variance matrices
   if(type==diffusion) {
     std::vector<double> average(1);
@@ -117,10 +115,14 @@ void FlexibleBin::update(bool nowAddAHill) {
     // THE AVERAGE VALUE
     // beware: the pbc
     delta.resize(ncv);
-    for(unsigned i=0; i<ncv; i++) cv.push_back(paction->getArgument(i));
+    for(unsigned i=0; i<ncv; i++) {
+      cv.push_back(paction->getArgument(i));
+    }
     if(average.size()==0) { // initial time: just set the initial vector
       average.resize(ncv);
-      for(unsigned i=0; i<ncv; i++) average[i]=cv[i];
+      for(unsigned i=0; i<ncv; i++) {
+        average[i]=cv[i];
+      }
     } else { // accumulate
       for(unsigned i=0; i<ncv; i++) {
         delta[i]=paction->difference(i,average[i],cv[i]);
@@ -239,7 +241,9 @@ std::vector<double> FlexibleBin::getInverseMatrix() const {
   std::vector<double> eigenvals(ncv);
 
   //eigenvecs: first is eigenvec number, second is eigenvec component
-  if(diagMat( matrix, eigenvals, eigenvecs )!=0) {plumed_merror("diagonalization in FlexibleBin failed! This matrix is weird\n");};
+  if(diagMat( matrix, eigenvals, eigenvecs )!=0) {
+    plumed_merror("diagonalization in FlexibleBin failed! This matrix is weird\n");
+  };
 
   for (i=0; i<ncv; i++) { //loop on the dimension
     if( limitmax[i] ) {
@@ -259,7 +263,8 @@ std::vector<double> FlexibleBin::getInverseMatrix() const {
       for (j=0; j<ncv; j++) { //loop on components
         double fact=std::pow(eigenvals[j]*eigenvecs[j][i],2);
         if(fact>fmax) {
-          fmax=fact; imax=j;
+          fmax=fact;
+          imax=j;
         }
       }
       if(fmax<std::pow(sigmamin[i],2) ) {
@@ -284,7 +289,8 @@ std::vector<double> FlexibleBin::getInverseMatrix() const {
       for(unsigned l=0; l<ncv; ++l) {
         scal+=eigenvecs[l][i]*newinvmatrix[l][j];
       }
-      uppervec[k]=scal; k++;
+      uppervec[k]=scal;
+      k++;
     }
   }
 #else
diff --git a/src/core/GREX.cpp b/src/core/GREX.cpp
index 7212055e3a..007cdc6c7b 100644
--- a/src/core/GREX.cpp
+++ b/src/core/GREX.cpp
@@ -35,8 +35,7 @@ GREX::GREX(PlumedMain&p):
   foreignDeltaBias(0),
   localUNow(0),
   localUSwap(0),
-  myreplica(-1) // = unset
-{
+  myreplica(-1) { // = unset
   p.setSuffix(".NA");
 }
 
@@ -67,7 +66,9 @@ void GREX::cmd(std::string_view key,const TypesafePtr & val) {
   } else {
     int iword=-1;
     const auto it=word_map.find(words[0]);
-    if(it!=word_map.end()) iword=it->second;
+    if(it!=word_map.end()) {
+      iword=it->second;
+    }
     switch(iword) {
     case cmd_initialized:
       CHECK_NOTNULL(val,key);
@@ -105,7 +106,9 @@ void GREX::cmd(std::string_view key,const TypesafePtr & val) {
       break;
     case cmd_prepare:
       CHECK_INIT(initialized,key);
-      if(intracomm.Get_rank()==0) return;
+      if(intracomm.Get_rank()==0) {
+        return;
+      }
       intracomm.Bcast(partner,0);
       calculate();
       break;
@@ -119,7 +122,9 @@ void GREX::cmd(std::string_view key,const TypesafePtr & val) {
       break;
     case cmd_calculate:
       CHECK_INIT(initialized,key);
-      if(intracomm.Get_rank()!=0) return;
+      if(intracomm.Get_rank()!=0) {
+        return;
+      }
       intracomm.Bcast(partner,0);
       calculate();
       break;
@@ -151,7 +156,9 @@ void GREX::cmd(std::string_view key,const TypesafePtr & val) {
       break;
     case cmd_shareAllDeltaBias:
       CHECK_INIT(initialized,key);
-      if(intracomm.Get_rank()!=0) return;
+      if(intracomm.Get_rank()!=0) {
+        return;
+      }
       allDeltaBias.assign(intercomm.Get_size(),0.0);
       allDeltaBias[intercomm.Get_rank()]=localDeltaBias;
       intercomm.Sum(allDeltaBias);
diff --git a/src/core/GREX.h b/src/core/GREX.h
index 772e99fbbb..6a23e54f2b 100644
--- a/src/core/GREX.h
+++ b/src/core/GREX.h
@@ -33,8 +33,7 @@ class PlumedMain;
 class Communicator;
 
 class GREX:
-  public WithCmd
-{
+  public WithCmd {
   bool initialized;
   ForwardDecl<Communicator> intracomm_fwd;
   Communicator& intracomm=*intracomm_fwd;
diff --git a/src/core/GenericMolInfo.cpp b/src/core/GenericMolInfo.cpp
index 2791d2d112..be83d98f31 100644
--- a/src/core/GenericMolInfo.cpp
+++ b/src/core/GenericMolInfo.cpp
@@ -59,8 +59,7 @@ GenericMolInfo::GenericMolInfo( const ActionOptions&ao ):
   ActionAnyorder(ao),
   ActionPilot(ao),
   ActionAtomistic(ao),
-  iswhole_(false)
-{
+  iswhole_(false) {
   plumed_assert(getStride()==1);
   // Read what is contained in the pdb file
   parse("MOLTYPE",mytype);
@@ -69,14 +68,18 @@ GenericMolInfo::GenericMolInfo( const ActionOptions&ao ):
   parseFlag("WHOLE", iswhole_);
 
   auto* moldat=plumed.getActionSet().selectLatest<GenericMolInfo*>(this);
-  if( moldat ) log<<"  overriding last MOLINFO with label " << moldat->getLabel()<<"\n";
+  if( moldat ) {
+    log<<"  overriding last MOLINFO with label " << moldat->getLabel()<<"\n";
+  }
 
   std::vector<AtomNumber> backbone;
   parseAtomList("CHAIN",backbone);
   if( read_backbone.size()==0 ) {
     for(unsigned i=1;; ++i) {
       parseAtomList("CHAIN",i,backbone);
-      if( backbone.size()==0 ) break;
+      if( backbone.size()==0 ) {
+        break;
+      }
       read_backbone.push_back(backbone);
       backbone.resize(0);
     }
@@ -86,17 +89,25 @@ GenericMolInfo::GenericMolInfo( const ActionOptions&ao ):
   if( read_backbone.size()==0 ) {
     parse("STRUCTURE",reference);
 
-    if( ! pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength()))plumed_merror("missing input file " + reference );
+    if( ! pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength())) {
+      plumed_merror("missing input file " + reference );
+    }
 
-    std::vector<std::string> chains; pdb.getChainNames( chains );
+    std::vector<std::string> chains;
+    pdb.getChainNames( chains );
     log.printf("  pdb file named %s contains %u chains \n",reference.c_str(), static_cast<unsigned>(chains.size()));
     for(unsigned i=0; i<chains.size(); ++i) {
-      unsigned start,end; std::string errmsg;
+      unsigned start,end;
+      std::string errmsg;
       pdb.getResidueRange( chains[i], start, end, errmsg );
-      if( errmsg.length()!=0 ) error( errmsg );
+      if( errmsg.length()!=0 ) {
+        error( errmsg );
+      }
       AtomNumber astart,aend;
       pdb.getAtomRange( chains[i], astart, aend, errmsg );
-      if( errmsg.length()!=0 ) error( errmsg );
+      if( errmsg.length()!=0 ) {
+        error( errmsg );
+      }
       log.printf("  chain named %s contains residues %u to %u and atoms %u to %u \n",chains[i].c_str(),start,end,astart.serial(),aend.serial());
     }
 
@@ -113,7 +124,9 @@ GenericMolInfo::GenericMolInfo( const ActionOptions&ao ):
       bool sorted=true;
       const auto & at=pdb.getAtomNumbers();
       for(unsigned i=0; i<at.size(); i++) {
-        if(at[i].index()!=i) sorted=false;
+        if(at[i].index()!=i) {
+          sorted=false;
+        }
       }
       if(!sorted) {
         log<<"  PDB is not sorted, python interpreter will be disabled\n";
@@ -167,44 +180,66 @@ std::map<std::string,std::string> GenericMolInfo::getSpecialKeywords() {
 }
 
 void GenericMolInfo::getBackbone( std::vector<std::string>& restrings, const std::string& fortype, std::vector< std::vector<AtomNumber> >& backbone ) {
-  if( fortype!=mytype ) error("cannot calculate a variable designed for " + fortype + " molecules for molecule type " + mytype );
-  if( MolDataClass::numberOfAtomsPerResidueInBackbone( mytype )==0 ) error("backbone is not defined for molecule type " + mytype );
+  if( fortype!=mytype ) {
+    error("cannot calculate a variable designed for " + fortype + " molecules for molecule type " + mytype );
+  }
+  if( MolDataClass::numberOfAtomsPerResidueInBackbone( mytype )==0 ) {
+    error("backbone is not defined for molecule type " + mytype );
+  }
 
   if( read_backbone.size()!=0 ) {
-    if( restrings.size()!=1 ) error("cannot interpret anything other than all for residues when using CHAIN keywords");
-    if( restrings[0]!="all" ) error("cannot interpret anything other than all for residues when using CHAIN keywords");
+    if( restrings.size()!=1 ) {
+      error("cannot interpret anything other than all for residues when using CHAIN keywords");
+    }
+    if( restrings[0]!="all" ) {
+      error("cannot interpret anything other than all for residues when using CHAIN keywords");
+    }
     backbone.resize( read_backbone.size() );
     for(unsigned i=0; i<read_backbone.size(); ++i) {
       backbone[i].resize( read_backbone[i].size() );
-      for(unsigned j=0; j<read_backbone[i].size(); ++j) backbone[i][j]=read_backbone[i][j];
+      for(unsigned j=0; j<read_backbone[i].size(); ++j) {
+        backbone[i][j]=read_backbone[i][j];
+      }
     }
   } else {
     bool useter=false; // This is used to deal with terminal groups in WHOLEMOLECULES
     if( restrings.size()==1 ) {
       useter=( restrings[0].find("ter")!=std::string::npos );
       if( restrings[0].find("all")!=std::string::npos ) {
-        std::vector<std::string> chains; pdb.getChainNames( chains );
+        std::vector<std::string> chains;
+        pdb.getChainNames( chains );
         for(unsigned i=0; i<chains.size(); ++i) {
-          unsigned r_start, r_end; std::string errmsg, mm, nn;
+          unsigned r_start, r_end;
+          std::string errmsg, mm, nn;
           pdb.getResidueRange( chains[i], r_start, r_end, errmsg );
           if( !useter ) {
             std::string resname = pdb.getResidueName( r_start );
-            if( MolDataClass::isTerminalGroup( mytype, resname ) ) r_start++;
+            if( MolDataClass::isTerminalGroup( mytype, resname ) ) {
+              r_start++;
+            }
             resname = pdb.getResidueName( r_end );
-            if( MolDataClass::isTerminalGroup( mytype, resname ) ) r_end--;
+            if( MolDataClass::isTerminalGroup( mytype, resname ) ) {
+              r_end--;
+            }
+          }
+          Tools::convert(r_start,mm);
+          Tools::convert(r_end,nn);
+          if(i==0) {
+            restrings[0] = mm + "-" + nn;
+          } else {
+            restrings.push_back(  mm + "-" + nn );
           }
-          Tools::convert(r_start,mm); Tools::convert(r_end,nn);
-          if(i==0) restrings[0] = mm + "-" + nn;
-          else restrings.push_back(  mm + "-" + nn );
         }
       }
     }
     Tools::interpretRanges(restrings);
 
     // Convert the list of involved residues into a list of segments of chains
-    int nk, nj; std::vector< std::vector<unsigned> > segments;
+    int nk, nj;
+    std::vector< std::vector<unsigned> > segments;
     std::vector<unsigned> thissegment;
-    Tools::convert(restrings[0],nk); thissegment.push_back(nk);
+    Tools::convert(restrings[0],nk);
+    thissegment.push_back(nk);
     for(unsigned i=1; i<restrings.size(); ++i) {
       Tools::convert(restrings[i-1],nk);
       Tools::convert(restrings[i],nj);
@@ -223,20 +258,27 @@ void GenericMolInfo::getBackbone( std::vector<std::string>& restrings, const std
       for(unsigned j=0; j<segments[i].size(); ++j) {
         std::string resname=pdb.getResidueName( segments[i][j] );
         if( !MolDataClass::allowedResidue(mytype, resname) ) {
-          std::string num; Tools::convert( segments[i][j], num );
+          std::string num;
+          Tools::convert( segments[i][j], num );
           error("residue " + num + " is not recognized for moltype " + mytype );
         }
         if( !useter && MolDataClass::isTerminalGroup( mytype, resname ) ) {
-          std::string num; Tools::convert( segments[i][j], num );
+          std::string num;
+          Tools::convert( segments[i][j], num );
           error("residue " + num + " appears to be a terminal group");
         }
-        if( resname=="GLY" ) warning("GLY residues are achiral - assuming HA1 atom is in CB position");
+        if( resname=="GLY" ) {
+          warning("GLY residues are achiral - assuming HA1 atom is in CB position");
+        }
         MolDataClass::getBackboneForResidue( mytype, segments[i][j], pdb, atomnumbers );
         if( atomnumbers.size()==0 ) {
-          std::string num; Tools::convert( segments[i][j], num );
+          std::string num;
+          Tools::convert( segments[i][j], num );
           error("Could not find required backbone atom in residue number " + num );
         } else {
-          for(unsigned k=0; k<atomnumbers.size(); ++k) backbone[i].push_back( atomnumbers[k] );
+          for(unsigned k=0; k<atomnumbers.size(); ++k) {
+            backbone[i].push_back( atomnumbers[k] );
+          }
         }
         atomnumbers.resize(0);
       }
@@ -278,13 +320,19 @@ void GenericMolInfo::interpretSymbol( const std::string& symbol, std::vector<Ato
         while(true) {
           selector->getline(res);
           words=Tools::getWords(res);
-          if(!words.empty() && words[0]=="Error") plumed_error()<<res;
-          if(!words.empty() && words[0]=="Selection:") break;
+          if(!words.empty() && words[0]=="Error") {
+            plumed_error()<<res;
+          }
+          if(!words.empty() && words[0]=="Selection:") {
+            break;
+          }
         }
         words.erase(words.begin());
         for(const auto & w : words) {
           int n;
-          if(w.empty()) continue;
+          if(w.empty()) {
+            continue;
+          }
           Tools::convert(w,n);
           atoms.push_back(AtomNumber::serial(n));
         }
@@ -319,14 +367,24 @@ void GenericMolInfo::interpretSymbol( const std::string& symbol, std::vector<Ato
       comm.Bcast(atoms,0);
     }
     log<<"  selection interpreted using ";
-    if(Tools::startWith(symbol,"mdt:")) log<<"mdtraj "<<cite("McGibbon et al, Biophys. J., 109, 1528 (2015)")<<"\n";
-    if(Tools::startWith(symbol,"mda:")) log<<"MDAnalysis "<<cite("Gowers et al, Proceedings of the 15th Python in Science Conference, doi:10.25080/majora-629e541a-00e (2016)")<<"\n";
-    if(Tools::startWith(symbol,"vmdexec:")) log<<"VMD "<<cite("Humphrey, Dalke, and Schulten, K., J. Molec. Graphics, 14, 33 (1996)")<<"\n";
-    if(Tools::startWith(symbol,"vmd:")) log<<"VMD (github.com/Eigenstate/vmd-python) "<<cite("Humphrey, Dalke, and Schulten, K., J. Molec. Graphics, 14, 33 (1996)")<<"\n";
+    if(Tools::startWith(symbol,"mdt:")) {
+      log<<"mdtraj "<<cite("McGibbon et al, Biophys. J., 109, 1528 (2015)")<<"\n";
+    }
+    if(Tools::startWith(symbol,"mda:")) {
+      log<<"MDAnalysis "<<cite("Gowers et al, Proceedings of the 15th Python in Science Conference, doi:10.25080/majora-629e541a-00e (2016)")<<"\n";
+    }
+    if(Tools::startWith(symbol,"vmdexec:")) {
+      log<<"VMD "<<cite("Humphrey, Dalke, and Schulten, K., J. Molec. Graphics, 14, 33 (1996)")<<"\n";
+    }
+    if(Tools::startWith(symbol,"vmd:")) {
+      log<<"VMD (github.com/Eigenstate/vmd-python) "<<cite("Humphrey, Dalke, and Schulten, K., J. Molec. Graphics, 14, 33 (1996)")<<"\n";
+    }
     return;
   }
   MolDataClass::specialSymbol( mytype, symbol, pdb, atoms );
-  if(atoms.empty()) error(symbol + " not found in your MOLINFO structure");
+  if(atoms.empty()) {
+    error(symbol + " not found in your MOLINFO structure");
+  }
 }
 
 std::string GenericMolInfo::getAtomName(AtomNumber a)const {
diff --git a/src/core/Group.cpp b/src/core/Group.cpp
index 0f4a28c914..d70d9e5fb1 100644
--- a/src/core/Group.cpp
+++ b/src/core/Group.cpp
@@ -142,14 +142,17 @@ PLUMED_REGISTER_ACTION(Group,"GROUP")
 
 Group::Group(const ActionOptions&ao):
   Action(ao),
-  ActionAtomistic(ao)
-{
+  ActionAtomistic(ao) {
   parseAtomList("ATOMS",atoms);
   std::string ndxfile,ndxgroup;
   parse("NDX_FILE",ndxfile);
   parse("NDX_GROUP",ndxgroup);
-  if(ndxfile.length()>0 && atoms.size()>0) error("either use explicit atom list or import from index file");
-  if(ndxfile.length()==0 && ndxgroup.size()>0) error("NDX_GROUP can be only used is NDX_FILE is also used");
+  if(ndxfile.length()>0 && atoms.size()>0) {
+    error("either use explicit atom list or import from index file");
+  }
+  if(ndxfile.length()==0 && ndxgroup.size()>0) {
+    error("NDX_GROUP can be only used is NDX_FILE is also used");
+  }
 
   if(ndxfile.length()>0) {
 
@@ -169,16 +172,22 @@ Group::Group(const ActionOptions&ao):
     for(unsigned i=0; i<remove.size(); i++) {
       const auto it = find(atoms.begin(),atoms.end(),remove[i]);
       if(it!=atoms.end()) {
-        if(k%25==0) log<<"\n";
+        if(k%25==0) {
+          log<<"\n";
+        }
         log<<" "<<(*it).serial();
         k++;
         atoms.erase(it);
-      } else notfound.push_back(remove[i]);
+      } else {
+        notfound.push_back(remove[i]);
+      }
     }
     log<<"\n";
     if(notfound.size()>0) {
       log<<"  the following atoms were not found:";
-      for(unsigned i=0; i<notfound.size(); i++) log<<" "<<notfound[i].serial();
+      for(unsigned i=0; i<notfound.size(); i++) {
+        log<<" "<<notfound[i].serial();
+      }
       log<<"\n";
     }
   }
@@ -198,7 +207,9 @@ Group::Group(const ActionOptions&ao):
 
   log.printf("  list of atoms:");
   for(unsigned i=0; i<atoms.size(); i++) {
-    if(i%25==0) log<<"\n";
+    if(i%25==0) {
+      log<<"\n";
+    }
     log<<" "<<atoms[i].serial();
   }
   log.printf("\n");
@@ -219,8 +230,11 @@ std::vector<std::string> Group::getGroupAtoms() const {
   std::vector<std::string> atoms_str(atoms.size());
   for(unsigned i=0; i<atoms.size(); ++i) {
     std::pair<std::size_t,std::size_t> a = getValueIndices( atoms[i] );
-    if( xpos[a.first]->getNumberOfValues()==1 ) atoms_str[i] = (xpos[a.first]->getPntrToAction())->getLabel();
-    else { Tools::convert( atoms[i].serial(), atoms_str[i] ); }
+    if( xpos[a.first]->getNumberOfValues()==1 ) {
+      atoms_str[i] = (xpos[a.first]->getPntrToAction())->getLabel();
+    } else {
+      Tools::convert( atoms[i].serial(), atoms_str[i] );
+    }
   }
   return atoms_str;
 }
diff --git a/src/core/PbcAction.cpp b/src/core/PbcAction.cpp
index ccbca7ebbe..6b036d73a7 100644
--- a/src/core/PbcAction.cpp
+++ b/src/core/PbcAction.cpp
@@ -48,31 +48,44 @@ void PbcAction::registerKeywords( Keywords& keys ) {
 PbcAction::PbcAction(const ActionOptions&ao):
   Action(ao),
   ActionToPutData(ao),
-  interface(NULL)
-{
-  std::vector<unsigned> shape(2); shape[0]=shape[1]=3;
-  addValue( shape ); setNotPeriodic(); setUnit( "length", "energy" );
-  getPntrToValue()->buildDataStore(); getPntrToValue()->reshapeMatrixStore(3);
+  interface(NULL) {
+  std::vector<unsigned> shape(2);
+  shape[0]=shape[1]=3;
+  addValue( shape );
+  setNotPeriodic();
+  setUnit( "length", "energy" );
+  getPntrToValue()->buildDataStore();
+  getPntrToValue()->reshapeMatrixStore(3);
 }
 
 
 void PbcAction::setPbc() {
   if( !interface ) {
     std::vector<DomainDecomposition*> allput=plumed.getActionSet().select<DomainDecomposition*>();
-    if( allput.size()>1 ) warning("found more than one interface so don't know how to broadcast cell");
+    if( allput.size()>1 ) {
+      warning("found more than one interface so don't know how to broadcast cell");
+    }
     interface = allput[0];
   }
-  Tensor box; if( interface ) interface->broadcastToDomains( getPntrToValue() );
-  for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) box(i,j) = getPntrToValue()->get(3*i+j);
+  Tensor box;
+  if( interface ) {
+    interface->broadcastToDomains( getPntrToValue() );
+  }
+  for(unsigned i=0; i<3; ++i)
+    for(unsigned j=0; j<3; ++j) {
+      box(i,j) = getPntrToValue()->get(3*i+j);
+    }
   pbc.setBox(box);
 }
 
 void PbcAction::wait() {
-  ActionToPutData::wait(); setPbc();
+  ActionToPutData::wait();
+  setPbc();
 }
 
 void PbcAction::readBinary(std::istream&i) {
-  ActionToPutData::readBinary(i); setPbc();
+  ActionToPutData::readBinary(i);
+  setPbc();
 }
 
 }
diff --git a/src/core/PbcAction.h b/src/core/PbcAction.h
index 91042478cf..32ae30184b 100644
--- a/src/core/PbcAction.h
+++ b/src/core/PbcAction.h
@@ -47,7 +47,9 @@ class PbcAction : public ActionToPutData {
   Pbc& getPbc();
   void wait() override;
   void readBinary(std::istream&i) override;
-  PbcAction* castToPbcAction() noexcept final { return this; }
+  PbcAction* castToPbcAction() noexcept final {
+    return this;
+  }
 };
 
 inline
diff --git a/src/core/PlumedMain.cpp b/src/core/PlumedMain.cpp
index c2e50f51b2..962aa7e6c3 100644
--- a/src/core/PlumedMain.cpp
+++ b/src/core/PlumedMain.cpp
@@ -106,10 +106,18 @@ namespace PLMD {
     plumed_assert(words.size()>2);
     int error_code;
     Tools::convert(words[2],error_code);
-    if(words[1]=="std::generic_category") throw std::system_error(error_code,std::generic_category(),what);
-    if(words[1]=="std::system_category") throw std::system_error(error_code,std::system_category(),what);
-    if(words[1]=="std::iostream_category") throw std::system_error(error_code,std::iostream_category(),what);
-    if(words[1]=="std::future_category") throw std::system_error(error_code,std::future_category(),what);
+    if(words[1]=="std::generic_category") {
+      throw std::system_error(error_code,std::generic_category(),what);
+    }
+    if(words[1]=="std::system_category") {
+      throw std::system_error(error_code,std::system_category(),what);
+    }
+    if(words[1]=="std::iostream_category") {
+      throw std::system_error(error_code,std::iostream_category(),what);
+    }
+    if(words[1]=="std::future_category") {
+      throw std::system_error(error_code,std::future_category(),what);
+    }
   }
 
   if(words[0]=="std::filesystem::filesystem_error") {
@@ -117,13 +125,25 @@ namespace PLMD {
     plumed_assert(words.size()>2);
     Tools::convert(words[2],error_code);
     std::error_code x_error_code;
-    if(words[1]=="std::generic_category") x_error_code=::std::error_code(error_code,::std::generic_category());
-    if(words[1]=="std::system_category") x_error_code=::std::error_code(error_code,::std::system_category());
-    if(words[1]=="std::iostream_category") x_error_code=::std::error_code(error_code,::std::iostream_category());
-    if(words[1]=="std::future_category") x_error_code=::std::error_code(error_code,::std::future_category());
+    if(words[1]=="std::generic_category") {
+      x_error_code=::std::error_code(error_code,::std::generic_category());
+    }
+    if(words[1]=="std::system_category") {
+      x_error_code=::std::error_code(error_code,::std::system_category());
+    }
+    if(words[1]=="std::iostream_category") {
+      x_error_code=::std::error_code(error_code,::std::iostream_category());
+    }
+    if(words[1]=="std::future_category") {
+      x_error_code=::std::error_code(error_code,::std::future_category());
+    }
 
-    if(words.size()<4) throw std::filesystem::filesystem_error(what,x_error_code);
-    if(words.size()<5) throw std::filesystem::filesystem_error(what,std::filesystem::path(words[3]),x_error_code);
+    if(words.size()<4) {
+      throw std::filesystem::filesystem_error(what,x_error_code);
+    }
+    if(words.size()<5) {
+      throw std::filesystem::filesystem_error(what,std::filesystem::path(words[3]),x_error_code);
+    }
     throw std::filesystem::filesystem_error(what,std::filesystem::path(words[3]),std::filesystem::path(words[4]),x_error_code);
   }
 
@@ -156,17 +176,29 @@ namespace PLMD {
 
   if(words[0]=="std::ios_base::failure") {
     int error_code=0;
-    if(words.size()>2) Tools::convert(words[2],error_code);
-    if(words.size()>1 && words[1]=="std::generic_category") throw std::ios_base::failure(what,std::error_code(error_code,std::generic_category()));
-    if(words.size()>1 && words[1]=="std::system_category") throw std::ios_base::failure(what,std::error_code(error_code,std::system_category()));
-    if(words.size()>1 && words[1]=="std::iostream_category") throw std::ios_base::failure(what,std::error_code(error_code,std::iostream_category()));
-    if(words.size()>1 && words[1]=="std::future_category") throw std::ios_base::failure(what,std::error_code(error_code,std::future_category()));
+    if(words.size()>2) {
+      Tools::convert(words[2],error_code);
+    }
+    if(words.size()>1 && words[1]=="std::generic_category") {
+      throw std::ios_base::failure(what,std::error_code(error_code,std::generic_category()));
+    }
+    if(words.size()>1 && words[1]=="std::system_category") {
+      throw std::ios_base::failure(what,std::error_code(error_code,std::system_category()));
+    }
+    if(words.size()>1 && words[1]=="std::iostream_category") {
+      throw std::ios_base::failure(what,std::error_code(error_code,std::iostream_category()));
+    }
+    if(words.size()>1 && words[1]=="std::future_category") {
+      throw std::ios_base::failure(what,std::error_code(error_code,std::future_category()));
+    }
     throw std::ios_base::failure(what);
   }
 
   if(words[0]=="int") {
     int value=0;
-    if(words.size()>1) Tools::convert(words[1],value);
+    if(words.size()>1) {
+      Tools::convert(words[1],value);
+    }
     throw value;
   }
 
@@ -256,8 +288,7 @@ PlumedMain::PlumedMain():
 // automatically write on log in destructor
   stopwatch_fwd(log),
   actionSet_fwd(*this),
-  passtools(DataPassingTools::create(sizeof(double)))
-{
+  passtools(DataPassingTools::create(sizeof(double))) {
   passtools->usingNaturalUnits=false;
   increaseReferenceCounter();
   log.link(comm);
@@ -304,7 +335,9 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
     } else {
       int iword=-1;
       const auto it=word_map.find(words[0]);
-      if(it!=word_map.end()) iword=it->second;
+      if(it!=word_map.end()) {
+        iword=it->second;
+      }
 
       switch(iword) {
       case cmd_setBox:
@@ -346,7 +379,9 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
       case cmd_setEnergy:
         CHECK_INIT(initialized,word);
         CHECK_NOTNULL(val,word);
-        if( name_of_energy!="" ) setInputValue( name_of_energy, 0, 1,  val );
+        if( name_of_energy!="" ) {
+          setInputValue( name_of_energy, 0, 1,  val );
+        }
         break;
       case cmd_setForces:
         CHECK_INIT(initialized,word);
@@ -416,15 +451,17 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         step=val.get<long long int>();
         startStep();
         break;
-      case cmd_setValue:
-      {
-        CHECK_INIT(initialized,words[0]); plumed_assert(nw==2); setInputValue( std::string(words[1]), 0, 1, val );
+      case cmd_setValue: {
+        CHECK_INIT(initialized,words[0]);
+        plumed_assert(nw==2);
+        setInputValue( std::string(words[1]), 0, 1, val );
       }
       break;
       /* ADDED WITH API=7 */
-      case cmd_setValueForces:
-      {
-        CHECK_INIT(initialized,words[0]); plumed_assert(nw==2); setInputForce( std::string(words[1]), val );
+      case cmd_setValueForces: {
+        CHECK_INIT(initialized,words[0]);
+        plumed_assert(nw==2);
+        setInputForce( std::string(words[1]), val );
       }
       break;
       // words used less frequently:
@@ -434,7 +471,9 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         for(const auto & pp : inputs ) {
           plumed_assert(pp);
           DomainDecomposition* dd=pp->castToDomainDecomposition();
-          if( dd ) dd->setAtomsNlocal(val.get<int>());
+          if( dd ) {
+            dd->setAtomsNlocal(val.get<int>());
+          }
         }
         break;
       case cmd_setAtomsGatindex:
@@ -442,7 +481,9 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         for(const auto & pp : inputs ) {
           plumed_assert(pp);
           DomainDecomposition* dd=pp->castToDomainDecomposition();
-          if( dd ) dd->setAtomsGatindex(val,false);
+          if( dd ) {
+            dd->setAtomsGatindex(val,false);
+          }
         }
         break;
       case cmd_setAtomsFGatindex:
@@ -450,7 +491,9 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         for(const auto & pp : inputs ) {
           plumed_assert(pp);
           DomainDecomposition* dd=pp->castToDomainDecomposition();
-          if( dd ) dd->setAtomsGatindex(val,false);
+          if( dd ) {
+            dd->setAtomsGatindex(val,false);
+          }
         }
         break;
       case cmd_setAtomsContiguous:
@@ -459,7 +502,9 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         for(const auto & pp : inputs ) {
           plumed_assert(pp);
           DomainDecomposition* dd=pp->castToDomainDecomposition();
-          if( dd ) dd->setAtomsContiguous(val.get<int>());
+          if( dd ) {
+            dd->setAtomsContiguous(val.get<int>());
+          }
         }
         break;
       case cmd_createFullList:
@@ -468,18 +513,22 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         for(const auto & pp : inputs ) {
           plumed_assert(pp);
           DomainDecomposition* dd=pp->castToDomainDecomposition();
-          if( dd ) dd->createFullList(val);
+          if( dd ) {
+            dd->createFullList(val);
+          }
         }
         break;
-      case cmd_getFullList:
-      {
+      case cmd_getFullList: {
         CHECK_INIT(initialized,word);
         CHECK_NOTNULL(val,word);
         unsigned nlists=0;
         for(const auto & pp : inputs ) {
           plumed_assert(pp);
           DomainDecomposition* dd=pp->castToDomainDecomposition();
-          if( dd ) { dd->getFullList(val); nlists++; }
+          if( dd ) {
+            dd->getFullList(val);
+            nlists++;
+          }
         }
         plumed_assert( nlists==1 );
       }
@@ -489,46 +538,58 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         for(const auto & pp : inputs ) {
           plumed_assert(pp);
           DomainDecomposition* dd=pp->castToDomainDecomposition();
-          if( dd ) dd->clearFullList();
+          if( dd ) {
+            dd->clearFullList();
+          }
         }
         break;
       /* ADDED WITH API==6 */
-      case cmd_getDataRank:
-      {
-        CHECK_INIT(initialized,words[0]); plumed_assert(nw==2 || nw==3);
-        std::string vtype=""; if( nw==3 ) vtype=" TYPE="+std::string(words[2]);
+      case cmd_getDataRank: {
+        CHECK_INIT(initialized,words[0]);
+        plumed_assert(nw==2 || nw==3);
+        std::string vtype="";
+        if( nw==3 ) {
+          vtype=" TYPE="+std::string(words[2]);
+        }
         readInputLine( "grab_" + std::string(words[1]) + ": GET ARG=" + std::string(words[1]) + vtype );
         ActionToGetData* as=actionSet.selectWithLabel<ActionToGetData*>("grab_"+std::string(words[1]));
-        plumed_assert( as ); as->get_rank( val );
+        plumed_assert( as );
+        as->get_rank( val );
       }
       break;
       /* ADDED WITH API==6 */
-      case cmd_getDataShape:
-      {
+      case cmd_getDataShape: {
         CHECK_INIT(initialized,std::string(words[0]));
         ActionToGetData* as1=actionSet.selectWithLabel<ActionToGetData*>("grab_"+std::string(words[1]));
-        plumed_assert( as1 ); as1->get_shape( val );
+        plumed_assert( as1 );
+        as1->get_shape( val );
       }
       break;
       /* ADDED WITH API==6 */
-      case cmd_setMemoryForData:
-      {
-        CHECK_INIT(initialized,words[0]); plumed_assert(nw==2 || nw==3);
+      case cmd_setMemoryForData: {
+        CHECK_INIT(initialized,words[0]);
+        plumed_assert(nw==2 || nw==3);
         ActionToGetData* as2=actionSet.selectWithLabel<ActionToGetData*>("grab_"+std::string(words[1]));
-        plumed_assert( as2 ); as2->set_memory( val );
+        plumed_assert( as2 );
+        as2->set_memory( val );
       }
       break;
       /* ADDED WITH API==6 */
-      case cmd_setErrorHandler:
-      {
-        if(val) error_handler=*static_cast<const plumed_error_handler*>(val.get<const void*>());
-        else error_handler.handler=NULL;
+      case cmd_setErrorHandler: {
+        if(val) {
+          error_handler=*static_cast<const plumed_error_handler*>(val.get<const void*>());
+        } else {
+          error_handler.handler=NULL;
+        }
       }
       break;
       case cmd_read:
         CHECK_INIT(initialized,word);
-        if(val)readInputFile(val.getCString());
-        else   readInputFile("plumed.dat");
+        if(val) {
+          readInputFile(val.getCString());
+        } else {
+          readInputFile("plumed.dat");
+        }
         break;
       case cmd_readInputLine:
         CHECK_INIT(initialized,word);
@@ -540,18 +601,21 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         CHECK_NOTNULL(val,word);
         readInputLines(val.getCString());
         break;
-      case cmd_clear:
-      {
+      case cmd_clear: {
         CHECK_INIT(initialized,word);
         std::vector<int> natoms;
         for(const auto & pp : inputs ) {
           plumed_assert(pp);
           DomainDecomposition* dd=pp->castToDomainDecomposition();
-          if ( dd ) natoms.push_back( dd->getNumberOfAtoms() );
+          if ( dd ) {
+            natoms.push_back( dd->getNumberOfAtoms() );
+          }
         }
-        actionSet.clearDelete(); inputs.clear();
+        actionSet.clearDelete();
+        inputs.clear();
         for(unsigned i=0; i<natoms.size(); ++i) {
-          std::string str_natoms; Tools::convert( natoms[i], str_natoms );
+          std::string str_natoms;
+          Tools::convert( natoms[i], str_natoms );
           readInputLine( MDEngine + ": DOMAIN_DECOMPOSITION NATOMS=" + str_natoms +
                          " VALUE1=posx UNIT1=length PERIODIC1=NO CONSTANT1=False ROLE1=x" +
                          " VALUE2=posy UNIT2=length PERIODIC2=NO CONSTANT2=False ROLE2=y" +
@@ -610,14 +674,16 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         CHECK_NOTINIT(initialized,word);
         passtools->usingNaturalUnits=true;
         break;
-      case cmd_setNoVirial:
-      {
+      case cmd_setNoVirial: {
         CHECK_NOTINIT(initialized,word);
         ActionToPutData* ap=actionSet.selectWithLabel<ActionToPutData*>("Box");
-        if( ap ) ap->noforce=true;
-        else {
+        if( ap ) {
+          ap->noforce=true;
+        } else {
           ActionForInterface* af = actionSet.selectWithLabel<ActionForInterface*>(MDEngine);
-          if( af ) plumed_merror("setNoVirial should be called after number of atoms have been set");
+          if( af ) {
+            plumed_merror("setNoVirial should be called after number of atoms have been set");
+          }
         }
       }
       break;
@@ -629,33 +695,38 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
       case cmd_setMPIComm:
         CHECK_NOTINIT(initialized,word);
         comm.Set_comm(val);
-        for(const auto & pp : inputs ) pp->Set_comm(comm);
+        for(const auto & pp : inputs ) {
+          pp->Set_comm(comm);
+        }
         break;
       case cmd_setMPIFComm:
         CHECK_NOTINIT(initialized,word);
         comm.Set_fcomm(val);
-        for(const auto & pp : inputs ) pp->Set_comm(comm);
+        for(const auto & pp : inputs ) {
+          pp->Set_comm(comm);
+        }
         break;
       case cmd_setMPImultiSimComm:
         CHECK_NOTINIT(initialized,word);
         multi_sim_comm.Set_comm(val);
         break;
-      case cmd_setNatoms:
-      {
+      case cmd_setNatoms: {
         CHECK_NOTINIT(initialized,word);
         CHECK_NOTNULL(val,word);
-        int natoms = val.get<int>(); std::string str_natoms; Tools::convert( natoms, str_natoms );
+        int natoms = val.get<int>();
+        std::string str_natoms;
+        Tools::convert( natoms, str_natoms );
         ActionForInterface* dd=actionSet.selectWithLabel<ActionForInterface*>(MDEngine);
-        if( !dd && natoms>0 ) readInputLine( MDEngine + ": DOMAIN_DECOMPOSITION NATOMS=" + str_natoms +  +
-                                               " VALUE1=posx UNIT1=length PERIODIC1=NO CONSTANT1=False ROLE1=x" +
-                                               " VALUE2=posy UNIT2=length PERIODIC2=NO CONSTANT2=False ROLE2=y" +
-                                               " VALUE3=posz UNIT3=length PERIODIC3=NO CONSTANT3=False ROLE3=z" +
-                                               " VALUE4=Masses UNIT4=mass PERIODIC4=NO CONSTANT4=True ROLE4=m" +
-                                               " VALUE5=Charges UNIT5=charge PERIODIC5=NO CONSTANT5=True ROLE5=q", true );
+        if( !dd && natoms>0 )
+          readInputLine( MDEngine + ": DOMAIN_DECOMPOSITION NATOMS=" + str_natoms +  +
+                         " VALUE1=posx UNIT1=length PERIODIC1=NO CONSTANT1=False ROLE1=x" +
+                         " VALUE2=posy UNIT2=length PERIODIC2=NO CONSTANT2=False ROLE2=y" +
+                         " VALUE3=posz UNIT3=length PERIODIC3=NO CONSTANT3=False ROLE3=z" +
+                         " VALUE4=Masses UNIT4=mass PERIODIC4=NO CONSTANT4=True ROLE4=m" +
+                         " VALUE5=Charges UNIT5=charge PERIODIC5=NO CONSTANT5=True ROLE5=q", true );
       }
       break;
-      case cmd_setTimestep:
-      {
+      case cmd_setTimestep: {
         CHECK_NOTINIT(initialized,word);
         CHECK_NOTNULL(val,word);
         ActionToPutData* ts = actionSet.selectWithLabel<ActionToPutData*>("timestep");
@@ -663,7 +734,9 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
           readInputLine("timestep: PUT UNIT=time PERIODIC=NO CONSTANT", true);
           ts = actionSet.selectWithLabel<ActionToPutData*>("timestep");
         }
-        if( !ts->setValuePointer("timestep", val ) ) plumed_error();
+        if( !ts->setValuePointer("timestep", val ) ) {
+          plumed_error();
+        }
         // The following is to avoid extra digits in case the MD code uses floats
         // e.g.: float f=0.002 when converted to double becomes 0.002000000094995
         // To avoid this, we keep only up to 6 significant digits after first one
@@ -676,13 +749,14 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
       }
       break;
       /* ADDED WITH API==2 */
-      case cmd_setKbT:
-      {
+      case cmd_setKbT: {
         CHECK_NOTINIT(initialized,word);
         CHECK_NOTNULL(val,word);
         readInputLine("kBT: PUT CONSTANT PERIODIC=NO UNIT=energy", true);
         ActionToPutData* kb = actionSet.selectWithLabel<ActionToPutData*>("kBT");
-        if( !kb->setValuePointer("kBT", val ) ) plumed_error();
+        if( !kb->setValuePointer("kBT", val ) ) {
+          plumed_error();
+        }
         kb->updateUnits( passtools.get() );
       }
       break;
@@ -690,21 +764,27 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
       case cmd_setRestart:
         CHECK_NOTINIT(initialized,word);
         CHECK_NOTNULL(val,word);
-        if(val.get<int>()!=0) restart=true;
+        if(val.get<int>()!=0) {
+          restart=true;
+        }
         break;
       /* ADDED WITH API==4 */
       case cmd_doCheckPoint:
         CHECK_INIT(initialized,word);
         CHECK_NOTNULL(val,word);
         doCheckPoint = false;
-        if(val.get<int>()!=0) doCheckPoint = true;
+        if(val.get<int>()!=0) {
+          doCheckPoint = true;
+        }
         break;
       /* ADDED WITH API==6 */
       case cmd_setNumOMPthreads:
         CHECK_NOTNULL(val,word);
         {
           auto nt=val.get<unsigned>();
-          if(nt==0) nt=1;
+          if(nt==0) {
+            nt=1;
+          }
           OpenMP::setNumThreads(nt);
         }
         break;
@@ -713,7 +793,9 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         CHECK_NOTNULL(val,word);
         {
           auto id=val.get<int>();
-          if(id>=0) gpuDeviceId=id;
+          if(id>=0) {
+            gpuDeviceId=id;
+          }
         }
         break;
       /* ADDED WITH API==6 */
@@ -724,8 +806,11 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
       /* ADDED WITH API==10 */
       case cmd_setNestedExceptions:
         CHECK_NOTNULL(val,word);
-        if(val.get<int>()!=0) nestedExceptions=true;
-        else nestedExceptions=false;
+        if(val.get<int>()!=0) {
+          nestedExceptions=true;
+        } else {
+          nestedExceptions=false;
+        }
         break;
       /* STOP API */
       case cmd_setMDEngine:
@@ -773,16 +858,18 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         CHECK_INIT(initialized,word);
         runJobsAtEndOfCalculation();
         break;
-      case cmd_isEnergyNeeded:
-      {
+      case cmd_isEnergyNeeded: {
         CHECK_INIT(initialized,word);
         CHECK_NOTNULL(val,word);
         if( name_of_energy =="" ) {
           val.set(int(0));
         } else {
           ActionToPutData* ap=actionSet.selectWithLabel<ActionToPutData*>(name_of_energy);
-          if(ap->isActive()) val.set(int(1));
-          else               val.set(int(0));
+          if(ap->isActive()) {
+            val.set(int(1));
+          } else {
+            val.set(int(0));
+          }
         }
       }
       break;
@@ -796,52 +883,68 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
         plumed_assert(nw==2);
         val.set(int(actionRegister().check(dlloader.getHandles(), std::string(words[1])) ? 1:0));
         break;
-      case cmd_setExtraCV:
-      {
+      case cmd_setExtraCV: {
         CHECK_NOTNULL(val,word);
         plumed_assert(nw==2);
-        if( valueExists(std::string(words[1])) ) setInputValue( std::string(words[1]), 0, 1, val );
+        if( valueExists(std::string(words[1])) ) {
+          setInputValue( std::string(words[1]), 0, 1, val );
+        }
       }
       break;
-      case cmd_setExtraCVForce:
-      {
-        CHECK_NOTNULL(val,word); plumed_assert(nw==2);
-        if( valueExists(std::string(words[1])) ) setInputForce( std::string(words[1]), val );
+      case cmd_setExtraCVForce: {
+        CHECK_NOTNULL(val,word);
+        plumed_assert(nw==2);
+        if( valueExists(std::string(words[1])) ) {
+          setInputForce( std::string(words[1]), val );
+        }
       }
       break;
       /* ADDED WITH API==10 */
       case cmd_isExtraCVNeeded:
         CHECK_NOTNULL(val,word);
-        plumed_assert(nw==2); val.set(int(0));
+        plumed_assert(nw==2);
+        val.set(int(0));
         for(const auto & p : inputs) {
-          if( p->getLabel()==words[1] && p->isActive() ) { val.set(int(1)); break; }
+          if( p->getLabel()==words[1] && p->isActive() ) {
+            val.set(int(1));
+            break;
+          }
         }
         break;
       case cmd_GREX:
-        if(!grex) grex=Tools::make_unique<GREX>(*this);
+        if(!grex) {
+          grex=Tools::make_unique<GREX>(*this);
+        }
         plumed_massert(grex,"error allocating grex");
         {
           std::string kk=std::string(words[1]);
-          for(unsigned i=2; i<words.size(); i++) kk+=" "+std::string(words[i]);
+          for(unsigned i=2; i<words.size(); i++) {
+            kk+=" "+std::string(words[i]);
+          }
           grex->cmd(kk.c_str(),val);
         }
         break;
       case cmd_CLTool:
         CHECK_NOTINIT(initialized,word);
-        if(!cltool) cltool=Tools::make_unique<CLToolMain>();
+        if(!cltool) {
+          cltool=Tools::make_unique<CLToolMain>();
+        }
         {
           std::string kk(words[1]);
-          for(unsigned i=2; i<words.size(); i++) kk+=" "+std::string(words[i]);
+          for(unsigned i=2; i<words.size(); i++) {
+            kk+=" "+std::string(words[i]);
+          }
           cltool->cmd(kk.c_str(),val);
         }
         break;
         break;
       /* ADDED WITH API==7 */
-      case cmd_convert:
-      {
+      case cmd_convert: {
         double v;
         plumed_assert(words.size()==2);
-        if(Tools::convertNoexcept(std::string(words[1]),v)) passtools->double2MD(v,val);
+        if(Tools::convertNoexcept(std::string(words[1]),v)) {
+          passtools->double2MD(v,val);
+        }
       }
       break;
       default:
@@ -871,7 +974,9 @@ void PlumedMain::cmd(std::string_view word,const TypesafePtr & val) {
 void PlumedMain::init() {
 // check that initialization just happens once
   initialized=true;
-  if(!log.isOpen()) log.link(stdout);
+  if(!log.isOpen()) {
+    log.link(stdout);
+  }
   log<<"PLUMED is starting\n";
   log<<"Version: "<<config::getVersionLong()<<" (git: "<<config::getVersionGit()<<") "
      <<"compiled on " <<config::getCompilationDate() << " at " << config::getCompilationTime() << "\n";
@@ -891,9 +996,13 @@ void PlumedMain::init() {
   for(const auto & pp : inputs ) {
     plumed_assert(pp);
     DomainDecomposition* dd=pp->castToDomainDecomposition();
-    if ( dd ) log.printf("Number of atoms: %d\n",dd->getNumberOfAtoms());
+    if ( dd ) {
+      log.printf("Number of atoms: %d\n",dd->getNumberOfAtoms());
+    }
+  }
+  if(grex) {
+    log.printf("GROMACS-like replica exchange is on\n");
   }
-  if(grex) log.printf("GROMACS-like replica exchange is on\n");
   log.printf("File suffix: %s\n",getSuffix().c_str());
   if(plumedDat.length()>0) {
     readInputFile(plumedDat);
@@ -901,11 +1010,13 @@ void PlumedMain::init() {
   }
   setUnits( passtools->usingNaturalUnits, passtools->units );
   ActionToPutData* ts = actionSet.selectWithLabel<ActionToPutData*>("timestep");
-  if(ts) log.printf("Timestep: %f\n",(ts->copyOutput(0))->get());
+  if(ts) {
+    log.printf("Timestep: %f\n",(ts->copyOutput(0))->get());
+  }
   ActionToPutData* kb = actionSet.selectWithLabel<ActionToPutData*>("kBT");
-  if(kb)
+  if(kb) {
     log.printf("KbT: %f\n",(kb->copyOutput(0))->get());
-  else {
+  } else {
     log.printf("KbT has not been set by the MD engine\n");
     log.printf("It should be set by hand where needed\n");
   }
@@ -916,9 +1027,12 @@ void PlumedMain::init() {
 }
 
 void PlumedMain::setupInterfaceActions() {
-  inputs.clear(); std::vector<ActionForInterface*> ap=actionSet.select<ActionForInterface*>();
+  inputs.clear();
+  std::vector<ActionForInterface*> ap=actionSet.select<ActionForInterface*>();
   for(unsigned i=0; i<ap.size(); ++i) {
-    if( ap[i]->getName()=="ENERGY" || ap[i]->getDependencies().size()==0 ) inputs.push_back( ap[i] );
+    if( ap[i]->getName()=="ENERGY" || ap[i]->getDependencies().size()==0 ) {
+      inputs.push_back( ap[i] );
+    }
   }
 }
 
@@ -937,15 +1051,21 @@ void PlumedMain::readInputFile(const std::string & str) {
 
 void PlumedMain::readInputFile(IFile & ifile) {
   std::vector<std::string> words;
-  while(Tools::getParsedLine(ifile,words) && !endPlumed) readInputWords(words,false);
+  while(Tools::getParsedLine(ifile,words) && !endPlumed) {
+    readInputWords(words,false);
+  }
   endPlumed=false;
   pilots=actionSet.select<ActionPilot*>();
   setupInterfaceActions();
 }
 
 void PlumedMain::readInputLine(const std::string & str, const bool& before_init) {
-  if( !before_init ) plumed_assert(initialized);
-  if(str.empty()) return;
+  if( !before_init ) {
+    plumed_assert(initialized);
+  }
+  if(str.empty()) {
+    return;
+  }
   std::vector<std::string> words=Tools::getWords(str);
   citations.clear();
   readInputWords(words,before_init);
@@ -958,7 +1078,9 @@ void PlumedMain::readInputLine(const std::string & str, const bool& before_init)
 
 void PlumedMain::readInputLines(const std::string & str) {
   plumed_assert(initialized);
-  if(str.empty()) return;
+  if(str.empty()) {
+    return;
+  }
 
   log<<"FILE: (temporary)\n";
 
@@ -967,7 +1089,9 @@ void PlumedMain::readInputLines(const std::string & str) {
   plumed_assert(fp);
 
   // make sure file is closed (and thus deleted) also if an exception occurs
-  auto deleter=[](auto fp) { std::fclose(fp); };
+  auto deleter=[](auto fp) {
+    std::fclose(fp);
+  };
   std::unique_ptr<FILE,decltype(deleter)> fp_deleter(fp,deleter);
 
   auto ret=std::fputs(str.c_str(),fp);
@@ -985,9 +1109,12 @@ void PlumedMain::readInputLines(const std::string & str) {
 }
 
 void PlumedMain::readInputWords(const std::vector<std::string> & words, const bool& before_init) {
-  if( !before_init ) plumed_assert(initialized);
-  if(words.empty())return;
-  else if(words[0]=="_SET_SUFFIX") {
+  if( !before_init ) {
+    plumed_assert(initialized);
+  }
+  if(words.empty()) {
+    return;
+  } else if(words[0]=="_SET_SUFFIX") {
     plumed_assert(words.size()==2);
     setSuffix(words[1]);
   } else {
@@ -997,7 +1124,9 @@ void PlumedMain::readInputWords(const std::vector<std::string> & words, const bo
     if(!action) {
       std::string msg;
       msg ="ERROR\nI cannot understand line:";
-      for(unsigned i=0; i<interpreted.size(); ++i) msg+=" "+interpreted[i];
+      for(unsigned i=0; i<interpreted.size(); ++i) {
+        msg+=" "+interpreted[i];
+      }
       msg+="\nMaybe a missing space or a typo?";
       log << msg;
       log.flush();
@@ -1061,12 +1190,16 @@ void PlumedMain::prepareDependencies() {
   };
 
 // This stops the driver calculation if there is not a read action
-  if( !active && !inputsAreActive() ) stopFlag.set(int(1));
+  if( !active && !inputsAreActive() ) {
+    stopFlag.set(int(1));
+  }
 
 // also, if one of them is the total energy, tell to atoms that energy should be collected
   for(const auto & p : actionSet) {
     if(p->isActive()) {
-      if(p->checkNeedsGradients()) p->setOption("GRADIENTS");
+      if(p->checkNeedsGradients()) {
+        p->setOption("GRADIENTS");
+      }
     }
   }
 
@@ -1074,21 +1207,29 @@ void PlumedMain::prepareDependencies() {
 
 bool PlumedMain::inputsAreActive() const {
   for(const auto & ip : inputs) {
-    if( ip->onStep() ) return true;
+    if( ip->onStep() ) {
+      return true;
+    }
   }
   return false;
 }
 
 void PlumedMain::shareAll() {
-  for(const auto & ip : inputs) ip->shareAll();
+  for(const auto & ip : inputs) {
+    ip->shareAll();
+  }
 }
 
 void PlumedMain::shareData() {
 // atom positions are shared (but only if there is something to do)
-  if(!active)return;
+  if(!active) {
+    return;
+  }
 // Stopwatch is stopped when sw goes out of scope
   auto sw=stopwatch.startStop("2 Sharing data");
-  for(const auto & ip : inputs) ip->share();
+  for(const auto & ip : inputs) {
+    ip->share();
+  }
 }
 
 void PlumedMain::performCalcNoUpdate() {
@@ -1112,17 +1253,24 @@ void PlumedMain::performCalc() {
 }
 
 void PlumedMain::waitData() {
-  if(!active)return;
+  if(!active) {
+    return;
+  }
 // Stopwatch is stopped when sw goes out of scope
   auto sw=stopwatch.startStop("3 Waiting for data");
   for(const auto & ip : inputs) {
-    if( ip->isActive() && ip->hasBeenSet() ) ip->wait();
-    else if( ip->isActive() ) ip->warning("input requested but this quantity has not been set");
+    if( ip->isActive() && ip->hasBeenSet() ) {
+      ip->wait();
+    } else if( ip->isActive() ) {
+      ip->warning("input requested but this quantity has not been set");
+    }
   }
 }
 
 void PlumedMain::justCalculate() {
-  if(!active)return;
+  if(!active) {
+    return;
+  }
 // Stopwatch is stopped when sw goes out of scope
   auto sw=stopwatch.startStop("4 Calculating (forward loop)");
   bias=0.0;
@@ -1132,9 +1280,15 @@ void PlumedMain::justCalculate() {
   // depend on masses and charges
   bool firststep=false;
   for(const auto & ip : inputs) {
-    if( ip->firststep ) firststep=true;
+    if( ip->firststep ) {
+      firststep=true;
+    }
+  }
+  if( firststep ) {
+    for(const auto & ip : inputs) {
+      ip->firststep=false;
+    }
   }
-  if( firststep ) { for(const auto & ip : inputs) ip->firststep=false; }
 
   int iaction=0;
 // calculate the active actions in order (assuming *backward* dependence)
@@ -1149,22 +1303,39 @@ void PlumedMain::justCalculate() {
         if(detailedTimers) {
           auto actionNumberLabel=std::to_string(iaction);
           const unsigned m=actionSet.size();
-          unsigned k=0; unsigned n=1; while(n<m) { n*=10; k++; }
+          unsigned k=0;
+          unsigned n=1;
+          while(n<m) {
+            n*=10;
+            k++;
+          }
           auto spaces=std::string(k-actionNumberLabel.length(),' ');
           sw=stopwatch.startStop("4A " + spaces + actionNumberLabel+" "+p->getLabel());
         }
         ActionWithValue*av=p->castToActionWithValue();
         ActionAtomistic*aa=p->castToActionAtomistic();
         {
-          if(av) av->clearInputForces();
-          if(av) av->clearDerivatives();
-          if( av && av->calculateOnUpdate() ) continue ;
+          if(av) {
+            av->clearInputForces();
+          }
+          if(av) {
+            av->clearDerivatives();
+          }
+          if( av && av->calculateOnUpdate() ) {
+            continue ;
+          }
         }
         {
-          if(aa) if(aa->isActive()) aa->retrieveAtoms();
+          if(aa)
+            if(aa->isActive()) {
+              aa->retrieveAtoms();
+            }
+        }
+        if(p->checkNumericalDerivatives()) {
+          p->calculateNumericalDerivatives();
+        } else {
+          p->calculate();
         }
-        if(p->checkNumericalDerivatives()) p->calculateNumericalDerivatives();
-        else p->calculate();
         // This retrieves components called bias
         if(av) {
           bias+=av->getOutputQuantity("bias");
@@ -1172,9 +1343,13 @@ void PlumedMain::justCalculate() {
           av->setGradientsIfNeeded();
         }
         // This makes all values that depend on the (fixed) masses and charges constant
-        if( firststep ) p->setupConstantValues( true );
+        if( firststep ) {
+          p->setupConstantValues( true );
+        }
         ActionWithVirtualAtom*avv=p->castToActionWithVirtualAtom();
-        if(avv)avv->setGradientsIfNeeded();
+        if(avv) {
+          avv->setGradientsIfNeeded();
+        }
       }
     } catch(...) {
       plumed_error_nested() << "An error happened while calculating " << p->getLabel();
@@ -1190,7 +1365,9 @@ void PlumedMain::justApply() {
 }
 
 void PlumedMain::backwardPropagate() {
-  if(!active)return;
+  if(!active) {
+    return;
+  }
   int iaction=0;
 // Stopwatch is stopped when sw goes out of scope
   auto sw=stopwatch.startStop("5 Applying (backward loop)");
@@ -1205,7 +1382,12 @@ void PlumedMain::backwardPropagate() {
       if(detailedTimers) {
         auto actionNumberLabel=std::to_string(iaction);
         const unsigned m=actionSet.size();
-        unsigned k=0; unsigned n=1; while(n<m) { n*=10; k++; }
+        unsigned k=0;
+        unsigned n=1;
+        while(n<m) {
+          n*=10;
+          k++;
+        }
         auto spaces=std::string(k-actionNumberLabel.length(),' ');
         sw=stopwatch.startStop("5A " + spaces + actionNumberLabel+" "+p->getLabel());
       }
@@ -1218,11 +1400,15 @@ void PlumedMain::backwardPropagate() {
 // Stopwatch is stopped when sw goes out of scope.
 // We explicitly declare a Stopwatch::Handler here to allow for conditional initialization.
   Stopwatch::Handler sw1;
-  if(detailedTimers) sw1=stopwatch.startStop("5B Update forces");
+  if(detailedTimers) {
+    sw1=stopwatch.startStop("5B Update forces");
+  }
 }
 
 void PlumedMain::update() {
-  if(!active)return;
+  if(!active) {
+    return;
+  }
 
 // Stopwatch is stopped when sw goes out of scope
   auto sw=stopwatch.startStop("6 Update");
@@ -1233,16 +1419,27 @@ void PlumedMain::update() {
     p->beforeUpdate();
     if(p->isActive() && p->checkUpdate() && updateFlagsTop()) {
       ActionWithValue* av=dynamic_cast<ActionWithValue*>(p.get());
-      if( av && av->calculateOnUpdate() ) { p->prepare(); p->calculate(); }
-      else p->update();
+      if( av && av->calculateOnUpdate() ) {
+        p->prepare();
+        p->calculate();
+      } else {
+        p->update();
+      }
     }
   }
-  while(!updateFlags.empty()) updateFlags.pop();
-  if(!updateFlags.empty()) plumed_merror("non matching changes in the update flags");
+  while(!updateFlags.empty()) {
+    updateFlags.pop();
+  }
+  if(!updateFlags.empty()) {
+    plumed_merror("non matching changes in the update flags");
+  }
 // Check that no action has told the calculation to stop
   if(stopNow) {
-    if(stopFlag) stopFlag.set(int(1));
-    else plumed_merror("your md code cannot handle plumed stop events - add a call to plumed.comm(stopFlag,stopCondition)");
+    if(stopFlag) {
+      stopFlag.set(int(1));
+    } else {
+      plumed_merror("your md code cannot handle plumed stop events - add a call to plumed.comm(stopFlag,stopCondition)");
+    }
   }
 
 // flush by default every 10000 steps
@@ -1251,7 +1448,9 @@ void PlumedMain::update() {
   if(step%10000==0||doCheckPoint) {
     fflush();
     log.flush();
-    for(const auto & p : actionSet) p->fflush();
+    for(const auto & p : actionSet) {
+      p->fflush();
+    }
   }
 }
 
@@ -1261,10 +1460,12 @@ void PlumedMain::load(const std::string& fileName) {
     size_t n=libName.find_last_of(".");
     std::string extension="";
     std::string base=libName;
-    if(n!=std::string::npos && n<libName.length()-1)
+    if(n!=std::string::npos && n<libName.length()-1) {
       extension=libName.substr(n+1);
-    if(n!=std::string::npos && n<libName.length())
+    }
+    if(n!=std::string::npos && n<libName.length()) {
       base=libName.substr(0,n);
+    }
 
     if(extension=="cpp") {
       libName="./"+base+"."+config::getVersionLong()+"."+config::getSoExt();
@@ -1273,10 +1474,15 @@ void PlumedMain::load(const std::string& fileName) {
 // installed with a name different from "plumed"
       std::string cmd=config::getEnvCommand()+" \""+config::getPlumedRoot()+"\"/scripts/mklib.sh -n -o "+libName+" "+fileName;
 
-      if(std::getenv("PLUMED_LOAD_ACTION_DEBUG")) log<<"Executing: "<<cmd;
-      else log<<"Compiling: "<<fileName<<" to "<<libName;
+      if(std::getenv("PLUMED_LOAD_ACTION_DEBUG")) {
+        log<<"Executing: "<<cmd;
+      } else {
+        log<<"Compiling: "<<fileName<<" to "<<libName;
+      }
 
-      if(comm.Get_size()>0) log<<" (only on master node)";
+      if(comm.Get_size()>0) {
+        log<<" (only on master node)";
+      }
       log<<"\n";
 
       // On MPI process (intracomm), we use Get_rank to make sure a single process does the compilation
@@ -1289,7 +1495,9 @@ void PlumedMain::load(const std::string& fileName) {
         // It however decreases the system load if many threads are used.
         auto s=section.startStop(cmd);
         int ret=std::system(cmd.c_str());
-        if(ret!=0) plumed_error() <<"An error happened while executing command "<<cmd<<"\n";
+        if(ret!=0) {
+          plumed_error() <<"An error happened while executing command "<<cmd<<"\n";
+        }
       }
       comm.Barrier();
     } else {
@@ -1303,7 +1511,9 @@ void PlumedMain::load(const std::string& fileName) {
     log<<"Loading shared library "<<libName.c_str()<<" at "<<p<<"\n";
     log<<"Here is the list of new actions\n";
     log<<"\n";
-    for(const auto & a : actionRegister().getKeysWithDLHandle(p)) log<<a<<"\n";
+    for(const auto & a : actionRegister().getKeysWithDLHandle(p)) {
+      log<<a<<"\n";
+    }
     log<<"\n";
   } else {
     plumed_error()<<"While loading library "<< fileName << " loading was not enabled, please check if dlopen was found at configure time";
@@ -1312,7 +1522,9 @@ void PlumedMain::load(const std::string& fileName) {
 
 void PlumedMain::resetInputs() {
   for(const auto & ip : inputs) {
-    if( ip->isActive() && ip->hasBeenSet() ) ip->reset();
+    if( ip->isActive() && ip->hasBeenSet() ) {
+      ip->reset();
+    }
   }
 }
 
@@ -1330,7 +1542,9 @@ FILE* PlumedMain::fopen(const char *path, const char *mode) {
   std::string suffix(getSuffix());
   std::string ppathsuf=ppath+suffix;
   FILE*fp=std::fopen(const_cast<char*>(ppathsuf.c_str()),const_cast<char*>(mmode.c_str()));
-  if(!fp) fp=std::fopen(const_cast<char*>(ppath.c_str()),const_cast<char*>(mmode.c_str()));
+  if(!fp) {
+    fp=std::fopen(const_cast<char*>(ppath.c_str()),const_cast<char*>(mmode.c_str()));
+  }
   plumed_massert(fp,"file " + ppath + " cannot be found");
   return fp;
 }
@@ -1364,14 +1578,20 @@ void PlumedMain::stop() {
 void PlumedMain::runJobsAtEndOfCalculation() {
   for(const auto & p : actionSet) {
     ActionWithValue* av=dynamic_cast<ActionWithValue*>(p.get());
-    if( av && av->calculateOnUpdate() ) p->activate();
+    if( av && av->calculateOnUpdate() ) {
+      p->activate();
+    }
   }
   for(const auto & p : actionSet) {
     ActionPilot* ap=dynamic_cast<ActionPilot*>(p.get());
     ActionWithValue* av=dynamic_cast<ActionWithValue*>(p.get());
-    if( av && av->calculateOnUpdate() ) { p->calculate(); }
-    else if( ap && !av && ap->getStride()==0 ) { p->update(); }
-    else p->runFinalJobs();
+    if( av && av->calculateOnUpdate() ) {
+      p->calculate();
+    } else if( ap && !av && ap->getStride()==0 ) {
+      p->update();
+    } else {
+      p->runFinalJobs();
+    }
   }
 }
 
@@ -1389,7 +1609,9 @@ unsigned PlumedMain::useCountReferenceCounter() const noexcept {
 
 bool PlumedMain::valueExists( const std::string& name ) const {
   for(const auto & p : inputs) {
-    if( p->getLabel()==name ) return true;
+    if( p->getLabel()==name ) {
+      return true;
+    }
   }
   return false;
 }
@@ -1397,7 +1619,12 @@ bool PlumedMain::valueExists( const std::string& name ) const {
 void PlumedMain::setInputValue( const std::string& name, const unsigned& start, const unsigned& stride, const TypesafePtr & val ) {
   bool found=false;
   for(const auto & pp : inputs) {
-    if( pp->setValuePointer( name, val ) ) { pp->setStart(name, start); pp->setStride(name, stride); found=true; break; }
+    if( pp->setValuePointer( name, val ) ) {
+      pp->setStart(name, start);
+      pp->setStride(name, stride);
+      found=true;
+      break;
+    }
   }
   plumed_massert( found, "found no action to set named " + name );
 }
@@ -1405,28 +1632,42 @@ void PlumedMain::setInputValue( const std::string& name, const unsigned& start,
 void PlumedMain::setInputForce( const std::string& name, const TypesafePtr & val ) {
   bool found=false;
   for(const auto & pp : inputs) {
-    if( pp->setForcePointer( name, val ) ) { found=true; break; }
+    if( pp->setForcePointer( name, val ) ) {
+      found=true;
+      break;
+    }
   }
   plumed_massert( found, "found no action to set named " + name );
 }
 
 void PlumedMain::setUnits( const bool& natural, const Units& u ) {
-  passtools->usingNaturalUnits = natural; passtools->units=u;
+  passtools->usingNaturalUnits = natural;
+  passtools->units=u;
   std::vector<ActionToPutData*> idata = actionSet.select<ActionToPutData*>();
-  for(const auto & ip : idata) ip->updateUnits( passtools.get() );
-  for(const auto & p : actionSet ) p->resetStoredTimestep();
+  for(const auto & ip : idata) {
+    ip->updateUnits( passtools.get() );
+  }
+  for(const auto & p : actionSet ) {
+    p->resetStoredTimestep();
+  }
 }
 
 void PlumedMain::startStep() {
-  for(const auto & ip : inputs) ip->resetForStepStart();
+  for(const auto & ip : inputs) {
+    ip->resetForStepStart();
+  }
 }
 
 void PlumedMain::writeBinary(std::ostream&o)const {
-  for(const auto & ip : inputs) ip->writeBinary(o);
+  for(const auto & ip : inputs) {
+    ip->writeBinary(o);
+  }
 }
 
 void PlumedMain::readBinary(std::istream&i) {
-  for(const auto & ip : inputs) ip->readBinary(i);
+  for(const auto & ip : inputs) {
+    ip->readBinary(i);
+  }
 }
 
 void PlumedMain::setEnergyValue( const std::string& name ) {
@@ -1459,20 +1700,26 @@ double PlumedMain::MDQuantityToPLUMED( const std::string& unit, const TypesafePt
 }
 
 double PlumedMain::DeprecatedAtoms::getKBoltzmann() const {
-  if( plumed.usingNaturalUnits() ) return 1.0;
+  if( plumed.usingNaturalUnits() ) {
+    return 1.0;
+  }
   return kBoltzmann/plumed.getUnits().getEnergy();
 }
 
 double PlumedMain::DeprecatedAtoms::getKbT() const {
   ActionForInterface* kb=plumed.getActionSet().selectWithLabel<ActionForInterface*>("kBT");
-  if( kb ) return (kb->copyOutput(0))->get();
+  if( kb ) {
+    return (kb->copyOutput(0))->get();
+  }
   return 0.0;
 }
 
 int PlumedMain::DeprecatedAtoms::getNatoms() const {
   std::vector<ActionToPutData*> inputs=plumed.getActionSet().select<ActionToPutData*>();
   for(const auto & pp : inputs ) {
-    if( pp->getRole()=="x" ) return (pp->copyOutput(0))->getShape()[0];
+    if( pp->getRole()=="x" ) {
+      return (pp->copyOutput(0))->getShape()[0];
+    }
   }
   return 0;
 }
diff --git a/src/core/PlumedMain.h b/src/core/PlumedMain.h
index a50ba85fb7..902ecfe10e 100644
--- a/src/core/PlumedMain.h
+++ b/src/core/PlumedMain.h
@@ -79,8 +79,7 @@ which defines completely the external plumed interface.
 It does not contain any static data.
 */
 class PlumedMain:
-  public WithCmd
-{
+  public WithCmd {
 /// Pointers to files opened in actions associated to this object.
 /// Notice that with the current implementation this should be at the top of this
 /// structure. Indeed, this should be destroyed *after* all the actions allocated
@@ -430,7 +429,9 @@ class PlumedMain:
 /// Referenge to the log stream
   Log & getLog();
 /// Return the number of the step
-  long long int getStep()const {return step;}
+  long long int getStep()const {
+    return step;
+  }
 /// Stop the run
   void exit(int c=0);
 /// Load a shared library
@@ -458,7 +459,11 @@ class PlumedMain:
 /// Check if restarting
   bool getRestart()const;
 /// Set restart flag
-  void setRestart(bool f) {if(!doParseOnly) restart=f;}
+  void setRestart(bool f) {
+    if(!doParseOnly) {
+      restart=f;
+    }
+  }
 /// Check if checkpointing
   bool getCPT()const;
 /// Set exchangeStep flag
@@ -475,7 +480,9 @@ class PlumedMain:
   void resetActive(bool active);
 
 /// Access to exchange patterns
-  ExchangePatterns& getExchangePatterns() {return exchangePatterns;}
+  ExchangePatterns& getExchangePatterns() {
+    return exchangePatterns;
+  }
 
 /// Push a state to update flags
   void updateFlagsPush(bool);
@@ -606,7 +613,9 @@ bool PlumedMain::callErrorHandler(int code,const char* msg)const {
   if(error_handler.handler) {
     error_handler.handler(error_handler.ptr,code,msg);
     return true;
-  } else return false;
+  } else {
+    return false;
+  }
 }
 
 
diff --git a/src/core/PlumedMainInitializer.cpp b/src/core/PlumedMainInitializer.cpp
index 674fa0c7f8..cc854a8334 100644
--- a/src/core/PlumedMainInitializer.cpp
+++ b/src/core/PlumedMainInitializer.cpp
@@ -113,7 +113,9 @@ extern "C" {
   static void plumed_plumedmain_cmd_safe(void*plumed,const char*key,plumed_safeptr_x safe) {
     plumed_massert(plumed,"trying to use a plumed object which is not initialized");
     auto p=static_cast<PLMD::PlumedMain*>(plumed);
-    if(getenvTypesafeDebug()) typesafeDebug(key,safe);
+    if(getenvTypesafeDebug()) {
+      typesafeDebug(key,safe);
+    }
     p->cmd(key,PLMD::TypesafePtr::fromSafePtr(&safe));
   }
 }
@@ -130,70 +132,120 @@ static void translate_current(plumed_nothrow_handler_x nothrow,void**nested=null
     // cppcheck-suppress rethrowNoCurrentException
     throw;
   } catch(const PLMD::ExceptionTypeError & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,20300,msg,opt);
   } catch(const PLMD::ExceptionError & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,20200,msg,opt);
   } catch(const PLMD::ExceptionDebug & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,20100,msg,opt);
   } catch(const PLMD::Exception & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,20000,msg,opt);
   } catch(const PLMD::lepton::Exception & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,19900,msg,opt);
     // 11000 to 12000 are "bad exceptions". message will be copied without new allocations
   } catch(const std::bad_variant_access & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,11700,msg,opt);
   } catch(const std::bad_optional_access & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,11600,msg,opt);
   } catch(const std::bad_exception & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,11500,msg,opt);
   } catch(const std::bad_array_new_length & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,11410,msg,opt);
   } catch(const std::bad_alloc & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,11400,msg,opt);
   } catch(const std::bad_function_call & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,11300,msg,opt);
   } catch(const std::bad_weak_ptr & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,11200,msg,opt);
   } catch(const std::bad_any_cast & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,11150,msg,opt);
   } catch(const std::bad_cast & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,11100,msg,opt);
   } catch(const std::bad_typeid & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,11000,msg,opt);
   } catch(const std::regex_error & e) {
-    if(!msg) msg=e.what();
-    if(e.code()==std::regex_constants::error_collate) nothrow.handler(nothrow.ptr,10240,msg,opt);
-    else if(e.code()==std::regex_constants::error_ctype) nothrow.handler(nothrow.ptr,10241,msg,opt);
-    else if(e.code()==std::regex_constants::error_escape) nothrow.handler(nothrow.ptr,10242,msg,opt);
-    else if(e.code()==std::regex_constants::error_backref) nothrow.handler(nothrow.ptr,10243,msg,opt);
-    else if(e.code()==std::regex_constants::error_brack) nothrow.handler(nothrow.ptr,10244,msg,opt);
-    else if(e.code()==std::regex_constants::error_paren) nothrow.handler(nothrow.ptr,10245,msg,opt);
-    else if(e.code()==std::regex_constants::error_brace) nothrow.handler(nothrow.ptr,10246,msg,opt);
-    else if(e.code()==std::regex_constants::error_badbrace) nothrow.handler(nothrow.ptr,10247,msg,opt);
-    else if(e.code()==std::regex_constants::error_range) nothrow.handler(nothrow.ptr,10248,msg,opt);
-    else if(e.code()==std::regex_constants::error_space) nothrow.handler(nothrow.ptr,10249,msg,opt);
-    else if(e.code()==std::regex_constants::error_badrepeat) nothrow.handler(nothrow.ptr,10250,msg,opt);
-    else if(e.code()==std::regex_constants::error_complexity) nothrow.handler(nothrow.ptr,10251,msg,opt);
-    else if(e.code()==std::regex_constants::error_stack) nothrow.handler(nothrow.ptr,10252,msg,opt);
+    if(!msg) {
+      msg=e.what();
+    }
+    if(e.code()==std::regex_constants::error_collate) {
+      nothrow.handler(nothrow.ptr,10240,msg,opt);
+    } else if(e.code()==std::regex_constants::error_ctype) {
+      nothrow.handler(nothrow.ptr,10241,msg,opt);
+    } else if(e.code()==std::regex_constants::error_escape) {
+      nothrow.handler(nothrow.ptr,10242,msg,opt);
+    } else if(e.code()==std::regex_constants::error_backref) {
+      nothrow.handler(nothrow.ptr,10243,msg,opt);
+    } else if(e.code()==std::regex_constants::error_brack) {
+      nothrow.handler(nothrow.ptr,10244,msg,opt);
+    } else if(e.code()==std::regex_constants::error_paren) {
+      nothrow.handler(nothrow.ptr,10245,msg,opt);
+    } else if(e.code()==std::regex_constants::error_brace) {
+      nothrow.handler(nothrow.ptr,10246,msg,opt);
+    } else if(e.code()==std::regex_constants::error_badbrace) {
+      nothrow.handler(nothrow.ptr,10247,msg,opt);
+    } else if(e.code()==std::regex_constants::error_range) {
+      nothrow.handler(nothrow.ptr,10248,msg,opt);
+    } else if(e.code()==std::regex_constants::error_space) {
+      nothrow.handler(nothrow.ptr,10249,msg,opt);
+    } else if(e.code()==std::regex_constants::error_badrepeat) {
+      nothrow.handler(nothrow.ptr,10250,msg,opt);
+    } else if(e.code()==std::regex_constants::error_complexity) {
+      nothrow.handler(nothrow.ptr,10251,msg,opt);
+    } else if(e.code()==std::regex_constants::error_stack) {
+      nothrow.handler(nothrow.ptr,10252,msg,opt);
+    }
     // fallback to generic runtime_error
-    else nothrow.handler(nothrow.ptr,10200,msg,opt);
+    else {
+      nothrow.handler(nothrow.ptr,10200,msg,opt);
+    }
   } catch(const std::filesystem::filesystem_error & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     int value=e.code().value();
 
     opt[2]="c"; // "c" passes the error code.
@@ -204,11 +256,17 @@ static void translate_current(plumed_nothrow_handler_x nothrow,void**nested=null
     int system_category=2;
     int iostream_category=3;
     int future_category=4;
-    if(e.code().category()==std::generic_category()) opt[5]=&generic_category;
-    else if(e.code().category()==std::system_category()) opt[5]=&system_category;
-    else if(e.code().category()==std::iostream_category()) opt[5]=&iostream_category;
-    else if(e.code().category()==std::future_category()) opt[5]=&future_category;
-    else opt[5]=nullptr;
+    if(e.code().category()==std::generic_category()) {
+      opt[5]=&generic_category;
+    } else if(e.code().category()==std::system_category()) {
+      opt[5]=&system_category;
+    } else if(e.code().category()==std::iostream_category()) {
+      opt[5]=&iostream_category;
+    } else if(e.code().category()==std::future_category()) {
+      opt[5]=&future_category;
+    } else {
+      opt[5]=nullptr;
+    }
 
     // local class, just needed to propely pass path information
     // path is stored as a span of bytes.
@@ -240,74 +298,124 @@ static void translate_current(plumed_nothrow_handler_x nothrow,void**nested=null
 
     nothrow.handler(nothrow.ptr,10229,msg,opt);
   } catch(const std::ios_base::failure & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     int value=e.code().value();
     opt[2]="c"; // "c" passes the error code.
     opt[3]=&value;
-    if(e.code().category()==std::generic_category()) nothrow.handler(nothrow.ptr,10230,msg,opt);
-    else if(e.code().category()==std::system_category()) nothrow.handler(nothrow.ptr,10231,msg,opt);
-    else if(e.code().category()==std::iostream_category()) nothrow.handler(nothrow.ptr,10232,msg,opt);
-    else if(e.code().category()==std::future_category()) nothrow.handler(nothrow.ptr,10233,msg,opt);
-    else
+    if(e.code().category()==std::generic_category()) {
+      nothrow.handler(nothrow.ptr,10230,msg,opt);
+    } else if(e.code().category()==std::system_category()) {
+      nothrow.handler(nothrow.ptr,10231,msg,opt);
+    } else if(e.code().category()==std::iostream_category()) {
+      nothrow.handler(nothrow.ptr,10232,msg,opt);
+    } else if(e.code().category()==std::future_category()) {
+      nothrow.handler(nothrow.ptr,10233,msg,opt);
+    } else
       // 10239 represents std::ios_base::failure with default constructur
+    {
       nothrow.handler(nothrow.ptr,10239,msg,opt);
+    }
   } catch(const std::system_error & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     int value=e.code().value();
     opt[2]="c"; // "c" passes the error code.
     opt[3]=&value;
-    if(e.code().category()==std::generic_category()) nothrow.handler(nothrow.ptr,10220,msg,opt);
-    else if(e.code().category()==std::system_category()) nothrow.handler(nothrow.ptr,10221,msg,opt);
-    else if(e.code().category()==std::iostream_category()) nothrow.handler(nothrow.ptr,10222,msg,opt);
-    else if(e.code().category()==std::future_category()) nothrow.handler(nothrow.ptr,10223,msg,opt);
+    if(e.code().category()==std::generic_category()) {
+      nothrow.handler(nothrow.ptr,10220,msg,opt);
+    } else if(e.code().category()==std::system_category()) {
+      nothrow.handler(nothrow.ptr,10221,msg,opt);
+    } else if(e.code().category()==std::iostream_category()) {
+      nothrow.handler(nothrow.ptr,10222,msg,opt);
+    } else if(e.code().category()==std::future_category()) {
+      nothrow.handler(nothrow.ptr,10223,msg,opt);
+    }
     // fallback to generic runtime_error
-    else nothrow.handler(nothrow.ptr,10200,msg,opt);
+    else {
+      nothrow.handler(nothrow.ptr,10200,msg,opt);
+    }
   } catch(const std::underflow_error &e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,10215,msg,opt);
   } catch(const std::overflow_error &e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,10210,msg,opt);
   } catch(const std::range_error &e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,10205,msg,opt);
   } catch(const std::runtime_error & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,10200,msg,opt);
   } catch(const std::future_error & e) {
-    if(!msg) msg=e.what();
-    if(e.code()==std::make_error_code(std::future_errc::broken_promise)) nothrow.handler(nothrow.ptr,10125,msg,opt);
-    else if(e.code()==std::make_error_code(std::future_errc::future_already_retrieved)) nothrow.handler(nothrow.ptr,10126,msg,opt);
-    else if(e.code()==std::make_error_code(std::future_errc::promise_already_satisfied)) nothrow.handler(nothrow.ptr,10127,msg,opt);
-    else if(e.code()==std::make_error_code(std::future_errc::no_state)) nothrow.handler(nothrow.ptr,10128,msg,opt);
+    if(!msg) {
+      msg=e.what();
+    }
+    if(e.code()==std::make_error_code(std::future_errc::broken_promise)) {
+      nothrow.handler(nothrow.ptr,10125,msg,opt);
+    } else if(e.code()==std::make_error_code(std::future_errc::future_already_retrieved)) {
+      nothrow.handler(nothrow.ptr,10126,msg,opt);
+    } else if(e.code()==std::make_error_code(std::future_errc::promise_already_satisfied)) {
+      nothrow.handler(nothrow.ptr,10127,msg,opt);
+    } else if(e.code()==std::make_error_code(std::future_errc::no_state)) {
+      nothrow.handler(nothrow.ptr,10128,msg,opt);
+    }
     // fallback to generic logic_error
-    else nothrow.handler(nothrow.ptr,10100,msg,opt);
+    else {
+      nothrow.handler(nothrow.ptr,10100,msg,opt);
+    }
   } catch(const std::out_of_range & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,10120,msg,opt);
   } catch(const std::length_error & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,10115,msg,opt);
   } catch(const std::domain_error & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,10110,msg,opt);
   } catch(const std::invalid_argument & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,10105,msg,opt);
   } catch(const std::logic_error & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,10100,msg,opt);
     // generic exception. message will be copied without new allocations
     // reports all non caught exceptions that are derived from std::exception
     // for instance, boost exceptions would end up here
   } catch(const std::exception & e) {
-    if(!msg) msg=e.what();
+    if(!msg) {
+      msg=e.what();
+    }
     nothrow.handler(nothrow.ptr,10000,msg,opt);
   } catch(const char* m) {
-    if(!msg) msg=m;
+    if(!msg) {
+      msg=m;
+    }
     nothrow.handler(nothrow.ptr,10000,msg,opt);
   } catch(const std::string & s) {
-    if(!msg) msg=s.c_str();
+    if(!msg) {
+      msg=s.c_str();
+    }
     nothrow.handler(nothrow.ptr,10000,msg,opt);
   } catch (...) {
     // if exception cannot be translated, we add a bad_exception to the stack
@@ -357,7 +465,9 @@ extern "C" {
 // was linked against a different C++ library
     try {
       plumed_massert(plumed,"trying to use a plumed object which is not initialized");
-      if(getenvTypesafeDebug()) typesafeDebug(key,safe);
+      if(getenvTypesafeDebug()) {
+        typesafeDebug(key,safe);
+      }
       p->cmd(key,PLMD::TypesafePtr::fromSafePtr(&safe));
     } catch(...) {
       if(p->getNestedExceptions()) {
@@ -436,33 +546,41 @@ class PlumedMainInitializer {
   const bool debug;
 public:
   PlumedMainInitializer():
-    debug(std::getenv("PLUMED_LOAD_DEBUG"))
-  {
+    debug(std::getenv("PLUMED_LOAD_DEBUG")) {
 // make sure static plumed_function_pointers is initialized here
     plumed_symbol_table_init();
-    if(debug) std::fprintf(stderr,"+++ Initializing PLUMED with plumed_symbol_table version %i at %p\n",plumed_symbol_table.version,(void*)&plumed_symbol_table);
+    if(debug) {
+      std::fprintf(stderr,"+++ Initializing PLUMED with plumed_symbol_table version %i at %p\n",plumed_symbol_table.version,(void*)&plumed_symbol_table);
+    }
 #if defined(__PLUMED_HAS_DLOPEN)
     if(std::getenv("PLUMED_LOAD_SKIP_REGISTRATION")) {
-      if(debug) std::fprintf(stderr,"+++ Skipping registration +++\n");
+      if(debug) {
+        std::fprintf(stderr,"+++ Skipping registration +++\n");
+      }
       return;
     }
     typedef plumed_plumedmain_function_holder_x* (*plumed_kernel_register_type_x)(const plumed_plumedmain_function_holder_x*);
     plumed_kernel_register_type_x plumed_kernel_register=nullptr;
     void* handle=nullptr;
 #if defined(__PLUMED_HAS_RTLD_DEFAULT)
-    if(debug) std::fprintf(stderr,"+++ Registering functions. Looking in RTLD_DEFAULT +++\n");
+    if(debug) {
+      std::fprintf(stderr,"+++ Registering functions. Looking in RTLD_DEFAULT +++\n");
+    }
     void* dls=dlsym(RTLD_DEFAULT,"plumed_kernel_register");
 #else
     handle=dlopen(NULL,RTLD_LOCAL);
-    if(debug) std::fprintf(stderr,"+++ Registering functions. dlopen handle at %p +++\n",handle);
+    if(debug) {
+      std::fprintf(stderr,"+++ Registering functions. dlopen handle at %p +++\n",handle);
+    }
     void* dls=dlsym(handle,"plumed_kernel_register");
 #endif
     *(void **)(&plumed_kernel_register)=dls;
     if(debug) {
       if(plumed_kernel_register) {
         std::fprintf(stderr,"+++ plumed_kernel_register found at %p +++\n",dls);
+      } else {
+        std::fprintf(stderr,"+++ plumed_kernel_register not found +++\n");
       }
-      else std::fprintf(stderr,"+++ plumed_kernel_register not found +++\n");
     }
     void*createp;
     void*cmdp;
@@ -470,17 +588,24 @@ class PlumedMainInitializer {
     plumed_convert_fptr(createp,plumed_symbol_table.functions.create);
     plumed_convert_fptr(cmdp,plumed_symbol_table.functions.cmd);
     plumed_convert_fptr(finalizep,plumed_symbol_table.functions.finalize);
-    if(plumed_kernel_register && debug) std::fprintf(stderr,"+++ Registering functions at %p (%p,%p,%p) +++\n",
-          (void*)&plumed_symbol_table.functions,createp,cmdp,finalizep);
-    if(plumed_kernel_register) (*plumed_kernel_register)(&plumed_symbol_table.functions);
+    if(plumed_kernel_register && debug)
+      std::fprintf(stderr,"+++ Registering functions at %p (%p,%p,%p) +++\n",
+                   (void*)&plumed_symbol_table.functions,createp,cmdp,finalizep);
+    if(plumed_kernel_register) {
+      (*plumed_kernel_register)(&plumed_symbol_table.functions);
+    }
 // Notice that handle could be null in the following cases:
 // - if we use RTLD_DEFAULT
 // - on Linux if we don't use RTLD_DEFAULT, since dlopen(NULL,RTLD_LOCAL) returns a null pointer.
-    if(handle) dlclose(handle);
+    if(handle) {
+      dlclose(handle);
+    }
 #endif
   }
   ~PlumedMainInitializer() {
-    if(debug) std::fprintf(stderr,"+++ Finalizing PLUMED with plumed_symbol_table at %p\n",(void*)&plumed_symbol_table);
+    if(debug) {
+      std::fprintf(stderr,"+++ Finalizing PLUMED with plumed_symbol_table at %p\n",(void*)&plumed_symbol_table);
+    }
   }
 } PlumedMainInitializerRegisterMe;
 }
diff --git a/src/core/RegisterBase.cpp b/src/core/RegisterBase.cpp
index 00be774de6..a181ba8bbc 100644
--- a/src/core/RegisterBase.cpp
+++ b/src/core/RegisterBase.cpp
@@ -51,18 +51,18 @@ Singleton & getSingleton() {
 }
 
 Register::RegistrationLock::RegistrationLock(const std::string & fullPath):
-  active(true)
-{
+  active(true) {
   pushDLRegistration(fullPath);
 }
 
 Register::RegistrationLock::~RegistrationLock() noexcept {
-  if(active) popDLRegistration();
+  if(active) {
+    popDLRegistration();
+  }
 }
 
 Register::RegistrationLock::RegistrationLock(RegistrationLock&& other) noexcept:
-  active(other.active)
-{
+  active(other.active) {
   other.active=false;
 }
 
@@ -83,14 +83,18 @@ void Register::pushDLRegistration(const std::string & fullPath) {
 
 void Register::popDLRegistration() noexcept {
   auto & singleton=getSingleton();
-  for(auto & reg : singleton.registers) reg->clearStaged();
+  for(auto & reg : singleton.registers) {
+    reg->clearStaged();
+  }
   singleton.registeringCounter--;
   singleton.registeringMutex.unlock();
 }
 
 void Register::completeAllRegistrations(void* image) {
   auto & singleton=getSingleton();
-  for(auto & reg : singleton.registers) reg->completeRegistration(image);
+  for(auto & reg : singleton.registers) {
+    reg->completeRegistration(image);
+  }
 }
 
 std::string Register::imageToString(void* image) {
@@ -121,7 +125,9 @@ Register::~Register() noexcept {
   // this is to protect removal
   std::unique_lock lock(singleton.registeringMutex);
   auto it=std::find(singleton.registers.begin(),singleton.registers.end(),this);
-  if(it!=singleton.registers.end()) singleton.registers.erase(it);
+  if(it!=singleton.registers.end()) {
+    singleton.registers.erase(it);
+  }
 }
 
 std::vector<std::string> Register::getKeysWithDLHandle(void* image) const {
@@ -129,7 +135,9 @@ std::vector<std::string> Register::getKeysWithDLHandle(void* image) const {
   const auto prefix=imageToString(image)+":";
   for(auto & k : getKeys()) {
     if(Tools::startWith(k,prefix)) {
-      if(!std::getenv("PLUMED_LOAD_ACTION_DEBUG")) k=k.substr(prefix.length());
+      if(!std::getenv("PLUMED_LOAD_ACTION_DEBUG")) {
+        k=k.substr(prefix.length());
+      }
       res.push_back(k);
     }
   }
@@ -138,7 +146,9 @@ std::vector<std::string> Register::getKeysWithDLHandle(void* image) const {
 
 std::ostream & operator<<(std::ostream &log,const Register &reg) {
   std::vector<std::string> s(reg.getKeys());
-  for(unsigned i=0; i<s.size(); i++) log<<"  "<<s[i]<<"\n";
+  for(unsigned i=0; i<s.size(); i++) {
+    log<<"  "<<s[i]<<"\n";
+  }
   return log;
 }
 
diff --git a/src/core/RegisterBase.h b/src/core/RegisterBase.h
index d08c3e4a4c..158165db5e 100644
--- a/src/core/RegisterBase.h
+++ b/src/core/RegisterBase.h
@@ -185,10 +185,14 @@ template<class Content>
 bool RegisterBase<Content>::check(const std::vector<void*> & images,const std::string & key) const {
   // lock map for reading
   std::shared_lock<std::shared_mutex> lock(mutex);
-  if(m.count(key)>0) return true;
+  if(m.count(key)>0) {
+    return true;
+  }
   for(auto image : images) {
     std::string k=imageToString(image)+":"+key;
-    if(m.count(k)>0) return true;
+    if(m.count(k)>0) {
+      return true;
+    }
   }
   return false;
 }
@@ -206,7 +210,9 @@ const Content & RegisterBase<Content>::get(const std::vector<void*> & images,con
   std::shared_lock<std::shared_mutex> lock(mutex);
   for(auto image = images.rbegin(); image != images.rend(); ++image) {
     auto qualified_key=imageToString(*image) + ":" + key;
-    if(m.count(qualified_key)>0) return m.find(qualified_key)->second->content;
+    if(m.count(qualified_key)>0) {
+      return m.find(qualified_key)->second->content;
+    }
   }
   plumed_assert(m.count(key)>0);
   return m.find(key)->second->content;
@@ -218,7 +224,9 @@ const std::string & RegisterBase<Content>::getFullPath(const std::vector<void*>
   std::shared_lock<std::shared_mutex> lock(mutex);
   for(auto image = images.rbegin(); image != images.rend(); ++image) {
     auto qualified_key=imageToString(*image) + ":" + key;
-    if(m.count(qualified_key)>0) return m.find(qualified_key)->second->fullPath;
+    if(m.count(qualified_key)>0) {
+      return m.find(qualified_key)->second->fullPath;
+    }
   }
   plumed_assert(m.count(key)>0);
   return m.find(key)->second->fullPath;
@@ -239,7 +247,8 @@ void RegisterBase<Content>::remove(ID id) {
   if(id.ptr) {
     for(auto p=m.begin(); p!=m.end(); ++p) {
       if(p->second.get()==id.ptr) {
-        m.erase(p); break;
+        m.erase(p);
+        break;
       }
     }
   }
@@ -250,7 +259,9 @@ std::vector<std::string> RegisterBase<Content>::getKeys() const {
   // lock map for reading
   std::shared_lock<std::shared_mutex> lock(mutex);
   std::vector<std::string> s;
-  for(const auto & it : m) s.push_back(it.first);
+  for(const auto & it : m) {
+    s.push_back(it.first);
+  }
   std::sort(s.begin(),s.end());
   return s;
 }
@@ -259,7 +270,9 @@ template<class Content>
 RegisterBase<Content>::~RegisterBase() noexcept {
   if(m.size()>0) {
     std::string names="";
-    for(const auto & p : m) names+=p.first+" ";
+    for(const auto & p : m) {
+      names+=p.first+" ";
+    }
     std::cerr<<"WARNING: Directive "+ names +" has not been properly unregistered. This might lead to memory leak!!\n";
   }
 }
diff --git a/src/core/TargetDist.cpp b/src/core/TargetDist.cpp
index 40cd2c3828..3f76b16fcc 100644
--- a/src/core/TargetDist.cpp
+++ b/src/core/TargetDist.cpp
@@ -50,9 +50,14 @@ void TargetDist::read( const PDB& pdb, const std::vector<Value*> & ar ) {
 void TargetDist::read( const std::vector<double>& targ, const std::vector<Value*> & ar ) {
   plumed_assert( targ.size()==ar.size() );
 
-  target.resize( ar.size() ); args.resize( ar.size() );
+  target.resize( ar.size() );
+  args.resize( ar.size() );
   log.printf("  distance from this point in cv space : ");
-  for(unsigned i=0; i<target.size(); ++i) { log.printf("%f ", targ[i]); target[i]=targ[i]; args[i]=ar[i]; }
+  for(unsigned i=0; i<target.size(); ++i) {
+    log.printf("%f ", targ[i]);
+    target[i]=targ[i];
+    args[i]=ar[i];
+  }
   log.printf("\n");
 }
 
@@ -61,10 +66,13 @@ double TargetDist::calculate( std::vector<double>& derivs ) {
   double dist=0;
   for(unsigned i=0; i<args.size(); ++i) {
     double tmp=args[i]->difference( target[i], args[i]->get() );
-    derivs[i]=tmp; dist+=tmp*tmp;
+    derivs[i]=tmp;
+    dist+=tmp*tmp;
   }
   dist=std::sqrt(dist);
-  for(unsigned i=0; i<args.size(); ++i) derivs[i]/=dist;
+  for(unsigned i=0; i<args.size(); ++i) {
+    derivs[i]/=dist;
+  }
   return dist;
 }
 
diff --git a/src/core/Value.cpp b/src/core/Value.cpp
index 6f4466bc3f..3637db4fa5 100644
--- a/src/core/Value.cpp
+++ b/src/core/Value.cpp
@@ -51,9 +51,9 @@ Value::Value():
   max(0.0),
   max_minus_min(0.0),
   inv_max_minus_min(0.0),
-  derivativeIsZeroWhenValueIsZero(false)
-{
-  data.resize(1); inputForce.resize(1);
+  derivativeIsZeroWhenValueIsZero(false) {
+  data.resize(1);
+  inputForce.resize(1);
 }
 
 Value::Value(const std::string& name):
@@ -76,9 +76,9 @@ Value::Value(const std::string& name):
   max(0.0),
   max_minus_min(0.0),
   inv_max_minus_min(0.0),
-  derivativeIsZeroWhenValueIsZero(false)
-{
-  data.resize(1); inputForce.resize(1);
+  derivativeIsZeroWhenValueIsZero(false) {
+  data.resize(1);
+  inputForce.resize(1);
   data[0]=inputForce[0]=0;
 }
 
@@ -101,40 +101,60 @@ Value::Value(ActionWithValue* av, const std::string& name, const bool withderiv,
   max(0.0),
   max_minus_min(0.0),
   inv_max_minus_min(0.0),
-  derivativeIsZeroWhenValueIsZero(false)
-{
+  derivativeIsZeroWhenValueIsZero(false) {
   if( action ) {
-    if( action->getName()=="ACCUMULATE" || action->getName()=="COLLECT" ) valtype=average;
+    if( action->getName()=="ACCUMULATE" || action->getName()=="COLLECT" ) {
+      valtype=average;
+    }
+  }
+  if( action ) {
+    storedata=action->getName()=="PUT" || valtype==average;
+  }
+  if( ss.size() && withderiv ) {
+    storedata=true;
   }
-  if( action ) storedata=action->getName()=="PUT" || valtype==average;
-  if( ss.size() && withderiv ) storedata=true;
   setShape( ss );
 }
 
 void Value::setValType( const std::string& vtype ) {
-  if( vtype=="normal" ) valtype=normal;
-  else if( vtype=="constant" ) valtype=constant;
-  else if( vtype=="average" ) valtype=average;
-  else if( vtype=="calcFromAverage" ) valtype=calcFromAverage;
-  else plumed_merror("invalid valtype " + vtype );
+  if( vtype=="normal" ) {
+    valtype=normal;
+  } else if( vtype=="constant" ) {
+    valtype=constant;
+  } else if( vtype=="average" ) {
+    valtype=average;
+  } else if( vtype=="calcFromAverage" ) {
+    valtype=calcFromAverage;
+  } else {
+    plumed_merror("invalid valtype " + vtype );
+  }
 }
 
 void Value::setShape( const std::vector<unsigned>&ss ) {
-  std::size_t tot=1; shape.resize( ss.size() );
-  for(unsigned i=0; i<shape.size(); ++i) { tot = tot*ss[i]; shape[i]=ss[i]; }
+  std::size_t tot=1;
+  shape.resize( ss.size() );
+  for(unsigned i=0; i<shape.size(); ++i) {
+    tot = tot*ss[i];
+    shape[i]=ss[i];
+  }
 
   if( shape.size()>0 && hasDeriv ) {
     // This is for grids
     ngrid_der = shape.size();
-    if( action ) ngrid_der = action->getNumberOfDerivatives();
+    if( action ) {
+      ngrid_der = action->getNumberOfDerivatives();
+    }
     std::size_t ndata = tot*(1+ngrid_der);
-    data.resize( ndata ); inputForce.resize( tot );
+    data.resize( ndata );
+    inputForce.resize( tot );
   } else if( shape.size()==0 ) {
     // This is for scalars
-    data.resize(1); inputForce.resize(1);
+    data.resize(1);
+    inputForce.resize(1);
   } else if( storedata && shape.size()<2 ) {
     // This is for vectors (matrices have special version because we have sparse storage)
-    data.resize( tot ); inputForce.resize( tot );
+    data.resize( tot );
+    inputForce.resize( tot );
   }
 }
 
@@ -155,22 +175,32 @@ bool Value::isPeriodic()const {
 }
 
 bool Value::applyForce(std::vector<double>& forces ) const {
-  if( !hasForce || valtype!=normal ) return false;
+  if( !hasForce || valtype!=normal ) {
+    return false;
+  }
   plumed_dbg_massert( data.size()-1==forces.size()," forces array has wrong size" );
   const unsigned N=data.size()-1;
-  for(unsigned i=0; i<N; ++i) forces[i]=inputForce[0]*data[1+i];
+  for(unsigned i=0; i<N; ++i) {
+    forces[i]=inputForce[0]*data[1+i];
+  }
   return true;
 }
 
 void Value::setNotPeriodic() {
-  min=0; max=0; periodicity=notperiodic;
+  min=0;
+  max=0;
+  periodicity=notperiodic;
 }
 
 void Value::setDomain(const std::string& pmin,const std::string& pmax) {
   str_min=pmin;
-  if( !Tools::convertNoexcept(str_min,min) ) action->error("could not convert period string " + str_min + " to real");
+  if( !Tools::convertNoexcept(str_min,min) ) {
+    action->error("could not convert period string " + str_min + " to real");
+  }
   str_max=pmax;
-  if( !Tools::convertNoexcept(str_max,max) ) action->error("could not convert period string " + str_max + " to read");
+  if( !Tools::convertNoexcept(str_max,max) ) {
+    action->error("could not convert period string " + str_max + " to read");
+  }
   setupPeriodicity();
 }
 
@@ -188,7 +218,9 @@ void Value::getDomain(double&minout,double&maxout) const {
 
 void Value::setGradients( ActionAtomistic* aa, unsigned& start ) {
   // Can't do gradients if we don't have derivatives
-  if( !hasDeriv ) return;
+  if( !hasDeriv ) {
+    return;
+  }
   plumed_assert( shape.size()==0 );
   for(unsigned j=0; j<aa->getNumberOfAtoms(); ++j) {
     Vector der(data[1+start+3*j],data[1+start+3*j+1],data[1+start+3*j+2]);
@@ -198,7 +230,10 @@ void Value::setGradients( ActionAtomistic* aa, unsigned& start ) {
 }
 
 void Value::passGradients( const double& der, std::map<AtomNumber,Vector>& g ) const {
-  for(const auto & p : gradients) { AtomNumber iatom=p.first; g[iatom] += p.second*der; }
+  for(const auto & p : gradients) {
+    AtomNumber iatom=p.first;
+    g[iatom] += p.second*der;
+  }
 }
 
 double Value::projection(const Value& v1,const Value&v2) {
@@ -222,15 +257,24 @@ ActionWithValue* Value::getPntrToAction() {
 
 void Value::set(const std::size_t& n, const double& v ) {
   value_set=true;
-  if( getRank()==0 ) { plumed_assert( n==0 ); data[n]=v; applyPeriodicity(n); }
-  else if( !hasDeriv ) { plumed_dbg_massert( n<data.size(), "failing in " + getName() ); data[n]=v; applyPeriodicity(n); }
-  else { data[n*(1+ngrid_der)] = v; }
+  if( getRank()==0 ) {
+    plumed_assert( n==0 );
+    data[n]=v;
+    applyPeriodicity(n);
+  } else if( !hasDeriv ) {
+    plumed_dbg_massert( n<data.size(), "failing in " + getName() );
+    data[n]=v;
+    applyPeriodicity(n);
+  } else {
+    data[n*(1+ngrid_der)] = v;
+  }
 }
 
 void Value::push_back( const double& v ) {
   value_set=true;
   if( shape.size()==1 ) {
-    data.push_back(v); shape[0]++;
+    data.push_back(v);
+    shape[0]++;
   } else if( shape.size()==2 ) {
     data.push_back(v);
     shape[0] = std::ceil( data.size() / shape[1] );
@@ -241,7 +285,9 @@ std::size_t Value::getIndexInStore( const std::size_t& ival ) const {
   if( shape.size()==2 && ncols<shape[1] ) {
     unsigned irow = std::floor( ival / shape[1] ), jcol = ival%shape[1];
     for(unsigned i=0; i<getRowLength(irow); ++i) {
-      if( getRowIndex(irow,i)==jcol ) return irow*ncols+i;
+      if( getRowIndex(irow,i)==jcol ) {
+        return irow*ncols+i;
+      }
     }
     plumed_merror("cannot get store index");
   }
@@ -249,20 +295,28 @@ std::size_t Value::getIndexInStore( const std::size_t& ival ) const {
 }
 
 double Value::get(const std::size_t& ival, const bool trueind) const {
-  if( hasDeriv ) return data[ival*(1+ngrid_der)];
+  if( hasDeriv ) {
+    return data[ival*(1+ngrid_der)];
+  }
 #ifdef DNDEBUG
-  if( action ) plumed_dbg_massert( ival<getNumberOfValues(), "could not get value from " + name );
+  if( action ) {
+    plumed_dbg_massert( ival<getNumberOfValues(), "could not get value from " + name );
+  }
 #endif
   if( shape.size()==2 && ncols<shape[1] && trueind ) {
     unsigned irow = std::floor( ival / shape[1] ), jcol = ival%shape[1];
     // This is a special treatment for the lower triangular matrices that are used when
     // we do ITRE with COLLECT_FRAMES
     if( ncols==0 ) {
-      if( jcol<=irow ) return data[0.5*irow*(irow+1) + jcol];
+      if( jcol<=irow ) {
+        return data[0.5*irow*(irow+1) + jcol];
+      }
       return 0;
     }
     for(unsigned i=0; i<getRowLength(irow); ++i) {
-      if( getRowIndex(irow,i)==jcol ) return data[irow*ncols+i];
+      if( getRowIndex(irow,i)==jcol ) {
+        return data[irow*ncols+i];
+      }
     }
     return 0.0;
   }
@@ -275,9 +329,13 @@ void Value::addForce(const std::size_t& iforce, double f, const bool trueind) {
   if( shape.size()==2 && !hasDeriv && ncols<shape[1] && trueind ) {
     unsigned irow = std::floor( iforce / shape[0] ), jcol = iforce%shape[0];
     for(unsigned i=0; i<getRowLength(irow); ++i) {
-      if( getRowIndex(irow,i)==jcol ) { inputForce[irow*ncols+i]+=f; return; }
+      if( getRowIndex(irow,i)==jcol ) {
+        inputForce[irow*ncols+i]+=f;
+        return;
+      }
     }
-    plumed_assert( fabs(f)<epsilon ); return;
+    plumed_assert( fabs(f)<epsilon );
+    return;
   }
   plumed_massert( iforce<inputForce.size(), "can't add force to " + name );
   inputForce[iforce]+=f;
@@ -285,29 +343,46 @@ void Value::addForce(const std::size_t& iforce, double f, const bool trueind) {
 
 
 void Value::buildDataStore( const bool forprint ) {
-  if( getRank()==0 ) return;
-  storedata=true; setShape( shape );
-  if( !forprint ) return ;
+  if( getRank()==0 ) {
+    return;
+  }
+  storedata=true;
+  setShape( shape );
+  if( !forprint ) {
+    return ;
+  }
   ActionWithVector* av=dynamic_cast<ActionWithVector*>( action );
-  if( av ) (av->getFirstActionInChain())->never_reduce_tasks=true;
+  if( av ) {
+    (av->getFirstActionInChain())->never_reduce_tasks=true;
+  }
 }
 
 void Value::reshapeMatrixStore( const unsigned& n ) {
   plumed_dbg_assert( shape.size()==2 && !hasDeriv );
-  if( !storedata ) return ;
-  ncols=n; if( ncols>shape[1] ) ncols=shape[1];
+  if( !storedata ) {
+    return ;
+  }
+  ncols=n;
+  if( ncols>shape[1] ) {
+    ncols=shape[1];
+  }
   unsigned size=shape[0]*ncols;
   if( matrix_bookeeping.size()!=(size+shape[0]) ) {
-    data.resize( size ); inputForce.resize( size );
+    data.resize( size );
+    inputForce.resize( size );
     matrix_bookeeping.resize( size + shape[0], 0 );
     if( ncols>=shape[1] ) {
       for(unsigned i=0; i<shape[0]; ++i) {
         matrix_bookeeping[(1+ncols)*i] = shape[1];
-        for(unsigned j=0; j<shape[1]; ++j) matrix_bookeeping[(1+ncols)*i+1+j]=j;
+        for(unsigned j=0; j<shape[1]; ++j) {
+          matrix_bookeeping[(1+ncols)*i+1+j]=j;
+        }
       }
     }
   }
-  if( ncols<shape[1] ) std::fill(matrix_bookeeping.begin(), matrix_bookeeping.end(), 0);
+  if( ncols<shape[1] ) {
+    std::fill(matrix_bookeeping.begin(), matrix_bookeeping.end(), 0);
+  }
 }
 
 void Value::setPositionInMatrixStash( const unsigned& p ) {
@@ -316,15 +391,23 @@ void Value::setPositionInMatrixStash( const unsigned& p ) {
 }
 
 bool Value::ignoreStoredValue(const std::string& c) const {
-  if( !storedata && shape.size()>0 ) return true;
+  if( !storedata && shape.size()>0 ) {
+    return true;
+  }
   ActionWithVector* av=dynamic_cast<ActionWithVector*>(action);
-  if( av ) return (av->getFirstActionInChain())->getLabel()==c;
+  if( av ) {
+    return (av->getFirstActionInChain())->getLabel()==c;
+  }
   return false;
 }
 
 void Value::setConstant() {
-  valtype=constant; storedata=true; setShape( shape );
-  if( getRank()==2 && !hasDeriv ) reshapeMatrixStore( shape[1] );
+  valtype=constant;
+  storedata=true;
+  setShape( shape );
+  if( getRank()==2 && !hasDeriv ) {
+    reshapeMatrixStore( shape[1] );
+  }
 }
 
 void Value::writeBinary(std::ostream&o) const {
@@ -333,22 +416,34 @@ void Value::writeBinary(std::ostream&o) const {
 
 void Value::setSymmetric( const bool& sym ) {
   plumed_assert( shape.size()==2 && !hasDeriv );
-  if( sym && shape[0]!=shape[1] ) plumed_merror("non-square matrix cannot be symmetric");
+  if( sym && shape[0]!=shape[1] ) {
+    plumed_merror("non-square matrix cannot be symmetric");
+  }
   symmetric=sym;
 }
 
 void Value::retrieveEdgeList( unsigned& nedge, std::vector<std::pair<unsigned,unsigned> >& active, std::vector<double>& elems ) {
-  nedge=0; plumed_dbg_assert( shape.size()==2 && !hasDeriv );
+  nedge=0;
+  plumed_dbg_assert( shape.size()==2 && !hasDeriv );
   // Check we have enough space to store the edge list
-  if( elems.size()<shape[0]*ncols ) { elems.resize( shape[0]*ncols ); active.resize( shape[0]*ncols ); }
+  if( elems.size()<shape[0]*ncols ) {
+    elems.resize( shape[0]*ncols );
+    active.resize( shape[0]*ncols );
+  }
 
   for(unsigned i=0; i<shape[0]; ++i) {
     unsigned ncol = getRowLength(i);
     for(unsigned j=0; j<ncol; ++j) {
-      if( fabs(get(i*ncols+j,false))<epsilon ) continue;
-      if( symmetric && getRowIndex(i,j)>i ) continue;
-      active[nedge].first = i; active[nedge].second = getRowIndex(i,j);
-      elems[nedge] = get(i*ncols+j,false); nedge++;
+      if( fabs(get(i*ncols+j,false))<epsilon ) {
+        continue;
+      }
+      if( symmetric && getRowIndex(i,j)>i ) {
+        continue;
+      }
+      active[nedge].first = i;
+      active[nedge].second = getRowIndex(i,j);
+      elems[nedge] = get(i*ncols+j,false);
+      nedge++;
     }
   }
 }
@@ -359,26 +454,37 @@ void Value::readBinary(std::istream&i) {
 
 void Value::convertIndexToindices(const std::size_t& index, std::vector<unsigned>& indices ) const {
   if( hasDeriv || getRank()==1 ) {
-    std::size_t kk=index; indices[0]=index%shape[0];
+    std::size_t kk=index;
+    indices[0]=index%shape[0];
     for(unsigned i=1; i<shape.size()-1; ++i) {
       kk=(kk-indices[i-1])/shape[i-1];
       indices[i]=kk%shape[i];
     }
-    if(shape.size()>=2) indices[shape.size()-1]=(kk-indices[shape.size()-2])/shape[shape.size()-2];
+    if(shape.size()>=2) {
+      indices[shape.size()-1]=(kk-indices[shape.size()-2])/shape[shape.size()-2];
+    }
   } else if( getRank()==2 ) {
-    indices[0]=std::floor( index/shape[1] ); indices[1] = index%shape[1];
+    indices[0]=std::floor( index/shape[1] );
+    indices[1] = index%shape[1];
   }
 }
 
 void Value::print( OFile& ofile ) const {
-  if( isPeriodic() ) { ofile.printField( "min_" + name, str_min ); ofile.printField("max_" + name, str_max ); }
+  if( isPeriodic() ) {
+    ofile.printField( "min_" + name, str_min );
+    ofile.printField("max_" + name, str_max );
+  }
   if( shape.size()==0 || getNumberOfValues()==1 ) {
     ofile.printField( name, get(0) );
   } else {
     std::vector<unsigned> indices( shape.size() );
     for(unsigned i=0; i<getNumberOfValues(); ++i) {
-      convertIndexToindices( i, indices ); std::string num, fname = name;
-      for(unsigned i=0; i<shape.size(); ++i) { Tools::convert( indices[i]+1, num ); fname += "." + num; }
+      convertIndexToindices( i, indices );
+      std::string num, fname = name;
+      for(unsigned i=0; i<shape.size(); ++i) {
+        Tools::convert( indices[i]+1, num );
+        fname += "." + num;
+      }
       ofile.printField( fname, get(i) );
     }
   }
@@ -393,10 +499,18 @@ bool Value::calculateOnUpdate() const {
 }
 
 std::string Value::getValueType() const {
-  if( getRank()==0 ) return "scalar";
-  if( getRank()>0 && hasDerivatives() ) return "grid";
-  if( getRank()==1 ) return "vector";
-  if( getRank()==2 ) return "matrix";
+  if( getRank()==0 ) {
+    return "scalar";
+  }
+  if( getRank()>0 && hasDerivatives() ) {
+    return "grid";
+  }
+  if( getRank()==1 ) {
+    return "vector";
+  }
+  if( getRank()==2 ) {
+    return "matrix";
+  }
   plumed_merror("unknown type for value " + getName() );
   return "";
 }
diff --git a/src/core/Value.h b/src/core/Value.h
index 20cbfeeee6..07448e973b 100644
--- a/src/core/Value.h
+++ b/src/core/Value.h
@@ -254,7 +254,9 @@ inline
 void Value::applyPeriodicity(const unsigned& ival) {
   if(periodicity==periodic) {
     data[ival]=min+difference(min,data[ival]);
-    if(data[ival]<min)data[ival]+=max_minus_min;
+    if(data[ival]<min) {
+      data[ival]+=max_minus_min;
+    }
   }
 }
 
@@ -274,7 +276,9 @@ void Value::add(double v) {
 
 inline
 void Value::add(const std::size_t& n, const double& v ) {
-  value_set=true; data[n]+=v; applyPeriodicity(n);
+  value_set=true;
+  data[n]+=v;
+  applyPeriodicity(n);
 }
 
 inline
@@ -290,7 +294,9 @@ const std::string& Value::getName()const {
 inline
 unsigned Value::getNumberOfDerivatives() const {
   plumed_massert(hasDeriv,"the derivatives array for this value has zero size");
-  if( shape.size()>0 ) return shape.size();
+  if( shape.size()>0 ) {
+    return shape.size();
+  }
   return data.size() - 1;
 }
 
@@ -307,8 +313,12 @@ bool Value::hasDerivatives() const {
 
 inline
 void Value::resizeDerivatives(int n) {
-  if( shape.size()>0 ) return;
-  if(hasDeriv) data.resize(1+n);
+  if( shape.size()>0 ) {
+    return;
+  }
+  if(hasDeriv) {
+    data.resize(1+n);
+  }
 }
 
 inline
@@ -325,22 +335,34 @@ void Value::setDerivative(unsigned i, double d) {
 
 inline
 void Value::clearInputForce() {
-  if( !hasForce ) return;
-  hasForce=false; std::fill(inputForce.begin(),inputForce.end(),0);
+  if( !hasForce ) {
+    return;
+  }
+  hasForce=false;
+  std::fill(inputForce.begin(),inputForce.end(),0);
 }
 
 inline
 void Value::clearInputForce( const std::vector<AtomNumber>& index ) {
-  if( !hasForce ) return;
-  hasForce=false; for(const auto & p : index) inputForce[p.index()]=0;
+  if( !hasForce ) {
+    return;
+  }
+  hasForce=false;
+  for(const auto & p : index) {
+    inputForce[p.index()]=0;
+  }
 }
 
 inline
 void Value::clearDerivatives( const bool force ) {
-  if( !force && (valtype==constant || valtype==average) ) return;
+  if( !force && (valtype==constant || valtype==average) ) {
+    return;
+  }
 
   value_set=false;
-  if( data.size()>1 ) std::fill(data.begin()+1, data.end(), 0);
+  if( data.size()>1 ) {
+    std::fill(data.begin()+1, data.end(), 0);
+  }
 }
 
 inline
@@ -370,7 +392,9 @@ double Value::difference(double d1,double d2)const {
     // remember: pbc brings the difference in a range of -0.5:0.5
     s=Tools::pbc(s);
     return s*max_minus_min;
-  } else plumed_merror("periodicity should be set to compute differences");
+  } else {
+    plumed_merror("periodicity should be set to compute differences");
+  }
 }
 
 inline
@@ -401,13 +425,18 @@ const std::vector<unsigned>& Value::getShape() const {
 
 inline
 unsigned Value::getNumberOfValues() const {
-  unsigned size=1; for(unsigned i=0; i<shape.size(); ++i) size *= shape[i];
+  unsigned size=1;
+  for(unsigned i=0; i<shape.size(); ++i) {
+    size *= shape[i];
+  }
   return size;
 }
 
 inline
 unsigned Value::getNumberOfStoredValues() const {
-  if( getRank()==2 && !hasDeriv ) return shape[0]*ncols;
+  if( getRank()==2 && !hasDeriv ) {
+    return shape[0]*ncols;
+  }
   return getNumberOfValues();
 }
 
diff --git a/src/core/WithCmd.h b/src/core/WithCmd.h
index 49af18604a..31d8873f75 100644
--- a/src/core/WithCmd.h
+++ b/src/core/WithCmd.h
@@ -59,7 +59,9 @@ class WithCmd {
     cmd(key,TypesafePtr::setNelemAndShape(val,0,shape));
   }
   void cmd(std::string_view key,const TypesafePtr & val,std::initializer_list<SizeLike> shape) {
-    if(shape.size()>4) plumed_error() << "Maximum shape size is 4";
+    if(shape.size()>4) {
+      plumed_error() << "Maximum shape size is 4";
+    }
     std::array<std::size_t,5> shape_;
     unsigned j=0;
     for(auto i : shape) {
diff --git a/src/crystdistrib/BopsShortcut.cpp b/src/crystdistrib/BopsShortcut.cpp
index f06ecc1e4c..7b7dfe1c5b 100644
--- a/src/crystdistrib/BopsShortcut.cpp
+++ b/src/crystdistrib/BopsShortcut.cpp
@@ -64,39 +64,61 @@ void BopsShortcut::registerKeywords( Keywords& keys ) {
   keys.add("compulsory", "CUTOFF", "cutoff for the distance matrix");
 //  keys.add("compulsory","SWITCH","the switching function that acts on the distances between points)");
   keys.setValueDescription("the values of the bops order parameters");
-  keys.needsAction("DISTANCE_MATRIX"); keys.needsAction("QUATERNION_BOND_PRODUCT_MATRIX"); keys.needsAction("CUSTOM");
-  keys.needsAction("ONES"); keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("DISTANCE_MATRIX");
+  keys.needsAction("QUATERNION_BOND_PRODUCT_MATRIX");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("ONES");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
 }
 
 BopsShortcut::BopsShortcut(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Open a file and read in the kernels
-  double h_dops,h_bops; std::string kfunc, kfunc_dops,kfunc_bops,fname_dops,fname_bops;
-  parse("KERNELFILE_DOPS",fname_dops); parse("KERNELFILE_BOPS",fname_bops); IFile ifile_dops, ifile_bops; ifile_dops.open(fname_dops); ifile_bops.open(fname_bops);
+  double h_dops,h_bops;
+  std::string kfunc, kfunc_dops,kfunc_bops,fname_dops,fname_bops;
+  parse("KERNELFILE_DOPS",fname_dops);
+  parse("KERNELFILE_BOPS",fname_bops);
+  IFile ifile_dops, ifile_bops;
+  ifile_dops.open(fname_dops);
+  ifile_bops.open(fname_bops);
   for(unsigned k=0;; ++k) {
-    if( !ifile_dops.scanField("height",h_dops) || !ifile_bops.scanField("height",h_bops) ) break;//checks eof
-    std::string ktype_dops, ktype_bops;  ifile_dops.scanField("kerneltype",ktype_dops); ifile_bops.scanField("kerneltype",ktype_bops);
-    if( ktype_dops!="gaussian" ) error("cannot process kernels of type " + ktype_dops );//straightup error
-    if( ktype_bops!="gaussian" ) error("cannot process kernels of type " + ktype_bops );
-
-    double mu_dops, mu_i, mu_j, mu_k; std::string hstr_dops, hstr_bops, smu_dops,smu_i, smu_j, smu_k, sigmastr,kappastr;
+    if( !ifile_dops.scanField("height",h_dops) || !ifile_bops.scanField("height",h_bops) ) {
+      break;  //checks eof
+    }
+    std::string ktype_dops, ktype_bops;
+    ifile_dops.scanField("kerneltype",ktype_dops);
+    ifile_bops.scanField("kerneltype",ktype_bops);
+    if( ktype_dops!="gaussian" ) {
+      error("cannot process kernels of type " + ktype_dops );  //straightup error
+    }
+    if( ktype_bops!="gaussian" ) {
+      error("cannot process kernels of type " + ktype_bops );
+    }
+
+    double mu_dops, mu_i, mu_j, mu_k;
+    std::string hstr_dops, hstr_bops, smu_dops,smu_i, smu_j, smu_k, sigmastr,kappastr;
 
 
     Tools::convert( h_dops, hstr_dops );
     Tools::convert( h_bops, hstr_bops );
 
-    ifile_dops.scanField("mu",mu_dops); Tools::convert( mu_dops, smu_dops );
+    ifile_dops.scanField("mu",mu_dops);
+    Tools::convert( mu_dops, smu_dops );
     //ifile_bops.scanField("mu_w",mu_w); Tools::convert( mu_w, smu_w );
-    ifile_bops.scanField("mu_i",mu_i); Tools::convert( mu_i, smu_i );
-    ifile_bops.scanField("mu_j",mu_j); Tools::convert( mu_j, smu_j );
-    ifile_bops.scanField("mu_k",mu_k); Tools::convert( mu_k, smu_k );
+    ifile_bops.scanField("mu_i",mu_i);
+    Tools::convert( mu_i, smu_i );
+    ifile_bops.scanField("mu_j",mu_j);
+    Tools::convert( mu_j, smu_j );
+    ifile_bops.scanField("mu_k",mu_k);
+    Tools::convert( mu_k, smu_k );
 
 
     double sigma,kappa;
-    ifile_dops.scanField("sigma",sigma); Tools::convert( sigma, sigmastr );
-    ifile_bops.scanField("kappa",kappa); Tools::convert( kappa, kappastr );
+    ifile_dops.scanField("sigma",sigma);
+    Tools::convert( sigma, sigmastr );
+    ifile_bops.scanField("kappa",kappa);
+    Tools::convert( kappa, kappastr );
 
 
 
@@ -105,24 +127,35 @@ BopsShortcut::BopsShortcut(const ActionOptions&ao):
 
     kfunc_bops += "*exp(" + kappastr + "*(i*" + smu_i + "+j*" + smu_j + "+k*" + smu_k + "))";
     kfunc_dops += "*exp(-(x-" + smu_dops +")^2/" + "(2*" + sigmastr +"*" +sigmastr + "))";
-    if (k==0) kfunc = kfunc_dops + "*" + kfunc_bops; else kfunc+= "+" + kfunc_dops + "*" + kfunc_bops;
+    if (k==0) {
+      kfunc = kfunc_dops + "*" + kfunc_bops;
+    } else {
+      kfunc+= "+" + kfunc_dops + "*" + kfunc_bops;
+    }
   }
   std::string sp_str, specA, specB, grpinfo;
   double cutoff;
-  parse("SPECIES",sp_str); parse("SPECIESA",specA); parse("SPECIESB",specB); parse("CUTOFF",cutoff);
+  parse("SPECIES",sp_str);
+  parse("SPECIESA",specA);
+  parse("SPECIESB",specB);
+  parse("CUTOFF",cutoff);
   if( sp_str.length()>0 ) {
     grpinfo="GROUP=" + sp_str;
   } else {//not sure how to use this
-    if( specA.length()==0 || specB.length()==0 ) error("no atoms were specified in input use either SPECIES or SPECIESA + SPECIESB");
+    if( specA.length()==0 || specB.length()==0 ) {
+      error("no atoms were specified in input use either SPECIES or SPECIESA + SPECIESB");
+    }
     grpinfo="GROUPA=" + specA + " GROUPB=" + specB;
   }
-  std::string cutstr; Tools::convert( cutoff, cutstr );
+  std::string cutstr;
+  Tools::convert( cutoff, cutstr );
   // Setup the contact matrix
 //  std::string switchstr; parse("SWITCH",switchstr);
   readInputLine( getShortcutLabel() + "_cmat: DISTANCE_MATRIX  " + grpinfo + " CUTOFF=" + cutstr + " COMPONENTS");
 
   if( specA.length()==0 ) {
-    std::string quatstr; parse("QUATERNIONS",quatstr);
+    std::string quatstr;
+    parse("QUATERNIONS",quatstr);
     readInputLine( getShortcutLabel() + "_quatprod: QUATERNION_BOND_PRODUCT_MATRIX ARG=" + quatstr + ".*," + getShortcutLabel() + "_cmat.*" );
   }  else {
     plumed_error();
@@ -144,7 +177,8 @@ BopsShortcut::BopsShortcut(const ActionOptions&ao):
   // Find the number of ones we need to multiply by
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_cmat");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   //
   readInputLine( getShortcutLabel() + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_kfunc," + getShortcutLabel() + "_ones");
diff --git a/src/crystdistrib/DopsShortcut.cpp b/src/crystdistrib/DopsShortcut.cpp
index 7465b3b732..70c017de69 100644
--- a/src/crystdistrib/DopsShortcut.cpp
+++ b/src/crystdistrib/DopsShortcut.cpp
@@ -61,38 +61,67 @@ void DopsShortcut::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","KERNELFILE","the file containing the list of kernel parameters.  We expect h, mu and sigma parameters for a 1D Gaussian kernel of the form h*exp(-(x-mu)^2/2sigma^2)");
   keys.add("compulsory","CUTOFF","6.25","to make the calculation faster we calculate a cutoff value on the distances.  The input to this keyword determines x in this expreession max(mu + sqrt(2*x)/sigma)");
   keys.setValueDescription("the values of the DOPS order parameters");
-  keys.needsAction("DISTANCE_MATRIX"); keys.needsAction("CUSTOM"); keys.needsAction("ONES"); keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("DISTANCE_MATRIX");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("ONES");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
 }
 
 DopsShortcut::DopsShortcut(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Open a file and read in the kernels
-  double cutoff=0, h; std::string kfunc,fname; double dp2cutoff; parse("CUTOFF",dp2cutoff);
-  parse("KERNELFILE",fname); IFile ifile; ifile.open(fname);
+  double cutoff=0, h;
+  std::string kfunc,fname;
+  double dp2cutoff;
+  parse("CUTOFF",dp2cutoff);
+  parse("KERNELFILE",fname);
+  IFile ifile;
+  ifile.open(fname);
   for(unsigned k=0;; ++k) {
-    if( !ifile.scanField("height",h) ) break;
-    std::string ktype; ifile.scanField("kerneltype",ktype); if( ktype!="gaussian" ) error("cannot process kernels of type " + ktype );
-    double mu, sigma; ifile.scanField("mu",mu); ifile.scanField("sigma",sigma); ifile.scanField();
-    std::string hstr, mustr, sigmastr; Tools::convert( h, hstr );
-    Tools::convert( 2*sigma*sigma, sigmastr ); Tools::convert( mu, mustr );
+    if( !ifile.scanField("height",h) ) {
+      break;
+    }
+    std::string ktype;
+    ifile.scanField("kerneltype",ktype);
+    if( ktype!="gaussian" ) {
+      error("cannot process kernels of type " + ktype );
+    }
+    double mu, sigma;
+    ifile.scanField("mu",mu);
+    ifile.scanField("sigma",sigma);
+    ifile.scanField();
+    std::string hstr, mustr, sigmastr;
+    Tools::convert( h, hstr );
+    Tools::convert( 2*sigma*sigma, sigmastr );
+    Tools::convert( mu, mustr );
     // Get a sensible value for the cutoff
     double support = sqrt(2.0*dp2cutoff)*(1.0/sigma);
-    if( mu+support>cutoff ) cutoff= mu + support;
+    if( mu+support>cutoff ) {
+      cutoff= mu + support;
+    }
     // And make the kernel
-    if( k==0 ) kfunc = hstr; else kfunc += "+" + hstr;
+    if( k==0 ) {
+      kfunc = hstr;
+    } else {
+      kfunc += "+" + hstr;
+    }
     kfunc += "*exp(-(x-" + mustr +")^2/" + sigmastr + ")";
   }
   std::string sp_str, specA, specB, grpinfo;
-  parse("SPECIES",sp_str); parse("SPECIESA",specA); parse("SPECIESB",specB);
+  parse("SPECIES",sp_str);
+  parse("SPECIESA",specA);
+  parse("SPECIESB",specB);
   if( sp_str.length()>0 ) {
     grpinfo="GROUP=" + sp_str;
   } else {
-    if( specA.length()==0 || specB.length()==0 ) error("no atoms were specified in input use either SPECIES or SPECIESA + SPECIESB");
+    if( specA.length()==0 || specB.length()==0 ) {
+      error("no atoms were specified in input use either SPECIES or SPECIESA + SPECIESB");
+    }
     grpinfo="GROUPA=" + specA + " GROUPB=" + specB;
   }
-  std::string cutstr; Tools::convert( cutoff, cutstr );
+  std::string cutstr;
+  Tools::convert( cutoff, cutstr );
   // Setup the contact matrix
   readInputLine( getShortcutLabel() + "_cmat: DISTANCE_MATRIX  " + grpinfo + " CUTOFF=" + cutstr);
   // And the kernels
@@ -100,7 +129,8 @@ DopsShortcut::DopsShortcut(const ActionOptions&ao):
   // Find the number of ones we need to multiply by
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_cmat");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   // And the final order parameters
   readInputLine( getShortcutLabel() + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_kval," + getShortcutLabel() + "_ones");
diff --git a/src/crystdistrib/Quaternion.cpp b/src/crystdistrib/Quaternion.cpp
index 700b04d016..557a595117 100644
--- a/src/crystdistrib/Quaternion.cpp
+++ b/src/crystdistrib/Quaternion.cpp
@@ -119,7 +119,8 @@ typedef colvar::MultiColvarTemplate<Quaternion> QuaternionMulti;
 PLUMED_REGISTER_ACTION(QuaternionMulti,"QUATERNION_VECTOR")
 
 void Quaternion::registerKeywords( Keywords& keys ) {
-  Colvar::registerKeywords( keys ); keys.setDisplayName("QUATERNION");
+  Colvar::registerKeywords( keys );
+  keys.setDisplayName("QUATERNION");
   keys.add("atoms","ATOMS","the three atom that we are using to calculate the quaternion");
   keys.addOutputComponent("w","default","the real component of quaternion");
   keys.addOutputComponent("i","default","the i component of the quaternion");
@@ -133,12 +134,15 @@ Quaternion::Quaternion(const ActionOptions&ao):
   pbc(true),
   value(4),
   derivs(4),
-  virial(4)
-{
-  for(unsigned i=0; i<4; ++i) derivs[i].resize(3);
+  virial(4) {
+  for(unsigned i=0; i<4; ++i) {
+    derivs[i].resize(3);
+  }
   std::vector<AtomNumber> atoms;
   parseAtomList(-1,atoms,this);
-  if(atoms.size()!=3) error("Number of specified atoms should be 3");
+  if(atoms.size()!=3) {
+    error("Number of specified atoms should be 3");
+  }
   // please note, I do NO checking if these atoms are in the same molecule at all, so be careful in your input
 
   bool nopbc=!pbc;
@@ -151,25 +155,35 @@ Quaternion::Quaternion(const ActionOptions&ao):
 
 void Quaternion::parseAtomList( const int& num, std::vector<AtomNumber>& t, ActionAtomistic* aa ) {
   aa->parseAtomList("ATOMS",num,t);
-  if( t.size()==3 ) aa->log.printf("  involving atoms %d %d %d\n",t[0].serial(),t[1].serial(),t[0].serial());
+  if( t.size()==3 ) {
+    aa->log.printf("  involving atoms %d %d %d\n",t[0].serial(),t[1].serial(),t[0].serial());
+  }
 }
 
 unsigned Quaternion::getModeAndSetupValues( ActionWithValue* av ) {
   // This sets up values that we can pass around in PLUMED
-  av->addComponentWithDerivatives("w"); av->componentIsNotPeriodic("w");
-  av->addComponentWithDerivatives("i"); av->componentIsNotPeriodic("i");
-  av->addComponentWithDerivatives("j"); av->componentIsNotPeriodic("j");
-  av->addComponentWithDerivatives("k"); av->componentIsNotPeriodic("k");
+  av->addComponentWithDerivatives("w");
+  av->componentIsNotPeriodic("w");
+  av->addComponentWithDerivatives("i");
+  av->componentIsNotPeriodic("i");
+  av->addComponentWithDerivatives("j");
+  av->componentIsNotPeriodic("j");
+  av->addComponentWithDerivatives("k");
+  av->componentIsNotPeriodic("k");
   return 0;
 }
 
 void Quaternion::calculate() {
-  if(pbc) makeWhole();
+  if(pbc) {
+    makeWhole();
+  }
 
   calculateCV( 0, masses, charges, getPositions(), value, derivs, virial, this );
   for(unsigned j=0; j<4; ++j) {
     Value* valuej=getPntrToComponent(j);
-    for(unsigned i=0; i<3; ++i) setAtomsDerivatives(valuej,i,derivs[j][i] );
+    for(unsigned i=0; i<3; ++i) {
+      setAtomsDerivatives(valuej,i,derivs[j][i] );
+    }
     setBoxDerivatives(valuej,virial[j]);
     valuej->set(value[j]);
   }
@@ -184,8 +198,10 @@ void Quaternion::calculateCV( const unsigned& mode, const std::vector<double>& m
   Vector vec2_comp = delta( pos[0], pos[2] ); //components between atom 1 and 3
 
 ////////x-vector calculations///////
-  double magx = vec1_comp.modulo(); Vector xt = vec1_comp / magx;
-  std::vector<Tensor> dx(3); double magx3= magx*magx*magx;
+  double magx = vec1_comp.modulo();
+  Vector xt = vec1_comp / magx;
+  std::vector<Tensor> dx(3);
+  double magx3= magx*magx*magx;
 //dx[i] - derivatives of atom i's coordinates
   dx[0](0,0) = ( -(vec1_comp[1]*vec1_comp[1]+vec1_comp[2]*vec1_comp[2])/magx3 ); //dx[0]/dx0
   dx[0](0,1) = (  vec1_comp[0]*vec1_comp[1]/magx3 );                 // dx[0]/dy0
@@ -211,13 +227,16 @@ void Quaternion::calculateCV( const unsigned& mode, const std::vector<double>& m
 ////////y-vector calculations////////
   //project vec2_comp on to vec1_comp
   //first do dot product of unormalized x and unormed y, divided by magnitude of x^2
-  double dp = dotProduct( vec1_comp, vec2_comp ); double magx2=magx*magx;
-  std::vector<Vector> fac_derivs(3); double magx4=magx2*magx2, fac = dp/magx2; //fac meaning factor on front
+  double dp = dotProduct( vec1_comp, vec2_comp );
+  double magx2=magx*magx;
+  std::vector<Vector> fac_derivs(3);
+  double magx4=magx2*magx2, fac = dp/magx2; //fac meaning factor on front
   fac_derivs[0] = (-vec2_comp - vec1_comp)/magx2 + 2*dp*vec1_comp / magx4;
   fac_derivs[1] = (vec2_comp)/(magx2) - 2*dp*vec1_comp / magx4;
   fac_derivs[2] = (vec1_comp)/(magx2);   //atom 1, components x2,y2,z2
   //now multiply fac by unormed x, and subtract it from unormed y, then normalize
-  Vector yt = vec2_comp - fac*vec1_comp; std::vector<Tensor> dy(3);
+  Vector yt = vec2_comp - fac*vec1_comp;
+  std::vector<Tensor> dy(3);
   dy[0](0,0) = -1 - fac_derivs[0][0]*vec1_comp[0] + fac;   // dy[0]/dx0
   dy[0](0,1) = -fac_derivs[0][1]*vec1_comp[0];             // dy[0]/dy0
   dy[0](0,2) = -fac_derivs[0][2]*vec1_comp[0];
@@ -248,17 +267,27 @@ void Quaternion::calculateCV( const unsigned& mode, const std::vector<double>& m
   dy[2](2,1) = -fac_derivs[2][1]*vec1_comp[2];
   dy[2](2,2) = 1 - fac_derivs[2][2]*vec1_comp[2];
   //now normalize, and we have our y vector
-  double magy = yt.modulo(); double imagy = 1/magy, magy3 = magy*magy*magy;
-  Tensor abc; for(unsigned i=0; i<3; ++i) abc.setRow(i, yt);
-  Tensor abc_diag; abc_diag.setRow(0, Vector(yt[0], 0, 0)); abc_diag.setRow(1, Vector(0, yt[1], 0)); abc_diag.setRow(2, Vector(0, 0, yt[2]));
+  double magy = yt.modulo();
+  double imagy = 1/magy, magy3 = magy*magy*magy;
+  Tensor abc;
+  for(unsigned i=0; i<3; ++i) {
+    abc.setRow(i, yt);
+  }
+  Tensor abc_diag;
+  abc_diag.setRow(0, Vector(yt[0], 0, 0));
+  abc_diag.setRow(1, Vector(0, yt[1], 0));
+  abc_diag.setRow(2, Vector(0, 0, yt[2]));
   Tensor abc_prod = matmul(abc_diag, abc);
-  for(unsigned i=0; i<3; ++i) dy[i] = dy[i]/magy - matmul(abc_prod, dy[i])/magy3;
+  for(unsigned i=0; i<3; ++i) {
+    dy[i] = dy[i]/magy - matmul(abc_prod, dy[i])/magy3;
+  }
   //normalize now, derivatives are with respect to un-normalized y vector
   yt = yt / magy;
 
 ///////z-vector calculations/////////
 //comparatively simple
-  Vector zt = crossProduct(xt,yt); std::vector<Tensor> dz(3);
+  Vector zt = crossProduct(xt,yt);
+  std::vector<Tensor> dz(3);
   dz[0].setCol( 0, crossProduct( dx[0].getCol(0), yt ) + crossProduct( xt, dy[0].getCol(0) ) );
   dz[0].setCol( 1, crossProduct( dx[0].getCol(1), yt ) + crossProduct( xt, dy[0].getCol(1) ) );
   dz[0].setCol( 2, crossProduct( dx[0].getCol(2), yt ) + crossProduct( xt, dy[0].getCol(2) ) );
@@ -319,69 +348,106 @@ void Quaternion::calculateCV( const unsigned& mode, const std::vector<double>& m
   std::vector<Vector> dS(3);
   if (tr > 1.0E-8) { //to avoid numerical instability
     double S = 1/(sqrt(tr) * 2); // S=4*qw
-    for(unsigned i=0; i<3; ++i) dS[i] = (-2*S*S*S)*(tdx[i].getRow(0) + tdy[i].getRow(1) + tdz[i].getRow(2));
+    for(unsigned i=0; i<3; ++i) {
+      dS[i] = (-2*S*S*S)*(tdx[i].getRow(0) + tdy[i].getRow(1) + tdz[i].getRow(2));
+    }
 
     vals[0] = 0.25 / S;
-    for(unsigned i=0; i<3; ++i) derivs[0][i] =-0.25*dS[i]/(S*S);
+    for(unsigned i=0; i<3; ++i) {
+      derivs[0][i] =-0.25*dS[i]/(S*S);
+    }
 
     vals[1] = (z[1] - y[2]) * S;
-    for(unsigned i=0; i<3; ++i) derivs[1][i] = (S)*(tdz[i].getRow(1) - tdy[i].getRow(2)) + (z[1]-y[2])*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[1][i] = (S)*(tdz[i].getRow(1) - tdy[i].getRow(2)) + (z[1]-y[2])*dS[i];
+    }
 
     vals[2] = (x[2] - z[0]) * S;
-    for(unsigned i=0; i<3; ++i) derivs[2][i] = (S)*(tdx[i].getRow(2) - tdz[i].getRow(0)) + (x[2]-z[0])*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[2][i] = (S)*(tdx[i].getRow(2) - tdz[i].getRow(0)) + (x[2]-z[0])*dS[i];
+    }
 
     vals[3] = (y[0] - x[1]) * S;
-    for(unsigned i=0; i<3; ++i) derivs[3][i] = (S)*(tdy[i].getRow(0) - tdx[i].getRow(1)) + (y[0]-x[1])*dS[i];
-  }
-  else if ((x[0] > y[1])&(x[0] > z[2])) {
+    for(unsigned i=0; i<3; ++i) {
+      derivs[3][i] = (S)*(tdy[i].getRow(0) - tdx[i].getRow(1)) + (y[0]-x[1])*dS[i];
+    }
+  } else if ((x[0] > y[1])&(x[0] > z[2])) {
     float S = sqrt(1.0 + x[0] - y[1] - z[2]) * 2; // S=4*qx
-    for(unsigned i=0; i<3; ++i) dS[i] = (2/S)*(tdx[i].getRow(0) - tdy[i].getRow(1) - tdz[i].getRow(2));
+    for(unsigned i=0; i<3; ++i) {
+      dS[i] = (2/S)*(tdx[i].getRow(0) - tdy[i].getRow(1) - tdz[i].getRow(2));
+    }
 
     vals[0] = (z[1] - y[2]) / S;
-    for(unsigned i=0; i<3; ++i) derivs[0][i] = (1/S)*(tdz[i].getRow(1) - tdy[i].getRow(2)) - (vals[0]/S)*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[0][i] = (1/S)*(tdz[i].getRow(1) - tdy[i].getRow(2)) - (vals[0]/S)*dS[i];
+    }
 
     vals[1] = 0.25 * S;
-    for(unsigned i=0; i<3; ++i) derivs[1][i] =0.25*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[1][i] =0.25*dS[i];
+    }
 
     vals[2] = (x[1] + y[0]) / S;
-    for(unsigned i=0; i<3; ++i) derivs[2][i] = (1/S)*(tdx[i].getRow(1) + tdy[i].getRow(0)) - (vals[2]/S)*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[2][i] = (1/S)*(tdx[i].getRow(1) + tdy[i].getRow(0)) - (vals[2]/S)*dS[i];
+    }
 
     vals[3] = (x[2] + z[0]) / S;
-    for(unsigned i=0; i<3; ++i) derivs[3][i] = (1/S)*(tdx[i].getRow(2) + tdz[i].getRow(0)) - (vals[3]/S)*dS[i];
-  }
-  else if (y[1] > z[2]) {
+    for(unsigned i=0; i<3; ++i) {
+      derivs[3][i] = (1/S)*(tdx[i].getRow(2) + tdz[i].getRow(0)) - (vals[3]/S)*dS[i];
+    }
+  } else if (y[1] > z[2]) {
     float S = sqrt(1.0 + y[1] - x[0] - z[2]) * 2; // S=4*qy
-    for(unsigned i=0; i<3; ++i) dS[i] = (2/S)*( -tdx[i].getRow(0) + tdy[i].getRow(1) - tdz[i].getRow(2));
+    for(unsigned i=0; i<3; ++i) {
+      dS[i] = (2/S)*( -tdx[i].getRow(0) + tdy[i].getRow(1) - tdz[i].getRow(2));
+    }
 
 
     vals[0] = (x[2] - z[0]) / S;
-    for(unsigned i=0; i<3; ++i) derivs[0][i] = (1/S)*(tdx[i].getRow(2) - tdz[i].getRow(0)) - (vals[0]/S)*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[0][i] = (1/S)*(tdx[i].getRow(2) - tdz[i].getRow(0)) - (vals[0]/S)*dS[i];
+    }
 
     vals[1] = (x[1] + y[0]) / S;
-    for(unsigned i=0; i<3; ++i) derivs[1][i] = (1/S)*(tdx[i].getRow(1) + tdy[i].getRow(0)) - (vals[1]/S)*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[1][i] = (1/S)*(tdx[i].getRow(1) + tdy[i].getRow(0)) - (vals[1]/S)*dS[i];
+    }
 
     vals[2] = 0.25 * S;
-    for(unsigned i=0; i<3; ++i) derivs[2][i] =0.25*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[2][i] =0.25*dS[i];
+    }
 
     vals[3] = (y[2] + z[1]) / S;
-    for(unsigned i=0; i<3; ++i) derivs[3][i] = (1/S)*(tdy[i].getRow(2) + tdz[i].getRow(1)) - (vals[3]/S)*dS[i];
-  }
-  else {
+    for(unsigned i=0; i<3; ++i) {
+      derivs[3][i] = (1/S)*(tdy[i].getRow(2) + tdz[i].getRow(1)) - (vals[3]/S)*dS[i];
+    }
+  } else {
     float S = sqrt(1.0 + z[2] - x[0] - y[1]) * 2; // S=4*qz
-    for(unsigned i=0; i<3; ++i) dS[i] = (2/S)*(-tdx[i].getRow(0) - tdy[i].getRow(1) + tdz[i].getRow(2));
+    for(unsigned i=0; i<3; ++i) {
+      dS[i] = (2/S)*(-tdx[i].getRow(0) - tdy[i].getRow(1) + tdz[i].getRow(2));
+    }
 
 
     vals[0] = (y[0] - x[1]) / S;
-    for(unsigned i=0; i<3; ++i) derivs[0][i] = (1/S)*(tdy[i].getRow(0) - tdx[i].getRow(1)) - (vals[0]/S)*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[0][i] = (1/S)*(tdy[i].getRow(0) - tdx[i].getRow(1)) - (vals[0]/S)*dS[i];
+    }
 
     vals[1] = (x[2] + z[0]) / S;
-    for(unsigned i=0; i<3; ++i) derivs[1][i] = (1/S)*(tdx[i].getRow(2) + tdz[i].getRow(0)) - (vals[1]/S)*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[1][i] = (1/S)*(tdx[i].getRow(2) + tdz[i].getRow(0)) - (vals[1]/S)*dS[i];
+    }
 
     vals[2] = (y[2] + z[1]) / S;
-    for(unsigned i=0; i<3; ++i) derivs[2][i] = (1/S)*(tdy[i].getRow(2) + tdz[i].getRow(1)) - (vals[2]/S)*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[2][i] = (1/S)*(tdy[i].getRow(2) + tdz[i].getRow(1)) - (vals[2]/S)*dS[i];
+    }
 
     vals[3] = 0.25 * S;
-    for(unsigned i=0; i<3; ++i) derivs[3][i] =0.25*dS[i];
+    for(unsigned i=0; i<3; ++i) {
+      derivs[3][i] =0.25*dS[i];
+    }
   }
   setBoxDerivativesNoPbc( pos, derivs, virial );
 
diff --git a/src/crystdistrib/QuaternionBondProductMatrix.cpp b/src/crystdistrib/QuaternionBondProductMatrix.cpp
index fb92cb1969..c4b5739e5a 100644
--- a/src/crystdistrib/QuaternionBondProductMatrix.cpp
+++ b/src/crystdistrib/QuaternionBondProductMatrix.cpp
@@ -73,7 +73,8 @@ PLUMED_REGISTER_ACTION(QuaternionBondProductMatrix,"QUATERNION_BOND_PRODUCT_MATR
 
 
 void QuaternionBondProductMatrix::registerKeywords( Keywords& keys ) {
-  ActionWithMatrix::registerKeywords(keys); keys.use("ARG");
+  ActionWithMatrix::registerKeywords(keys);
+  keys.use("ARG");
   keys.addOutputComponent("w","default","the real component of quaternion");
   keys.addOutputComponent("i","default","the i component of the quaternion");
   keys.addOutputComponent("j","default","the j component of the quaternion");
@@ -82,39 +83,75 @@ void QuaternionBondProductMatrix::registerKeywords( Keywords& keys ) {
 
 QuaternionBondProductMatrix::QuaternionBondProductMatrix(const ActionOptions&ao):
   Action(ao),
-  ActionWithMatrix(ao)
-{
-  if( getNumberOfArguments()!=8 ) error("should be eight arguments to this action, 4 quaternion components and 4 matrices");
+  ActionWithMatrix(ao) {
+  if( getNumberOfArguments()!=8 ) {
+    error("should be eight arguments to this action, 4 quaternion components and 4 matrices");
+  }
   unsigned nquat = getPntrToArgument(0)->getNumberOfValues();
   for(unsigned i=0; i<4; ++i) {
-    Value* myarg=getPntrToArgument(i); myarg->buildDataStore();
-    if( myarg->getRank()!=1 ) error("first four arguments to this action should be vectors");
-    if( (myarg->getPntrToAction())->getName()!="QUATERNION_VECTOR" ) error("first four arguments to this action should be quaternions");
-    std::string mylab=getPntrToArgument(i)->getName(); std::size_t dot=mylab.find_first_of(".");
-    if( i==0 && mylab.substr(dot+1)!="w" ) error("quaternion arguments are in wrong order");
-    if( i==1 && mylab.substr(dot+1)!="i" ) error("quaternion arguments are in wrong order");
-    if( i==2 && mylab.substr(dot+1)!="j" ) error("quaternion arguments are in wrong order");
-    if( i==3 && mylab.substr(dot+1)!="k" ) error("quaternion arguments are in wrong order");
+    Value* myarg=getPntrToArgument(i);
+    myarg->buildDataStore();
+    if( myarg->getRank()!=1 ) {
+      error("first four arguments to this action should be vectors");
+    }
+    if( (myarg->getPntrToAction())->getName()!="QUATERNION_VECTOR" ) {
+      error("first four arguments to this action should be quaternions");
+    }
+    std::string mylab=getPntrToArgument(i)->getName();
+    std::size_t dot=mylab.find_first_of(".");
+    if( i==0 && mylab.substr(dot+1)!="w" ) {
+      error("quaternion arguments are in wrong order");
+    }
+    if( i==1 && mylab.substr(dot+1)!="i" ) {
+      error("quaternion arguments are in wrong order");
+    }
+    if( i==2 && mylab.substr(dot+1)!="j" ) {
+      error("quaternion arguments are in wrong order");
+    }
+    if( i==3 && mylab.substr(dot+1)!="k" ) {
+      error("quaternion arguments are in wrong order");
+    }
   }
   std::vector<unsigned> shape( getPntrToArgument(4)->getShape() );
   for(unsigned i=4; i<8; ++i) {
     Value* myarg=getPntrToArgument(i);
-    if( myarg->getRank()!=2 ) error("second four arguments to this action should be matrices");
-    if( myarg->getShape()[0]!=shape[0] || myarg->getShape()[1]!=shape[1] ) error("matrices should all have the same shape");
-    if( myarg->getShape()[0]!=nquat ) error("number of rows in matrix should equal number of input quaternions");
-    std::string mylab=getPntrToArgument(i)->getName(); std::size_t dot=mylab.find_first_of(".");
-    if( i==5 && mylab.substr(dot+1)!="x" ) error("quaternion arguments are in wrong order");
-    if( i==6 && mylab.substr(dot+1)!="y" ) error("quaternion arguments are in wrong order");
-    if( i==7 && mylab.substr(dot+1)!="z" ) error("quaternion arguments are in wrong order");
+    if( myarg->getRank()!=2 ) {
+      error("second four arguments to this action should be matrices");
+    }
+    if( myarg->getShape()[0]!=shape[0] || myarg->getShape()[1]!=shape[1] ) {
+      error("matrices should all have the same shape");
+    }
+    if( myarg->getShape()[0]!=nquat ) {
+      error("number of rows in matrix should equal number of input quaternions");
+    }
+    std::string mylab=getPntrToArgument(i)->getName();
+    std::size_t dot=mylab.find_first_of(".");
+    if( i==5 && mylab.substr(dot+1)!="x" ) {
+      error("quaternion arguments are in wrong order");
+    }
+    if( i==6 && mylab.substr(dot+1)!="y" ) {
+      error("quaternion arguments are in wrong order");
+    }
+    if( i==7 && mylab.substr(dot+1)!="z" ) {
+      error("quaternion arguments are in wrong order");
+    }
+  }
+  addComponent( "w", shape );
+  componentIsNotPeriodic("w");
+  addComponent( "i", shape );
+  componentIsNotPeriodic("i");
+  addComponent( "j", shape );
+  componentIsNotPeriodic("j");
+  addComponent( "k", shape );
+  componentIsNotPeriodic("k");
+  done_in_chain=true;
+  nderivatives = buildArgumentStore(0);
+
+  std::string headstr=getFirstActionInChain()->getLabel();
+  stored.resize( getNumberOfArguments() );
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    stored[i] = getPntrToArgument(i)->ignoreStoredValue( headstr );
   }
-  addComponent( "w", shape ); componentIsNotPeriodic("w");
-  addComponent( "i", shape ); componentIsNotPeriodic("i");
-  addComponent( "j", shape ); componentIsNotPeriodic("j");
-  addComponent( "k", shape ); componentIsNotPeriodic("k");
-  done_in_chain=true; nderivatives = buildArgumentStore(0);
-
-  std::string headstr=getFirstActionInChain()->getLabel(); stored.resize( getNumberOfArguments() );
-  for(unsigned i=0; i<getNumberOfArguments(); ++i) stored[i] = getPntrToArgument(i)->ignoreStoredValue( headstr );
 }
 
 unsigned QuaternionBondProductMatrix::getNumberOfDerivatives() {
@@ -123,42 +160,58 @@ unsigned QuaternionBondProductMatrix::getNumberOfDerivatives() {
 
 unsigned QuaternionBondProductMatrix::getNumberOfColumns() const {
   const ActionWithMatrix* am=dynamic_cast<const ActionWithMatrix*>( getPntrToArgument(4)->getPntrToAction() );
-  plumed_assert( am ); return am->getNumberOfColumns();
+  plumed_assert( am );
+  return am->getNumberOfColumns();
 }
 
 void QuaternionBondProductMatrix::setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const {
   unsigned start_n = getPntrToArgument(4)->getShape()[0], size_v = getPntrToArgument(4)->getShape()[1];
-  if( indices.size()!=size_v+1 ) indices.resize( size_v+1 );
-  for(unsigned i=0; i<size_v; ++i) indices[i+1] = start_n + i;
+  if( indices.size()!=size_v+1 ) {
+    indices.resize( size_v+1 );
+  }
+  for(unsigned i=0; i<size_v; ++i) {
+    indices[i+1] = start_n + i;
+  }
   myvals.setSplitIndex( size_v + 1 );
 }
 
 void QuaternionBondProductMatrix::performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const {
   unsigned ind2=index2;
-  if( index2>=getPntrToArgument(0)->getShape()[0] ) ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  if( index2>=getPntrToArgument(0)->getShape()[0] ) {
+    ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  }
 
   std::vector<double> quat(4), bond(4), quatTemp(4);
   std::vector<Tensor4d> dqt(2); //dqt[0] -> derivs w.r.t quat [dwt/dw1 dwt/di1 dwt/dj1 dwt/dk1]
   //[dit/dw1 dit/di1 dit/dj1 dit/dk1] etc, and dqt[1] is w.r.t the vector-turned-quaternion called bond
 
   // Retrieve the quaternion
-  for(unsigned i=0; i<4; ++i) quat[i] = getArgumentElement( i, index1, myvals );
+  for(unsigned i=0; i<4; ++i) {
+    quat[i] = getArgumentElement( i, index1, myvals );
+  }
 
   // Retrieve the components of the matrix
   double weight = getElementOfMatrixArgument( 4, index1, ind2, myvals );
-  for(unsigned i=1; i<4; ++i) bond[i] = getElementOfMatrixArgument( 4+i, index1, ind2, myvals );
+  for(unsigned i=1; i<4; ++i) {
+    bond[i] = getElementOfMatrixArgument( 4+i, index1, ind2, myvals );
+  }
 
   // calculate normalization factor
   bond[0]=0.0;
   double normFac = 1/sqrt(bond[1]*bond[1] + bond[2]*bond[2] + bond[3]*bond[3]);
-  if (bond[1] == 0.0 && bond[2]==0.0 && bond[3]==0) normFac=1; //just for the case where im comparing a quat to itself, itll be 0 at the end anyway
+  if (bond[1] == 0.0 && bond[2]==0.0 && bond[3]==0) {
+    normFac=1;  //just for the case where im comparing a quat to itself, itll be 0 at the end anyway
+  }
   double normFac3 = normFac*normFac*normFac;
   //I hold off on normalizing because this can be done at the very end, and it makes the derivatives with respect to 'bond' more simple
 
 
 
   std::vector<double> quat_conj(4);
-  quat_conj[0] = quat[0]; quat_conj[1] = -1*quat[1]; quat_conj[2] = -1*quat[2]; quat_conj[3] = -1*quat[3];
+  quat_conj[0] = quat[0];
+  quat_conj[1] = -1*quat[1];
+  quat_conj[2] = -1*quat[2];
+  quat_conj[3] = -1*quat[3];
   //make a conjugate of q1 my own sanity
 
 
@@ -171,7 +224,11 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
   //real part of q1*q2
 
   for(unsigned i=0; i<4; ++i) {
-    if( i>0 ) {pref=-1; conj=-1; pref2=-1;}
+    if( i>0 ) {
+      pref=-1;
+      conj=-1;
+      pref2=-1;
+    }
     quatTemp[0]+=pref*quat_conj[i]*bond[i];
     dqt[0](0,i) = conj*pref*bond[i];
     dqt[1](0,i) = pref2*quat_conj[i];
@@ -184,11 +241,19 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
   pref2=1;
 
   for (unsigned i=0; i<4; i++) {
-    if(i==3) pref=-1;
-    else pref=1;
-    if(i==2) pref2=-1;
-    else pref2=1;
-    if (i>0) conj=-1;
+    if(i==3) {
+      pref=-1;
+    } else {
+      pref=1;
+    }
+    if(i==2) {
+      pref2=-1;
+    } else {
+      pref2=1;
+    }
+    if (i>0) {
+      conj=-1;
+    }
 
     quatTemp[1]+=pref*quat_conj[i]*bond[(5-i)%4];
     dqt[0](1,i) =conj*pref*bond[(5-i)%4];
@@ -203,11 +268,19 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
   conj=1;
 
   for (unsigned i=0; i<4; i++) {
-    if(i==1) pref=-1;
-    else pref=1;
-    if (i==3) pref2=-1;
-    else pref2=1;
-    if (i>0) conj=-1;
+    if(i==1) {
+      pref=-1;
+    } else {
+      pref=1;
+    }
+    if (i==3) {
+      pref2=-1;
+    } else {
+      pref2=1;
+    }
+    if (i>0) {
+      conj=-1;
+    }
 
     quatTemp[2]+=pref*quat_conj[i]*bond[(i+2)%4];
     dqt[0](2,i)=conj*pref*bond[(i+2)%4];
@@ -222,11 +295,19 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
   conj=1;
 
   for (unsigned i=0; i<4; i++) {
-    if(i==2) pref=-1;
-    else pref=1;
-    if(i==1) pref2=-1;
-    else pref2=1;
-    if(i>0) conj=-1;
+    if(i==2) {
+      pref=-1;
+    } else {
+      pref=1;
+    }
+    if(i==1) {
+      pref2=-1;
+    } else {
+      pref2=1;
+    }
+    if(i>0) {
+      conj=-1;
+    }
     quatTemp[3]+=pref*quat_conj[i]*bond[(3-i)];
     dqt[0](3,i)=conj*pref*bond[3-i];
     dqt[1](3,i)= pref2*quat_conj[3-i];
@@ -242,10 +323,15 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
   pref=1;
   pref2=1;
   for(unsigned i=0; i<4; ++i) {
-    if( i>0 ) {pref=-1; pref2=-1;}
+    if( i>0 ) {
+      pref=-1;
+      pref2=-1;
+    }
     myvals.addValue( getConstPntrToComponent(0)->getPositionInStream(), normFac*pref*quatTemp[i]*quat[i] );
     wf+=normFac*pref*quatTemp[i]*quat[i];
-    if( doNotCalculateDerivatives() ) continue ;
+    if( doNotCalculateDerivatives() ) {
+      continue ;
+    }
     tempDot=(dotProduct(Vector4d(quat[0],-quat[1],-quat[2],-quat[3]), dqt[0].getCol(i)) + pref2*quatTemp[i])*normFac;
     addDerivativeOnVectorArgument( stored[i], 0, i,   index1, tempDot, myvals);
   }
@@ -253,8 +339,11 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
   //addDerivativeOnMatrixArgument( false, 0, 4, index1, ind2, 0.0, myvals );
   for(unsigned i=0; i<4; ++i) {
     tempDot=dotProduct(Vector4d(quat[0],-quat[1],-quat[2],-quat[3]), dqt[1].getCol(i))*normFac;
-    if (i!=0 )addDerivativeOnMatrixArgument( stored[4+i], 0, 4+i, index1, ind2, tempDot, myvals );
-    else addDerivativeOnMatrixArgument( stored[4+i], 0, 4+i, index1, ind2, 0.0, myvals );
+    if (i!=0 ) {
+      addDerivativeOnMatrixArgument( stored[4+i], 0, 4+i, index1, ind2, tempDot, myvals );
+    } else {
+      addDerivativeOnMatrixArgument( stored[4+i], 0, 4+i, index1, ind2, 0.0, myvals );
+    }
   }
 // for (unsigned i=0; i<4; ++i) {
 //myvals.addValue( getConstPntrToComponent(0)->getPositionInStream(), 0.0 );
@@ -268,13 +357,21 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
   pref=1;
   pref2=1;
   for (unsigned i=0; i<4; i++) {
-    if(i==3) pref=-1;
-    else pref=1;
+    if(i==3) {
+      pref=-1;
+    } else {
+      pref=1;
+    }
     myvals.addValue( getConstPntrToComponent(1)->getPositionInStream(), normFac*pref*quatTemp[i]*quat[(5-i)%4]);
     xf+=normFac*pref*quatTemp[i]*quat[(5-i)%4];
-    if(i==2) pref2=-1;
-    else pref2=1;
-    if( doNotCalculateDerivatives() ) continue ;
+    if(i==2) {
+      pref2=-1;
+    } else {
+      pref2=1;
+    }
+    if( doNotCalculateDerivatives() ) {
+      continue ;
+    }
     tempDot=(dotProduct(Vector4d(quat[1],quat[0],quat[3],-quat[2]), dqt[0].getCol(i)) + pref2*quatTemp[(5-i)%4])*normFac;
     addDerivativeOnVectorArgument( stored[i], 1, i,   index1, tempDot, myvals);
   }
@@ -282,8 +379,11 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
 
   for(unsigned i=0; i<4; ++i) {
     tempDot=dotProduct(Vector4d(quat[1],quat[0],quat[3],-quat[2]), dqt[1].getCol(i))*normFac;
-    if (i!=0) addDerivativeOnMatrixArgument( stored[4+i], 1, 4+i, index1, ind2, tempDot+(-bond[i]*normFac*normFac*xf), myvals );
-    else  addDerivativeOnMatrixArgument( stored[4+i], 1, 4+i, index1, ind2, 0.0, myvals );
+    if (i!=0) {
+      addDerivativeOnMatrixArgument( stored[4+i], 1, 4+i, index1, ind2, tempDot+(-bond[i]*normFac*normFac*xf), myvals );
+    } else {
+      addDerivativeOnMatrixArgument( stored[4+i], 1, 4+i, index1, ind2, 0.0, myvals );
+    }
 
   }
 
@@ -292,14 +392,22 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
   pref=1;
   pref2=1;
   for (unsigned i=0; i<4; i++) {
-    if(i==1) pref=-1;
-    else pref=1;
-    if (i==3) pref2=-1;
-    else pref2=1;
+    if(i==1) {
+      pref=-1;
+    } else {
+      pref=1;
+    }
+    if (i==3) {
+      pref2=-1;
+    } else {
+      pref2=1;
+    }
 
     myvals.addValue( getConstPntrToComponent(2)->getPositionInStream(), normFac*pref*quatTemp[i]*quat[(i+2)%4]);
     yf+=normFac*pref*quatTemp[i]*quat[(i+2)%4];
-    if( doNotCalculateDerivatives() ) continue ;
+    if( doNotCalculateDerivatives() ) {
+      continue ;
+    }
     tempDot=(dotProduct(Vector4d(quat[2],-quat[3],quat[0],quat[1]), dqt[0].getCol(i)) + pref2*quatTemp[(i+2)%4])*normFac;
     addDerivativeOnVectorArgument( stored[i], 2, i,   index1, tempDot, myvals);
   }
@@ -307,8 +415,11 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
 
   for(unsigned i=0; i<4; ++i) {
     tempDot=dotProduct(Vector4d(quat[2],-quat[3],quat[0],quat[1]), dqt[1].getCol(i))*normFac;
-    if (i!=0) addDerivativeOnMatrixArgument( stored[4+i], 2, 4+i, index1, ind2, tempDot+(-bond[i]*normFac*normFac*yf), myvals );
-    else  addDerivativeOnMatrixArgument( stored[4+i], 2, 4+i, index1, ind2, 0.0, myvals );
+    if (i!=0) {
+      addDerivativeOnMatrixArgument( stored[4+i], 2, 4+i, index1, ind2, tempDot+(-bond[i]*normFac*normFac*yf), myvals );
+    } else {
+      addDerivativeOnMatrixArgument( stored[4+i], 2, 4+i, index1, ind2, 0.0, myvals );
+    }
 
 
   }
@@ -317,14 +428,22 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
   pref=1;
   pref2=1;
   for (unsigned i=0; i<4; i++) {
-    if(i==2) pref=-1;
-    else pref=1;
-    if(i==1) pref2=-1;
-    else pref2=1;
+    if(i==2) {
+      pref=-1;
+    } else {
+      pref=1;
+    }
+    if(i==1) {
+      pref2=-1;
+    } else {
+      pref2=1;
+    }
 
     myvals.addValue( getConstPntrToComponent(3)->getPositionInStream(), normFac*pref*quatTemp[i]*quat[(3-i)]);
     zf+=normFac*pref*quatTemp[i]*quat[(3-i)];
-    if( doNotCalculateDerivatives() ) continue ;
+    if( doNotCalculateDerivatives() ) {
+      continue ;
+    }
     tempDot=(dotProduct(Vector4d(quat[3],quat[2],-quat[1],quat[0]), dqt[0].getCol(i)) + pref2*quatTemp[(3-i)])*normFac;
     addDerivativeOnVectorArgument( stored[i], 3, i,   index1, tempDot, myvals);
   }
@@ -332,48 +451,72 @@ void QuaternionBondProductMatrix::performTask( const std::string& controller, co
 
   for(unsigned i=0; i<4; ++i) {
     tempDot=dotProduct(Vector4d(quat[3],quat[2],-quat[1],quat[0]), dqt[1].getCol(i))*normFac;
-    if (i!=0) addDerivativeOnMatrixArgument( stored[4+i], 3, 4+i, index1, ind2, tempDot+(-bond[i]*normFac*normFac*zf), myvals );
-    else addDerivativeOnMatrixArgument( stored[4+i], 3, 4+i, index1, ind2, 0.0, myvals );
+    if (i!=0) {
+      addDerivativeOnMatrixArgument( stored[4+i], 3, 4+i, index1, ind2, tempDot+(-bond[i]*normFac*normFac*zf), myvals );
+    } else {
+      addDerivativeOnMatrixArgument( stored[4+i], 3, 4+i, index1, ind2, 0.0, myvals );
+    }
 
 
   }
-  if( doNotCalculateDerivatives() ) return ;
+  if( doNotCalculateDerivatives() ) {
+    return ;
+  }
 
   for(unsigned outcomp=0; outcomp<4; ++outcomp) {
     unsigned ostrn = getConstPntrToComponent(outcomp)->getPositionInStream();
     for(unsigned i=4; i<8; ++i) {
       bool found=false;
       for(unsigned j=4; j<i; ++j) {
-        if( arg_deriv_starts[i]==arg_deriv_starts[j] ) { found=true; break; }
+        if( arg_deriv_starts[i]==arg_deriv_starts[j] ) {
+          found=true;
+          break;
+        }
+      }
+      if( found || !stored[i] ) {
+        continue;
       }
-      if( found || !stored[i] ) continue;
 
       unsigned istrn = getPntrToArgument(i)->getPositionInStream();
       for(unsigned k=0; k<myvals.getNumberActive(istrn); ++k) {
-        unsigned kind=myvals.getActiveIndex(istrn,k); myvals.updateIndex( ostrn, kind );
+        unsigned kind=myvals.getActiveIndex(istrn,k);
+        myvals.updateIndex( ostrn, kind );
       }
     }
   }
 }
 
 void QuaternionBondProductMatrix::runEndOfRowJobs( const unsigned& ival, const std::vector<unsigned> & indices, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() || !matrixChainContinues() ) return ;
+  if( doNotCalculateDerivatives() || !matrixChainContinues() ) {
+    return ;
+  }
 
   for(unsigned j=0; j<getNumberOfComponents(); ++j) {
     unsigned nmat = getConstPntrToComponent(j)->getPositionInMatrixStash(), nmat_ind = myvals.getNumberOfMatrixRowDerivatives( nmat );
-    std::vector<unsigned>& matrix_indices( myvals.getMatrixRowDerivativeIndices( nmat ) ); unsigned ntwo_atoms = myvals.getSplitIndex();
+    std::vector<unsigned>& matrix_indices( myvals.getMatrixRowDerivativeIndices( nmat ) );
+    unsigned ntwo_atoms = myvals.getSplitIndex();
     // Quaternion
-    for(unsigned k=0; k<4; ++k) { matrix_indices[nmat_ind] = arg_deriv_starts[k] + ival; nmat_ind++; }
+    for(unsigned k=0; k<4; ++k) {
+      matrix_indices[nmat_ind] = arg_deriv_starts[k] + ival;
+      nmat_ind++;
+    }
     // Loop over row of matrix
     for(unsigned n=4; n<8; ++n) {
       bool found=false;
       for(unsigned k=4; k<n; ++k) {
-        if( arg_deriv_starts[k]==arg_deriv_starts[n] ) { found=true; break; }
+        if( arg_deriv_starts[k]==arg_deriv_starts[n] ) {
+          found=true;
+          break;
+        }
+      }
+      if( found ) {
+        continue;
       }
-      if( found ) continue;
       unsigned istrn = getPntrToArgument(n)->getPositionInMatrixStash();
       std::vector<unsigned>& imat_indices( myvals.getMatrixRowDerivativeIndices( istrn ) );
-      for(unsigned k=0; k<myvals.getNumberOfMatrixRowDerivatives( istrn ); ++k) matrix_indices[nmat_ind + k] = arg_deriv_starts[n] + imat_indices[k];
+      for(unsigned k=0; k<myvals.getNumberOfMatrixRowDerivatives( istrn ); ++k) {
+        matrix_indices[nmat_ind + k] = arg_deriv_starts[n] + imat_indices[k];
+      }
       nmat_ind += myvals.getNumberOfMatrixRowDerivatives( getPntrToArgument(4)->getPositionInMatrixStash() );
     }
     myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind );
diff --git a/src/crystdistrib/QuaternionProductMatrix.cpp b/src/crystdistrib/QuaternionProductMatrix.cpp
index 53213f7ab0..024b2afb91 100644
--- a/src/crystdistrib/QuaternionProductMatrix.cpp
+++ b/src/crystdistrib/QuaternionProductMatrix.cpp
@@ -41,7 +41,9 @@ class QuaternionProductMatrix : public ActionWithMatrix {
   static void registerKeywords( Keywords& keys );
   explicit QuaternionProductMatrix(const ActionOptions&);
   unsigned getNumberOfDerivatives();
-  unsigned getNumberOfColumns() const override { return getConstPntrToComponent(0)->getShape()[1]; }
+  unsigned getNumberOfColumns() const override {
+    return getConstPntrToComponent(0)->getShape()[1];
+  }
   void setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const ;
   void performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const override;
   void runEndOfRowJobs( const unsigned& ival, const std::vector<unsigned> & indices, MultiValue& myvals ) const override ;
@@ -50,7 +52,8 @@ class QuaternionProductMatrix : public ActionWithMatrix {
 PLUMED_REGISTER_ACTION(QuaternionProductMatrix,"QUATERNION_PRODUCT_MATRIX")
 
 void QuaternionProductMatrix::registerKeywords( Keywords& keys ) {
-  ActionWithMatrix::registerKeywords(keys); keys.use("ARG");
+  ActionWithMatrix::registerKeywords(keys);
+  keys.use("ARG");
   keys.addOutputComponent("w","default","the real component of quaternion");
   keys.addOutputComponent("i","default","the i component of the quaternion");
   keys.addOutputComponent("j","default","the j component of the quaternion");
@@ -59,25 +62,48 @@ void QuaternionProductMatrix::registerKeywords( Keywords& keys ) {
 
 QuaternionProductMatrix::QuaternionProductMatrix(const ActionOptions&ao):
   Action(ao),
-  ActionWithMatrix(ao)
-{
-  if( getNumberOfArguments()!=8 ) error("should be eight arguments to this action.  Four quaternions for each set of atoms.  You can repeat actions");
+  ActionWithMatrix(ao) {
+  if( getNumberOfArguments()!=8 ) {
+    error("should be eight arguments to this action.  Four quaternions for each set of atoms.  You can repeat actions");
+  }
   unsigned nquat = getPntrToArgument(0)->getNumberOfValues();
   for(unsigned i=0; i<8; ++i) {
-    Value* myarg=getPntrToArgument(i); if( i==4 ) nquat = getPntrToArgument(i)->getNumberOfValues();
-    if( myarg->getRank()!=1 ) error("all arguments to this action should be vectors");
-    if( (myarg->getPntrToAction())->getName()!="QUATERNION_VECTOR" ) error("all arguments to this action should be quaternions");
-    std::string mylab=getPntrToArgument(i)->getName(); std::size_t dot=mylab.find_first_of(".");
-    if( (i==0 || i==4) && mylab.substr(dot+1)!="w" ) error("quaternion arguments are in wrong order");
-    if( (i==1 || i==5) && mylab.substr(dot+1)!="i" ) error("quaternion arguments are in wrong order");
-    if( (i==2 || i==6) && mylab.substr(dot+1)!="j" ) error("quaternion arguments are in wrong order");
-    if( (i==3 || i==7) && mylab.substr(dot+1)!="k" ) error("quaternion arguments are in wrong order");
+    Value* myarg=getPntrToArgument(i);
+    if( i==4 ) {
+      nquat = getPntrToArgument(i)->getNumberOfValues();
+    }
+    if( myarg->getRank()!=1 ) {
+      error("all arguments to this action should be vectors");
+    }
+    if( (myarg->getPntrToAction())->getName()!="QUATERNION_VECTOR" ) {
+      error("all arguments to this action should be quaternions");
+    }
+    std::string mylab=getPntrToArgument(i)->getName();
+    std::size_t dot=mylab.find_first_of(".");
+    if( (i==0 || i==4) && mylab.substr(dot+1)!="w" ) {
+      error("quaternion arguments are in wrong order");
+    }
+    if( (i==1 || i==5) && mylab.substr(dot+1)!="i" ) {
+      error("quaternion arguments are in wrong order");
+    }
+    if( (i==2 || i==6) && mylab.substr(dot+1)!="j" ) {
+      error("quaternion arguments are in wrong order");
+    }
+    if( (i==3 || i==7) && mylab.substr(dot+1)!="k" ) {
+      error("quaternion arguments are in wrong order");
+    }
   }
-  std::vector<unsigned> shape(2); shape[0]=getPntrToArgument(0)->getShape()[0]; shape[1]=getPntrToArgument(4)->getShape()[0];
-  addComponent( "w", shape ); componentIsNotPeriodic("w");
-  addComponent( "i", shape ); componentIsNotPeriodic("i");
-  addComponent( "j", shape ); componentIsNotPeriodic("j");
-  addComponent( "k", shape ); componentIsNotPeriodic("k");
+  std::vector<unsigned> shape(2);
+  shape[0]=getPntrToArgument(0)->getShape()[0];
+  shape[1]=getPntrToArgument(4)->getShape()[0];
+  addComponent( "w", shape );
+  componentIsNotPeriodic("w");
+  addComponent( "i", shape );
+  componentIsNotPeriodic("i");
+  addComponent( "j", shape );
+  componentIsNotPeriodic("j");
+  addComponent( "k", shape );
+  componentIsNotPeriodic("k");
   nderivatives = buildArgumentStore(0);
 }
 
@@ -87,21 +113,31 @@ unsigned QuaternionProductMatrix::getNumberOfDerivatives() {
 
 void QuaternionProductMatrix::setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const {
   unsigned start_n = getPntrToArgument(0)->getShape()[0], size_v = getPntrToArgument(4)->getShape()[0];
-  if( indices.size()!=size_v+1 ) indices.resize( size_v+1 );
-  for(unsigned i=0; i<size_v; ++i) indices[i+1] = start_n + i;
+  if( indices.size()!=size_v+1 ) {
+    indices.resize( size_v+1 );
+  }
+  for(unsigned i=0; i<size_v; ++i) {
+    indices[i+1] = start_n + i;
+  }
   myvals.setSplitIndex( size_v + 1 );
 }
 
 void QuaternionProductMatrix::performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const {
   unsigned ostrn, ind2=index2;
-  if( index2>=getPntrToArgument(0)->getShape()[0] ) ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  if( index2>=getPntrToArgument(0)->getShape()[0] ) {
+    ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  }
 
   std::vector<double> quat1(4), quat2(4);
 
   // Retrieve the first quaternion
-  for(unsigned i=0; i<4; ++i) quat1[i] = getArgumentElement( i, index1, myvals );
+  for(unsigned i=0; i<4; ++i) {
+    quat1[i] = getArgumentElement( i, index1, myvals );
+  }
   // Retrieve the second quaternion
-  for(unsigned i=0; i<4; ++i) quat2[i] = getArgumentElement( 4+i, ind2, myvals );
+  for(unsigned i=0; i<4; ++i) {
+    quat2[i] = getArgumentElement( 4+i, ind2, myvals );
+  }
 
   //make q1 the conjugate
   quat1[1] *= -1;
@@ -114,10 +150,17 @@ void QuaternionProductMatrix::performTask( const std::string& controller, const
   double conj=1;
 //real part of q1*q2
   for(unsigned i=0; i<4; ++i) {
-    if( i>0 ) {pref=-1; pref2=-1;}
+    if( i>0 ) {
+      pref=-1;
+      pref2=-1;
+    }
     myvals.addValue( getConstPntrToComponent(0)->getPositionInStream(), pref*quat1[i]*quat2[i] );
-    if( doNotCalculateDerivatives() ) continue ;
-    if (i>0) conj=-1;
+    if( doNotCalculateDerivatives() ) {
+      continue ;
+    }
+    if (i>0) {
+      conj=-1;
+    }
     addDerivativeOnVectorArgument( false, 0, i, index1, conj*pref*quat2[i], myvals );
     addDerivativeOnVectorArgument( false, 0, 4+i, ind2, pref2*quat1[i], myvals );
   }
@@ -126,13 +169,23 @@ void QuaternionProductMatrix::performTask( const std::string& controller, const
   conj=1;
   pref2=1;
   for (unsigned i=0; i<4; i++) {
-    if(i==3) pref=-1;
-    else pref=1;
-    if(i==2) pref2=-1;
-    else pref2=1;
+    if(i==3) {
+      pref=-1;
+    } else {
+      pref=1;
+    }
+    if(i==2) {
+      pref2=-1;
+    } else {
+      pref2=1;
+    }
     myvals.addValue( getConstPntrToComponent(1)->getPositionInStream(), pref*quat1[i]*quat2[(5-i)%4]);
-    if( doNotCalculateDerivatives() ) continue ;
-    if (i>0) conj=-1;
+    if( doNotCalculateDerivatives() ) {
+      continue ;
+    }
+    if (i>0) {
+      conj=-1;
+    }
     addDerivativeOnVectorArgument( false, 1, i, index1, conj*pref*quat2[(5-i)%4], myvals );
     addDerivativeOnVectorArgument( false, 1, 4+i, ind2, pref2*quat1[(5-i)%4], myvals );
   }
@@ -142,13 +195,23 @@ void QuaternionProductMatrix::performTask( const std::string& controller, const
   conj=1;
   pref2=1;
   for (unsigned i=0; i<4; i++) {
-    if(i==1) pref=-1;
-    else pref=1;
-    if (i==3) pref2=-1;
-    else pref2=1;
+    if(i==1) {
+      pref=-1;
+    } else {
+      pref=1;
+    }
+    if (i==3) {
+      pref2=-1;
+    } else {
+      pref2=1;
+    }
     myvals.addValue( getConstPntrToComponent(2)->getPositionInStream(), pref*quat1[i]*quat2[(i+2)%4]);
-    if( doNotCalculateDerivatives() ) continue ;
-    if (i>0) conj=-1;
+    if( doNotCalculateDerivatives() ) {
+      continue ;
+    }
+    if (i>0) {
+      conj=-1;
+    }
     addDerivativeOnVectorArgument( false, 2, i, index1, conj*pref*quat2[(i+2)%4], myvals );
     addDerivativeOnVectorArgument( false, 2, 4+i, ind2, pref2*quat1[(i+2)%4], myvals );
   }
@@ -158,13 +221,23 @@ void QuaternionProductMatrix::performTask( const std::string& controller, const
   conj=1;
   pref2=1;
   for (unsigned i=0; i<4; i++) {
-    if(i==2) pref=-1;
-    else pref=1;
-    if(i==1) pref2=-1;
-    else pref2=1;
+    if(i==2) {
+      pref=-1;
+    } else {
+      pref=1;
+    }
+    if(i==1) {
+      pref2=-1;
+    } else {
+      pref2=1;
+    }
     myvals.addValue( getConstPntrToComponent(3)->getPositionInStream(), pref*quat1[i]*quat2[(3-i)]);
-    if( doNotCalculateDerivatives() ) continue ;
-    if (i>0) conj=-1;
+    if( doNotCalculateDerivatives() ) {
+      continue ;
+    }
+    if (i>0) {
+      conj=-1;
+    }
     addDerivativeOnVectorArgument( false, 3, i, index1, conj*pref*quat2[3-i], myvals );
     addDerivativeOnVectorArgument( false, 3, 4+i, ind2, pref2*quat1[3-i], myvals );
 
@@ -174,19 +247,34 @@ void QuaternionProductMatrix::performTask( const std::string& controller, const
 }
 
 void QuaternionProductMatrix::runEndOfRowJobs( const unsigned& ival, const std::vector<unsigned> & indices, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() || !matrixChainContinues() ) return ;
+  if( doNotCalculateDerivatives() || !matrixChainContinues() ) {
+    return ;
+  }
 
   for(unsigned j=0; j<getNumberOfComponents(); ++j) {
     unsigned nmat = getConstPntrToComponent(j)->getPositionInMatrixStash(), nmat_ind = myvals.getNumberOfMatrixRowDerivatives( nmat );
-    std::vector<unsigned>& matrix_indices( myvals.getMatrixRowDerivativeIndices( nmat ) ); unsigned ntwo_atoms = myvals.getSplitIndex();
+    std::vector<unsigned>& matrix_indices( myvals.getMatrixRowDerivativeIndices( nmat ) );
+    unsigned ntwo_atoms = myvals.getSplitIndex();
     // Quaternion for first molecule
-    unsigned base = 0; for(unsigned k=0; k<4; ++k) { matrix_indices[nmat_ind] = base + ival; base += getPntrToArgument(k)->getShape()[0]; nmat_ind++; }
+    unsigned base = 0;
+    for(unsigned k=0; k<4; ++k) {
+      matrix_indices[nmat_ind] = base + ival;
+      base += getPntrToArgument(k)->getShape()[0];
+      nmat_ind++;
+    }
     // Loop over row of matrix
     for(unsigned i=1; i<ntwo_atoms; ++i) {
-      unsigned ind2 = indices[i]; if( ind2>=getPntrToArgument(0)->getShape()[0] ) ind2 = indices[i] - getPntrToArgument(0)->getShape()[0];
+      unsigned ind2 = indices[i];
+      if( ind2>=getPntrToArgument(0)->getShape()[0] ) {
+        ind2 = indices[i] - getPntrToArgument(0)->getShape()[0];
+      }
       base = 4*getPntrToArgument(0)->getShape()[0];
       // Quaternion of second molecule
-      for(unsigned k=0; k<4; ++k) { matrix_indices[nmat_ind] = base + ind2; base += getPntrToArgument(4+k)->getShape()[0]; nmat_ind++; }
+      for(unsigned k=0; k<4; ++k) {
+        matrix_indices[nmat_ind] = base + ind2;
+        base += getPntrToArgument(4+k)->getShape()[0];
+        nmat_ind++;
+      }
     }
     myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind );
   }
diff --git a/src/crystdistrib/RopsShortcut.cpp b/src/crystdistrib/RopsShortcut.cpp
index d647de6664..22aa869ad3 100644
--- a/src/crystdistrib/RopsShortcut.cpp
+++ b/src/crystdistrib/RopsShortcut.cpp
@@ -64,39 +64,62 @@ void RopsShortcut::registerKeywords( Keywords& keys ) {
   keys.add("compulsory", "CUTOFF", "cutoff for the distance matrix");
 //  keys.add("compulsory","SWITCH","the switching function that acts on the distances between points)");
   keys.setValueDescription("the values of the ROPS order parameters");
-  keys.needsAction("DISTANCE_MATRIX"); keys.needsAction("QUATERNION_PRODUCT_MATRIX");
-  keys.needsAction("ONES"); keys.needsAction("CUSTOM"); keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("DISTANCE_MATRIX");
+  keys.needsAction("QUATERNION_PRODUCT_MATRIX");
+  keys.needsAction("ONES");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
 }
 
 RopsShortcut::RopsShortcut(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Open a file and read in the kernels
-  double h_dops,h_rops; std::string kfunc, kfunc_dops,kfunc_rops,fname_dops,fname_rops;
-  parse("KERNELFILE_DOPS",fname_dops); parse("KERNELFILE_ROPS",fname_rops); IFile ifile_dops, ifile_rops; ifile_dops.open(fname_dops); ifile_rops.open(fname_rops);
+  double h_dops,h_rops;
+  std::string kfunc, kfunc_dops,kfunc_rops,fname_dops,fname_rops;
+  parse("KERNELFILE_DOPS",fname_dops);
+  parse("KERNELFILE_ROPS",fname_rops);
+  IFile ifile_dops, ifile_rops;
+  ifile_dops.open(fname_dops);
+  ifile_rops.open(fname_rops);
   for(unsigned k=0;; ++k) {
-    if( !ifile_dops.scanField("height",h_dops) || !ifile_rops.scanField("height",h_rops) ) break;//checks eof
-    std::string ktype_dops, ktype_rops;  ifile_dops.scanField("kerneltype",ktype_dops); ifile_rops.scanField("kerneltype",ktype_rops);
-    if( ktype_dops!="gaussian" ) error("cannot process kernels of type " + ktype_dops );//straightup error
-    if( ktype_rops!="gaussian" ) error("cannot process kernels of type " + ktype_rops );
-
-    double mu_dops,mu_w, mu_i, mu_j, mu_k; std::string hstr_dops, hstr_rops, smu_dops,smu_w, smu_i, smu_j, smu_k, sigmastr,kappastr;
+    if( !ifile_dops.scanField("height",h_dops) || !ifile_rops.scanField("height",h_rops) ) {
+      break;  //checks eof
+    }
+    std::string ktype_dops, ktype_rops;
+    ifile_dops.scanField("kerneltype",ktype_dops);
+    ifile_rops.scanField("kerneltype",ktype_rops);
+    if( ktype_dops!="gaussian" ) {
+      error("cannot process kernels of type " + ktype_dops );  //straightup error
+    }
+    if( ktype_rops!="gaussian" ) {
+      error("cannot process kernels of type " + ktype_rops );
+    }
+
+    double mu_dops,mu_w, mu_i, mu_j, mu_k;
+    std::string hstr_dops, hstr_rops, smu_dops,smu_w, smu_i, smu_j, smu_k, sigmastr,kappastr;
 
 
     Tools::convert( h_dops, hstr_dops );
     Tools::convert( h_rops, hstr_rops );
 
-    ifile_dops.scanField("mu",mu_dops); Tools::convert( mu_dops, smu_dops );
-    ifile_rops.scanField("mu_w",mu_w); Tools::convert( mu_w, smu_w );
-    ifile_rops.scanField("mu_i",mu_i); Tools::convert( mu_i, smu_i );
-    ifile_rops.scanField("mu_j",mu_j); Tools::convert( mu_j, smu_j );
-    ifile_rops.scanField("mu_k",mu_k); Tools::convert( mu_k, smu_k );
+    ifile_dops.scanField("mu",mu_dops);
+    Tools::convert( mu_dops, smu_dops );
+    ifile_rops.scanField("mu_w",mu_w);
+    Tools::convert( mu_w, smu_w );
+    ifile_rops.scanField("mu_i",mu_i);
+    Tools::convert( mu_i, smu_i );
+    ifile_rops.scanField("mu_j",mu_j);
+    Tools::convert( mu_j, smu_j );
+    ifile_rops.scanField("mu_k",mu_k);
+    Tools::convert( mu_k, smu_k );
 
 
     double sigma,kappa;
-    ifile_dops.scanField("sigma",sigma); Tools::convert( sigma, sigmastr );
-    ifile_rops.scanField("kappa",kappa); Tools::convert( kappa, kappastr );
+    ifile_dops.scanField("sigma",sigma);
+    Tools::convert( sigma, sigmastr );
+    ifile_rops.scanField("kappa",kappa);
+    Tools::convert( kappa, kappastr );
 
 
 
@@ -105,24 +128,35 @@ RopsShortcut::RopsShortcut(const ActionOptions&ao):
 
     kfunc_rops += "*exp(" + kappastr + "*(w*" + smu_w + "+i*" + smu_i + "+j*" + smu_j + "+k*" + smu_k + ")^2)";
     kfunc_dops += "*exp(-(x-" + smu_dops +")^2/" + "(2*" + sigmastr +"*" +sigmastr + "))";
-    if (k==0) kfunc = kfunc_dops + "*" + kfunc_rops; else kfunc+= "+" + kfunc_dops + "*" + kfunc_rops;
+    if (k==0) {
+      kfunc = kfunc_dops + "*" + kfunc_rops;
+    } else {
+      kfunc+= "+" + kfunc_dops + "*" + kfunc_rops;
+    }
   }
   std::string sp_str, specA, specB, grpinfo;
   double cutoff;
-  parse("SPECIES",sp_str); parse("SPECIESA",specA); parse("SPECIESB",specB); parse("CUTOFF",cutoff);
+  parse("SPECIES",sp_str);
+  parse("SPECIESA",specA);
+  parse("SPECIESB",specB);
+  parse("CUTOFF",cutoff);
   if( sp_str.length()>0 ) {
     grpinfo="GROUP=" + sp_str;
   } else {//not sure how to use this
-    if( specA.length()==0 || specB.length()==0 ) error("no atoms were specified in input use either SPECIES or SPECIESA + SPECIESB");
+    if( specA.length()==0 || specB.length()==0 ) {
+      error("no atoms were specified in input use either SPECIES or SPECIESA + SPECIESB");
+    }
     grpinfo="GROUPA=" + specA + " GROUPB=" + specB;
   }
-  std::string cutstr; Tools::convert( cutoff, cutstr );
+  std::string cutstr;
+  Tools::convert( cutoff, cutstr );
   // Setup the contact matrix
 //  std::string switchstr; parse("SWITCH",switchstr);
   readInputLine( getShortcutLabel() + "_cmat: DISTANCE_MATRIX  " + grpinfo + " CUTOFF=" + cutstr);
 
   if( specA.length()==0 ) {
-    std::string quatstr; parse("QUATERNIONS",quatstr);
+    std::string quatstr;
+    parse("QUATERNIONS",quatstr);
     readInputLine( getShortcutLabel() + "_quatprod: QUATERNION_PRODUCT_MATRIX ARG=" + quatstr + ".*," + quatstr + ".*" );
   }  else {
     plumed_error();
@@ -134,7 +168,8 @@ RopsShortcut::RopsShortcut(const ActionOptions&ao):
   // Find the number of ones we need to multiply by
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_cmat");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   //
   readInputLine( getShortcutLabel() + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_kfunc," + getShortcutLabel() + "_ones");
diff --git a/src/dimred/ArrangePoints.cpp b/src/dimred/ArrangePoints.cpp
index 357eefe4d0..30910e3c14 100644
--- a/src/dimred/ArrangePoints.cpp
+++ b/src/dimred/ArrangePoints.cpp
@@ -59,7 +59,9 @@ class ArrangePoints :
 public:
   static void registerKeywords( Keywords& keys );
   ArrangePoints( const ActionOptions& );
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
   void prepare() override ;
   void calculate() override ;
   virtual void optimize( std::vector<double>& pos );
@@ -69,8 +71,10 @@ class ArrangePoints :
 PLUMED_REGISTER_ACTION(ArrangePoints,"ARRANGE_POINTS")
 
 void ArrangePoints::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.use("ARG");
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("numbered","TARGET","the matrix of target quantities that you would like to match");
   keys.add("numbered","FUNC","a function that is applied on the distances between the points in the low dimensional space");
   keys.add("numbered","WEIGHTS","the matrix with the weights of the target quantities");
@@ -92,96 +96,153 @@ ArrangePoints::ArrangePoints( const ActionOptions& ao ) :
   ActionWithValue(ao),
   ActionWithArguments(ao),
   current_index(0),
-  dist_target(-1)
-{
+  dist_target(-1) {
   dimout = getNumberOfArguments();
-  std::vector<unsigned> shape(1); shape[0]=getPntrToArgument(0)->getNumberOfValues();
+  std::vector<unsigned> shape(1);
+  shape[0]=getPntrToArgument(0)->getNumberOfValues();
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( shape[0]!=getPntrToArgument(i)->getNumberOfValues() ) error("mismatch between sizes of input coordinates");
-    std::string num; Tools::convert( i+1, num ); addComponent( "coord-" + num, shape );
-    componentIsNotPeriodic( "coord-" + num ); getPntrToArgument(i)->buildDataStore();
+    if( shape[0]!=getPntrToArgument(i)->getNumberOfValues() ) {
+      error("mismatch between sizes of input coordinates");
+    }
+    std::string num;
+    Tools::convert( i+1, num );
+    addComponent( "coord-" + num, shape );
+    componentIsNotPeriodic( "coord-" + num );
+    getPntrToArgument(i)->buildDataStore();
   }
-  std::vector<Value*> args( getArguments() ), target, weights; std::string sfd, errors;
+  std::vector<Value*> args( getArguments() ), target, weights;
+  std::string sfd, errors;
   // Read in target "distances" and target weights
   for(unsigned i=1;; ++i) {
-    target.resize(0); if( !parseArgumentList("TARGET",i,target) ) break;
-    std::string inum; Tools::convert( i, inum ); checkInputMatrix( "TARGET" + inum, shape[0], target );
-    if( !parseArgumentList("WEIGHTS",i,weights) ) error("missing WEIGHTS" + inum + " keyword in input");
+    target.resize(0);
+    if( !parseArgumentList("TARGET",i,target) ) {
+      break;
+    }
+    std::string inum;
+    Tools::convert( i, inum );
+    checkInputMatrix( "TARGET" + inum, shape[0], target );
+    if( !parseArgumentList("WEIGHTS",i,weights) ) {
+      error("missing WEIGHTS" + inum + " keyword in input");
+    }
     checkInputMatrix( "WEIGHTS" + inum, shape[0], weights );
-    args.push_back( target[0] ); args.push_back( weights[0] );
-    bool has_sf = parseNumbered("FUNC",i,sfd); switchingFunction.push_back( SwitchingFunction() );
+    args.push_back( target[0] );
+    args.push_back( weights[0] );
+    bool has_sf = parseNumbered("FUNC",i,sfd);
+    switchingFunction.push_back( SwitchingFunction() );
     if( !has_sf ) {
-      switchingFunction[i-1].set( "CUSTOM FUNC=1-sqrt(x2) R_0=1.0", errors ); dist_target=i-1;
+      switchingFunction[i-1].set( "CUSTOM FUNC=1-sqrt(x2) R_0=1.0", errors );
+      dist_target=i-1;
     } else {
       switchingFunction[i-1].set( sfd, errors );
-      if( errors.length()!=0 ) error("problem reading switching function description " + errors);
+      if( errors.length()!=0 ) {
+        error("problem reading switching function description " + errors);
+      }
     }
     log.printf("  %sth term seeks to match tranformed distances with those in matrix %s \n", inum.c_str(), target[0]->getName().c_str() );
     log.printf("  in %sth term distances are transformed by 1-switching function with r_0=%s \n", inum.c_str(), switchingFunction[i-1].description().c_str() );
     log.printf("  in %sth term weights of matrix elements in stress function are given by %s \n", inum.c_str(), weights[0]->getName().c_str() );
   }
-  std::string mtype; parse("MINTYPE",mtype);
+  std::string mtype;
+  parse("MINTYPE",mtype);
   if( mtype=="conjgrad" ) {
     mintype=conjgrad;
     log.printf("  minimimising stress function using conjugate gradients\n");
   } else if( mtype=="pointwise") {
     mintype=pointwise;
     log.printf("  minimimising stress function using pointwise global optimisation\n");
-    npoints.resize(dimout); nfgrid.resize(dimout);
-    parseVector("CGRID_SIZE",npoints); parse("BUFFER",gbuf); parse("NCYCLES",ncycles);
-    parseVector("FGRID_SIZE",nfgrid); if( nfgrid[0]!=0 && dimout!=2 ) error("interpolation only works in two dimensions");
+    npoints.resize(dimout);
+    nfgrid.resize(dimout);
+    parseVector("CGRID_SIZE",npoints);
+    parse("BUFFER",gbuf);
+    parse("NCYCLES",ncycles);
+    parseVector("FGRID_SIZE",nfgrid);
+    if( nfgrid[0]!=0 && dimout!=2 ) {
+      error("interpolation only works in two dimensions");
+    }
     log.printf("  doing %u cycles of global optimization sweeps\n",ncycles);
     log.printf("  using coarse grid of points that is %u",npoints[0]);
-    for(unsigned j=1; j<npoints.size(); ++j) log.printf(" by %u",npoints[j]);
+    for(unsigned j=1; j<npoints.size(); ++j) {
+      log.printf(" by %u",npoints[j]);
+    }
     log.printf("\n  grid is %f times larger than the difference between the position of the minimum and maximum projection \n",gbuf);
     if( nfgrid[0]>0 ) {
       log.printf("  interpolating stress onto grid of points that is %u",nfgrid[0]);
-      for(unsigned j=1; j<nfgrid.size(); ++j) log.printf(" by %u",nfgrid[j]);
+      for(unsigned j=1; j<nfgrid.size(); ++j) {
+        log.printf(" by %u",nfgrid[j]);
+      }
       log.printf("\n");
     }
   } else if( mtype=="smacof" ) {
-    mintype=smacof; if( dist_target<0 ) error("one of targets must be distances in order to use smacof");
+    mintype=smacof;
+    if( dist_target<0 ) {
+      error("one of targets must be distances in order to use smacof");
+    }
     log.printf("  minimising stress fucntion using smacof\n");
-    parse("SMACTOL",smacof_tol); parse("SMACREG",smacof_reg);
+    parse("SMACTOL",smacof_tol);
+    parse("SMACREG",smacof_reg);
     log.printf("  tolerance for smacof algorithms equals %f \n", smacof_tol);
     log.printf("  using %f as regularisation parameter for weights in smacof algorithm\n", smacof_reg);
-  } else error("invalid MINTYPE");
+  } else {
+    error("invalid MINTYPE");
+  }
   if( mintype!=smacof) {
-    parse("CGTOL",cgtol); log.printf("  tolerance for conjugate gradient algorithm equals %f \n",cgtol);
+    parse("CGTOL",cgtol);
+    log.printf("  tolerance for conjugate gradient algorithm equals %f \n",cgtol);
   }
-  parse("MAXITER",maxiter); log.printf("  maximum number of iterations for minimimization algorithms equals %d \n", maxiter );
-  requestArguments( args ); checkRead();
+  parse("MAXITER",maxiter);
+  log.printf("  maximum number of iterations for minimimization algorithms equals %d \n", maxiter );
+  requestArguments( args );
+  checkRead();
 }
 
 void ArrangePoints::checkInputMatrix( const std::string& key, const unsigned& nvals, const std::vector<Value*>& mat ) const {
   mat[0]->buildDataStore();
-  if( mat.size()!=1 ) error("should only be one value in input to " + key );
-  if( mat[0]->getRank()!=2 || mat[0]->hasDerivatives() ) error("input to " + key + " keyword should be a matrix");
-  if( mat[0]->getShape()[0]!=nvals || mat[0]->getShape()[1]!=nvals ) error("input to " + key + " keyword has the wrong size");
+  if( mat.size()!=1 ) {
+    error("should only be one value in input to " + key );
+  }
+  if( mat[0]->getRank()!=2 || mat[0]->hasDerivatives() ) {
+    error("input to " + key + " keyword should be a matrix");
+  }
+  if( mat[0]->getShape()[0]!=nvals || mat[0]->getShape()[1]!=nvals ) {
+    error("input to " + key + " keyword has the wrong size");
+  }
 }
 
 double ArrangePoints::calculateStress( const std::vector<double>& p, std::vector<double>& d ) {
-  double stress=0; for(unsigned i=0; i<p.size(); ++i) d[i]=0.0;
+  double stress=0;
+  for(unsigned i=0; i<p.size(); ++i) {
+    d[i]=0.0;
+  }
   std::vector<double> dtmp(dimout);
   std::vector<unsigned> shape( getPntrToArgument( dimout )->getShape() );
   unsigned targi=shape[0]*current_index;
   unsigned nmatrices = ( getNumberOfArguments() - dimout ) / 2;
   for(unsigned i=0; i<shape[0]; ++i) {
-    if( i==current_index ) continue ;
+    if( i==current_index ) {
+      continue ;
+    }
     // Calculate distance in low dimensional space
-    double dd2=0; for(unsigned k=0; k<dimout; ++k) { dtmp[k]=p[k] - mypos[dimout*i+k]; dd2+=dtmp[k]*dtmp[k]; }
+    double dd2=0;
+    for(unsigned k=0; k<dimout; ++k) {
+      dtmp[k]=p[k] - mypos[dimout*i+k];
+      dd2+=dtmp[k]*dtmp[k];
+    }
 
     for(unsigned k=0; k<nmatrices; ++k ) {
       // Now do transformations and calculate differences
       double df, fd = 1. - switchingFunction[k].calculateSqr( dd2, df );
       // Get the weight for this connection
       double weight = 0;
-      for(unsigned j=0; j<shape[0]; ++j) weight += getPntrToArgument( dimout + 2*k + 1 )->get( shape[0]*i+j );
+      for(unsigned j=0; j<shape[0]; ++j) {
+        weight += getPntrToArgument( dimout + 2*k + 1 )->get( shape[0]*i+j );
+      }
       // Get the difference for the connection
       double fdiff = fd - getPntrToArgument( dimout + 2*k )->get( targi+i );
       // Calculate derivatives
       double pref = -2.*weight*fdiff*df;
-      for(unsigned n=0; n<dimout; ++n) d[n] += pref*dtmp[n];
+      for(unsigned n=0; n<dimout; ++n) {
+        d[n] += pref*dtmp[n];
+      }
       // Accumulate the total stress
       stress += weight*fdiff*fdiff;
     }
@@ -191,15 +252,22 @@ double ArrangePoints::calculateStress( const std::vector<double>& p, std::vector
 
 double ArrangePoints::calculateFullStress( const std::vector<double>& p, std::vector<double>& d ) {
   // Zero derivative and stress accumulators
-  for(unsigned i=0; i<p.size(); ++i) d[i]=0.0;
-  double stress=0; std::vector<double> dtmp( dimout );
+  for(unsigned i=0; i<p.size(); ++i) {
+    d[i]=0.0;
+  }
+  double stress=0;
+  std::vector<double> dtmp( dimout );
 
   unsigned nmatrices = ( getNumberOfArguments() - dimout ) / 2;
   std::vector<unsigned> shape( getPntrToArgument( dimout )->getShape() );
   for(unsigned i=1; i<shape[0]; ++i) {
     for(unsigned j=0; j<i; ++j) {
       // Calculate distance in low dimensional space
-      double dd2=0; for(unsigned k=0; k<dimout; ++k) { dtmp[k]=p[dimout*i+k] - p[dimout*j+k]; dd2+=dtmp[k]*dtmp[k]; }
+      double dd2=0;
+      for(unsigned k=0; k<dimout; ++k) {
+        dtmp[k]=p[dimout*i+k] - p[dimout*j+k];
+        dd2+=dtmp[k]*dtmp[k];
+      }
 
       for(unsigned k=0; k<nmatrices; ++k ) {
         // Now do transformations and calculate differences
@@ -210,7 +278,11 @@ double ArrangePoints::calculateFullStress( const std::vector<double>& p, std::ve
         double fdiff = fd - getPntrToArgument( dimout + 2*k )->get( shape[0]*i+j );
         // Calculate derivatives
         double pref = -2.*weight*fdiff*df;
-        for(unsigned n=0; n<dimout; ++n) { double dterm=pref*dtmp[n]; d[dimout*i+n]+=dterm; d[dimout*j+n]-=dterm; }
+        for(unsigned n=0; n<dimout; ++n) {
+          double dterm=pref*dtmp[n];
+          d[dimout*i+n]+=dterm;
+          d[dimout*j+n]-=dterm;
+        }
         // Accumulate the total stress
         stress += weight*fdiff*fdiff;
       }
@@ -226,13 +298,20 @@ double ArrangePoints::recalculateSmacofWeights( const std::vector<double>& p, SM
   for(unsigned i=1; i<shape[0]; ++i) {
     for(unsigned j=0; j<i; ++j) {
       // Calculate distance in low dimensional space
-      double dd2=0; for(unsigned k=0; k<dimout; ++k) { double dtmp=p[dimout*i+k] - p[dimout*j+k]; dd2+=dtmp*dtmp; }
+      double dd2=0;
+      for(unsigned k=0; k<dimout; ++k) {
+        double dtmp=p[dimout*i+k] - p[dimout*j+k];
+        dd2+=dtmp*dtmp;
+      }
       // Calculate difference between target difference and true difference
-      double wval=0, dd1 = sqrt(dd2); double diff = mysmacof.getDistance(i,j) - dd1;
+      double wval=0, dd1 = sqrt(dd2);
+      double diff = mysmacof.getDistance(i,j) - dd1;
 
       for(unsigned k=0; k<nmatrices; ++k ) {
         // Don't need to do anything for distances we are matching
-        if( k==dist_target ) continue;
+        if( k==dist_target ) {
+          continue;
+        }
         // Now do transformations and calculate differences
         double df, fd = 1. - switchingFunction[k].calculateSqr( dd2, df );
         // Get the weight for this connection
@@ -240,11 +319,15 @@ double ArrangePoints::recalculateSmacofWeights( const std::vector<double>& p, SM
         // Get the difference for the connection
         double fdiff = getPntrToArgument( dimout + 2*k )->get( shape[0]*i+j ) - fd;
         // Now set the weight if difference in distance is larger than regularisation parameter
-        if( fabs(diff)>smacof_reg  ) wval -= weight*fdiff*df*dd1 / diff;
+        if( fabs(diff)>smacof_reg  ) {
+          wval -= weight*fdiff*df*dd1 / diff;
+        }
         // And the total stress and weights
-        stress += weight*fdiff*fdiff; totalWeight += weight;
+        stress += weight*fdiff*fdiff;
+        totalWeight += weight;
       }
-      mysmacof.setWeight( j, i, wval ); mysmacof.setWeight( i, j, wval );
+      mysmacof.setWeight( j, i, wval );
+      mysmacof.setWeight( i, j, wval );
     }
   }
   return stress / totalWeight;
@@ -258,18 +341,28 @@ void ArrangePoints::optimize( std::vector<double>& pos ) {
     unsigned nvals=getPntrToArgument( dimout )->getShape()[0];
     std::vector<double> gmin( dimout ), gmax( dimout ), mypoint( dimout );
     // Find the extent of the grid
-    for(unsigned j=0; j<dimout; ++j) gmin[j]=gmax[j]=pos[j];
+    for(unsigned j=0; j<dimout; ++j) {
+      gmin[j]=gmax[j]=pos[j];
+    }
     for(unsigned i=1; i<nvals; ++i) {
       for(unsigned j=0; j<dimout; ++j) {
-        if( pos[dimout*i+j] < gmin[j] ) gmin[j] = pos[dimout*i+j];
-        if( pos[dimout*i+j] > gmax[j] ) gmax[j] = pos[dimout*i+j];
+        if( pos[dimout*i+j] < gmin[j] ) {
+          gmin[j] = pos[dimout*i+j];
+        }
+        if( pos[dimout*i+j] > gmax[j] ) {
+          gmax[j] = pos[dimout*i+j];
+        }
       }
     }
     for(unsigned j=0; j<dimout; ++j) {
       double gbuffer = 0.5*gbuf*( gmax[j]-gmin[j] ) - 0.5*( gmax[j]- gmin[j] );
-      gmin[j]-=gbuffer; gmax[j]+=gbuffer;
+      gmin[j]-=gbuffer;
+      gmax[j]+=gbuffer;
+    }
+    mypos.resize( pos.size() );
+    for(unsigned i=0; i<mypos.size(); ++i) {
+      mypos[i] = pos[i];
     }
-    mypos.resize( pos.size() ); for(unsigned i=0; i<mypos.size(); ++i) mypos[i] = pos[i];
     gridtools::GridSearch<ArrangePoints> mygridsearch( gmin, gmax, npoints, nfgrid, this );
     // Run multiple loops over all projections
     for(unsigned i=0; i<ncycles; ++i) {
@@ -278,20 +371,27 @@ void ArrangePoints::optimize( std::vector<double>& pos ) {
         current_index=j;
 
         // Find current projection of jth point
-        for(unsigned k=0; k<dimout; ++k) mypoint[k]=mypos[j*dimout+k];
+        for(unsigned k=0; k<dimout; ++k) {
+          mypoint[k]=mypos[j*dimout+k];
+        }
         // Minimise using grid search
         bool moved=mygridsearch.minimise( mypoint, &ArrangePoints::calculateStress );
         if( moved ) {
           // Reassign the new projection
-          for(unsigned k=0; k<dimout; ++k) mypos[dimout*j+k]=mypoint[k];
+          for(unsigned k=0; k<dimout; ++k) {
+            mypos[dimout*j+k]=mypoint[k];
+          }
           // Minimise output using conjugate gradient
           mycgminimise.minimise( cgtol, mypos, &ArrangePoints::calculateFullStress );
         }
       }
-      for(unsigned i=0; i<mypos.size(); ++i) pos[i] = mypos[i];
+      for(unsigned i=0; i<mypos.size(); ++i) {
+        pos[i] = mypos[i];
+      }
     }
   } else if( mintype==smacof ) {
-    SMACOF mysmacof( getPntrToArgument( dimout + 2*dist_target) ); double stress = recalculateSmacofWeights( pos, mysmacof );
+    SMACOF mysmacof( getPntrToArgument( dimout + 2*dist_target) );
+    double stress = recalculateSmacofWeights( pos, mysmacof );
 
     for(unsigned i=0; i<maxiter; ++i) {
       // Optimise using smacof and current weights
@@ -299,7 +399,9 @@ void ArrangePoints::optimize( std::vector<double>& pos ) {
       // Recalculate weights matrix and sigma
       double newsig = recalculateSmacofWeights( pos, mysmacof );
       // Test whether or not the algorithm has converged
-      if( fabs( newsig - stress )<smacof_tol ) break;
+      if( fabs( newsig - stress )<smacof_tol ) {
+        break;
+      }
       // Make initial sigma into new sigma so that the value of new sigma is used every time so that the error can be reduced
       stress=newsig;
     }
@@ -310,7 +412,9 @@ void ArrangePoints::prepare() {
   // Make sure all the components are the right size
   std::vector<unsigned> shape(1,getPntrToArgument( dimout )->getShape()[0]);
   for(unsigned j=0; j<dimout; ++j) {
-    if( getPntrToComponent(j)->getShape()[0]!=shape[0] ) getPntrToComponent(j)->setShape( shape );
+    if( getPntrToComponent(j)->getShape()[0]!=shape[0] ) {
+      getPntrToComponent(j)->setShape( shape );
+    }
   }
 }
 
@@ -319,13 +423,17 @@ void ArrangePoints::calculate() {
   unsigned nvals = getPntrToArgument( dimout )->getShape()[0];
   std::vector<double> pos( dimout*nvals );
   for(unsigned i=0; i<nvals; ++i) {
-    for(unsigned j=0; j<dimout; ++j) pos[ dimout*i + j ] = getPntrToArgument(j)->get(i);
+    for(unsigned j=0; j<dimout; ++j) {
+      pos[ dimout*i + j ] = getPntrToArgument(j)->get(i);
+    }
   }
   // Do the optimization
   optimize( pos );
   // And set the final values
   for(unsigned i=0; i<nvals; ++i) {
-    for(unsigned j=0; j<dimout; ++j) getPntrToComponent(j)->set( i, pos[dimout*i+j] );
+    for(unsigned j=0; j<dimout; ++j) {
+      getPntrToComponent(j)->set( i, pos[dimout*i+j] );
+    }
   }
 }
 
diff --git a/src/dimred/ClassicalMultiDimensionalScaling.cpp b/src/dimred/ClassicalMultiDimensionalScaling.cpp
index ff948203e2..4e5d723fd6 100644
--- a/src/dimred/ClassicalMultiDimensionalScaling.cpp
+++ b/src/dimred/ClassicalMultiDimensionalScaling.cpp
@@ -176,24 +176,35 @@ void ClassicalMultiDimensionalScaling::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","ARG","the arguments that you would like to make the histogram for");
   keys.add("compulsory","NLOW_DIM","number of low-dimensional coordinates required");
   keys.setValueDescription("the low dimensional projections for the input data points");
-  keys.needsAction("TRANSPOSE"); keys.needsAction("DISSIMILARITIES"); keys.needsAction("MATRIX_VECTOR_PRODUCT"); keys.needsAction("VSTACK");
-  keys.needsAction("SUM"); keys.needsAction("CUSTOM"); keys.needsAction("OUTER_PRODUCT"); keys.needsAction("DIAGONALIZE");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("DISSIMILARITIES");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("VSTACK");
+  keys.needsAction("SUM");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("OUTER_PRODUCT");
+  keys.needsAction("DIAGONALIZE");
 }
 
 ClassicalMultiDimensionalScaling::ClassicalMultiDimensionalScaling( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Find the argument name
-  std::string argn; parse("ARG",argn); std::string dissimilarities="";
+  std::string argn;
+  parse("ARG",argn);
+  std::string dissimilarities="";
   ActionShortcut* as = plumed.getActionSet().getShortcutActionWithLabel( argn );
-  if( !as ) error("found no action with name " + argn );
+  if( !as ) {
+    error("found no action with name " + argn );
+  }
   if( as->getName()!="COLLECT_FRAMES" ) {
     if( as->getName().find("LANDMARK_SELECT")==std::string::npos ) {
       error("found no COLLECT_FRAMES or LANDMARK_SELECT action with label " + argn );
     } else {
       ActionWithValue* dissims = plumed.getActionSet().selectWithLabel<ActionWithValue*>( argn + "_sqrdissims");
-      if( dissims ) dissimilarities = argn + "_sqrdissims";
+      if( dissims ) {
+        dissimilarities = argn + "_sqrdissims";
+      }
     }
   }
   if( dissimilarities.length()==0 ) {
@@ -219,16 +230,27 @@ ClassicalMultiDimensionalScaling::ClassicalMultiDimensionalScaling( const Action
   // Step 4: subtract the column sums
   readInputLine( getShortcutLabel() + "_cmat: CUSTOM ARG=" + getShortcutLabel() + "_csummat," + getShortcutLabel() + "_intT FUNC=y-x PERIODIC=NO");
   // And generate the multidimensional scaling projection
-  unsigned ndim; parse("NLOW_DIM",ndim);
-  std::string vecstr="1"; for(unsigned i=1; i<ndim; ++i) { std::string num; Tools::convert( i+1, num ); vecstr += "," + num; }
+  unsigned ndim;
+  parse("NLOW_DIM",ndim);
+  std::string vecstr="1";
+  for(unsigned i=1; i<ndim; ++i) {
+    std::string num;
+    Tools::convert( i+1, num );
+    vecstr += "," + num;
+  }
   readInputLine( getShortcutLabel() + "_eig: DIAGONALIZE ARG=" + getShortcutLabel() + "_cmat VECTORS=" + vecstr );
   for(unsigned i=0; i<ndim; ++i) {
-    std::string num; Tools::convert( i+1, num );
+    std::string num;
+    Tools::convert( i+1, num );
     readInputLine( getShortcutLabel() + "-" +  num + ": CUSTOM ARG=" + getShortcutLabel() + "_eig.vals-" + num + "," + getShortcutLabel() + "_eig.vecs-" + num + " FUNC=sqrt(x)*y PERIODIC=NO");
   }
   std::string eigvec_args = " ARG=" + getShortcutLabel() + "-1";
   // The final output is a stack of all the low dimensional coordinates
-  for(unsigned i=1; i<ndim; ++i) { std::string num; Tools::convert( i+1, num ); eigvec_args += "," + getShortcutLabel() + "-" + num; }
+  for(unsigned i=1; i<ndim; ++i) {
+    std::string num;
+    Tools::convert( i+1, num );
+    eigvec_args += "," + getShortcutLabel() + "-" + num;
+  }
   readInputLine( getShortcutLabel() + ": VSTACK" + eigvec_args );
 }
 
diff --git a/src/dimred/PCA.cpp b/src/dimred/PCA.cpp
index 711697f6e3..35ad7ea727 100644
--- a/src/dimred/PCA.cpp
+++ b/src/dimred/PCA.cpp
@@ -114,20 +114,30 @@ void PCA::registerKeywords( Keywords& keys ) {
   keys.add("optional","FILE","the file on which to output the low dimensional coordinates");
   keys.add("optional","FMT","the format to use when outputting the low dimensional coordinates");
   keys.setValueDescription("the projections of the input coordinates on the PCA components that were found from the covariance matrix");
-  keys.needsAction("LOGSUMEXP"); keys.needsAction("TRANSPOSE"); keys.needsAction("MATRIX_VECTOR_PRODUCT");
-  keys.needsAction("CONSTANT"); keys.needsAction("COLLECT"); keys.needsAction("OUTER_PRODUCT"); keys.needsAction("CUSTOM");
-  keys.needsAction("MATRIX_PRODUCT"); keys.needsAction("DIAGONALIZE"); keys.needsAction("VSTACK"); keys.needsAction("DUMPPDB");
+  keys.needsAction("LOGSUMEXP");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("COLLECT");
+  keys.needsAction("OUTER_PRODUCT");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("MATRIX_PRODUCT");
+  keys.needsAction("DIAGONALIZE");
+  keys.needsAction("VSTACK");
+  keys.needsAction("DUMPPDB");
 }
 
 
 PCA::PCA(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Find the argument name
-  std::string argn; parse("ARG",argn);
+  std::string argn;
+  parse("ARG",argn);
   ActionShortcut* as = plumed.getActionSet().getShortcutActionWithLabel( argn );
-  if( !as || as->getName()!="COLLECT_FRAMES" ) error("found no COLLECT_FRAMES action with label " + argn );
+  if( !as || as->getName()!="COLLECT_FRAMES" ) {
+    error("found no COLLECT_FRAMES action with label " + argn );
+  }
   // Get the final weights using the logsumexp trick
   readInputLine( getShortcutLabel() + "_weights: LOGSUMEXP ARG=" + argn + "_logweights");
   // Now transpose the collected frames
@@ -138,9 +148,14 @@ PCA::PCA(const ActionOptions&ao):
   readInputLine( getShortcutLabel() + "_averages: OUTER_PRODUCT ARG=" + argn + "_ones," + getShortcutLabel() + "_mean");
   // Make a matrix of weights
   ActionWithValue* av2 = plumed.getActionSet().selectWithLabel<ActionWithValue*>( argn + "_data" );
-  if( !av2 ) error("count not find data");
+  if( !av2 ) {
+    error("count not find data");
+  }
   unsigned nones = (av2->copyOutput(0))->getShape()[1];
-  std::string ones="1"; for(unsigned i=1; i<nones; ++i) ones += ",1";
+  std::string ones="1";
+  for(unsigned i=1; i<nones; ++i) {
+    ones += ",1";
+  }
   readInputLine( getShortcutLabel() + "_wones: CONSTANT VALUES=" + ones );
   readInputLine( getShortcutLabel() + "_wmat: OUTER_PRODUCT ARG=" + getShortcutLabel() + "_weights," + getShortcutLabel() + "_wones");
   // And compute the data substract the mean
@@ -150,32 +165,68 @@ PCA::PCA(const ActionOptions&ao):
   readInputLine( getShortcutLabel() + "_wdiffT: TRANSPOSE ARG=" + getShortcutLabel() + "_wdiff");
   readInputLine( getShortcutLabel() + "_covar: MATRIX_PRODUCT ARG=" + getShortcutLabel() + "_wdiffT," + getShortcutLabel() + "_wdiff");
   // Read the dimensionality of the low dimensional space
-  unsigned ndim; parse("NLOW_DIM",ndim); std::string vecstr="1";
-  if( ndim<=0 || ndim>nones ) error("cannot generate projection in space of dimension higher than input coordinates");
-  for(unsigned i=1; i<ndim; ++i) { std::string num; Tools::convert( i+1, num ); vecstr += "," + num; }
+  unsigned ndim;
+  parse("NLOW_DIM",ndim);
+  std::string vecstr="1";
+  if( ndim<=0 || ndim>nones ) {
+    error("cannot generate projection in space of dimension higher than input coordinates");
+  }
+  for(unsigned i=1; i<ndim; ++i) {
+    std::string num;
+    Tools::convert( i+1, num );
+    vecstr += "," + num;
+  }
   readInputLine( getShortcutLabel() + "_eig: DIAGONALIZE ARG=" + getShortcutLabel() + "_covar VECTORS=" + vecstr );
   // Now create a matrix to hold the output data
   std::string outd = "ARG=" + getShortcutLabel() + "_mean";
-  for(unsigned i=0; i<ndim; ++i) { std::string num; Tools::convert( i+1, num ); outd += "," + getShortcutLabel() + "_eig.vecs-" + num; }
+  for(unsigned i=0; i<ndim; ++i) {
+    std::string num;
+    Tools::convert( i+1, num );
+    outd += "," + getShortcutLabel() + "_eig.vecs-" + num;
+  }
   readInputLine( getShortcutLabel() + "_pcaT: VSTACK " + outd );
   readInputLine( getShortcutLabel() + "_pca: TRANSPOSE ARG=" + getShortcutLabel() + "_pcaT");
   // And output it all
-  std::string filename, pstride; parse("STRIDE",pstride); parse("FILE",filename);
+  std::string filename, pstride;
+  parse("STRIDE",pstride);
+  parse("FILE",filename);
   if( filename.length()>0 && av2->getName()=="VSTACK" ) {
-    std::vector<std::string> argnames; av2->getMatrixColumnTitles( argnames );
-    std::string argname_str=argnames[0]; for(unsigned i=1; i<argnames.size(); ++i) argname_str += "," + argnames[i];
-    std::string fmt; parse("FMT",fmt); if( fmt.length()>0 ) fmt=" FMT=" + fmt;
+    std::vector<std::string> argnames;
+    av2->getMatrixColumnTitles( argnames );
+    std::string argname_str=argnames[0];
+    for(unsigned i=1; i<argnames.size(); ++i) {
+      argname_str += "," + argnames[i];
+    }
+    std::string fmt;
+    parse("FMT",fmt);
+    if( fmt.length()>0 ) {
+      fmt=" FMT=" + fmt;
+    }
     readInputLine("DUMPPDB DESCRIPTION=PCA ARG_NAMES=" + argname_str + " ARG=" + getShortcutLabel() + "_pca FILE=" + filename + " STRIDE=" + pstride + fmt );
   } else {
-    if( av2->getName()!="COLLECT" ) error("input data should be VSTACK if list of arguments of COLLECT if atom positions");
+    if( av2->getName()!="COLLECT" ) {
+      error("input data should be VSTACK if list of arguments of COLLECT if atom positions");
+    }
     ActionAtomistic* rmsdact = plumed.getActionSet().selectWithLabel<ActionAtomistic*>( argn + "_getposx" );
-    if( !rmsdact ) error("could not find action that gets positions from trajectory for RMSD");
-    std::vector<AtomNumber> atoms( rmsdact->getAbsoluteIndexes() ); std::string indices; Tools::convert( atoms[0].serial(), indices );
-    for(unsigned i=1; i<atoms.size(); ++i) { std::string jnum; Tools::convert( atoms[i].serial(), jnum ); indices += "," + jnum; }
+    if( !rmsdact ) {
+      error("could not find action that gets positions from trajectory for RMSD");
+    }
+    std::vector<AtomNumber> atoms( rmsdact->getAbsoluteIndexes() );
+    std::string indices;
+    Tools::convert( atoms[0].serial(), indices );
+    for(unsigned i=1; i<atoms.size(); ++i) {
+      std::string jnum;
+      Tools::convert( atoms[i].serial(), jnum );
+      indices += "," + jnum;
+    }
     readInputLine("DUMPPDB DESCRIPTION=PCA ATOM_INDICES=" + indices + " ATOMS=" + getShortcutLabel() + "_pca FILE=" + filename + " STRIDE=" + pstride );
   }
   outd = "ARG=" + getShortcutLabel() + "_eig.vecs-1";
-  for(unsigned i=1; i<ndim; ++i) { std::string num; Tools::convert( i+1, num ); outd += "," + getShortcutLabel() + "_eig.vecs-" + num; }
+  for(unsigned i=1; i<ndim; ++i) {
+    std::string num;
+    Tools::convert( i+1, num );
+    outd += "," + getShortcutLabel() + "_eig.vecs-" + num;
+  }
   readInputLine( getShortcutLabel() + "_eigv: VSTACK " + outd );
   readInputLine( getShortcutLabel() + ": MATRIX_PRODUCT ARG=" + getShortcutLabel() + "_diff," + getShortcutLabel() + "_eigv");
 }
diff --git a/src/dimred/ProjectPoints.cpp b/src/dimred/ProjectPoints.cpp
index 1b6bb2de57..eb05df3121 100644
--- a/src/dimred/ProjectPoints.cpp
+++ b/src/dimred/ProjectPoints.cpp
@@ -49,7 +49,9 @@ class ProjectPoints : public ActionWithVector {
 public:
   static void registerKeywords( Keywords& keys );
   ProjectPoints( const ActionOptions& );
-  unsigned getNumberOfDerivatives() { return 0; }
+  unsigned getNumberOfDerivatives() {
+    return 0;
+  }
   void prepare() override ;
   void performTask( const unsigned& current, MultiValue& myvals ) const override ;
   double calculateStress( const std::vector<double>& pp, std::vector<double>& der );
@@ -60,7 +62,8 @@ class ProjectPoints : public ActionWithVector {
 PLUMED_REGISTER_ACTION(ProjectPoints,"PROJECT_POINTS")
 
 void ProjectPoints::registerKeywords( Keywords& keys ) {
-  ActionWithVector::registerKeywords( keys ); keys.use("ARG");
+  ActionWithVector::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("numbered","TARGET","the matrix of target quantities that you would like to match");
   keys.add("numbered","FUNC","a function that is applied on the distances between the points in the low dimensional space");
   keys.add("numbered","WEIGHTS","the matrix with the weights of the target quantities");
@@ -73,67 +76,119 @@ ProjectPoints::ProjectPoints( const ActionOptions& ao ) :
   Action(ao),
   ActionWithVector(ao),
   rowstart(OpenMP::getNumThreads()),
-  myminimiser( this )
-{
-  dimout = getNumberOfArguments(); unsigned nvals=getPntrToArgument(0)->getNumberOfValues();
+  myminimiser( this ) {
+  dimout = getNumberOfArguments();
+  unsigned nvals=getPntrToArgument(0)->getNumberOfValues();
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( nvals!=getPntrToArgument(i)->getNumberOfValues() ) error("mismatch between numbers of projections");
+    if( nvals!=getPntrToArgument(i)->getNumberOfValues() ) {
+      error("mismatch between numbers of projections");
+    }
   }
-  std::vector<Value*> args( getArguments() ), target, weights; std::string sfd, errors; unsigned ntoproj=0;
+  std::vector<Value*> args( getArguments() ), target, weights;
+  std::string sfd, errors;
+  unsigned ntoproj=0;
   // Read in target "distances" and target weights
   for(unsigned i=1;; ++i) {
-    target.resize(0); if( !parseArgumentList("TARGET",i,target) ) break;
-    std::string inum; Tools::convert( i, inum );
-    if( target.size()!=1 ) error("should only be one value in input to TARGET" + inum );
-    if( (target[0]->getRank()!=1 && target[0]->getRank()!=2) || target[0]->hasDerivatives() ) error("input to TARGET" + inum + " keyword should be a vector/matrix");
-    if( target[0]->getShape()[0]!=nvals ) error("number of rows in target matrix should match number of input coordinates");
-    if( i==1 && target[0]->getRank()==1 ) { ntoproj = 1; }
-    else if( ntoproj==1 && target[0]->getRank()!=1 ) error("mismatch between numbers of target distances");
-    else if( i==1 ) ntoproj = target[0]->getShape()[1];
-    else if( ntoproj!=target[0]->getShape()[1] ) error("mismatch between numbers of target distances");
-    if( !parseArgumentList("WEIGHTS",i,weights) ) error("missing WEIGHTS" + inum + " keyword in input");
-    if( weights.size()!=1 ) error("should only be one value in input to WEIGHTS" + inum );
-    if( weights[0]->getRank()!=1 || weights[0]->hasDerivatives() ) error("input to WEIGHTS" + inum + " keyword should be a vector");
-    if( weights[0]->getShape()[0]!=nvals ) error("number of weights should match number of input coordinates");
-    target[0]->buildDataStore(); weights[0]->buildDataStore(); args.push_back( target[0] ); args.push_back( weights[0] );
-    bool has_sf = parseNumbered("FUNC",i,sfd); switchingFunction.push_back( SwitchingFunction() );
+    target.resize(0);
+    if( !parseArgumentList("TARGET",i,target) ) {
+      break;
+    }
+    std::string inum;
+    Tools::convert( i, inum );
+    if( target.size()!=1 ) {
+      error("should only be one value in input to TARGET" + inum );
+    }
+    if( (target[0]->getRank()!=1 && target[0]->getRank()!=2) || target[0]->hasDerivatives() ) {
+      error("input to TARGET" + inum + " keyword should be a vector/matrix");
+    }
+    if( target[0]->getShape()[0]!=nvals ) {
+      error("number of rows in target matrix should match number of input coordinates");
+    }
+    if( i==1 && target[0]->getRank()==1 ) {
+      ntoproj = 1;
+    } else if( ntoproj==1 && target[0]->getRank()!=1 ) {
+      error("mismatch between numbers of target distances");
+    } else if( i==1 ) {
+      ntoproj = target[0]->getShape()[1];
+    } else if( ntoproj!=target[0]->getShape()[1] ) {
+      error("mismatch between numbers of target distances");
+    }
+    if( !parseArgumentList("WEIGHTS",i,weights) ) {
+      error("missing WEIGHTS" + inum + " keyword in input");
+    }
+    if( weights.size()!=1 ) {
+      error("should only be one value in input to WEIGHTS" + inum );
+    }
+    if( weights[0]->getRank()!=1 || weights[0]->hasDerivatives() ) {
+      error("input to WEIGHTS" + inum + " keyword should be a vector");
+    }
+    if( weights[0]->getShape()[0]!=nvals ) {
+      error("number of weights should match number of input coordinates");
+    }
+    target[0]->buildDataStore();
+    weights[0]->buildDataStore();
+    args.push_back( target[0] );
+    args.push_back( weights[0] );
+    bool has_sf = parseNumbered("FUNC",i,sfd);
+    switchingFunction.push_back( SwitchingFunction() );
     if( !has_sf ) {
       switchingFunction[i-1].set( "CUSTOM FUNC=1-sqrt(x2) R_0=1.0", errors );
     } else {
       switchingFunction[i-1].set( sfd, errors );
-      if( errors.length()!=0 ) error("problem reading switching function description " + errors);
+      if( errors.length()!=0 ) {
+        error("problem reading switching function description " + errors);
+      }
     }
     log.printf("  %sth term seeks to match tranformed distances with those in matrix %s \n", inum.c_str(), target[0]->getName().c_str() );
     log.printf("  in %sth term distances are transformed by 1-switching function with r_0=%s \n", inum.c_str(), switchingFunction[i-1].description().c_str() );
     log.printf("  in %sth term weights of matrix elements in stress function are given by %s \n", inum.c_str(), weights[0]->getName().c_str() );
   }
-  std::vector<unsigned> shape(1); shape[0]=ntoproj; if( ntoproj==1 ) shape.resize(0);
+  std::vector<unsigned> shape(1);
+  shape[0]=ntoproj;
+  if( ntoproj==1 ) {
+    shape.resize(0);
+  }
   for(unsigned i=0; i<dimout; ++i) {
-    std::string num; Tools::convert( i+1, num ); addComponent( "coord-" + num, shape );
+    std::string num;
+    Tools::convert( i+1, num );
+    addComponent( "coord-" + num, shape );
     componentIsNotPeriodic( "coord-" + num );
   }
   // Create a list of tasks to perform
-  parse("CGTOL",cgtol); log.printf("  tolerance for conjugate gradient algorithm equals %f \n",cgtol);
-  requestArguments( args ); checkRead();
+  parse("CGTOL",cgtol);
+  log.printf("  tolerance for conjugate gradient algorithm equals %f \n",cgtol);
+  requestArguments( args );
+  checkRead();
 }
 
 void ProjectPoints::prepare() {
-  if( getPntrToComponent(0)->getRank()==0 ) return;
+  if( getPntrToComponent(0)->getRank()==0 ) {
+    return;
+  }
 
-  std::vector<unsigned> shape(1); shape[0] = getPntrToArgument(dimout)->getShape()[0];
+  std::vector<unsigned> shape(1);
+  shape[0] = getPntrToArgument(dimout)->getShape()[0];
   for(unsigned i=0; i<dimout; ++i) {
-    if( getPntrToComponent(i)->getShape()[0]!=shape[0] ) getPntrToComponent(i)->setShape(shape);
+    if( getPntrToComponent(i)->getShape()[0]!=shape[0] ) {
+      getPntrToComponent(i)->setShape(shape);
+    }
   }
 }
 
 double ProjectPoints::calculateStress( const std::vector<double>& pp, std::vector<double>& der ) {
-  unsigned nmatrices = ( getNumberOfArguments() - dimout ) / 2; double stress=0;
+  unsigned nmatrices = ( getNumberOfArguments() - dimout ) / 2;
+  double stress=0;
 
   unsigned t=OpenMP::getThreadNum();
-  std::vector<double> dtmp( pp.size() ); unsigned nland = getPntrToArgument(0)->getShape()[0];
+  std::vector<double> dtmp( pp.size() );
+  unsigned nland = getPntrToArgument(0)->getShape()[0];
   for(unsigned i=0; i<nland; ++i) {
     // Calculate distance in low dimensional space
-    double dd2 = 0; for(unsigned k=0; k<pp.size(); ++k) { dtmp[k] = pp[k] - getPntrToArgument(k)->get(i); dd2 += dtmp[k]*dtmp[k]; }
+    double dd2 = 0;
+    for(unsigned k=0; k<pp.size(); ++k) {
+      dtmp[k] = pp[k] - getPntrToArgument(k)->get(i);
+      dd2 += dtmp[k]*dtmp[k];
+    }
 
     for(unsigned k=0; k<nmatrices; ++k ) {
       // Now do transformations and calculate differences
@@ -143,7 +198,10 @@ double ProjectPoints::calculateStress( const std::vector<double>& pp, std::vecto
       // Get the difference for the connection
       double fdiff = fd - getPntrToArgument( dimout + 2*k )->get( rowstart[t]+i );
       // Calculate derivatives
-      double pref = -2.*weight*fdiff*df; for(unsigned n=0; n<pp.size(); ++n) der[n]+=pref*dtmp[n];
+      double pref = -2.*weight*fdiff*df;
+      for(unsigned n=0; n<pp.size(); ++n) {
+        der[n]+=pref*dtmp[n];
+      }
       // Accumulate the total stress
       stress += weight*fdiff*fdiff;
     }
@@ -152,31 +210,53 @@ double ProjectPoints::calculateStress( const std::vector<double>& pp, std::vecto
 }
 
 void ProjectPoints::getProjection( const unsigned& current, std::vector<double>& point ) const {
-  Value* targ = getPntrToArgument( dimout ); unsigned nland = getPntrToArgument(0)->getShape()[0];
-  unsigned base = current; if( targ->getRank()==2 ) base = current*targ->getShape()[1];
-  unsigned closest=0; double mindist = targ->get( base );
+  Value* targ = getPntrToArgument( dimout );
+  unsigned nland = getPntrToArgument(0)->getShape()[0];
+  unsigned base = current;
+  if( targ->getRank()==2 ) {
+    base = current*targ->getShape()[1];
+  }
+  unsigned closest=0;
+  double mindist = targ->get( base );
   for(unsigned i=1; i<nland; ++i) {
     double dist = targ->get( base + i );
-    if( dist<mindist ) { mindist=dist; closest=i; }
+    if( dist<mindist ) {
+      mindist=dist;
+      closest=i;
+    }
   }
   // Put the initial guess near to the closest landmark  -- may wish to use grid here again Sandip??
-  Random random; random.setSeed(-1234);
-  for(unsigned j=0; j<dimout; ++j) point[j] = getPntrToArgument(j)->get(closest) + (random.RandU01() - 0.5)*0.01;
+  Random random;
+  random.setSeed(-1234);
+  for(unsigned j=0; j<dimout; ++j) {
+    point[j] = getPntrToArgument(j)->get(closest) + (random.RandU01() - 0.5)*0.01;
+  }
   // And do the optimisation
-  rowstart[OpenMP::getThreadNum()]=current; if( targ->getRank()==2 ) rowstart[OpenMP::getThreadNum()] = current*targ->getShape()[1];
+  rowstart[OpenMP::getThreadNum()]=current;
+  if( targ->getRank()==2 ) {
+    rowstart[OpenMP::getThreadNum()] = current*targ->getShape()[1];
+  }
   myminimiser.minimise( cgtol, point, &ProjectPoints::calculateStress );
 }
 
 void ProjectPoints::performTask( const unsigned& current, MultiValue& myvals ) const {
-  std::vector<double> point( dimout ); getProjection( current, point );
-  for(unsigned j=0; j<dimout; ++j) myvals.setValue( getConstPntrToComponent(j)->getPositionInStream(), point[j] );
+  std::vector<double> point( dimout );
+  getProjection( current, point );
+  for(unsigned j=0; j<dimout; ++j) {
+    myvals.setValue( getConstPntrToComponent(j)->getPositionInStream(), point[j] );
+  }
 }
 
 void ProjectPoints::calculate() {
   if( getPntrToComponent(0)->getRank()==0 ) {
-    std::vector<double> point( dimout ); getProjection( 0, point );
-    for(unsigned i=0; i<dimout; ++i) getPntrToComponent(i)->set(point[i]);
-  } else runAllTasks();
+    std::vector<double> point( dimout );
+    getProjection( 0, point );
+    for(unsigned i=0; i<dimout; ++i) {
+      getPntrToComponent(i)->set(point[i]);
+    }
+  } else {
+    runAllTasks();
+  }
 }
 
 }
diff --git a/src/dimred/SMACOF.cpp b/src/dimred/SMACOF.cpp
index ded2f633e9..b07076a81b 100644
--- a/src/dimred/SMACOF.cpp
+++ b/src/dimred/SMACOF.cpp
@@ -24,83 +24,120 @@
 namespace PLMD {
 namespace dimred {
 
-SMACOF::SMACOF( const Value* target)
-{
+SMACOF::SMACOF( const Value* target) {
   std::vector<unsigned> shape( target->getShape() );
-  Distances.resize( shape[0], shape[1] ); Weights.resize( shape[0], shape[1] );
+  Distances.resize( shape[0], shape[1] );
+  Weights.resize( shape[0], shape[1] );
   for(unsigned i=0; i<shape[0]; ++i) {
-    for(unsigned j=0; j<shape[1]; ++j) Distances(i,j) = sqrt( target->get(shape[0]*i+j) );
+    for(unsigned j=0; j<shape[1]; ++j) {
+      Distances(i,j) = sqrt( target->get(shape[0]*i+j) );
+    }
   }
 }
 
 void SMACOF::optimize( const double& tol, const unsigned& maxloops, std::vector<double>& proj ) {
-  unsigned M = Distances.nrows(); unsigned nlow=proj.size() / M; Matrix<double> Z( M, nlow );
+  unsigned M = Distances.nrows();
+  unsigned nlow=proj.size() / M;
+  Matrix<double> Z( M, nlow );
   // Transfer initial projection to matrix
   unsigned k = 0;
   for(unsigned i=0; i<M; ++i) {
-    for(unsigned j=0; j<nlow; ++j) { Z(i,j)=proj[k]; k++; }
+    for(unsigned j=0; j<nlow; ++j) {
+      Z(i,j)=proj[k];
+      k++;
+    }
   }
 
   // Calculate V
   Matrix<double> V(M,M);
   for(unsigned i=0; i<M; ++i) {
     for(unsigned j=0; j<M; ++j) {
-      if(i==j) continue;
+      if(i==j) {
+        continue;
+      }
       V(i,j)=-Weights(i,j);
     }
     for(unsigned j=0; j<M; ++j) {
-      if(i==j)continue;
+      if(i==j) {
+        continue;
+      }
       V(i,i)-=V(i,j);
     }
   }
   // And pseudo invert V
-  Matrix<double> mypseudo(M, M); pseudoInvert(V, mypseudo);
-  Matrix<double> dists( M, M ); double myfirstsig = calculateSigma( Z, dists );
+  Matrix<double> mypseudo(M, M);
+  pseudoInvert(V, mypseudo);
+  Matrix<double> dists( M, M );
+  double myfirstsig = calculateSigma( Z, dists );
 
   // initial sigma is made up of the original distances minus the distances between the projections all squared.
   Matrix<double> temp( M, M ), BZ( M, M ), newZ( M, nlow );
   for(unsigned n=0; n<maxloops; ++n) {
-    if(n==maxloops-1) plumed_merror("ran out of steps in SMACOF algorithm");
+    if(n==maxloops-1) {
+      plumed_merror("ran out of steps in SMACOF algorithm");
+    }
 
     // Recompute BZ matrix
     for(unsigned i=0; i<M; ++i) {
       for(unsigned j=0; j<M; ++j) {
-        if(i==j) continue;  //skips over the diagonal elements
-
-        if( dists(i,j)>0 ) BZ(i,j) = -Weights(i,j)*Distances(i,j) / dists(i,j);
-        else BZ(i,j)=0.;
+        if(i==j) {
+          continue;  //skips over the diagonal elements
+        }
+
+        if( dists(i,j)>0 ) {
+          BZ(i,j) = -Weights(i,j)*Distances(i,j) / dists(i,j);
+        } else {
+          BZ(i,j)=0.;
+        }
       }
       //the diagonal elements are -off diagonal elements BZ(i,i)-=BZ(i,j)   (Equation 8.25)
       BZ(i,i)=0; //create the space memory for the diagonal elements which are scalars
       for(unsigned j=0; j<M; ++j) {
-        if(i==j) continue;
+        if(i==j) {
+          continue;
+        }
         BZ(i,i)-=BZ(i,j);
       }
     }
 
-    mult( mypseudo, BZ, temp); mult(temp, Z, newZ);
+    mult( mypseudo, BZ, temp);
+    mult(temp, Z, newZ);
     //Compute new sigma
     double newsig = calculateSigma( newZ, dists );
     //Computing whether the algorithm has converged (has the mass of the potato changed
     //when we put it back in the oven!)
-    if( fabs( newsig - myfirstsig )<tol ) break;
-    myfirstsig=newsig; Z = newZ;
+    if( fabs( newsig - myfirstsig )<tol ) {
+      break;
+    }
+    myfirstsig=newsig;
+    Z = newZ;
   }
 
   // Transfer final projection matrix to output proj
   k = 0;
   for(unsigned i=0; i<M; ++i) {
-    for(unsigned j=0; j<nlow; ++j) { proj[k]=Z(i,j); k++; }
+    for(unsigned j=0; j<nlow; ++j) {
+      proj[k]=Z(i,j);
+      k++;
+    }
   }
 }
 
 double SMACOF::calculateSigma( const Matrix<double>& Z, Matrix<double>& dists ) {
-  unsigned M = Distances.nrows(); double sigma=0; double totalWeight=0;
+  unsigned M = Distances.nrows();
+  double sigma=0;
+  double totalWeight=0;
   for(unsigned i=1; i<M; ++i) {
     for(unsigned j=0; j<i; ++j) {
-      double dlow=0; for(unsigned k=0; k<Z.ncols(); ++k) { double tmp=Z(i,k) - Z(j,k); dlow+=tmp*tmp; }
-      dists(i,j)=dists(j,i)=sqrt(dlow); double tmp3 = Distances(i,j) - dists(i,j);
-      sigma += Weights(i,j)*tmp3*tmp3; totalWeight+=Weights(i,j);
+      double dlow=0;
+      for(unsigned k=0; k<Z.ncols(); ++k) {
+        double tmp=Z(i,k) - Z(j,k);
+        dlow+=tmp*tmp;
+      }
+      dists(i,j)=dists(j,i)=sqrt(dlow);
+      double tmp3 = Distances(i,j) - dists(i,j);
+      sigma += Weights(i,j)*tmp3*tmp3;
+      totalWeight+=Weights(i,j);
     }
   }
   return sigma / totalWeight;
diff --git a/src/dimred/SketchMap.cpp b/src/dimred/SketchMap.cpp
index 698ad35b8c..14f25e74ea 100644
--- a/src/dimred/SketchMap.cpp
+++ b/src/dimred/SketchMap.cpp
@@ -65,35 +65,53 @@ void SketchMap::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","SMACREG","0.001","this is used to ensure that we don't divide by zero when updating weights for SMACOF algorithm");
   keys.setValueDescription("the sketch-map projection of the input points");
   keys.addOutputComponent("osample","PROJECT_ALL","the out-of-sample projections");
-  keys.needsAction("CLASSICAL_MDS"); keys.needsAction("MORE_THAN"); keys.needsAction("SUM"); keys.needsAction("CUSTOM");
-  keys.needsAction("OUTER_PRODUCT"); keys.needsAction("ARRANGE_POINTS"); keys.needsAction("PROJECT_POINTS"); keys.needsAction("VSTACK");
+  keys.needsAction("CLASSICAL_MDS");
+  keys.needsAction("MORE_THAN");
+  keys.needsAction("SUM");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("OUTER_PRODUCT");
+  keys.needsAction("ARRANGE_POINTS");
+  keys.needsAction("PROJECT_POINTS");
+  keys.needsAction("VSTACK");
 }
 
 SketchMap::SketchMap( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Get the high dimensioal data
-  std::string argn; parse("ARG",argn); std::string dissimilarities = getShortcutLabel() + "_mds_mat";
+  std::string argn;
+  parse("ARG",argn);
+  std::string dissimilarities = getShortcutLabel() + "_mds_mat";
   ActionShortcut* as = plumed.getActionSet().getShortcutActionWithLabel( argn );
-  if( !as ) error("found no action with name " + argn );
+  if( !as ) {
+    error("found no action with name " + argn );
+  }
   if( as->getName()!="COLLECT_FRAMES" ) {
     if( as->getName().find("LANDMARK_SELECT")==std::string::npos ) {
       error("found no COLLECT_FRAMES or LANDMARK_SELECT action with label " + argn );
     } else {
       ActionWithValue* dissims = plumed.getActionSet().selectWithLabel<ActionWithValue*>( argn + "_sqrdissims");
-      if( dissims ) dissimilarities = argn + "_sqrdissims";
+      if( dissims ) {
+        dissimilarities = argn + "_sqrdissims";
+      }
     }
   }
-  unsigned ndim; parse("NLOW_DIM",ndim);
-  std::string str_ndim; Tools::convert( ndim, str_ndim );
+  unsigned ndim;
+  parse("NLOW_DIM",ndim);
+  std::string str_ndim;
+  Tools::convert( ndim, str_ndim );
   // Construct a projection using classical MDS
   readInputLine( getShortcutLabel() + "_mds: CLASSICAL_MDS ARG=" + argn + " NLOW_DIM=" + str_ndim );
   // Transform the dissimilarities using the switching function
-  std::string hdfunc; parse("HIGH_DIM_FUNCTION",hdfunc);
+  std::string hdfunc;
+  parse("HIGH_DIM_FUNCTION",hdfunc);
   readInputLine( getShortcutLabel() + "_hdmat: MORE_THAN ARG=" + dissimilarities + " SQUARED SWITCH={" + hdfunc + "}");
   // Now for the weights - read the vector of weights first
-  std::string wvec; parse("WEIGHTS",wvec); if( wvec.length()==0 ) wvec = argn + "_weights";
+  std::string wvec;
+  parse("WEIGHTS",wvec);
+  if( wvec.length()==0 ) {
+    wvec = argn + "_weights";
+  }
   // Now calculate the sum of thse weights
   readInputLine( wvec + "_sum: SUM ARG=" + wvec + " PERIODIC=NO");
   // And normalise the vector of weights using this sum
@@ -101,43 +119,94 @@ SketchMap::SketchMap( const ActionOptions& ao):
   // And now create the matrix of weights
   readInputLine( wvec + "_mat: OUTER_PRODUCT ARG=" + wvec + "_normed," + wvec + "_normed");
   // Run the arrange points object
-  std::string ldfunc, cgtol, maxiter; parse("LOW_DIM_FUNCTION",ldfunc); parse("CGTOL",cgtol); parse("MAXITER",maxiter); unsigned ncycles; parse("NCYCLES",ncycles);
-  std::string num, argstr, lname=getShortcutLabel() + "_ap"; if( ncycles>0 ) lname = getShortcutLabel() + "_cg";
-  argstr = "ARG=" + getShortcutLabel() + "_mds-1"; for(unsigned i=1; i<ndim; ++i) { Tools::convert( i+1, num ); argstr += "," + getShortcutLabel() + "_mds-" + num; }
-  bool usesmacof; parseFlag("USE_SMACOF",usesmacof);
+  std::string ldfunc, cgtol, maxiter;
+  parse("LOW_DIM_FUNCTION",ldfunc);
+  parse("CGTOL",cgtol);
+  parse("MAXITER",maxiter);
+  unsigned ncycles;
+  parse("NCYCLES",ncycles);
+  std::string num, argstr, lname=getShortcutLabel() + "_ap";
+  if( ncycles>0 ) {
+    lname = getShortcutLabel() + "_cg";
+  }
+  argstr = "ARG=" + getShortcutLabel() + "_mds-1";
+  for(unsigned i=1; i<ndim; ++i) {
+    Tools::convert( i+1, num );
+    argstr += "," + getShortcutLabel() + "_mds-" + num;
+  }
+  bool usesmacof;
+  parseFlag("USE_SMACOF",usesmacof);
   if( usesmacof ) {
-    std::string smactol, smacreg; parse("SMACTOL",smactol); parse("SMACREG",smacreg);
+    std::string smactol, smacreg;
+    parse("SMACTOL",smactol);
+    parse("SMACREG",smacreg);
     readInputLine( lname + ": ARRANGE_POINTS " + argstr  + " MINTYPE=smacof TARGET1=" + getShortcutLabel() + "_hdmat FUNC1={" + ldfunc + "} WEIGHTS1=" + wvec + "_mat" +
                    " MAXITER=" + maxiter + " SMACTOL=" + smactol + " SMACREG=" + smacreg + " TARGET2=" + getShortcutLabel() + "_mds_mat WEIGHTS2=" + wvec + "_mat");
   } else {
     readInputLine( lname + ": ARRANGE_POINTS " + argstr  + " MINTYPE=conjgrad TARGET1=" + getShortcutLabel() + "_hdmat FUNC1={" + ldfunc + "} WEIGHTS1=" + wvec + "_mat CGTOL=" + cgtol);
     if( ncycles>0 ) {
-      std::string buf; parse("BUFFER",buf);
-      std::vector<std::string> fgrid; parseVector("FGRID_SIZE",fgrid);
-      std::string ncyc; Tools::convert(ncycles,ncyc); std::string pwise_args=" NCYCLES=" + ncyc + " BUFFER=" + buf;
+      std::string buf;
+      parse("BUFFER",buf);
+      std::vector<std::string> fgrid;
+      parseVector("FGRID_SIZE",fgrid);
+      std::string ncyc;
+      Tools::convert(ncycles,ncyc);
+      std::string pwise_args=" NCYCLES=" + ncyc + " BUFFER=" + buf;
       if( fgrid.size()>0 ) {
-        if( fgrid.size()!=ndim ) error("number of elements of fgrid is not correct");
-        pwise_args += " FGRID_SIZE=" + fgrid[0];  for(unsigned i=1; i<fgrid.size(); ++i) pwise_args += "," + fgrid[i];
+        if( fgrid.size()!=ndim ) {
+          error("number of elements of fgrid is not correct");
+        }
+        pwise_args += " FGRID_SIZE=" + fgrid[0];
+        for(unsigned i=1; i<fgrid.size(); ++i) {
+          pwise_args += "," + fgrid[i];
+        }
+      }
+      std::vector<std::string> cgrid(ndim);
+      parseVector("CGRID_SIZE",cgrid);
+      pwise_args += " CGRID_SIZE=" + cgrid[0];
+      for(unsigned i=1; i<cgrid.size(); ++i) {
+        pwise_args += "," + cgrid[i];
+      }
+      argstr="ARG=" + getShortcutLabel() + "_cg.coord-1";
+      for(unsigned i=1; i<ndim; ++i) {
+        Tools::convert( i+1, num );
+        argstr += "," + getShortcutLabel() + "_cg.coord-" + num;
       }
-      std::vector<std::string> cgrid(ndim); parseVector("CGRID_SIZE",cgrid);
-      pwise_args += " CGRID_SIZE=" + cgrid[0]; for(unsigned i=1; i<cgrid.size(); ++i) pwise_args += "," + cgrid[i];
-      argstr="ARG=" + getShortcutLabel() + "_cg.coord-1"; for(unsigned i=1; i<ndim; ++i) { Tools::convert( i+1, num ); argstr += "," + getShortcutLabel() + "_cg.coord-" + num; }
       readInputLine( getShortcutLabel() + "_ap: ARRANGE_POINTS " + argstr  + pwise_args + " MINTYPE=pointwise TARGET1=" + getShortcutLabel() + "_hdmat FUNC1={" + ldfunc + "} WEIGHTS1=" + wvec + "_mat CGTOL=" + cgtol);
     }
   }
-  argstr="ARG=" + getShortcutLabel() + "_ap.coord-1"; for(unsigned i=1; i<ndim; ++i) { Tools::convert( i+1, num ); argstr += "," + getShortcutLabel() + "_ap.coord-" + num; }
+  argstr="ARG=" + getShortcutLabel() + "_ap.coord-1";
+  for(unsigned i=1; i<ndim; ++i) {
+    Tools::convert( i+1, num );
+    argstr += "," + getShortcutLabel() + "_ap.coord-" + num;
+  }
   readInputLine( getShortcutLabel() + ": VSTACK " + argstr );
-  bool projall; parseFlag("PROJECT_ALL",projall); if( !projall ) return ;
-  parse("OS_CGTOL",cgtol); argstr = getShortcutLabel() + "_ap.coord-1"; for(unsigned i=1; i<ndim; ++i) { Tools::convert( i+1, num ); argstr += "," + getShortcutLabel() + "_ap.coord-" + num; }
+  bool projall;
+  parseFlag("PROJECT_ALL",projall);
+  if( !projall ) {
+    return ;
+  }
+  parse("OS_CGTOL",cgtol);
+  argstr = getShortcutLabel() + "_ap.coord-1";
+  for(unsigned i=1; i<ndim; ++i) {
+    Tools::convert( i+1, num );
+    argstr += "," + getShortcutLabel() + "_ap.coord-" + num;
+  }
   if( as->getName().find("LANDMARK_SELECT")==std::string::npos ) {
     readInputLine( getShortcutLabel() + "_osample_pp: PROJECT_POINTS " + argstr + " TARGET1=" + getShortcutLabel() + "_hdmat FUNC1={" + ldfunc + "} WEIGHTS1=" + wvec + "_normed CGTOL=" + cgtol );
   } else {
     ActionWithValue* dissims = plumed.getActionSet().selectWithLabel<ActionWithValue*>( argn + "_rectdissims");
-    if( !dissims ) error("cannot PROJECT_ALL as " + as->getName() + " with label " + argn + " was involved without the DISSIMILARITIES keyword");
+    if( !dissims ) {
+      error("cannot PROJECT_ALL as " + as->getName() + " with label " + argn + " was involved without the DISSIMILARITIES keyword");
+    }
     readInputLine( getShortcutLabel() + "_lhdmat: MORE_THAN ARG=" + argn + "_rectdissims SQUARED SWITCH={" + hdfunc + "}");
     readInputLine( getShortcutLabel() + "_osample_pp: PROJECT_POINTS ARG=" + argstr + " TARGET1=" + getShortcutLabel() + "_lhdmat FUNC1={" + ldfunc + "} WEIGHTS1=" + wvec + "_normed CGTOL=" + cgtol );
   }
-  argstr="ARG=" + getShortcutLabel() + "_osample_pp.coord-1"; for(unsigned i=1; i<ndim; ++i) { Tools::convert( i+1, num ); argstr += "," + getShortcutLabel() + "_osample_pp.coord-" + num; }
+  argstr="ARG=" + getShortcutLabel() + "_osample_pp.coord-1";
+  for(unsigned i=1; i<ndim; ++i) {
+    Tools::convert( i+1, num );
+    argstr += "," + getShortcutLabel() + "_osample_pp.coord-" + num;
+  }
   readInputLine( getShortcutLabel() + "_osample: VSTACK " + argstr );
 }
 
diff --git a/src/dimred/SketchMapProjection.cpp b/src/dimred/SketchMapProjection.cpp
index a047bd5ed0..41ae44badb 100644
--- a/src/dimred/SketchMapProjection.cpp
+++ b/src/dimred/SketchMapProjection.cpp
@@ -44,41 +44,59 @@ class SketchMapProjection : public ActionShortcut {
 PLUMED_REGISTER_ACTION(SketchMapProjection,"SKETCHMAP_PROJECTION")
 
 void SketchMapProjection::registerKeywords( Keywords& keys ) {
-  ActionShortcut::registerKeywords( keys ); mapping::Path::registerInputFileKeywords( keys );
+  ActionShortcut::registerKeywords( keys );
+  mapping::Path::registerInputFileKeywords( keys );
   keys.add("compulsory","PROPERTY","the property to be used in the index. This should be in the REMARK of the reference");
   keys.add("compulsory","WEIGHT","the weight of each individual landmark in the stress fucntion that is to be optimised");
   keys.add("compulsory","HIGH_DIM_FUNCTION","the parameters of the switching function in the high dimensional space");
   keys.add("compulsory","LOW_DIM_FUNCTION","the parameters of the switching function in the low dimensional space");
   keys.add("compulsory","CGTOL","1E-6","The tolerance for the conjugate gradient minimization that finds the out of sample projections");
   keys.setValueDescription("the out-of-sample projections of the input arguments using the input sketch-map projection");
-  keys.needsAction("RMSD"); keys.needsAction("PDB2CONSTANT"); keys.needsAction("CONSTANT"); keys.needsAction("CUSTOM");
-  keys.needsAction("EUCLIDEAN_DISTANCE"); keys.needsAction("NORMALIZED_EUCLIDEAN_DISTANCE");
-  keys.needsAction("SUM"); keys.needsAction("MORE_THAN"); keys.needsAction("PROJECT_POINTS");
+  keys.needsAction("RMSD");
+  keys.needsAction("PDB2CONSTANT");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("EUCLIDEAN_DISTANCE");
+  keys.needsAction("NORMALIZED_EUCLIDEAN_DISTANCE");
+  keys.needsAction("SUM");
+  keys.needsAction("MORE_THAN");
+  keys.needsAction("PROJECT_POINTS");
 }
 
 SketchMapProjection::SketchMapProjection( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Use path to read in the projections
   std::string refname, refactions, metric;
-  std::vector<std::string> argnames; parseVector("ARG",argnames);
-  std::string type, reference_data, reference; parse("REFERENCE",reference); parse("TYPE",type);
+  std::vector<std::string> argnames;
+  parseVector("ARG",argnames);
+  std::string type, reference_data, reference;
+  parse("REFERENCE",reference);
+  parse("TYPE",type);
   mapping::Path::readInputFrames( reference, type, argnames, false, this, reference_data );
   // And read in the data that we want on the projections
-  std::vector<std::string> pnames; parseVector("PROPERTY",pnames);
-  std::string weights; parse("WEIGHT",weights); pnames.push_back( weights );
+  std::vector<std::string> pnames;
+  parseVector("PROPERTY",pnames);
+  std::string weights;
+  parse("WEIGHT",weights);
+  pnames.push_back( weights );
   // Now create fixed vectors using some sort of reference action
   mapping::Path::readPropertyInformation( pnames, getShortcutLabel(), reference, this );
   // Normalise the vector of weights
   readInputLine( getShortcutLabel() + "_wsum: SUM PERIODIC=NO ARG=" + weights + "_ref");
   readInputLine( getShortcutLabel() + "_weights: CUSTOM ARG=" + getShortcutLabel() + "_wsum," +  weights + "_ref FUNC=y/x PERIODIC=NO");
   // Transform the high dimensional distances
-  std::string hdfunc; parse("HIGH_DIM_FUNCTION",hdfunc);
+  std::string hdfunc;
+  parse("HIGH_DIM_FUNCTION",hdfunc);
   readInputLine( getShortcutLabel() + "_targ: MORE_THAN ARG=" + getShortcutLabel() + "_data SQUARED SWITCH={" + hdfunc + "}");
   // Create the projection object
-  std::string ldfunc, cgtol; parse("LOW_DIM_FUNCTION",ldfunc); parse("CGTOL",cgtol);
-  std::string argstr="ARG=" + pnames[0] + "_ref"; for(unsigned i=1; i<pnames.size()-1; ++i) argstr += "," + pnames[i] + "_ref";
+  std::string ldfunc, cgtol;
+  parse("LOW_DIM_FUNCTION",ldfunc);
+  parse("CGTOL",cgtol);
+  std::string argstr="ARG=" + pnames[0] + "_ref";
+  for(unsigned i=1; i<pnames.size()-1; ++i) {
+    argstr += "," + pnames[i] + "_ref";
+  }
   readInputLine( getShortcutLabel() + ": PROJECT_POINTS " + argstr + " TARGET1=" + getShortcutLabel() + "_targ " +
                  "FUNC1={" + ldfunc + "} WEIGHTS1=" + getShortcutLabel() + "_weights CGTOL=" + cgtol );
 }
diff --git a/src/drr/DRR.cpp b/src/drr/DRR.cpp
index 88105a6c6b..6975889e39 100644
--- a/src/drr/DRR.cpp
+++ b/src/drr/DRR.cpp
@@ -27,10 +27,11 @@ using std::begin;
 using std::end;
 
 bool DRRAxis::isInBoundary(double x) const {
-  if (x < min || x > max)
+  if (x < min || x > max) {
     return false;
-  else
+  } else {
     return true;
+  }
 }
 
 bool DRRAxis::isRealPeriodic() const {
@@ -79,13 +80,16 @@ void DRRForceGrid::fillTable(const vector<vector<double>> &in) {
   table.resize(ndims, vector<double>(sampleSize, 0));
   for (size_t i = 0; i < ndims; ++i) {
     size_t repeatAll = 1, repeatOne = 1;
-    for (size_t j = i + 1; j < ndims; ++j)
+    for (size_t j = i + 1; j < ndims; ++j) {
       repeatOne *= in[j].size();
-    for (size_t j = 0; j < i; ++j)
+    }
+    for (size_t j = 0; j < i; ++j) {
       repeatAll *= in[j].size();
+    }
     size_t in_i_sz = in[i].size();
-    for (size_t l = 0; l < in_i_sz; ++l)
+    for (size_t l = 0; l < in_i_sz; ++l) {
       std::fill_n(begin(table[i]) + l * repeatOne, repeatOne, in[i][l]);
+    }
     for (size_t k = 0; k < repeatAll - 1; ++k)
       std::copy_n(begin(table[i]), repeatOne * in_i_sz,
                   begin(table[i]) + repeatOne * in_i_sz * (k + 1));
@@ -115,14 +119,16 @@ DRRForceGrid::DRRForceGrid(const vector<DRRAxis> &p_dimensions,
     ss.precision(std::numeric_limits<double>::max_digits10);
     ss << std::fixed << "# " << dimensions[i].min << ' '
        << dimensions[i].binWidth << ' ' << dimensions[i].nbins;
-    if (dimensions[i].isPeriodic())
+    if (dimensions[i].isPeriodic()) {
       ss << " 1" << '\n';
-    else
+    } else {
       ss << " 0" << '\n';
+    }
   }
   headers = ss.str();
-  if (initializeTable)
+  if (initializeTable) {
     fillTable(mp);
+  }
   forces.resize(sampleSize * ndims, 0.0);
   samples.resize(sampleSize, 0);
   outputunit = 1.0;
@@ -141,8 +147,9 @@ DRRForceGrid::DRRForceGrid(const vector<DRRAxis> &p_dimensions,
 bool DRRForceGrid::isInBoundary(const vector<double> &pos) const {
   bool result = true;
   for (size_t i = 0; i < ndims; ++i) {
-    if (pos[i] < dimensions[i].min || pos[i] > dimensions[i].max)
+    if (pos[i] < dimensions[i].min || pos[i] > dimensions[i].max) {
       return false;
+    }
   }
   return result;
 }
@@ -158,8 +165,9 @@ size_t DRRForceGrid::sampleAddress(const vector<double> &pos) const {
 bool DRRForceGrid::store(const vector<double> &pos, const vector<double> &f,
                          unsigned long int nsamples) {
   if (isInBoundary(pos)) {
-    if (nsamples == 0)
+    if (nsamples == 0) {
       return true;
+    }
     const size_t baseaddr = sampleAddress(pos);
     samples[baseaddr] += nsamples;
     auto it_fa = begin(forces) + baseaddr * ndims;
@@ -180,8 +188,9 @@ vector<DRRAxis> DRRForceGrid::merge(const vector<DRRAxis> &dA,
 vector<double>
 DRRForceGrid::getAccumulatedForces(const vector<double> &pos) const {
   vector<double> result(ndims, 0);
-  if (!isInBoundary(pos))
+  if (!isInBoundary(pos)) {
     return result;
+  }
   const size_t force_addr = sampleAddress(pos) * ndims;
   std::copy(begin(forces) + force_addr, begin(forces) + force_addr + ndims,
             begin(result));
@@ -208,11 +217,14 @@ vector<double> DRRForceGrid::getGradient(const vector<double> &pos,
   }
   const size_t baseaddr = sampleAddress(pos);
   const unsigned long int &count = samples[baseaddr];
-  if (count == 0)
+  if (count == 0) {
     return result;
+  }
   auto it_fa = begin(forces) + baseaddr * ndims;
   std::transform(it_fa, it_fa + ndims, begin(result),
-  [&count](double fa) { return (-1.0) * fa / count; });
+  [&count](double fa) {
+    return (-1.0) * fa / count;
+  });
   return result;
 }
 
@@ -480,8 +492,9 @@ vector<double> CZAR::getGradient(const vector<double> &pos,
   const size_t baseaddr = sampleAddress(pos);
   const vector<double> log_deriv(getCountsLogDerivative(pos));
   const unsigned long int &count = samples[baseaddr];
-  if (count == 0)
+  if (count == 0) {
     return result;
+  }
   auto it_fa = begin(forces) + baseaddr * ndims;
   std::transform(it_fa, it_fa + ndims, begin(log_deriv), begin(result),
   [&count, this](double fa, double ld) {
diff --git a/src/drr/DRR.h b/src/drr/DRR.h
index 3f6fd88802..dbe293a936 100644
--- a/src/drr/DRR.h
+++ b/src/drr/DRR.h
@@ -84,15 +84,29 @@ class DRRAxis {
     periodic = true;
   }
   /// Getters
-  double getMin() const { return this->min; }
-  double getMax() const { return this->max; }
-  double getWidth() const { return binWidth; }
-  double getDomainMax() const { return this->domainMax; }
-  double getDomainMin() const { return this->domainMin; }
-  size_t getBins() const { return this->nbins; }
+  double getMin() const {
+    return this->min;
+  }
+  double getMax() const {
+    return this->max;
+  }
+  double getWidth() const {
+    return binWidth;
+  }
+  double getDomainMax() const {
+    return this->domainMax;
+  }
+  double getDomainMin() const {
+    return this->domainMin;
+  }
+  size_t getBins() const {
+    return this->nbins;
+  }
 
   /// Check periodicity
-  bool isPeriodic() const { return this->periodic; }
+  bool isPeriodic() const {
+    return this->periodic;
+  }
   /// Check real periodicity, i.e. the maximum == the domain maximum
   bool isRealPeriodic() const;
 
@@ -198,9 +212,13 @@ class DRRForceGrid {
   static vector<DRRAxis> merge(const vector<DRRAxis> &dA,
                                const vector<DRRAxis> &dB);
   /// Get suffix
-  string getSuffix() const { return suffix; }
+  string getSuffix() const {
+    return suffix;
+  }
   /// Set unit for .grad output
-  void setOutputUnit(double unit) { outputunit = unit; }
+  void setOutputUnit(double unit) {
+    outputunit = unit;
+  }
   /// Destructor
   virtual ~DRRForceGrid() {}
 
@@ -266,10 +284,11 @@ class DRRForceGrid {
       ss.precision(std::numeric_limits<double>::max_digits10);
       ss << std::fixed << "# " << dimensions[i].min << ' '
          << dimensions[i].binWidth << ' ' << dimensions[i].nbins;
-      if (dimensions[i].isPeriodic())
+      if (dimensions[i].isPeriodic()) {
         ss << " 1" << '\n';
-      else
+      } else {
         ss << " 0" << '\n';
+      }
     }
     fillTable(mp);
     headers = ss.str();
@@ -336,8 +355,12 @@ class CZAR : public DRRForceGrid {
     : DRRForceGrid(p_dimensions, p_suffix, initializeTable), kbt(p_kbt) {}
   vector<double> getGradient(const vector<double> &pos,
                              bool SkipCheck = false) const;
-  double getkbt() const { return kbt; }
-  void setkbt(double p_kbt) { kbt = p_kbt; }
+  double getkbt() const {
+    return kbt;
+  }
+  void setkbt(double p_kbt) {
+    kbt = p_kbt;
+  }
   static CZAR mergewindow(const CZAR &cWA, const CZAR &cWB);
   void writeZCountZGrad(const string &filename, bool addition = false) const;
   ~CZAR() {}
diff --git a/src/drr/DynamicReferenceRestraining.cpp b/src/drr/DynamicReferenceRestraining.cpp
index 77c40ff532..7cc246387b 100644
--- a/src/drr/DynamicReferenceRestraining.cpp
+++ b/src/drr/DynamicReferenceRestraining.cpp
@@ -357,8 +357,7 @@ DynamicReferenceRestraining::DynamicReferenceRestraining(
     useCZARestimator(true), useUIestimator(false), mergeHistoryFiles(false),
     textoutput(false), withExternalForce(false), withExternalFict(false),
     reflectingWall(getNumberOfArguments(), 0),
-    maxFactors(getNumberOfArguments(), 1.0)
-{
+    maxFactors(getNumberOfArguments(), 1.0) {
   log << "eABF/DRR: You now are using the extended adaptive biasing "
       "force(eABF) method."
       << '\n';
@@ -454,8 +453,9 @@ DynamicReferenceRestraining::DynamicReferenceRestraining(
   vector<string> zgmin(ndims);
   parseVector("GRID_MIN", gmin);
   parseVector("ZGRID_MIN", zgmin);
-  if (gmin.size() != ndims)
+  if (gmin.size() != ndims) {
     error("eABF/DRR: not enough values for GRID_MIN");
+  }
   if (zgmin.size() != ndims) {
     log << "eABF/DRR: You didn't specify ZGRID_MIN. " << '\n'
         << "eABF/DRR: The GRID_MIN will be used instead.";
@@ -465,8 +465,9 @@ DynamicReferenceRestraining::DynamicReferenceRestraining(
   vector<string> zgmax(ndims);
   parseVector("GRID_MAX", gmax);
   parseVector("ZGRID_MAX", zgmax);
-  if (gmax.size() != ndims)
+  if (gmax.size() != ndims) {
     error("eABF/DRR: not enough values for GRID_MAX");
+  }
   if (zgmax.size() != ndims) {
     log << "eABF/DRR: You didn't specify ZGRID_MAX. " << '\n'
         << "eABF/DRR: The GRID_MAX will be used instead.";
@@ -614,8 +615,9 @@ DynamicReferenceRestraining::DynamicReferenceRestraining(
       componentIsPeriodic(comp, a, b);
       delim[i].setPeriodicity(c, d);
       zdelim[i].setPeriodicity(c, d);
-    } else
+    } else {
       componentIsNotPeriodic(comp);
+    }
     fictValue[i] = getPntrToComponent(comp);
     // Velocity output
     comp = getPntrToArgument(i)->getName() + "_vfict";
diff --git a/src/drr/colvar_UIestimator.h b/src/drr/colvar_UIestimator.h
index 250a69687c..10805c49d5 100644
--- a/src/drr/colvar_UIestimator.h
+++ b/src/drr/colvar_UIestimator.h
@@ -40,47 +40,41 @@
 namespace PLMD {
 namespace drr {
 
-namespace UIestimator
-{
+namespace UIestimator {
 const int Y_SIZE = 21;
 const int HALF_Y_SIZE = 10;
 const double BOLTZMANN = 0.0083144621;
 const int EXTENDED_X_SIZE = HALF_Y_SIZE;
 
-class n_matrix    // spare matrix, stores the distribution matrix of n(x,y)
-{
+class n_matrix {  // spare matrix, stores the distribution matrix of n(x,y)
 public:
   n_matrix() {}
   n_matrix(const std::vector<double> & lowerboundary_p,   // lowerboundary of x
            const std::vector<double> & upperboundary_p,   // upperboundary of
            const std::vector<double> & width_p,           // width of x
            const int y_size)           // size of y, for example, ysize=7, then when x=1, the distribution of y in [-2,4] is considered
-    : lowerboundary(lowerboundary_p), upperboundary(upperboundary_p), width(width_p)
-  {
+    : lowerboundary(lowerboundary_p), upperboundary(upperboundary_p), width(width_p) {
     this->dimension = lowerboundary.size();
     this->y_size = y_size;     // keep in mind the internal (spare) matrix is stored in diagonal form
     this->y_total_size = int(pow(y_size, dimension) + 0.000001);
 
     // the range of the matrix is [lowerboundary, upperboundary]
     x_total_size = 1;
-    for (int i = 0; i < dimension; i++)
-    {
+    for (int i = 0; i < dimension; i++) {
       x_size.push_back(int((upperboundary[i] - lowerboundary[i]) / width[i] + 0.000001));
       x_total_size *= x_size[i];
     }
 
     // initialize the internal matrix
     matrix.reserve(x_total_size);
-    for (int i = 0; i < x_total_size; i++)
-    {
+    for (int i = 0; i < x_total_size; i++) {
       matrix.push_back(std::vector<int>(y_total_size, 0));
     }
 
     temp.resize(dimension);
   }
 
-  int inline get_value(const std::vector<double> & x, const std::vector<double> & y)
-  {
+  int inline get_value(const std::vector<double> & x, const std::vector<double> & y) {
     //if (matrix[convert_x(x)][convert_y(x, y)]!=0)
     //{
     //std::cout<<convert_x(x)<<" "<<convert_y(x, y)<<" "<<x[0]<<" "<<x[1]<<" "<<y[0]<<" "<<y[1]<<" ";
@@ -89,13 +83,11 @@ class n_matrix    // spare matrix, stores the distribution matrix of n(x,y)
     return matrix[convert_x(x)][convert_y(x, y)];
   }
 
-  void inline set_value(const std::vector<double> & x, const std::vector<double> & y, const int value)
-  {
+  void inline set_value(const std::vector<double> & x, const std::vector<double> & y, const int value) {
     matrix[convert_x(x)][convert_y(x,y)] = value;
   }
 
-  void inline increase_value(const std::vector<double> & x, const std::vector<double> & y, const int value)
-  {
+  void inline increase_value(const std::vector<double> & x, const std::vector<double> & y, const int value) {
     matrix[convert_x(x)][convert_y(x,y)] += value;
   }
 
@@ -113,57 +105,50 @@ class n_matrix    // spare matrix, stores the distribution matrix of n(x,y)
 
   std::vector<int> temp;         // this vector is used in convert_x and convert_y to save computational resource
 
-  int convert_x(const std::vector<double> & x)        // convert real x value to its interal index
-  {
-    for (int i = 0; i < dimension; i++)
-    {
+  int convert_x(const std::vector<double> & x) {      // convert real x value to its interal index
+    for (int i = 0; i < dimension; i++) {
       temp[i] = int((x[i] - lowerboundary[i]) / width[i] + 0.000001);
     }
 
     int index = 0;
-    for (int i = 0; i < dimension; i++)
-    {
-      if (i + 1 < dimension)
-      {
+    for (int i = 0; i < dimension; i++) {
+      if (i + 1 < dimension) {
         int x_temp = 1;
-        for (int j = i + 1; j < dimension; j++)
+        for (int j = i + 1; j < dimension; j++) {
           x_temp *= x_size[j];
+        }
         index += temp[i] * x_temp;
-      }
-      else
+      } else {
         index += temp[i];
+      }
     }
     return index;
   }
 
-  int convert_y(const std::vector<double> & x, const std::vector<double> & y)        // convert real y value to its interal index
-  {
-    for (int i = 0; i < dimension; i++)
-    {
+  int convert_y(const std::vector<double> & x, const std::vector<double> & y) {      // convert real y value to its interal index
+    for (int i = 0; i < dimension; i++) {
       temp[i] = round((round(y[i] / width[i] + 0.000001) - round(x[i] / width[i] + 0.000001)) + (y_size - 1) / 2 + 0.000001);
     }
 
     int index = 0;
-    for (int i = 0; i < dimension; i++)
-    {
-      if (i + 1 < dimension)
+    for (int i = 0; i < dimension; i++) {
+      if (i + 1 < dimension) {
         index += temp[i] * int(pow(y_size, dimension - i - 1) + 0.000001);
-      else
+      } else {
         index += temp[i];
+      }
     }
     return index;
   }
 
-  double round(double r)
-  {
+  double round(double r) {
     return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
   }
 };
 
 // vector, store the sum_x, sum_x_square, count_y
 template <typename T>
-class n_vector
-{
+class n_vector {
 public:
   n_vector() {}
   n_vector(const std::vector<double> & lowerboundary,   // lowerboundary of x
@@ -171,13 +156,11 @@ class n_vector
            const std::vector<double> & width_p,                // width of x
            const int y_size,           // size of y, for example, ysize=7, then when x=1, the distribution of y in [-2,4] is considered
            const T & default_value)          //   the default value of T
-    :width(width_p)
-  {
+    :width(width_p) {
     this->dimension = lowerboundary.size();
 
     x_total_size = 1;
-    for (int i = 0; i < dimension; i++)
-    {
+    for (int i = 0; i < dimension; i++) {
       this->lowerboundary.push_back(lowerboundary[i] - (y_size - 1) / 2 * width[i] - 0.000001);
       this->upperboundary.push_back(upperboundary[i] + (y_size - 1) / 2 * width[i] + 0.000001);
 
@@ -191,18 +174,15 @@ class n_vector
     temp.resize(dimension);
   }
 
-  T inline get_value(const std::vector<double> & x)
-  {
+  T inline get_value(const std::vector<double> & x) {
     return vector[convert_x(x)];
   }
 
-  void inline set_value(const std::vector<double> & x, const T & value)
-  {
+  void inline set_value(const std::vector<double> & x, const T & value) {
     vector[convert_x(x)] = value;
   }
 
-  void inline increase_value(const std::vector<double> & x, const T & value)
-  {
+  void inline increase_value(const std::vector<double> & x, const T & value) {
     vector[convert_x(x)] += value;
   }
 private:
@@ -217,32 +197,28 @@ class n_vector
 
   std::vector<int> temp;         // this vector is used in convert_x and convert_y to save computational resource
 
-  int convert_x(const std::vector<double> & x)        // convert real x value to its interal index
-  {
-    for (int i = 0; i < dimension; i++)
-    {
+  int convert_x(const std::vector<double> & x) {      // convert real x value to its interal index
+    for (int i = 0; i < dimension; i++) {
       temp[i] = int((x[i] - lowerboundary[i]) / width[i] + 0.000001);
     }
 
     int index = 0;
-    for (int i = 0; i < dimension; i++)
-    {
-      if (i + 1 < dimension)
-      {
+    for (int i = 0; i < dimension; i++) {
+      if (i + 1 < dimension) {
         int x_temp = 1;
-        for (int j = i + 1; j < dimension; j++)
+        for (int j = i + 1; j < dimension; j++) {
           x_temp *= x_size[j];
+        }
         index += temp[i] * x_temp;
-      }
-      else
+      } else {
         index += temp[i];
+      }
     }
     return index;
   }
 };
 
-class UIestimator      // the implemension of UI estimator
-{
+class UIestimator {    // the implemension of UI estimator
 public:
   UIestimator() {}
 
@@ -260,13 +236,11 @@ class UIestimator      // the implemension of UI estimator
       width(width_p), krestr(krestr_p),
       output_filename(output_filename_p), output_freq(output_freq_p),
       restart(restart_p), input_filename(input_filename_p),
-      temperature(temperature_p)
-  {
+      temperature(temperature_p) {
 
     dimension = lowerboundary.size();
 
-    for (int i = 0; i < dimension; i++)
-    {
+    for (int i = 0; i < dimension; i++) {
       sum_x.push_back(n_vector<double>(lowerboundary, upperboundary, width, Y_SIZE, 0.0));
       sum_x_square.push_back(n_vector<double>(lowerboundary, upperboundary, width, Y_SIZE, 0.0));
 
@@ -283,46 +257,40 @@ class UIestimator      // the implemension of UI estimator
     written = false;
     written_1D = false;
 
-    if (dimension == 1)
-    {
+    if (dimension == 1) {
       std::vector<double> upperboundary_temp = upperboundary;
       upperboundary_temp[0] = upperboundary[0] + width[0];
       oneD_pmf = n_vector<double>(lowerboundary, upperboundary_temp, width, 1, 0.0);
     }
 
-    if (restart == true)
-    {
+    if (restart == true) {
       input_grad = n_vector<std::vector<double> >(lowerboundary, upperboundary, width, 1, std::vector<double>(dimension, 0.0));
       input_count = n_vector<int>(lowerboundary, upperboundary, width, 1, 0);
 
       // initialize input_Grad and input_count
       std::vector<double> loop_flag(dimension, 0);
-      for (int i = 0; i < dimension; i++)
-      {
+      for (int i = 0; i < dimension; i++) {
         loop_flag[i] = lowerboundary[i];
       }
-      while (true)
-      {
-        for (int i = 0; i < dimension; i++)
-        {
+      while (true) {
+        for (int i = 0; i < dimension; i++) {
           input_grad.set_value(loop_flag, std::vector<double>(dimension,0));
         }
         input_count.set_value(loop_flag, 0);
 
         // iterate over any dimensions
         int i = dimension - 1;
-        while (true)
-        {
+        while (true) {
           loop_flag[i] += width[i];
-          if (loop_flag[i] > upperboundary[i] - width[i] + 0.00001)
-          {
+          if (loop_flag[i] > upperboundary[i] - width[i] + 0.00001) {
             loop_flag[i] = lowerboundary[i];
             i--;
-            if (i < 0)
+            if (i < 0) {
               goto INITIAL_LOOPEND;
-          }
-          else
+            }
+          } else {
             break;
+          }
         }
       }
 INITIAL_LOOPEND:
@@ -333,8 +301,7 @@ class UIestimator      // the implemension of UI estimator
   ~UIestimator() {}
 
   // called from MD engine every step
-  bool update(const int step, const std::vector<double> & x, std::vector<double> y)
-  {
+  bool update(const int step, const std::vector<double> & x, std::vector<double> y) {
 
     //std::cout<<"weeeee: :"<<std::endl;
     //for (int i = 0; i < dimension; i++)
@@ -343,26 +310,22 @@ class UIestimator      // the implemension of UI estimator
     //}
     //std::cout<<std::endl;
 
-    if (step % output_freq == 0)
-    {
+    if (step % output_freq == 0) {
       calc_pmf();
       write_files();
       //write_interal_data();
     }
 
-    for (int i = 0; i < dimension; i++)
-    {
+    for (int i = 0; i < dimension; i++) {
       // for dihedral RC, it is possible that x = 179 and y = -179, should correct it
       // may have problem, need to fix
-      if (x[i] > 150 && y[i] < -150)
-      {
+      if (x[i] > 150 && y[i] < -150) {
         //std::vector<double> x_temp(x);
         //x_temp[i] -= 360;
         //update(7, x_temp, y);
         y[i] += 360;
       }
-      if (x[i] < -150 && y[i] > 150)
-      {
+      if (x[i] < -150 && y[i] > 150) {
         //std::vector<double> x_temp(x);
         //x_temp[i] += 360;
         //update(7, x_temp, y);
@@ -371,8 +334,9 @@ class UIestimator      // the implemension of UI estimator
 
       if (x[i] < lowerboundary[i] - EXTENDED_X_SIZE * width[i] + 0.00001 || x[i] > upperboundary[i] + EXTENDED_X_SIZE * width[i] - 0.00001 \
           || y[i] - x[i] < -HALF_Y_SIZE * width[i] + 0.00001 || y[i] - x[i] > HALF_Y_SIZE * width[i] - 0.00001 \
-          || y[i] - lowerboundary[i] < -HALF_Y_SIZE * width[i] + 0.00001 || y[i] - upperboundary[i] > HALF_Y_SIZE * width[i] - 0.00001)
+          || y[i] - lowerboundary[i] < -HALF_Y_SIZE * width[i] + 0.00001 || y[i] - upperboundary[i] > HALF_Y_SIZE * width[i] - 0.00001) {
         return false;
+      }
     }
 
     //for (int i = 0; i < dimension; i++)
@@ -381,19 +345,18 @@ class UIestimator      // the implemension of UI estimator
     //}
     //std::cout<<std::endl;
 
-    for (int i = 0; i < dimension; i++)
-    {
+    for (int i = 0; i < dimension; i++) {
       sum_x[i].increase_value(y, x[i]);
       sum_x_square[i].increase_value(y, x[i] * x[i]);
     }
     count_y.increase_value(y, 1);
 
-    for (int i = 0; i < dimension; i++)
-    {
+    for (int i = 0; i < dimension; i++) {
       //if (x[i] < lowerboundary[i] + 0.000001 || x[i] > upperboundary[i] - 0.000001)
       // adapt colvars precision
-      if (x[i] < lowerboundary[i] + 0.00001 || x[i] > upperboundary[i] - 0.00001)
+      if (x[i] < lowerboundary[i] + 0.00001 || x[i] > upperboundary[i] - 0.00001) {
         return false;
+      }
     }
     distribution_x_y.increase_value(x, y, 1);
 
@@ -401,8 +364,7 @@ class UIestimator      // the implemension of UI estimator
   }
 
   // update the output_filename
-  void update_output_filename(const std::string& filename)
-  {
+  void update_output_filename(const std::string& filename) {
     output_filename = filename;
   }
 
@@ -440,39 +402,34 @@ class UIestimator      // the implemension of UI estimator
   bool written_1D;
 
   // calculate gradients from the internal variables
-  void calc_pmf()
-  {
+  void calc_pmf() {
     int norm;
 
     std::vector<double> loop_flag(dimension, 0);
-    for (int i = 0; i < dimension; i++)
-    {
+    for (int i = 0; i < dimension; i++) {
       loop_flag[i] = lowerboundary[i] - HALF_Y_SIZE * width[i];
     }
 
-    while (true)
-    {
+    while (true) {
       norm = count_y.get_value(loop_flag) > 0 ? count_y.get_value(loop_flag) : 1;
-      for (int i = 0; i < dimension; i++)
-      {
+      for (int i = 0; i < dimension; i++) {
         x_av[i].set_value(loop_flag, sum_x[i].get_value(loop_flag) / norm);
         sigma_square[i].set_value(loop_flag, sum_x_square[i].get_value(loop_flag) / norm - x_av[i].get_value(loop_flag) * x_av[i].get_value(loop_flag));
       }
 
       // iterate over any dimensions
       int i = dimension - 1;
-      while (true)
-      {
+      while (true) {
         loop_flag[i] += width[i];
-        if (loop_flag[i] > upperboundary[i] + HALF_Y_SIZE * width[i] - width[i] + 0.00001)
-        {
+        if (loop_flag[i] > upperboundary[i] + HALF_Y_SIZE * width[i] - width[i] + 0.00001) {
           loop_flag[i] = lowerboundary[i] - HALF_Y_SIZE * width[i];
           i--;
-          if (i < 0)
+          if (i < 0) {
             goto LOOPEND;
-        }
-        else
+          }
+        } else {
           break;
+        }
       }
     }
 LOOPEND:
@@ -483,55 +440,49 @@ class UIestimator      // the implemension of UI estimator
 
     std::vector<double> loop_flag_x(dimension, 0);
     std::vector<double> loop_flag_y(dimension, 0);
-    for (int i = 0; i < dimension; i++)
-    {
+    for (int i = 0; i < dimension; i++) {
       loop_flag_x[i] = lowerboundary[i];
       loop_flag_y[i] = loop_flag_x[i] - HALF_Y_SIZE * width[i];
     }
 
-    while (true)
-    {
+    while (true) {
       norm = 0;
-      for (int i = 0; i < dimension; i++)
-      {
+      for (int i = 0; i < dimension; i++) {
         av[i] = 0;
         diff_av[i] = 0;
         loop_flag_y[i] = loop_flag_x[i] - HALF_Y_SIZE * width[i];
       }
 
-      while (true)
-      {
+      while (true) {
         //std::cout<<"pppppppppppppppppppppp "<<loop_flag_x[0]<<" "<<loop_flag_x[1]<<" "<<loop_flag_y[0]<<" "<<loop_flag_y[1]<<std::endl;
         norm += distribution_x_y.get_value(loop_flag_x, loop_flag_y);
-        for (int i = 0; i < dimension; i++)
-        {
-          if (sigma_square[i].get_value(loop_flag_y) > 0.00001 || sigma_square[i].get_value(loop_flag_y) < -0.00001)
+        for (int i = 0; i < dimension; i++) {
+          if (sigma_square[i].get_value(loop_flag_y) > 0.00001 || sigma_square[i].get_value(loop_flag_y) < -0.00001) {
             av[i] += distribution_x_y.get_value(loop_flag_x, loop_flag_y) * ( (loop_flag_x[i] + 0.5 * width[i]) - x_av[i].get_value(loop_flag_y)) / sigma_square[i].get_value(loop_flag_y);
+          }
 
           diff_av[i] += distribution_x_y.get_value(loop_flag_x, loop_flag_y) * (loop_flag_x[i] - loop_flag_y[i]);
         }
 
         // iterate over any dimensions
         int i = dimension - 1;
-        while (true)
-        {
+        while (true) {
           loop_flag_y[i] += width[i];
-          if (loop_flag_y[i] > loop_flag_x[i] + HALF_Y_SIZE * width[i] - width[i] + 0.00001)
-          {
+          if (loop_flag_y[i] > loop_flag_x[i] + HALF_Y_SIZE * width[i] - width[i] + 0.00001) {
             loop_flag_y[i] = loop_flag_x[i] - HALF_Y_SIZE * width[i];
             i--;
-            if (i < 0)
+            if (i < 0) {
               goto LOOPEND2;
-          }
-          else
+            }
+          } else {
             break;
+          }
         }
       }
 LOOPEND2:
 
       std::vector<double> grad_temp(dimension, 0);
-      for (int i = 0; i < dimension; i++)
-      {
+      for (int i = 0; i < dimension; i++) {
         diff_av[i] /= (norm > 0 ? norm : 1);
         av[i] = BOLTZMANN * temperature * av[i] / (norm > 0 ? norm : 1);
         grad_temp[i] = av[i] - krestr[i] * diff_av[i];
@@ -541,27 +492,26 @@ class UIestimator      // the implemension of UI estimator
 
       // iterate over any dimensions
       int i = dimension - 1;
-      while (true)
-      {
+      while (true) {
         loop_flag_x[i] += width[i];
-        if (loop_flag_x[i] > upperboundary[i] - width[i] + 0.00001)
-        {
+        if (loop_flag_x[i] > upperboundary[i] - width[i] + 0.00001) {
           loop_flag_x[i] = lowerboundary[i];
           i--;
-          if (i < 0)
+          if (i < 0) {
             goto LOOPEND3;
-        }
-        else
+          }
+        } else {
           break;
+        }
       }
     }
-LOOPEND3:;
+LOOPEND3:
+    ;
   }
 
 
   // calculate 1D pmf
-  void calc_1D_pmf()
-  {
+  void calc_1D_pmf() {
     std::vector<double> last_position(1, 0);
     std::vector<double> position(1, 0);
 
@@ -570,33 +520,28 @@ LOOPEND3:;
 
     oneD_pmf.set_value(lowerboundary, 0);
     last_position = lowerboundary;
-    for (double i = lowerboundary[0] + width[0]; i < upperboundary[0] + 0.000001; i += width[0])
-    {
+    for (double i = lowerboundary[0] + width[0]; i < upperboundary[0] + 0.000001; i += width[0]) {
       position[0] = i + 0.000001;
-      if (restart == false || input_count.get_value(last_position) == 0)
-      {
+      if (restart == false || input_count.get_value(last_position) == 0) {
         dG = oneD_pmf.get_value(last_position) + grad.get_value(last_position)[0] * width[0];
-      }
-      else
-      {
+      } else {
         dG = oneD_pmf.get_value(last_position) + ((grad.get_value(last_position)[0] * count.get_value(last_position) + input_grad.get_value(last_position)[0] * input_count.get_value(last_position)) / (count.get_value(last_position) + input_count.get_value(last_position))) * width[0];
       }
-      if (dG < min)
+      if (dG < min) {
         min = dG;
+      }
       oneD_pmf.set_value(position, dG);
       last_position[0] = i + 0.000001;
     }
 
-    for (double i = lowerboundary[0]; i < upperboundary[0] + 0.000001; i += width[0])
-    {
+    for (double i = lowerboundary[0]; i < upperboundary[0] + 0.000001; i += width[0]) {
       position[0] = i + 0.000001;
       oneD_pmf.set_value(position, oneD_pmf.get_value(position) - min);
     }
   }
 
   // write 1D pmf
-  void write_1D_pmf()
-  {
+  void write_1D_pmf() {
     std::string pmf_filename = output_filename + ".UI.pmf";
 
     // only for colvars module!
@@ -605,8 +550,7 @@ LOOPEND3:;
     std::ofstream ofile_pmf(pmf_filename.c_str());
 
     std::vector<double> position(1, 0);
-    for (double i = lowerboundary[0]; i < upperboundary[0] + 0.000001; i += width[0])
-    {
+    for (double i = lowerboundary[0]; i < upperboundary[0] + 0.000001; i += width[0]) {
       ofile_pmf << i << " ";
       position[0] = i + 0.000001;
       ofile_pmf << oneD_pmf.get_value(position) << std::endl;
@@ -617,11 +561,9 @@ LOOPEND3:;
   }
 
   // write heads of the output files
-  void writehead(std::ofstream& os) const
-  {
+  void writehead(std::ofstream& os) const {
     os << "# " << dimension << std::endl;
-    for (int i = 0; i < dimension; i++)
-    {
+    for (int i = 0; i < dimension; i++) {
       os.precision(std::numeric_limits<double>::max_digits10);
       os << "# " << std::fixed << lowerboundary[i] << " " << width[i] << " " << int((upperboundary[i] - lowerboundary[i]) / width[i] + 0.000001) << " " << 0 << std::endl;
     }
@@ -685,8 +627,7 @@ LOOPEND3:;
 //   }
 
   // write output files
-  void write_files()
-  {
+  void write_files() {
     std::string grad_filename = output_filename + ".UI.grad";
     std::string hist_filename = output_filename + ".UI.hist.grad";
     std::string count_filename = output_filename + ".UI.count";
@@ -704,47 +645,39 @@ LOOPEND3:;
     writehead(ofile_hist);
     writehead(ofile_count);
 
-    if (dimension == 1)
-    {
+    if (dimension == 1) {
       calc_1D_pmf();
       write_1D_pmf();
     }
 
     std::vector<double> loop_flag(dimension, 0);
-    for (int i = 0; i < dimension; i++)
-    {
+    for (int i = 0; i < dimension; i++) {
       loop_flag[i] = lowerboundary[i];
     }
-    while (true)
-    {
-      for (int i = 0; i < dimension; i++)
-      {
+    while (true) {
+      for (int i = 0; i < dimension; i++) {
         ofile << std::fixed << std::setprecision(6) << loop_flag[i] + 0.5 * width[i] << " ";
         ofile_hist << std::fixed << std::setprecision(6) << loop_flag[i] + 0.5 * width[i] << " ";
         ofile_count << std::fixed << std::setprecision(6) << loop_flag[i] + 0.5 * width[i] << " ";
       }
 
-      if (restart == false)
-      {
-        for (int i = 0; i < dimension; i++)
-        {
+      if (restart == false) {
+        for (int i = 0; i < dimension; i++) {
           ofile << std::fixed << std::setprecision(6) << grad.get_value(loop_flag)[i] << " ";
           ofile_hist << std::fixed << std::setprecision(6) << grad.get_value(loop_flag)[i] << " ";
         }
         ofile << std::endl;
         ofile_hist << std::endl;
         ofile_count << count.get_value(loop_flag) << " " <<std::endl;
-      }
-      else
-      {
+      } else {
         double final_grad = 0;
-        for (int i = 0; i < dimension; i++)
-        {
+        for (int i = 0; i < dimension; i++) {
           int total_count_temp = (count.get_value(loop_flag) + input_count.get_value(loop_flag));
-          if (input_count.get_value(loop_flag) == 0)
+          if (input_count.get_value(loop_flag) == 0) {
             final_grad = grad.get_value(loop_flag)[i];
-          else
+          } else {
             final_grad = ((grad.get_value(loop_flag)[i] * count.get_value(loop_flag) + input_grad.get_value(loop_flag)[i] * input_count.get_value(loop_flag)) / total_count_temp);
+          }
           ofile << std::fixed << std::setprecision(6) << final_grad << " ";
           ofile_hist << std::fixed << std::setprecision(6) << final_grad << " ";
         }
@@ -755,21 +688,20 @@ LOOPEND3:;
 
       // iterate over any dimensions
       int i = dimension - 1;
-      while (true)
-      {
+      while (true) {
         loop_flag[i] += width[i];
-        if (loop_flag[i] > upperboundary[i] - width[i] + 0.00001)
-        {
+        if (loop_flag[i] > upperboundary[i] - width[i] + 0.00001) {
           loop_flag[i] = lowerboundary[i];
           i--;
           ofile << std::endl;
           ofile_hist << std::endl;
           ofile_count << std::endl;
-          if (i < 0)
+          if (i < 0) {
             goto LOOPEND4;
-        }
-        else
+          }
+        } else {
           break;
+        }
       }
     }
 LOOPEND4:
@@ -781,8 +713,7 @@ LOOPEND3:;
   }
 
   // read input files
-  void read_inputfiles(const std::vector<std::string>& input_filename)
-  {
+  void read_inputfiles(const std::vector<std::string>& input_filename) {
     char sharp;
     double nothing;
     int dimension_temp;
@@ -791,8 +722,7 @@ LOOPEND3:;
     std::vector<double> position_temp(dimension, 0);
     std::vector<double> grad_temp(dimension, 0);
     int count_temp = 0;
-    for (unsigned int i = 0; i < input_filename.size(); i++)
-    {
+    for (unsigned int i = 0; i < input_filename.size(); i++) {
       int size = 1, size_temp = 0;
 
       std::string count_filename = input_filename[i] + ".UI.count";
@@ -804,38 +734,30 @@ LOOPEND3:;
       count_file >> sharp >> dimension_temp;
       grad_file >> sharp >> dimension_temp;
 
-      for (int j = 0; j < dimension; j++)
-      {
+      for (int j = 0; j < dimension; j++) {
         count_file >> sharp >> nothing >> nothing >> size_temp >> nothing;
         grad_file >> sharp >> nothing >> nothing >> nothing >> nothing;
         size *= size_temp;
       }
 
-      for (int j = 0; j < size; j++)
-      {
-        do
-        {
-          for (int k = 0; k < dimension; k++)
-          {
+      for (int j = 0; j < size; j++) {
+        do {
+          for (int k = 0; k < dimension; k++) {
             count_file >> position_temp[k];
             grad_file >> nothing;
           }
 
-          for (int l = 0; l < dimension; l++)
-          {
+          for (int l = 0; l < dimension; l++) {
             grad_file >> grad_temp[l];
           }
           count_file >> count_temp;
-        }
-        while (position_temp[i] < lowerboundary[i] - 0.000001 || position_temp[i] > upperboundary[i] + 0.000001);
+        } while (position_temp[i] < lowerboundary[i] - 0.000001 || position_temp[i] > upperboundary[i] + 0.000001);
 
-        if (count_temp == 0)
-        {
+        if (count_temp == 0) {
           continue;
         }
 
-        for (int m = 0; m < dimension; m++)
-        {
+        for (int m = 0; m < dimension; m++) {
           grad_temp[m] = (grad_temp[m] * count_temp + input_grad.get_value(position_temp)[m] * input_count.get_value(position_temp)) / (count_temp + input_count.get_value(position_temp));
         }
         input_grad.set_value(position_temp, grad_temp);
diff --git a/src/drr/drrtool.cpp b/src/drr/drrtool.cpp
index 0de438af11..964d78375e 100644
--- a/src/drr/drrtool.cpp
+++ b/src/drr/drrtool.cpp
@@ -78,7 +78,9 @@ class drrtool : public CLTool {
   void extractdrr(const vector<string> &filename);
   void mergewindows(const vector<string> &filename, string outputname);
   void calcDivergence(const vector<string> &filename, const string &fmt);
-  string description() const { return "Extract or merge the drrstate files."; }
+  string description() const {
+    return "Extract or merge the drrstate files.";
+  }
 
 private:
   bool verbosity;
@@ -164,11 +166,13 @@ void drrtool::extractdrr(const vector<string> &filename) {
     }
     string outputname(filename[j]);
     outputname.resize(outputname.length() - suffix.length());
-    if (verbosity)
+    if (verbosity) {
       std::cout << "Writing ABF(naive) estimator files..." << '\n';
+    }
     abfgrid.writeAll(outputname);
-    if (verbosity)
+    if (verbosity) {
       std::cout << "Writing CZAR estimator files..." << '\n';
+    }
     czarestimator.writeAll(outputname);
     czarestimator.writeZCountZGrad(outputname);
   }
@@ -211,9 +215,13 @@ void drrtool::mergewindows(const vector<string> &filename, string outputname) {
     // Generate new file name for merged grad and count
     vector<string> tmp_name = filename;
     std::transform(std::begin(tmp_name), std::end(tmp_name), std::begin(tmp_name),
-    [&](const string & s) {return s.substr(0, s.find(suffix));});
+    [&](const string & s) {
+      return s.substr(0, s.find(suffix));
+    });
     outputname = std::accumulate(std::begin(tmp_name), std::end(tmp_name), string(""),
-    [](const string & a, const string & b) {return a + b + "+";});
+    [](const string & a, const string & b) {
+      return a + b + "+";
+    });
     outputname.resize(outputname.size() - 1);
     std::cerr << "You have not specified an output filename for the merged"
               << " result, so the default name \"" + outputname
diff --git a/src/eds/EDS.cpp b/src/eds/EDS.cpp
index 6b86d470d9..c93ef9bbe6 100644
--- a/src/eds/EDS.cpp
+++ b/src/eds/EDS.cpp
@@ -31,10 +31,8 @@ using namespace bias;
 // namespace is lowercase to match
 // module names being all lowercase
 
-namespace PLMD
-{
-namespace eds
-{
+namespace PLMD {
+namespace eds {
 
 //+PLUMEDOC EDSMOD_BIAS EDS
 /*
@@ -192,8 +190,7 @@ eds: EDS ARG=d1 CENTER=2.0 TEMP=1.0 IN_RESTART=restart.eds FREEZE MEAN
 */
 //+ENDPLUMEDOC
 
-class EDS : public Bias
-{
+class EDS : public Bias {
 
 private:
   /*We will get this and store it once, since on-the-fly changing number of CVs will be fatal*/
@@ -278,8 +275,7 @@ class EDS : public Bias
 
 PLUMED_REGISTER_ACTION(EDS, "EDS")
 
-void EDS::registerKeywords(Keywords &keys)
-{
+void EDS::registerKeywords(Keywords &keys) {
   Bias::registerKeywords(keys);
   keys.use("ARG");
   keys.add("optional", "CENTER", "The desired centers (equilibrium values) which will be sought during the adaptive linear biasing. This is for fixed centers");
@@ -359,8 +355,7 @@ EDS::EDS(const ActionOptions &ao) : PLUMED_BIAS_INIT(ao),
   pseudo_virial_sum_(0.0),
   max_logweight_(0.0),
   wsum_(0.0),
-  value_force2_(NULL)
-{
+  value_force2_(NULL) {
   double temp = -1.0;
   bool b_mean = false;
   std::vector<Value *> wvalues;
@@ -369,8 +364,7 @@ EDS::EDS(const ActionOptions &ao) : PLUMED_BIAS_INIT(ao),
   componentIsNotPeriodic("force2");
   value_force2_ = getPntrToComponent("force2");
 
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
     std::string comp = getPntrToArgument(i)->getName() + "_coupling";
     addComponent(comp);
     componentIsNotPeriodic(comp);
@@ -408,70 +402,60 @@ EDS::EDS(const ActionOptions &ao) : PLUMED_BIAS_INIT(ao),
    * 3. Reading Restarts
    */
 
-  if (center_.size() == 0)
-  {
-    if (center_values_.size() == 0)
+  if (center_.size() == 0) {
+    if (center_values_.size() == 0) {
       error("Must set either CENTER or CENTER_ARG");
-    else if (center_values_.size() != ncvs_)
+    } else if (center_values_.size() != ncvs_) {
       error("CENTER_ARG must contain the same number of variables as ARG");
+    }
     b_c_values_ = true;
     center_.resize(ncvs_);
     log.printf("  EDS will use possibly varying centers\n");
-  }
-  else
-  {
-    if (center_.size() != ncvs_)
+  } else {
+    if (center_.size() != ncvs_) {
       error("Must have same number of CENTER arguments as ARG arguments");
-    else if (center_values_.size() != 0)
+    } else if (center_values_.size() != 0) {
       error("You can only set CENTER or CENTER_ARG. Not both");
+    }
     b_c_values_ = false;
     log.printf("  EDS will use fixed centers\n");
   }
 
   // check for weights
-  if (wvalues.size() > 1)
-  {
+  if (wvalues.size() > 1) {
     error("LOGWEIGHTS can only support one weight set. Please only pass one action");
-  }
-  else if (wvalues.size() == 1)
-  {
+  } else if (wvalues.size() == 1) {
     logweights_ = dynamic_cast<ReweightBase *>(wvalues[0]->getPntrToAction());
     b_weights_ = true;
   }
 
   log.printf("  setting scaling:");
-  if (scale_.size() > 0 && scale_.size() < ncvs_)
-  {
+  if (scale_.size() > 0 && scale_.size() < ncvs_) {
     error("the number of BIAS_SCALE values be the same as number of CVs");
-  }
-  else if (scale_.size() == 0 && b_c_values_)
-  {
+  } else if (scale_.size() == 0 && b_c_values_) {
     log.printf(" Setting SCALE to be 1 for all CVs\n");
     scale_.resize(ncvs_);
-    for (unsigned int i = 0; i < ncvs_; ++i)
+    for (unsigned int i = 0; i < ncvs_; ++i) {
       scale_[i] = 1;
-  }
-  else if (scale_.size() == 0 && !b_c_values_)
-  {
+    }
+  } else if (scale_.size() == 0 && !b_c_values_) {
     log.printf(" (default) ");
 
     scale_.resize(ncvs_);
-    for (unsigned int i = 0; i < scale_.size(); ++i)
-    {
-      if (center_[i] == 0)
+    for (unsigned int i = 0; i < scale_.size(); ++i) {
+      if (center_[i] == 0) {
         error("BIAS_SCALE parameter has been set to CENTER value of 0 (as is default). This will divide by 0, so giving up. See doc for EDS bias");
+      }
       scale_[i] = center_[i];
     }
-  }
-  else
-  {
-    for (unsigned int i = 0; i < scale_.size(); ++i)
+  } else {
+    for (unsigned int i = 0; i < scale_.size(); ++i) {
       log.printf(" %f", scale_[i]);
+    }
   }
   log.printf("\n");
 
-  if (b_lm_)
-  {
+  if (b_lm_) {
     log.printf("  EDS will perform Levenberg-Marquardt minimization with mixing parameter = %f\n", lm_mixing_par_);
     differences_.resize(ncvs_);
     alpha_vector_.resize(ncvs_);
@@ -481,36 +465,34 @@ EDS::EDS(const ActionOptions &ao) : PLUMED_BIAS_INIT(ao),
     lm_inv_.resize(ncvs_, ncvs_);
     covar2_ *= 0;
     lm_inv_ *= 0;
-    if (multi_prop_ != 1)
+    if (multi_prop_ != 1) {
       log.printf("     WARNING - doing LM minimization but MULTI_PROP!=1\n");
-  }
-  else if (b_covar_)
-  {
+    }
+  } else if (b_covar_) {
     log.printf("  EDS will utilize covariance matrix for update steps\n");
     covar_.resize(ncvs_, ncvs_);
-  }
-  else
-  {
+  } else {
     log.printf("  EDS will utilize variance for update steps\n");
     ssds_.resize(ncvs_);
   }
 
   b_virial_ = virial_scaling_;
 
-  if (b_virial_)
-  {
-    if (ncvs_ == 1)
+  if (b_virial_) {
+    if (ncvs_ == 1) {
       error("Minimizing the virial is only valid with multiply correlated collective variables.");
+    }
     // check that the CVs can be used to compute pseudo-virial
     log.printf("  EDS will compute virials of CVs and penalize with scale of %f. Checking CVs are valid...", virial_scaling_);
-    for (unsigned int i = 0; i < ncvs_; ++i)
-    {
+    for (unsigned int i = 0; i < ncvs_; ++i) {
       auto a = dynamic_cast<ActionAtomistic *>(getPntrToArgument(i)->getPntrToAction());
-      if (!a)
+      if (!a) {
         error("If using VIRIAL keyword, you must have normal CVs as arguments to EDS. Offending action: " + getPntrToArgument(i)->getPntrToAction()->getName());
+      }
       // cppcheck-suppress nullPointerRedundantCheck
-      if (!(a->getPbc().isOrthorombic()))
+      if (!(a->getPbc().isOrthorombic())) {
         log.printf("  WARNING: EDS Virial should have a orthorombic cell\n");
+      }
     }
     log.printf("done.\n");
     addComponent("pressure");
@@ -518,23 +500,18 @@ EDS::EDS(const ActionOptions &ao) : PLUMED_BIAS_INIT(ao),
     value_pressure_ = getPntrToComponent("pressure");
   }
 
-  if (b_mean && !b_freeze_)
-  {
+  if (b_mean && !b_freeze_) {
     error("EDS keyword MEAN can only be used along with keyword FREEZE");
   }
 
-  if (in_restart_name_ != "")
-  {
+  if (in_restart_name_ != "") {
     b_restart_ = true;
     log.printf("  reading simulation information from file: %s\n", in_restart_name_.c_str());
     readInRestart(b_mean);
-  }
-  else
-  {
+  } else {
 
     // in driver, this results in kbt of 0
-    if (kbt_ == 0)
-    {
+    if (kbt_ == 0) {
       error("  Unable to determine valid kBT. "
             "Could be because you are runnning from driver or MD didn't give temperature.\n"
             "Consider setting temperature manually with the TEMP keyword.");
@@ -544,19 +521,14 @@ EDS::EDS(const ActionOptions &ao) : PLUMED_BIAS_INIT(ao),
     log.printf("  kBT = %f\n", kbt_);
     log.printf("  Updating every %i steps\n", update_period_);
 
-    if (!b_c_values_)
-    {
+    if (!b_c_values_) {
       log.printf("  with centers:");
-      for (unsigned int i = 0; i < ncvs_; ++i)
-      {
+      for (unsigned int i = 0; i < ncvs_; ++i) {
         log.printf(" %f ", center_[i]);
       }
-    }
-    else
-    {
+    } else {
       log.printf("  with actions centers:");
-      for (unsigned int i = 0; i < ncvs_; ++i)
-      {
+      for (unsigned int i = 0; i < ncvs_; ++i) {
         log.printf(" %s ", center_values_[i]->getName().c_str());
         // add dependency on these actions
         addDependency(center_values_[i]->getPntrToAction());
@@ -564,8 +536,7 @@ EDS::EDS(const ActionOptions &ao) : PLUMED_BIAS_INIT(ao),
     }
 
     log.printf("\n  with initial ranges / rates:\n");
-    for (unsigned int i = 0; i < max_coupling_range_.size(); ++i)
-    {
+    for (unsigned int i = 0; i < max_coupling_range_.size(); ++i) {
       // this is just an empirical guess. Bigger range, bigger grads. Less frequent updates, bigger changes
       //
       // using the current maxing out scheme, max_coupling_range is the biggest step that can be taken in any given interval
@@ -574,79 +545,68 @@ EDS::EDS(const ActionOptions &ao) : PLUMED_BIAS_INIT(ao),
       log.printf("    %f / %f\n", max_coupling_range_[i], max_coupling_grad_[i]);
     }
 
-    if (seed_ > 0)
-    {
+    if (seed_ > 0) {
       log.printf("  setting random seed = %i", seed_);
       rand_.setSeed(seed_);
     }
 
     for (unsigned int i = 0; i < ncvs_; ++i)
-      if (target_coupling_[i] != 0.0)
+      if (target_coupling_[i] != 0.0) {
         b_adaptive_ = false;
+      }
 
-    if (!b_adaptive_)
-    {
-      if (b_ramp_)
-      {
+    if (!b_adaptive_) {
+      if (b_ramp_) {
         log.printf("  ramping up coupling constants over %i steps\n", update_period_);
       }
 
       log.printf("  with starting coupling constants");
-      for (unsigned int i = 0; i < set_coupling_.size(); ++i)
+      for (unsigned int i = 0; i < set_coupling_.size(); ++i) {
         log.printf(" %f", set_coupling_[i]);
+      }
       log.printf("\n");
       log.printf("  and final coupling constants");
-      for (unsigned int i = 0; i < target_coupling_.size(); ++i)
+      for (unsigned int i = 0; i < target_coupling_.size(); ++i) {
         log.printf(" %f", target_coupling_[i]);
+      }
       log.printf("\n");
     }
 
     // now do setup
-    if (b_ramp_)
-    {
+    if (b_ramp_) {
       update_period_ *= -1;
     }
 
-    for (unsigned int i = 0; i < set_coupling_.size(); ++i)
+    for (unsigned int i = 0; i < set_coupling_.size(); ++i) {
       current_coupling_[i] = set_coupling_[i];
+    }
 
     // if b_adaptive_, then first half will be used for equilibrating and second half for statistics
-    if (update_period_ > 0)
-    {
+    if (update_period_ > 0) {
       update_period_ /= 2;
     }
   }
 
-  if (b_freeze_)
-  {
+  if (b_freeze_) {
     b_adaptive_ = false;
     update_period_ = 0;
-    if (b_mean)
-    {
+    if (b_mean) {
       log.printf("  freezing bias at the average level from the restart file\n");
-    }
-    else
-    {
+    } else {
       log.printf("  freezing bias at current level\n");
     }
   }
 
-  if (multi_prop_ == -1.0)
-  {
+  if (multi_prop_ == -1.0) {
     log.printf("  Will update each dimension stochastically with probability 1 / number of CVs\n");
     multi_prop_ = 1.0 / ncvs_;
-  }
-  else if (multi_prop_ > 0 && multi_prop_ <= 1.0)
-  {
+  } else if (multi_prop_ > 0 && multi_prop_ <= 1.0) {
     log.printf("  Will update each dimension stochastically with probability %f\n", multi_prop_);
-  }
-  else
-  {
+  } else {
     error("  MULTI_PROP must be between 0 and 1\n");
   }
 
-  if (out_restart_name_.length() > 0)
-  {
+  if (out_restart_name_.length() > 0) {
     log.printf("  writing restart information every %i steps to file %s with format %s\n", abs(update_period_), out_restart_name_.c_str(), fmt_.c_str());
     b_write_restart_ = true;
     setupOutRestart();
@@ -656,53 +616,39 @@ EDS::EDS(const ActionOptions &ao) : PLUMED_BIAS_INIT(ao),
   log << "  Bibliography " << plumed.cite("G. M. Hocky, T. Dannenhoffer-Lafage, G. A. Voth, J. Chem. Theory Comput. 13 (9), 4593-4603 (2017)") << "\n";
 }
 
-void EDS::readInRestart(const bool b_mean)
-{
+void EDS::readInRestart(const bool b_mean) {
   int adaptive_i = 0;
 
   in_restart_.open(in_restart_name_);
 
-  if (in_restart_.FieldExist("kbt"))
-  {
+  if (in_restart_.FieldExist("kbt")) {
     in_restart_.scanField("kbt", kbt_);
-  }
-  else
-  {
+  } else {
     error("No field 'kbt' in restart file");
   }
   log.printf("  with kBT = %f\n", kbt_);
 
-  if (in_restart_.FieldExist("update_period"))
-  {
+  if (in_restart_.FieldExist("update_period")) {
     in_restart_.scanField("update_period", update_period_);
-  }
-  else
-  {
+  } else {
     error("No field 'update_period' in restart file");
   }
   log.printf("  Updating every %i steps\n", update_period_);
 
-  if (in_restart_.FieldExist("adaptive"))
-  {
+  if (in_restart_.FieldExist("adaptive")) {
     // note, no version of scanField for boolean
     in_restart_.scanField("adaptive", adaptive_i);
-  }
-  else
-  {
+  } else {
     error("No field 'adaptive' in restart file");
   }
   b_adaptive_ = bool(adaptive_i);
 
-  if (in_restart_.FieldExist("seed"))
-  {
+  if (in_restart_.FieldExist("seed")) {
     in_restart_.scanField("seed", seed_);
-  }
-  else
-  {
+  } else {
     error("No field 'seed' in restart file");
   }
-  if (seed_ > 0)
-  {
+  if (seed_ > 0) {
     log.printf("  setting random seed = %i", seed_);
     rand_.setSeed(seed_);
   }
@@ -712,11 +658,9 @@ void EDS::readInRestart(const bool b_mean)
   unsigned int N = 0;
   std::string cv_name;
 
-  while (in_restart_.scanField("time", time))
-  {
+  while (in_restart_.scanField("time", time)) {
 
-    for (unsigned int i = 0; i < ncvs_; ++i)
-    {
+    for (unsigned int i = 0; i < ncvs_; ++i) {
       cv_name = getPntrToArgument(i)->getName();
       in_restart_.scanField(cv_name + "_center", set_coupling_[i]);
       in_restart_.scanField(cv_name + "_set", set_coupling_[i]);
@@ -726,12 +670,12 @@ void EDS::readInRestart(const bool b_mean)
       in_restart_.scanField(cv_name + "_maxgrad", max_coupling_grad_[i]);
       in_restart_.scanField(cv_name + "_accum", coupling_accum_[i]);
       in_restart_.scanField(cv_name + "_mean", means_[i]);
-      if (in_restart_.FieldExist(cv_name + "_pseudovirial"))
-      {
-        if (b_virial_)
+      if (in_restart_.FieldExist(cv_name + "_pseudovirial")) {
+        if (b_virial_) {
           in_restart_.scanField(cv_name + "_pseudovirial", pseudo_virial_[i]);
-        else // discard the field
+        } else { // discard the field
           in_restart_.scanField(cv_name + "_pseudovirial", tmp);
+        }
       }
       // unused due to difference between covar/nocovar
       in_restart_.scanField(cv_name + "_std", tmp);
@@ -744,54 +688,53 @@ void EDS::readInRestart(const bool b_mean)
   }
 
   log.printf("  with centers:");
-  for (unsigned int i = 0; i < center_.size(); ++i)
-  {
+  for (unsigned int i = 0; i < center_.size(); ++i) {
     log.printf(" %f", center_[i]);
   }
   log.printf("\n  and scaling:");
-  for (unsigned int i = 0; i < scale_.size(); ++i)
-  {
+  for (unsigned int i = 0; i < scale_.size(); ++i) {
     log.printf(" %f", scale_[i]);
   }
 
   log.printf("\n  with initial ranges / rates:\n");
-  for (unsigned int i = 0; i < max_coupling_range_.size(); ++i)
-  {
+  for (unsigned int i = 0; i < max_coupling_range_.size(); ++i) {
     log.printf("    %f / %f\n", max_coupling_range_[i], max_coupling_grad_[i]);
   }
 
-  if (!b_adaptive_ && update_period_ < 0)
-  {
+  if (!b_adaptive_ && update_period_ < 0) {
     log.printf("  ramping up coupling constants over %i steps\n", -update_period_);
   }
 
-  if (b_mean)
-  {
+  if (b_mean) {
     log.printf("Loaded in averages for coupling constants...\n");
-    for (unsigned int i = 0; i < current_coupling_.size(); ++i)
+    for (unsigned int i = 0; i < current_coupling_.size(); ++i) {
       current_coupling_[i] = avg_bias[i] / N;
-    for (unsigned int i = 0; i < current_coupling_.size(); ++i)
+    }
+    for (unsigned int i = 0; i < current_coupling_.size(); ++i) {
       set_coupling_[i] = avg_bias[i] / N;
+    }
   }
 
   log.printf("  with current coupling constants:\n    ");
-  for (unsigned int i = 0; i < current_coupling_.size(); ++i)
+  for (unsigned int i = 0; i < current_coupling_.size(); ++i) {
     log.printf(" %f", current_coupling_[i]);
+  }
   log.printf("\n");
   log.printf("  with initial coupling constants:\n    ");
-  for (unsigned int i = 0; i < set_coupling_.size(); ++i)
+  for (unsigned int i = 0; i < set_coupling_.size(); ++i) {
     log.printf(" %f", set_coupling_[i]);
+  }
   log.printf("\n");
   log.printf("  and final coupling constants:\n    ");
-  for (unsigned int i = 0; i < target_coupling_.size(); ++i)
+  for (unsigned int i = 0; i < target_coupling_.size(); ++i) {
     log.printf(" %f", target_coupling_[i]);
+  }
   log.printf("\n");
 
   in_restart_.close();
 }
 
-void EDS::setupOutRestart()
-{
+void EDS::setupOutRestart() {
   out_restart_.link(*this);
   out_restart_.fmtField(fmt_);
   out_restart_.open(out_restart_name_);
@@ -803,13 +746,11 @@ void EDS::setupOutRestart()
   out_restart_.addConstantField("kbt").printField("kbt", kbt_);
 }
 
-void EDS::writeOutRestart()
-{
+void EDS::writeOutRestart() {
   std::string cv_name;
   out_restart_.printField("time", getTimeStep() * getStep());
 
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
     cv_name = getPntrToArgument(i)->getName();
     out_restart_.printField(cv_name + "_center", center_[i]);
     out_restart_.printField(cv_name + "_set", set_coupling_[i]);
@@ -819,34 +760,34 @@ void EDS::writeOutRestart()
     out_restart_.printField(cv_name + "_maxgrad", max_coupling_grad_[i]);
     out_restart_.printField(cv_name + "_accum", coupling_accum_[i]);
     out_restart_.printField(cv_name + "_mean", means_[i]);
-    if (b_virial_)
+    if (b_virial_) {
       out_restart_.printField(cv_name + "_pseudovirial", pseudo_virial_[i]);
-    if (!b_covar_ && !b_lm_)
+    }
+    if (!b_covar_ && !b_lm_) {
       out_restart_.printField(cv_name + "_std", ssds_[i] / (fmax(1, update_calls_ - 1)));
-    else
+    } else {
       out_restart_.printField(cv_name + "_std", covar_(i, i) / (fmax(1, update_calls_ - 1)));
+    }
   }
   out_restart_.printField();
 }
 
-void EDS::calculate()
-{
+void EDS::calculate() {
 
   // get center values from action if necessary
   if (b_c_values_)
-    for (unsigned int i = 0; i < ncvs_; ++i)
+    for (unsigned int i = 0; i < ncvs_; ++i) {
       center_[i] = center_values_[i]->get();
+    }
 
   apply_bias();
 }
 
-void EDS::apply_bias()
-{
+void EDS::apply_bias() {
   // Compute linear force as in "restraint"
   double ene = 0, totf2 = 0, cv, m, f;
 
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
     cv = difference(i, center_[i], getArgument(i));
     m = current_coupling_[i];
     f = -m;
@@ -859,17 +800,14 @@ void EDS::apply_bias()
   value_force2_->set(totf2);
 }
 
-void EDS::update_statistics()
-{
+void EDS::update_statistics() {
   double s, N, w = 1.0;
   std::vector<double> deltas(ncvs_);
 
   // update weight max, if necessary
-  if (b_weights_)
-  {
+  if (b_weights_) {
     w = logweights_->getLogWeight();
-    if (max_logweight_ < w)
-    {
+    if (max_logweight_ < w) {
       // we have new max. Need to shift existing values
       wsum_ *= exp(max_logweight_ - w);
       max_logweight_ = w;
@@ -878,27 +816,22 @@ void EDS::update_statistics()
     w = exp(w - max_logweight_);
     wsum_ += w;
     N = wsum_;
-  }
-  else
-  {
+  } else {
     N = fmax(1, update_calls_);
   }
 
   // Welford, West, and Hanso online variance method
   // with weights (default =  1.0)
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
     deltas[i] = difference(i, means_[i], getArgument(i)) * w;
     means_[i] += deltas[i] / N;
-    if (!b_covar_ && !b_lm_)
+    if (!b_covar_ && !b_lm_) {
       ssds_[i] += deltas[i] * difference(i, means_[i], getArgument(i));
+    }
   }
-  if (b_covar_ || b_lm_)
-  {
-    for (unsigned int i = 0; i < ncvs_; ++i)
-    {
-      for (unsigned int j = i; j < ncvs_; ++j)
-      {
+  if (b_covar_ || b_lm_) {
+    for (unsigned int i = 0; i < ncvs_; ++i) {
+      for (unsigned int j = i; j < ncvs_; ++j) {
         s = (N - 1) * deltas[i] * deltas[j] / N / N - covar_(i, j) / N;
         covar_(i, j) += s;
         // do this so we don't double count
@@ -906,43 +839,41 @@ void EDS::update_statistics()
       }
     }
   }
-  if (b_virial_)
+  if (b_virial_) {
     update_pseudo_virial();
+  }
 }
 
-void EDS::reset_statistics()
-{
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+void EDS::reset_statistics() {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
     means_[i] = 0;
-    if (!b_covar_ && !b_lm_)
+    if (!b_covar_ && !b_lm_) {
       ssds_[i] = 0;
+    }
   }
   if (b_covar_ || b_lm_)
     for (unsigned int i = 0; i < ncvs_; ++i)
-      for (unsigned int j = 0; j < ncvs_; ++j)
+      for (unsigned int j = 0; j < ncvs_; ++j) {
         covar_(i, j) = 0;
-  if (b_virial_)
-  {
-    for (unsigned int i = 0; i < ncvs_; ++i)
+      }
+  if (b_virial_) {
+    for (unsigned int i = 0; i < ncvs_; ++i) {
       pseudo_virial_[i] = 0;
+    }
     pseudo_virial_sum_ = 0;
   }
-  if (b_weights_)
-  {
+  if (b_weights_) {
     wsum_ = 0;
     max_logweight_ = 0;
   }
 }
 
-void EDS::calc_lm_step_size()
-{
+void EDS::calc_lm_step_size() {
   // calulcate step size
   // uses scale here, which by default is center
 
   mult(covar_, covar_, covar2_);
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
     differences_[i] = difference(i, center_[i], means_[i]);
     covar2_[i][i] += lm_mixing_par_ * covar2_[i][i];
   }
@@ -952,51 +883,46 @@ void EDS::calc_lm_step_size()
   Invert(covar2_, lm_inv_);
   mult(lm_inv_, alpha_vector_, alpha_vector_2_);
 
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
     step_size_[i] = 2 * alpha_vector_2_[i] / kbt_ / scale_[i];
   }
 }
 
-void EDS::calc_covar_step_size()
-{
+void EDS::calc_covar_step_size() {
   // calulcate step size
   // uses scale here, which by default is center
   double tmp;
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
     tmp = 0;
-    for (unsigned int j = 0; j < ncvs_; ++j)
+    for (unsigned int j = 0; j < ncvs_; ++j) {
       tmp += difference(i, center_[i], means_[i]) * covar_(i, j);
+    }
     step_size_[i] = 2 * tmp / kbt_ / scale_[i] * update_calls_ / fmax(1, update_calls_ - 1);
   }
 }
 
-void EDS::calc_ssd_step_size()
-{
+void EDS::calc_ssd_step_size() {
   double tmp;
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
     tmp = 2. * difference(i, center_[i], means_[i]) * ssds_[i] / fmax(1, update_calls_ - 1);
     step_size_[i] = tmp / kbt_ / scale_[i];
   }
 }
 
-void EDS::update_pseudo_virial()
-{
+void EDS::update_pseudo_virial() {
   // We want to compute the bias force on each atom times the position
   //  of the atoms.
   double p, netp = 0, netpv = 0;
   double volume = 0;
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
     // checked in setup to ensure this cast is valid.
     ActionAtomistic *cv = dynamic_cast<ActionAtomistic *>(getPntrToArgument(i)->getPntrToAction());
     Tensor v(cv->getVirial());
     Tensor box(cv->getBox());
     const unsigned int natoms = cv->getNumberOfAtoms();
-    if (!volume)
+    if (!volume) {
       volume = box.determinant();
+    }
 
     // pressure contribution is -dBias / dV
     // dBias / dV = alpha / w * dCV / dV
@@ -1014,10 +940,11 @@ void EDS::update_pseudo_virial()
     p *= (volume) / (kbt_ * natoms);
 
     // compute running mean of scaled
-    if (set_coupling_[i] != 0)
+    if (set_coupling_[i] != 0) {
       pseudo_virial_[i] = (p - pseudo_virial_[i]) / (fmax(1, update_calls_));
-    else
+    } else {
       pseudo_virial_[i] = 0;
+    }
     // update net pressure
     netpv += pseudo_virial_[i];
   }
@@ -1026,35 +953,35 @@ void EDS::update_pseudo_virial()
   pseudo_virial_sum_ = netpv;
 }
 
-void EDS::update_bias()
-{
+void EDS::update_bias() {
   log.flush();
-  if (b_lm_)
+  if (b_lm_) {
     calc_lm_step_size();
-  else if (b_covar_)
+  } else if (b_covar_) {
     calc_covar_step_size();
-  else
+  } else {
     calc_ssd_step_size();
+  }
 
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
 
     // multidimesional stochastic step
-    if (ncvs_ == 1 || (rand_.RandU01() < (multi_prop_)))
-    {
+    if (ncvs_ == 1 || (rand_.RandU01() < (multi_prop_))) {
 
-      if (b_virial_)
-      {
+      if (b_virial_) {
         // apply virial regularization
         //  P * dP/dcoupling
         //  coupling is already included in virial term due to plumed propogating from bias to forces
         //  thus we need to divide by it to get the derivative (since force is linear in coupling)
         if (fabs(set_coupling_[i]) > 0.000000001) // my heuristic for if EDS has started to prevent / 0
           // scale^2 here is to align units
+        {
           step_size_[i] -= 2 * scale_[i] * scale_[i] * virial_scaling_ * pseudo_virial_sum_ * pseudo_virial_sum_ / set_coupling_[i];
+        }
       }
-      if (step_size_[i] == 0)
+      if (step_size_[i] == 0) {
         continue;
+      }
 
       // clip gradient
       step_size_[i] = copysign(fmin(fabs(step_size_[i]), max_coupling_grad_[i]), step_size_[i]);
@@ -1064,9 +991,7 @@ void EDS::update_bias()
       // no negative sign because it's in step_size
       set_coupling_[i] += step_size_[i] * max_coupling_range_[i] / sqrt(coupling_accum_[i]);
       coupling_rate_[i] = (set_coupling_[i] - current_coupling_[i]) / update_period_;
-    }
-    else
-    {
+    } else {
       // do not change the bias
       coupling_rate_[i] = 0;
     }
@@ -1076,59 +1001,51 @@ void EDS::update_bias()
   reset_statistics();
 }
 
-void EDS::update()
-{
+void EDS::update() {
   // adjust parameters according to EDS recipe
   update_calls_++;
 
   // if we aren't wating for the bias to equilibrate, set flag to collect data
   // want statistics before writing restart
-  if (!b_equil_ && update_period_ > 0)
+  if (!b_equil_ && update_period_ > 0) {
     update_statistics();
+  }
 
   // write restart with correct statistics before bias update
   // check if we're ramping or doing normal updates and then restart if needed. The ramping check
   // is complicated because we could be frozen, finished ramping or not ramping.
   // The + 2 is so we have an extra line showing that the bias isn't changing (for my sanity and yours)
-  if (b_write_restart_)
-  {
+  if (b_write_restart_) {
     if (getStep() == 0 ||
         ((update_period_ < 0 && !b_freeze_ && update_calls_ <= fabs(update_period_) + 2) ||
-         (update_period_ > 0 && update_calls_ % update_period_ == 0)))
+         (update_period_ > 0 && update_calls_ % update_period_ == 0))) {
       writeOutRestart();
+    }
   }
 
   int b_finished_equil_flag = 1;
 
   // assume forces already applied and saved
   // are we ramping to a constant value and not done equilibrating?
-  if (update_period_ < 0)
-  {
-    if (update_calls_ <= fabs(update_period_) && !b_freeze_)
-    {
-      for (unsigned int i = 0; i < ncvs_; ++i)
+  if (update_period_ < 0) {
+    if (update_calls_ <= fabs(update_period_) && !b_freeze_) {
+      for (unsigned int i = 0; i < ncvs_; ++i) {
         current_coupling_[i] += (target_coupling_[i] - set_coupling_[i]) / fabs(update_period_);
+      }
     }
     // make sure we don't reset update calls
     b_finished_equil_flag = 0;
-  }
-  else if (update_period_ == 0)
-  { // do we have a no-update case?
+  } else if (update_period_ == 0) {
+    // do we have a no-update case?
     // not updating
     // pass
-  }
-  else if (b_equil_)
-  {
+  } else if (b_equil_) {
     // equilibrating
     // check if we've reached the setpoint
-    for (unsigned int i = 0; i < ncvs_; ++i)
-    {
-      if (coupling_rate_[i] == 0 || pow(current_coupling_[i] - set_coupling_[i], 2) < pow(coupling_rate_[i], 2))
-      {
+    for (unsigned int i = 0; i < ncvs_; ++i) {
+      if (coupling_rate_[i] == 0 || pow(current_coupling_[i] - set_coupling_[i], 2) < pow(coupling_rate_[i], 2)) {
         b_finished_equil_flag &= 1;
-      }
-      else
-      {
+      } else {
         current_coupling_[i] += coupling_rate_[i];
         b_finished_equil_flag = 0;
       }
@@ -1136,15 +1053,13 @@ void EDS::update()
   }
 
   // reduce all the flags
-  if (b_equil_ && b_finished_equil_flag)
-  {
+  if (b_equil_ && b_finished_equil_flag) {
     b_equil_ = false;
     update_calls_ = 0;
   }
 
   // Now we update coupling constant, if necessary
-  if (!b_equil_ && update_period_ > 0 && update_calls_ == update_period_ && !b_freeze_)
-  {
+  if (!b_equil_ && update_period_ > 0 && update_calls_ == update_period_ && !b_freeze_) {
     update_bias();
     update_calls_ = 0;
     avg_coupling_count_++;
@@ -1152,19 +1067,16 @@ void EDS::update()
   }                  // close update if
 
   // pass couplings out so they are accessible
-  for (unsigned int i = 0; i < ncvs_; ++i)
-  {
+  for (unsigned int i = 0; i < ncvs_; ++i) {
     out_coupling_[i]->set(current_coupling_[i]);
   }
 }
 
-EDS::~EDS()
-{
+EDS::~EDS() {
   out_restart_.close();
 }
 
-void EDS::turnOnDerivatives()
-{
+void EDS::turnOnDerivatives() {
   // do nothing
   // this is to avoid errors triggered when a bias is used as a CV
   // (This is done in ExtendedLagrangian.cpp)
diff --git a/src/envsim/EnvironmentSimilarity.cpp b/src/envsim/EnvironmentSimilarity.cpp
index 4f67821e4d..e1cef042c6 100644
--- a/src/envsim/EnvironmentSimilarity.cpp
+++ b/src/envsim/EnvironmentSimilarity.cpp
@@ -219,50 +219,77 @@ void EnvironmentSimilarity::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","LAMBDA","100","Lambda parameter.  This is only used if you have more than one reference environment");
   keys.add("compulsory","CUTOFF","3","how many multiples of sigma would you like to consider beyond the maximum distance in the environment");
   keys.add("optional","ATOM_NAMES_FILE","PDB file with atom names for all atoms in SPECIES. Atoms in reference environments will be compared only if atom names match.");
-  multicolvar::MultiColvarShortcuts::shortcutKeywords( keys ); keys.needsAction("GROUP");
-  keys.needsAction("DISTANCE_MATRIX"); keys.needsAction("ONES"); keys.needsAction("CONSTANT");
-  keys.needsAction("CUSTOM"); keys.needsAction("MATRIX_VECTOR_PRODUCT"); keys.needsAction("COMBINE");
+  multicolvar::MultiColvarShortcuts::shortcutKeywords( keys );
+  keys.needsAction("GROUP");
+  keys.needsAction("DISTANCE_MATRIX");
+  keys.needsAction("ONES");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("COMBINE");
 }
 
 EnvironmentSimilarity::EnvironmentSimilarity(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string atomNamesFile; parse("ATOM_NAMES_FILE",atomNamesFile); PDB atomnamepdb;
-  if( !atomNamesFile.empty() && !atomnamepdb.read(atomNamesFile,usingNaturalUnits(),0.1/getUnits().getLength()) ) error("missing input file " + atomNamesFile);
+  ActionShortcut(ao) {
+  std::string atomNamesFile;
+  parse("ATOM_NAMES_FILE",atomNamesFile);
+  PDB atomnamepdb;
+  if( !atomNamesFile.empty() && !atomnamepdb.read(atomNamesFile,usingNaturalUnits(),0.1/getUnits().getLength()) ) {
+    error("missing input file " + atomNamesFile);
+  }
 
-  double maxdist=0; std::vector<std::string> allspec(1);
-  std::string crystal_structure; parse("CRYSTAL_STRUCTURE", crystal_structure);
+  double maxdist=0;
+  std::vector<std::string> allspec(1);
+  std::string crystal_structure;
+  parse("CRYSTAL_STRUCTURE", crystal_structure);
   std::vector<std::vector<std::pair<unsigned,Vector> > > environments;
   if( crystal_structure=="CUSTOM" ) {
     if( !atomNamesFile.empty()  ) {
-      allspec[0]=atomnamepdb.getAtomName(atomnamepdb.getAtomNumbers()[0]); unsigned natoms=atomnamepdb.getPositions().size();
+      allspec[0]=atomnamepdb.getAtomName(atomnamepdb.getAtomNumbers()[0]);
+      unsigned natoms=atomnamepdb.getPositions().size();
       for(unsigned i=0; i<natoms; ++i) {
         bool found=false;
         for(unsigned j=0; j<allspec.size(); ++j) {
-          if( allspec[j]==atomnamepdb.getAtomName(atomnamepdb.getAtomNumbers()[i] ) ) { found=true; break; }
+          if( allspec[j]==atomnamepdb.getAtomName(atomnamepdb.getAtomNumbers()[i] ) ) {
+            found=true;
+            break;
+          }
+        }
+        if( !found ) {
+          allspec.push_back( atomnamepdb.getAtomName(atomnamepdb.getAtomNumbers()[i]) );
         }
-        if( !found ) allspec.push_back( atomnamepdb.getAtomName(atomnamepdb.getAtomNumbers()[i]) );
       }
     }
-    std::string reffile; parse("REFERENCE",reffile);
+    std::string reffile;
+    parse("REFERENCE",reffile);
     if( reffile.length()>0 ) {
-      PDB pdb; pdb.read(reffile,plumed.usingNaturalUnits(),0.1/plumed.getUnits().getLength());
+      PDB pdb;
+      pdb.read(reffile,plumed.usingNaturalUnits(),0.1/plumed.getUnits().getLength());
       environments.push_back( getReferenceEnvironment( pdb, allspec, maxdist ) );
       log.printf("  reading %d reference vectors from %s \n", environments[0].size(), reffile.c_str() );
     } else {
       for(unsigned int i=1;; i++) {
-        PDB pdb; if( !parseNumbered("REFERENCE_",i,reffile) ) break;
-        if( !pdb.read(reffile,usingNaturalUnits(),0.1/getUnits().getLength()) ) error("missing input file " + reffile );
+        PDB pdb;
+        if( !parseNumbered("REFERENCE_",i,reffile) ) {
+          break;
+        }
+        if( !pdb.read(reffile,usingNaturalUnits(),0.1/getUnits().getLength()) ) {
+          error("missing input file " + reffile );
+        }
         environments.push_back( getReferenceEnvironment( pdb, allspec, maxdist ) );
         log.printf("  Reference environment %d : reading %d reference vectors from %s \n", i, environments[i-1].size(), reffile.c_str() );
       }
     }
   } else {
-    std::vector<double> lattice_constants; parseVector("LATTICE_CONSTANTS", lattice_constants);
+    std::vector<double> lattice_constants;
+    parseVector("LATTICE_CONSTANTS", lattice_constants);
     if (crystal_structure == "FCC") {
-      if (lattice_constants.size() != 1) error("Number of LATTICE_CONSTANTS arguments must be one for FCC");
-      environments.resize(1); environments[0].resize(12);
+      if (lattice_constants.size() != 1) {
+        error("Number of LATTICE_CONSTANTS arguments must be one for FCC");
+      }
+      environments.resize(1);
+      environments[0].resize(12);
       environments[0][0]  = std::pair<unsigned,Vector>( 0, Vector(+0.5,+0.5,+0.0)*lattice_constants[0] );
       environments[0][1]  = std::pair<unsigned,Vector>( 0, Vector(-0.5,-0.5,+0.0)*lattice_constants[0] );
       environments[0][2]  = std::pair<unsigned,Vector>( 0, Vector(+0.5,-0.5,+0.0)*lattice_constants[0] );
@@ -277,8 +304,11 @@ EnvironmentSimilarity::EnvironmentSimilarity(const ActionOptions&ao):
       environments[0][11] = std::pair<unsigned,Vector>( 0, Vector(+0.0,+0.5,-0.5)*lattice_constants[0] );
       maxdist = std::sqrt(2)*lattice_constants[0]/2.;
     } else if (crystal_structure == "SC") {
-      if (lattice_constants.size() != 1) error("Number of LATTICE_CONSTANTS arguments must be one for SC");
-      environments.resize(1); environments[0].resize(6);
+      if (lattice_constants.size() != 1) {
+        error("Number of LATTICE_CONSTANTS arguments must be one for SC");
+      }
+      environments.resize(1);
+      environments[0].resize(6);
       environments[0][0]  = std::pair<unsigned,Vector>( 0, Vector(+1.0,+0.0,+0.0)*lattice_constants[0] );
       environments[0][1]  = std::pair<unsigned,Vector>( 0, Vector(-1.0,+0.0,+0.0)*lattice_constants[0] );
       environments[0][2]  = std::pair<unsigned,Vector>( 0, Vector(+0.0,+1.0,+0.0)*lattice_constants[0] );
@@ -287,8 +317,11 @@ EnvironmentSimilarity::EnvironmentSimilarity(const ActionOptions&ao):
       environments[0][5]  = std::pair<unsigned,Vector>( 0, Vector(+0.0,+0.0,-1.0)*lattice_constants[0] );
       maxdist = lattice_constants[0];
     } else if( crystal_structure == "BCC") {
-      if (lattice_constants.size() != 1) error("Number of LATTICE_CONSTANTS arguments must be one for BCC");
-      environments.resize(1); environments[0].resize(14);
+      if (lattice_constants.size() != 1) {
+        error("Number of LATTICE_CONSTANTS arguments must be one for BCC");
+      }
+      environments.resize(1);
+      environments[0].resize(14);
       environments[0][0]  = std::pair<unsigned,Vector>( 0, Vector(+0.5,+0.5,+0.5)*lattice_constants[0] );
       environments[0][1]  = std::pair<unsigned,Vector>( 0, Vector(-0.5,-0.5,-0.5)*lattice_constants[0] );
       environments[0][2]  = std::pair<unsigned,Vector>( 0, Vector(-0.5,+0.5,+0.5)*lattice_constants[0] );
@@ -305,8 +338,13 @@ EnvironmentSimilarity::EnvironmentSimilarity(const ActionOptions&ao):
       environments[0][13] = std::pair<unsigned,Vector>( 0, Vector(+0.0,+0.0,-1.0)*lattice_constants[0] );
       maxdist = lattice_constants[0];
     } else if (crystal_structure == "HCP") {
-      if (lattice_constants.size() != 2) error("Number of LATTICE_CONSTANTS arguments must be two for HCP");
-      environments.resize(2); environments[0].resize(12); environments[1].resize(12); double sqrt3=std::sqrt(3);
+      if (lattice_constants.size() != 2) {
+        error("Number of LATTICE_CONSTANTS arguments must be two for HCP");
+      }
+      environments.resize(2);
+      environments[0].resize(12);
+      environments[1].resize(12);
+      double sqrt3=std::sqrt(3);
       environments[0][0]  = std::pair<unsigned,Vector>( 0, Vector(+0.5,+sqrt3/2.0,+0.0)*lattice_constants[0] );
       environments[0][1]  = std::pair<unsigned,Vector>( 0, Vector(-0.5,+sqrt3/2.0,+0.0)*lattice_constants[0] );
       environments[0][2]  = std::pair<unsigned,Vector>( 0, Vector(+0.5,-sqrt3/2.0,+0.0)*lattice_constants[0] );
@@ -333,8 +371,12 @@ EnvironmentSimilarity::EnvironmentSimilarity(const ActionOptions&ao):
       environments[1][11] = std::pair<unsigned,Vector>( 0, Vector(+0.0,+sqrt3/3.0,+0.0)*lattice_constants[0] + Vector(+0.0,+0.0,-0.5)*lattice_constants[1] );
       maxdist = lattice_constants[0];
     } else if (crystal_structure == "DIAMOND") {
-      if (lattice_constants.size() != 1) error("Number of LATTICE_CONSTANTS arguments must be one for DIAMOND");
-      environments.resize(2); environments[0].resize(4); environments[1].resize(4);
+      if (lattice_constants.size() != 1) {
+        error("Number of LATTICE_CONSTANTS arguments must be one for DIAMOND");
+      }
+      environments.resize(2);
+      environments[0].resize(4);
+      environments[1].resize(4);
       environments[0][0]  = std::pair<unsigned,Vector>( 0, Vector(+1.0,+1.0,+1.0)*lattice_constants[0]/4.0 );
       environments[0][1]  = std::pair<unsigned,Vector>( 0, Vector(-1.0,-1.0,+1.0)*lattice_constants[0]/4.0 );
       environments[0][2]  = std::pair<unsigned,Vector>( 0, Vector(+1.0,-1.0,-1.0)*lattice_constants[0]/4.0 );
@@ -344,34 +386,62 @@ EnvironmentSimilarity::EnvironmentSimilarity(const ActionOptions&ao):
       environments[1][2]  = std::pair<unsigned,Vector>( 0, Vector(+1.0,+1.0,-1.0)*lattice_constants[0]/4.0 );
       environments[1][3]  = std::pair<unsigned,Vector>( 0, Vector(-1.0,-1.0,-1.0)*lattice_constants[0]/4.0 );
       maxdist = std::sqrt(3)*lattice_constants[0]/4.0;
-    } else error( crystal_structure + " is not a valid input for keyword CRYSTAL_STRUCTURE");
+    } else {
+      error( crystal_structure + " is not a valid input for keyword CRYSTAL_STRUCTURE");
+    }
   }
   std::string matlab = getShortcutLabel() + "_cmat";
-  double cutoff, sig; parse("SIGMA",sig); parse("CUTOFF",cutoff); std::string lcutoff; parse("LCUTOFF",lcutoff);
-  std::string sig2; Tools::convert( sig*sig, sig2 ); std::vector<std::vector<std::string> > funcstr(environments.size());
-  std::string str_cutoff; Tools::convert( maxdist + cutoff*sig, str_cutoff );
-  std::string str_natoms, xpos, ypos, zpos; Tools::convert( environments[0].size(), str_natoms );
+  double cutoff, sig;
+  parse("SIGMA",sig);
+  parse("CUTOFF",cutoff);
+  std::string lcutoff;
+  parse("LCUTOFF",lcutoff);
+  std::string sig2;
+  Tools::convert( sig*sig, sig2 );
+  std::vector<std::vector<std::string> > funcstr(environments.size());
+  std::string str_cutoff;
+  Tools::convert( maxdist + cutoff*sig, str_cutoff );
+  std::string str_natoms, xpos, ypos, zpos;
+  Tools::convert( environments[0].size(), str_natoms );
   for(unsigned j=0; j<environments.size(); ++j) {
     funcstr[j].resize( allspec.size() );
     for(unsigned k=0; k<allspec.size(); ++k) {
       for(unsigned i=0; i<environments[j].size(); ++i) {
-        if( environments[j][i].first!=k ) continue ;
-        Tools::convert( environments[j][i].second[0], xpos ); Tools::convert( environments[j][i].second[1], ypos ); Tools::convert( environments[j][i].second[2], zpos );
-        if( i==0 ) funcstr[j][k] = "FUNC=(step(w-" + lcutoff + ")*step(" + str_cutoff + "-w)/" + str_natoms + ")*(exp(-((x-" + xpos + ")^2+(y-" + ypos + ")^2+(z-" + zpos + ")^2)/(4*" + sig2 + "))";
-        else funcstr[j][k] += "+exp(-((x-" + xpos + ")^2+(y-" + ypos + ")^2+(z-" + zpos + ")^2)/(4*" + sig2 + "))";
+        if( environments[j][i].first!=k ) {
+          continue ;
+        }
+        Tools::convert( environments[j][i].second[0], xpos );
+        Tools::convert( environments[j][i].second[1], ypos );
+        Tools::convert( environments[j][i].second[2], zpos );
+        if( i==0 ) {
+          funcstr[j][k] = "FUNC=(step(w-" + lcutoff + ")*step(" + str_cutoff + "-w)/" + str_natoms + ")*(exp(-((x-" + xpos + ")^2+(y-" + ypos + ")^2+(z-" + zpos + ")^2)/(4*" + sig2 + "))";
+        } else {
+          funcstr[j][k] += "+exp(-((x-" + xpos + ")^2+(y-" + ypos + ")^2+(z-" + zpos + ")^2)/(4*" + sig2 + "))";
+        }
+      }
+      if( funcstr[j][k].length()>0 ) {
+        funcstr[j][k] += ")";
+      } else {
+        funcstr[j][k] ="FUNC=0";
       }
-      if( funcstr[j][k].length()>0 ) funcstr[j][k] += ")"; else funcstr[j][k] ="FUNC=0";
     }
   }
 
   // Create the constact matrix
-  std::string sp_str, specA, specB; parse("SPECIES",sp_str); parse("SPECIESA",specA); parse("SPECIESB",specB);
+  std::string sp_str, specA, specB;
+  parse("SPECIES",sp_str);
+  parse("SPECIESA",specA);
+  parse("SPECIESB",specB);
   if( sp_str.length()>0 ) {
     readInputLine( matlab + ": DISTANCE_MATRIX COMPONENTS GROUP=" + sp_str + " CUTOFF=" + str_cutoff );
     readInputLine( getShortcutLabel() + "_grp: GROUP ATOMS=" + sp_str );
   } else {
-    if( specA.length()==0 ) error("no atoms were specified use SPECIES or SPECIESA+SPECIESB");
-    if( specB.length()==0 ) error("no atoms were specified for SPECIESB");
+    if( specA.length()==0 ) {
+      error("no atoms were specified use SPECIES or SPECIESA+SPECIESB");
+    }
+    if( specB.length()==0 ) {
+      error("no atoms were specified for SPECIESB");
+    }
     readInputLine( matlab + ": DISTANCE_MATRIX COMPONENTS GROUPA=" + specA + " GROUPB=" + specB + " CUTOFF=" + str_cutoff );
     readInputLine( getShortcutLabel() + "_grp: GROUP ATOMS=" + specA );
   }
@@ -379,31 +449,47 @@ EnvironmentSimilarity::EnvironmentSimilarity(const ActionOptions&ao):
   // Make a vector containing all ones
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( matlab );
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   if( allspec.size()==1 ) {
     readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   } else {
     unsigned natoms=atomnamepdb.getPositions().size();
-    unsigned firstneigh=0; if( sp_str.length()==0 ) firstneigh = (av->copyOutput(0))->getShape()[0];
+    unsigned firstneigh=0;
+    if( sp_str.length()==0 ) {
+      firstneigh = (av->copyOutput(0))->getShape()[0];
+    }
     for(unsigned i=0; i<allspec.size(); ++i) {
-      std::string onesstr="0"; if( atomnamepdb.getAtomName(atomnamepdb.getAtomNumbers()[firstneigh])==allspec[i] ) onesstr = "1";
+      std::string onesstr="0";
+      if( atomnamepdb.getAtomName(atomnamepdb.getAtomNumbers()[firstneigh])==allspec[i] ) {
+        onesstr = "1";
+      }
       for(unsigned j=firstneigh+1; j<natoms; ++j) {
-        if( atomnamepdb.getAtomName(atomnamepdb.getAtomNumbers()[j])==allspec[i] ) onesstr += ",1";
-        else onesstr += ",0";
+        if( atomnamepdb.getAtomName(atomnamepdb.getAtomNumbers()[j])==allspec[i] ) {
+          onesstr += ",1";
+        } else {
+          onesstr += ",0";
+        }
       }
       readInputLine( getShortcutLabel() + "_ones_" + allspec[i] + ": CONSTANT VALUES=" + onesstr );
     }
   }
 
-  std::string envargstr,varstr, maxfuncstr, lambda; if( funcstr.size()>1 ) parse("LAMBDA",lambda);
+  std::string envargstr,varstr, maxfuncstr, lambda;
+  if( funcstr.size()>1 ) {
+    parse("LAMBDA",lambda);
+  }
   // And now do the funcstr bit
   for(unsigned j=0; j<funcstr.size(); ++j) {
-    std::string jnum; Tools::convert( j+1, jnum );
+    std::string jnum;
+    Tools::convert( j+1, jnum );
     if(j==0) {
-      varstr = "v" + jnum; maxfuncstr = "(1/" + lambda + ")*log(exp(" + lambda + "*v1)";
+      varstr = "v" + jnum;
+      maxfuncstr = "(1/" + lambda + ")*log(exp(" + lambda + "*v1)";
       envargstr = getShortcutLabel() + "_env" + jnum;
     } else {
-      varstr += ",v" + jnum; maxfuncstr += "+exp(" + lambda + "*v" + jnum + ")";
+      varstr += ",v" + jnum;
+      maxfuncstr += "+exp(" + lambda + "*v" + jnum + ")";
       envargstr += "," + getShortcutLabel() + "_env" + jnum;
     }
     // And coordination numbers
@@ -412,33 +498,52 @@ EnvironmentSimilarity::EnvironmentSimilarity(const ActionOptions&ao):
       for(unsigned i=0; i<allspec.size(); ++i) {
         readInputLine( getShortcutLabel() + "_" + allspec[i] + "_matenv" + jnum + ": CUSTOM ARG=" + matlab + ".x," + matlab + ".y," + matlab + ".z," + matlab + ".w VAR=x,y,z,w PERIODIC=NO " + funcstr[j][i] );
         readInputLine( getShortcutLabel() + "_" + allspec[i] + "_env" + jnum + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_" + allspec[i] + "_matenv" + jnum + "," + getShortcutLabel() + "_ones_" + allspec[i] );
-        if( i==0 ) argnames = getShortcutLabel() + "_" + allspec[i] + "_env" + jnum; else argnames += "," + getShortcutLabel() + "_" + allspec[i] + "_env" + jnum;
+        if( i==0 ) {
+          argnames = getShortcutLabel() + "_" + allspec[i] + "_env" + jnum;
+        } else {
+          argnames += "," + getShortcutLabel() + "_" + allspec[i] + "_env" + jnum;
+        }
+      }
+      if( funcstr.size()==1) {
+        readInputLine( getShortcutLabel() + ": COMBINE PERIODIC=NO ARG=" + argnames );
+      } else {
+        readInputLine( getShortcutLabel() + "_env" + jnum + ": COMBINE PERIODIC=NO ARG=" + argnames );
       }
-      if( funcstr.size()==1) readInputLine( getShortcutLabel() + ": COMBINE PERIODIC=NO ARG=" + argnames );
-      else readInputLine( getShortcutLabel() + "_env" + jnum + ": COMBINE PERIODIC=NO ARG=" + argnames );
     } else {
       readInputLine( getShortcutLabel() + "_matenv" + jnum + ": CUSTOM ARG=" + matlab + ".x," + matlab + ".y," + matlab + ".z," + matlab + ".w VAR=x,y,z,w PERIODIC=NO " + funcstr[j][0] );
-      if( funcstr.size()==1) readInputLine( getShortcutLabel() + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_matenv" + jnum + "," + getShortcutLabel() + "_ones");
-      else readInputLine( getShortcutLabel() + "_env" + jnum + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_matenv" + jnum + "," + getShortcutLabel() + "_ones");
+      if( funcstr.size()==1) {
+        readInputLine( getShortcutLabel() + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_matenv" + jnum + "," + getShortcutLabel() + "_ones");
+      } else {
+        readInputLine( getShortcutLabel() + "_env" + jnum + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_matenv" + jnum + "," + getShortcutLabel() + "_ones");
+      }
     }
   }
   // And get the maximum
-  if( funcstr.size()>1 ) readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + envargstr + " PERIODIC=NO VAR=" + varstr + " FUNC=" + maxfuncstr + ")" );
+  if( funcstr.size()>1 ) {
+    readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + envargstr + " PERIODIC=NO VAR=" + varstr + " FUNC=" + maxfuncstr + ")" );
+  }
   // Read in all the shortcut stuff
-  std::map<std::string,std::string> keymap; multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
+  std::map<std::string,std::string> keymap;
+  multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
   multicolvar::MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel(), "", keymap, this );
 }
 
 std::vector<std::pair<unsigned,Vector> > EnvironmentSimilarity::getReferenceEnvironment( const PDB& pdb, const std::vector<std::string>& anames,  double& maxdist ) {
-  unsigned natoms = pdb.getPositions().size(); std::vector<std::pair<unsigned,Vector> > env( natoms );
+  unsigned natoms = pdb.getPositions().size();
+  std::vector<std::pair<unsigned,Vector> > env( natoms );
   for(unsigned i=0; i<natoms; ++i) {
     unsigned identity=0;
     for(unsigned j=1; j<anames.size(); ++j) {
-      if( pdb.getAtomName(pdb.getAtomNumbers()[i])==anames[j] ) { identity=j; break; }
+      if( pdb.getAtomName(pdb.getAtomNumbers()[i])==anames[j] ) {
+        identity=j;
+        break;
+      }
     }
     env[i] = std::pair<unsigned,Vector>( identity, pdb.getPositions()[i] );
     double dist = env[i].second.modulo();
-    if( dist>maxdist ) maxdist = dist;
+    if( dist>maxdist ) {
+      maxdist = dist;
+    }
   }
   return env;
 }
diff --git a/src/fisst/FISST.cpp b/src/fisst/FISST.cpp
index 9d1f6038e2..c136226a86 100644
--- a/src/fisst/FISST.cpp
+++ b/src/fisst/FISST.cpp
@@ -220,14 +220,15 @@ FISST::FISST(const ActionOptions&ao):
   reset_period_(0),
   observable_freq_(0),
   kbt_(0.0),
-  value_force2_(NULL)
-{
-  if(ncvs_==0)
+  value_force2_(NULL) {
+  if(ncvs_==0) {
     error("Must specify at least one CV with ARG");
+  }
 
   //temporary
-  if(ncvs_>1)
+  if(ncvs_>1) {
     error("FISST only supports using one CV right now");
+  }
 
   addComponent("force2");
   componentIsNotPeriodic("force2");
@@ -258,8 +259,9 @@ FISST::FISST(const ActionOptions&ao):
   parse("IN_RESTART",in_restart_name_);
   checkRead();
 
-  if(center_.size() != ncvs_)
+  if(center_.size() != ncvs_) {
     error("Must have same number of CENTER arguments as ARG arguments");
+  }
 
   if(in_restart_name_ != "") {
     b_restart_ = true;
@@ -267,7 +269,9 @@ FISST::FISST(const ActionOptions&ao):
     readInRestart();
   } else {
 
-    if(! kbt_ > 0.0) kbt_=getkBT();
+    if(! kbt_ > 0.0) {
+      kbt_=getkBT();
+    }
 
     //in driver, this results in kbt of 0
     if(kbt_ == 0) {
@@ -285,7 +289,9 @@ FISST::FISST(const ActionOptions&ao):
     }
     log.printf("\n");
     observable_weight_.resize(n_interpolation_);
-    for(unsigned int i = 0; i<n_interpolation_; i++) observable_weight_[i] = 1.0;
+    for(unsigned int i = 0; i<n_interpolation_; i++) {
+      observable_weight_[i] = 1.0;
+    }
 
     forces_.resize(n_interpolation_);
     force_weight_.resize(n_interpolation_);
@@ -296,15 +302,18 @@ FISST::FISST(const ActionOptions&ao):
 
     log.printf("Using weight distribution %s with rate %f\n",initial_weight_dist_.c_str(),initial_weight_rate_);
     if(initial_weight_dist_ == "UNIFORM" ) {
-      for(unsigned int i = 0; i<n_interpolation_; i++) force_weight_[i] = 1.0;
-    }
-    else if (initial_weight_dist_ == "EXP" ) {
-      for(unsigned int i = 0; i<n_interpolation_; i++) force_weight_[i] = exp(-fabs(forces_[i])*initial_weight_rate_);
-    }
-    else if (initial_weight_dist_ == "GAUSS" ) {
-      for(unsigned int i = 0; i<n_interpolation_; i++) force_weight_[i] = exp(-pow(forces_[i],2)*initial_weight_rate_);
-    }
-    else {
+      for(unsigned int i = 0; i<n_interpolation_; i++) {
+        force_weight_[i] = 1.0;
+      }
+    } else if (initial_weight_dist_ == "EXP" ) {
+      for(unsigned int i = 0; i<n_interpolation_; i++) {
+        force_weight_[i] = exp(-fabs(forces_[i])*initial_weight_rate_);
+      }
+    } else if (initial_weight_dist_ == "GAUSS" ) {
+      for(unsigned int i = 0; i<n_interpolation_; i++) {
+        force_weight_[i] = exp(-pow(forces_[i],2)*initial_weight_rate_);
+      }
+    } else {
       error("  Specified weight distribution is not from the allowed list.");
 
     }
@@ -335,7 +344,9 @@ FISST::FISST(const ActionOptions&ao):
     setupOutRestart();
   }
   if(out_observable_name_.length()>0) {
-    if(observable_freq_==0) observable_freq_ = period_;
+    if(observable_freq_==0) {
+      observable_freq_ = period_;
+    }
     log.printf("  writing observable information every %i steps to file %s with format %s\n",observable_freq_,out_observable_name_.c_str(), fmt_.c_str());
     b_write_observable_ = true;
     setupOutObservable();
@@ -348,11 +359,13 @@ FISST::FISST(const ActionOptions&ao):
 void FISST::NormalizeForceWeights() {
   double denom = 0.0;
 
-  for(unsigned i=0; i<n_interpolation_; i++)
+  for(unsigned i=0; i<n_interpolation_; i++) {
     denom += gauss_weight_[i] * force_weight_[i];
+  }
 
-  for(unsigned i=0; i<n_interpolation_; i++)
+  for(unsigned i=0; i<n_interpolation_; i++) {
     force_weight_[i] /= denom;
+  }
 }
 
 void FISST::readInRestart() {
@@ -360,12 +373,16 @@ void FISST::readInRestart() {
 
   if(in_restart_.FieldExist("kbt")) {
     in_restart_.scanField("kbt",kbt_);
-  } else { error("No field 'kbt' in restart file"); }
+  } else {
+    error("No field 'kbt' in restart file");
+  }
   log.printf("  with kBT = %f\n",kbt_);
 
   if(in_restart_.FieldExist("period")) {
     in_restart_.scanField("period",period_);
-  } else { error("No field 'period' in restart file"); }
+  } else {
+    error("No field 'period' in restart file");
+  }
   log.printf("  Updating every %i steps\n",period_);
 
 //this one can be optional
@@ -376,14 +393,20 @@ void FISST::readInRestart() {
 
   if(in_restart_.FieldExist("n_interpolation")) {
     in_restart_.scanField("n_interpolation",n_interpolation_);
-  } else { error("No field 'n_interpolation' in restart file"); }
+  } else {
+    error("No field 'n_interpolation' in restart file");
+  }
 
   if(in_restart_.FieldExist("min_force")) {
     in_restart_.scanField("min_force",min_force_);
-  } else { error("No field 'min_force' in restart file"); }
+  } else {
+    error("No field 'min_force' in restart file");
+  }
   if(in_restart_.FieldExist("max_force")) {
     in_restart_.scanField("max_force",max_force_);
-  } else { error("No field 'max_force' in restart file"); }
+  } else {
+    error("No field 'max_force' in restart file");
+  }
   log.printf("  with forces from min_force=%e to max_force=%e over %i bins\n",min_force_,max_force_,n_interpolation_);
 
   unsigned int N = 0;
@@ -450,7 +473,9 @@ void FISST::setupOutRestart() {
   out_restart_.addConstantField("kbt").printField("kbt",kbt_);
   out_restart_.addConstantField("n_interpolation").printField("n_interpolation",n_interpolation_);
   out_restart_.addConstantField("period").printField("period",period_);
-  if(reset_period_>0) out_restart_.addConstantField("reset_period").printField("reset_period",reset_period_);
+  if(reset_period_>0) {
+    out_restart_.addConstantField("reset_period").printField("reset_period",reset_period_);
+  }
   out_restart_.addConstantField("min_force").printField("min_force",min_force_);
   out_restart_.addConstantField("max_force").printField("max_force",max_force_);
 }
@@ -497,16 +522,19 @@ void FISST::writeOutObservable() {
 
 void FISST::calculate() {
   if(getStep() == 0 ) {
-    if(b_write_restart_) writeOutRestart();
-    if(b_write_observable_) writeOutObservable();
+    if(b_write_restart_) {
+      writeOutRestart();
+    }
+    if(b_write_observable_) {
+      writeOutObservable();
+    }
   }
 
   if(! b_freeze_) {
     if(b_restart_ && b_first_restart_sample_) {
       //dont' update statistics if restarting and first sample
       b_first_restart_sample_ = false;
-    }
-    else {
+    } else {
       update_statistics();
     }
   }
@@ -515,7 +543,9 @@ void FISST::calculate() {
 
   //check about writing restart file
   if(getStep()>0 && getStep()%period_==0) {
-    if(b_write_restart_) writeOutRestart();
+    if(b_write_restart_) {
+      writeOutRestart();
+    }
   }
   if(getStep()>0 && getStep()%observable_freq_==0) {
     if(b_write_observable_) {
@@ -556,16 +586,14 @@ void FISST::update_statistics()  {
   int step = getStep();
   if(reset_period_>0 && step>0 && step%reset_period_==0) {
     n_samples_=1;
-  }
-  else {
+  } else {
     n_samples_++;
   }
   double d_n_samples = (double)n_samples_;
 
   for(unsigned int i = 0; i < ncvs_; ++i) {
     double Q_i = difference(i, center_[i], getArgument(i));
-    for(unsigned int j=0; j<n_interpolation_; j++)
-    {
+    for(unsigned int j=0; j<n_interpolation_; j++) {
       //if multiple cvs, these need to be updated to have 2 columns
       double f_j = forces_[j];
       double w_j = force_weight_[j];
@@ -574,8 +602,7 @@ void FISST::update_statistics()  {
       fbar_denum_integral += g_j * w_j * exp(beta_*f_j * Q_i);
     }
 
-    for(unsigned int j=0; j<n_interpolation_; j++)
-    {
+    for(unsigned int j=0; j<n_interpolation_; j++) {
       double f_j = forces_[j];
       double sample_weight = exp(beta_*f_j * Q_i) / fbar_denum_integral;
 
@@ -594,8 +621,7 @@ void FISST::update_statistics()  {
 }
 
 
-void FISST::update_bias()
-{
+void FISST::update_bias() {
   for(unsigned int i = 0; i < ncvs_; ++i) {
     double Q_i = difference(i, center_[i], getArgument(i));
     double fbar_num_integral = 0.0;
diff --git a/src/fisst/legendre_rule_fast.cpp b/src/fisst/legendre_rule_fast.cpp
index 8f518d08fb..0d2f758fda 100644
--- a/src/fisst/legendre_rule_fast.cpp
+++ b/src/fisst/legendre_rule_fast.cpp
@@ -73,16 +73,14 @@ void legendre_compute_glr ( int n, double x[], double w[] )
 //
 //  If N is odd, then zero is a root.
 //
-  if ( n % 2 == 1 )
-  {
+  if ( n % 2 == 1 ) {
     x[(n-1)/2] = p;
     w[(n-1)/2] = pp;
   }
 //
 //  If N is even, we have to call a function to find the first root.
 //
-  else
-  {
+  else {
     legendre_compute_glr2 ( p, n, &x[n/2], &w[n/2] );
   }
 //
@@ -92,17 +90,14 @@ void legendre_compute_glr ( int n, double x[], double w[] )
 //
 //  Compute the W.
 //
-  for ( i = 0; i < n; i++ )
-  {
+  for ( i = 0; i < n; i++ ) {
     w[i] = 2.0 / ( 1.0 - x[i] ) / ( 1.0 + x[i] ) / w[i] / w[i];
   }
   w_sum = 0.0;
-  for ( i = 0; i < n; i++ )
-  {
+  for ( i = 0; i < n; i++ ) {
     w_sum = w_sum + w[i];
   }
-  for ( i = 0; i < n; i++ )
-  {
+  for ( i = 0; i < n; i++ ) {
     w[i] = 2.0 * w[i] / w_sum;
   }
   return;
@@ -157,8 +152,7 @@ void legendre_compute_glr0 ( int n, double *p, double *pp )
   ppm2 = 0.0;
   ppm1 = 0.0;
 
-  for ( k = 0; k < n; k++)
-  {
+  for ( k = 0; k < n; k++) {
     dk = ( double ) k;
     *p = - dk * pm2 / ( dk + 1.0 );
     *pp = ( ( 2.0 * dk + 1.0 ) * pm1 - dk * ppm2 ) / ( dk + 1.0 );
@@ -236,13 +230,10 @@ void legendre_compute_glr1 ( int n, double *x, double *w )
   double *up;
   double xp;
 
-  if ( n % 2 == 1 )
-  {
+  if ( n % 2 == 1 ) {
     n2 = ( n - 1 ) / 2 - 1;
     s = 1;
-  }
-  else
-  {
+  } else {
     n2 = n / 2 - 1;
     s = 0;
   }
@@ -252,8 +243,7 @@ void legendre_compute_glr1 ( int n, double *x, double *w )
 
   dn = ( double ) n;
 
-  for ( j = n2 + 1; j < n - 1; j++ )
-  {
+  for ( j = n2 + 1; j < n - 1; j++ ) {
     xp = x[j];
 
     h = rk2_leg ( pi/2.0, -pi/2.0, xp, n ) - xp;
@@ -265,8 +255,7 @@ void legendre_compute_glr1 ( int n, double *x, double *w )
     up[0] = 0.0;
     up[1] = u[2];
 
-    for ( k = 0; k <= m - 2; k++ )
-    {
+    for ( k = 0; k <= m - 2; k++ ) {
       dk = ( double ) k;
 
       u[k+3] =
@@ -278,8 +267,7 @@ void legendre_compute_glr1 ( int n, double *x, double *w )
       up[k+2] = ( dk + 2.0 ) * u[k+3];
     }
 
-    for ( l = 0; l < 5; l++ )
-    {
+    for ( l = 0; l < 5; l++ ) {
       h = h - ts_mult ( u, h, m ) / ts_mult ( up, h, m-1 );
     }
 
@@ -287,8 +275,7 @@ void legendre_compute_glr1 ( int n, double *x, double *w )
     w[j+1] = ts_mult ( up, h, m - 1 );
   }
 
-  for ( k = 0; k <= n2 + s; k++ )
-  {
+  for ( k = 0; k <= n2 + s; k++ ) {
     x[k] = - x[n-1-k];
     w[k] = w[n-1-k];
   }
@@ -371,8 +358,7 @@ void legendre_compute_glr2 ( double pn0, int n, double *x1, double *d1 )
 
   up[0] = 0.0;
 
-  for ( k = 0; k <= m - 2; k = k + 2 )
-  {
+  for ( k = 0; k <= m - 2; k = k + 2 ) {
     dk = ( double ) k;
 
     u[k+2] = 0.0;
@@ -383,8 +369,7 @@ void legendre_compute_glr2 ( double pn0, int n, double *x1, double *d1 )
     up[k+2] = ( dk + 2.0 ) * u[k+3];
   }
 
-  for ( l = 0; l < 5; l++ )
-  {
+  for ( l = 0; l < 5; l++ ) {
     *x1 = *x1 - ts_mult ( u, *x1, m ) / ts_mult ( up, *x1, m-1 );
   }
   *d1 = ts_mult ( up, *x1, m-1 );
@@ -437,12 +422,10 @@ void rescale ( double a, double b, int n, double x[], double w[] )
 {
   int i;
 
-  for ( i = 0; i < n; i++ )
-  {
+  for ( i = 0; i < n; i++ ) {
     x[i] = ( ( a + b ) + ( b - a ) * x[i] ) / 2.0;
   }
-  for ( i = 0; i < n; i++ )
-  {
+  for ( i = 0; i < n; i++ ) {
     w[i] = ( b - a ) * w[i] / 2.0;
   }
   return;
@@ -494,8 +477,7 @@ double rk2_leg ( double t1, double t2, double x, int n )
   snn1 = sqrt ( ( double ) ( n * ( n + 1 ) ) );
   t = t1;
 
-  for ( j = 0; j < m; j++ )
-  {
+  for ( j = 0; j < m; j++ ) {
     f = ( 1.0 - x ) * ( 1.0 + x );
     k1 = - h * f / ( snn1 * sqrt ( f ) - 0.5 * x * sin ( 2.0 * t ) );
     x = x + k1;
@@ -549,8 +531,7 @@ double ts_mult ( double *u, double h, int n )
 
   ts = 0.0;
   hk = 1.0;
-  for ( k = 1; k<= n; k++ )
-  {
+  for ( k = 1; k<= n; k++ ) {
     ts = ts + u[k] * hk;
     hk = hk * h;
   }
diff --git a/src/fourier/FourierTransform.cpp b/src/fourier/FourierTransform.cpp
index 0734325b91..da521ef299 100644
--- a/src/fourier/FourierTransform.cpp
+++ b/src/fourier/FourierTransform.cpp
@@ -76,18 +76,23 @@ class FourierTransform : public gridtools::ActionWithGrid {
 public:
   static void registerKeywords( Keywords& keys );
   explicit FourierTransform(const ActionOptions&ao);
-  void setupOnFirstStep( const bool incalc ) override { plumed_error(); }
+  void setupOnFirstStep( const bool incalc ) override {
+    plumed_error();
+  }
   unsigned getNumberOfDerivatives() override ;
   const gridtools::GridCoordinatesObject& getGridCoordinatesObject() const override ;
   std::vector<std::string> getGridCoordinateNames() const override ;
-  void performTask( const unsigned& current, MultiValue& myvals ) const override { plumed_error(); }
+  void performTask( const unsigned& current, MultiValue& myvals ) const override {
+    plumed_error();
+  }
   void calculate() override ;
 };
 
 PLUMED_REGISTER_ACTION(FourierTransform,"FOURIER_TRANSFORM")
 
 void FourierTransform::registerKeywords( Keywords& keys ) {
-  ActionWithGrid::registerKeywords( keys ); keys.use("ARG");
+  ActionWithGrid::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("optional","FT_TYPE","choose what kind of data you want as output on the grid. Possible values are: ABS = compute the complex modulus of Fourier coefficients (DEFAULT); NORM = compute the norm (i.e. ABS^2) of Fourier coefficients; COMPLEX = store the FFTW complex output on the grid (as a vector).");
   keys.add("compulsory","FOURIER_PARAMETERS","default","what kind of normalization is applied to the output and if the Fourier transform in FORWARD or BACKWARD. This keyword takes the form FOURIER_PARAMETERS=A,B, where A and B can be 0, 1 or -1. The default values are A=1 (no normalization at all) and B=1 (forward FFT). Other possible choices for A are: "
            "A=-1: normalize by the number of data, "
@@ -103,9 +108,10 @@ FourierTransform::FourierTransform(const ActionOptions&ao):
   firsttime(true),
   real_output(true),
   store_norm(false),
-  fourier_params(2)
-{
-  if( getPntrToArgument(0)->getRank()!=2 ) error("fourier transform currently only works with two dimensional grids");
+  fourier_params(2) {
+  if( getPntrToArgument(0)->getRank()!=2 ) {
+    error("fourier transform currently only works with two dimensional grids");
+  }
 
   // Get the type of FT
   parse("FT_TYPE",output_type);
@@ -119,19 +125,26 @@ FourierTransform::FourierTransform(const ActionOptions&ao):
   } else if ( output_type=="COMPLEX" || output_type=="complex" ) {
     log<<"  keyword FT_TYPE is '"<< output_type <<"' : output grid will contain the COMPLEX Fourier coefficients\n";
     real_output=false;
-  } else error("keyword FT_TYPE unrecognized!");
+  } else {
+    error("keyword FT_TYPE unrecognized!");
+  }
 
   // Normalize output?
-  std::string params_str; parse("FOURIER_PARAMETERS",params_str);
+  std::string params_str;
+  parse("FOURIER_PARAMETERS",params_str);
   if (params_str=="default") {
     fourier_params.assign( fourier_params.size(), 1 );
     log.printf("  default values of Fourier parameters A=%i, B=%i : the output will NOT be normalized and BACKWARD Fourier transform is computed \n", fourier_params[0],fourier_params[1]);
   } else {
     std::vector<std::string> fourier_str = Tools::getWords(params_str, "\t\n ,");
-    if (fourier_str.size()>2) error("FOURIER_PARAMETERS can take just two values");
+    if (fourier_str.size()>2) {
+      error("FOURIER_PARAMETERS can take just two values");
+    }
     for (unsigned i=0; i<fourier_str.size(); ++i) {
       Tools::convert(fourier_str[i],fourier_params[i]);
-      if (fourier_params[i]>1 || fourier_params[i]<-1) error("values accepted for FOURIER_PARAMETERS are only -1, 1 or 0");
+      if (fourier_params[i]>1 || fourier_params[i]<-1) {
+        error("values accepted for FOURIER_PARAMETERS are only -1, 1 or 0");
+      }
     }
     log.printf("  Fourier parameters are A=%i, B=%i \n", fourier_params[0],fourier_params[1]);
   }
@@ -146,11 +159,19 @@ FourierTransform::FourierTransform(const ActionOptions&ao):
 
   unsigned dimension = getPntrToArgument(0)->getRank();
   gridtools::ActionWithGrid* ag=dynamic_cast<gridtools::ActionWithGrid*>( getPntrToArgument(0)->getPntrToAction() );
-  if( !ag ) error("input action should be a grid");
+  if( !ag ) {
+    error("input action should be a grid");
+  }
   const gridtools::GridCoordinatesObject & gcoords( ag->getGridCoordinatesObject() );
-  if( gcoords.getGridType()=="fibonacci" ) error("cannot fourier transform fibonacci grids");
-  std::vector<bool> ipbc( dimension ); for(unsigned i=0; i<dimension; ++i) ipbc[i] = gcoords.isPeriodic(i);
-  gridcoords.setup( "flat", ipbc, 0, 0.0 ); checkRead();
+  if( gcoords.getGridType()=="fibonacci" ) {
+    error("cannot fourier transform fibonacci grids");
+  }
+  std::vector<bool> ipbc( dimension );
+  for(unsigned i=0; i<dimension; ++i) {
+    ipbc[i] = gcoords.isPeriodic(i);
+  }
+  gridcoords.setup( "flat", ipbc, 0, 0.0 );
+  checkRead();
 #ifndef __PLUMED_HAS_FFTW
   error("this feature is only available if you compile PLUMED with FFTW");
 #endif
@@ -173,18 +194,27 @@ void FourierTransform::calculate() {
   if( firsttime ) {
     gridtools::ActionWithGrid* ag=dynamic_cast<gridtools::ActionWithGrid*>( getPntrToArgument(0)->getPntrToAction() );
     const gridtools::GridCoordinatesObject & gcoords( ag->getGridCoordinatesObject() );
-    std::vector<double> fspacing; std::vector<unsigned> snbins( getGridCoordinatesObject().getDimension() );
+    std::vector<double> fspacing;
+    std::vector<unsigned> snbins( getGridCoordinatesObject().getDimension() );
     std::vector<std::string> smin( gcoords.getDimension() ), smax( gcoords.getDimension() );
     for(unsigned i=0; i<getGridCoordinatesObject().getDimension(); ++i) {
-      smin[i]=gcoords.getMin()[i]; smax[i]=gcoords.getMax()[i];
+      smin[i]=gcoords.getMin()[i];
+      smax[i]=gcoords.getMax()[i];
       // Compute k-grid extents
-      double dmin, dmax; snbins[i]=gcoords.getNbin(false)[i];
-      Tools::convert(smin[i],dmin); Tools::convert(smax[i],dmax);
-      dmax=2.0*pi*snbins[i]/( dmax - dmin ); dmin=0.0;
-      Tools::convert(dmin,smin[i]); Tools::convert(dmax,smax[i]);
+      double dmin, dmax;
+      snbins[i]=gcoords.getNbin(false)[i];
+      Tools::convert(smin[i],dmin);
+      Tools::convert(smax[i],dmax);
+      dmax=2.0*pi*snbins[i]/( dmax - dmin );
+      dmin=0.0;
+      Tools::convert(dmin,smin[i]);
+      Tools::convert(dmax,smax[i]);
+    }
+    gridcoords.setBounds( smin, smax, snbins, fspacing );
+    firsttime=false;
+    for(unsigned i=0; i<getNumberOfComponents(); ++i) {
+      getPntrToComponent(i)->setShape( gcoords.getNbin(true) );
     }
-    gridcoords.setBounds( smin, smax, snbins, fspacing ); firsttime=false;
-    for(unsigned i=0; i<getNumberOfComponents(); ++i) getPntrToComponent(i)->setShape( gcoords.getNbin(true) );
   }
 
 #ifdef __PLUMED_HAS_FFTW
@@ -198,7 +228,10 @@ void FourierTransform::calculate() {
 
   // Get the size of the input data arrays (to allocate FFT data)
   std::vector<unsigned> N_input_data( gridcoords.getNbin(true) );
-  size_t fft_dimension=1; for(unsigned i=0; i<N_input_data.size(); ++i) fft_dimension*=static_cast<size_t>( N_input_data[i] );
+  size_t fft_dimension=1;
+  for(unsigned i=0; i<N_input_data.size(); ++i) {
+    fft_dimension*=static_cast<size_t>( N_input_data[i] );
+  }
   // FFT arrays
   std::vector<std::complex<double> > input_data(fft_dimension), fft_data(fft_dimension);
 
@@ -234,8 +267,11 @@ void FourierTransform::calculate() {
     if (real_output) {
       double ft_value;
       // Compute abs/norm and fix normalization
-      if (!store_norm) ft_value=std::abs( fft_data[out_ind[0]*N_out_data[0]+out_ind[1]] / norm );
-      else ft_value=std::norm( fft_data[out_ind[0]*N_out_data[0]+out_ind[1]] / norm );
+      if (!store_norm) {
+        ft_value=std::abs( fft_data[out_ind[0]*N_out_data[0]+out_ind[1]] / norm );
+      } else {
+        ft_value=std::norm( fft_data[out_ind[0]*N_out_data[0]+out_ind[1]] / norm );
+      }
       // Set the value
       getPntrToComponent(0)->set( i, ft_value);
     } else {
diff --git a/src/function/Bessel.cpp b/src/function/Bessel.cpp
index d853e209b0..afd8e24b8c 100644
--- a/src/function/Bessel.cpp
+++ b/src/function/Bessel.cpp
@@ -69,7 +69,9 @@ class Bessel : public FunctionTemplateBase {
   double chbevl(double x,std::vector<double>& array) const; // sub copied from scipy in C
   void fill_coefficients();
 public:
-  bool derivativesImplemented() override { return false; }
+  bool derivativesImplemented() override {
+    return false;
+  }
   void registerKeywords( Keywords& keys ) override;
   void read( ActionWithArguments* action ) override;
   void calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const override;
@@ -88,10 +90,17 @@ void Bessel::registerKeywords(Keywords& keys) {
 }
 
 void Bessel::read( ActionWithArguments* action ) {
-  if( action->getNumberOfArguments()!=1 ) action->error("should only be one argument to bessel actions");
-  if( action->getPntrToArgument(0)->isPeriodic() ) action->error("cannot use this function on periodic functions");
-  action->parse("ORDER",order); action->log.printf("  computing %dth order bessel function \n", order );
-  if( order!=0 ) action->error("only zero order bessel function is implemented");
+  if( action->getNumberOfArguments()!=1 ) {
+    action->error("should only be one argument to bessel actions");
+  }
+  if( action->getPntrToArgument(0)->isPeriodic() ) {
+    action->error("cannot use this function on periodic functions");
+  }
+  action->parse("ORDER",order);
+  action->log.printf("  computing %dth order bessel function \n", order );
+  if( order!=0 ) {
+    action->error("only zero order bessel function is implemented");
+  }
   fill_coefficients();
 }
 
@@ -122,7 +131,9 @@ void Bessel::calc( const ActionWithArguments* action, const std::vector<double>&
       return;
     }
     vals[0] = chbevl(32.0 / x - 2.0, B) / sqrt(x) ;
-  } else plumed_error();
+  } else {
+    plumed_error();
+  }
 }
 
 std::vector<double> Bessel::A;
diff --git a/src/function/Between.cpp b/src/function/Between.cpp
index 15667e9460..b902244e9a 100644
--- a/src/function/Between.cpp
+++ b/src/function/Between.cpp
@@ -75,32 +75,46 @@ void Between::registerKeywords(Keywords& keys) {
 }
 
 void Between::read( ActionWithArguments* action ) {
-  if( action->getNumberOfArguments()!=1 ) action->error("should only be one argument to between actions");
+  if( action->getNumberOfArguments()!=1 ) {
+    action->error("should only be one argument to between actions");
+  }
 
   std::string str_min, str_max, tstr_min, tstr_max;
   bool isPeriodic = action->getPntrToArgument(0)->isPeriodic();
-  if( isPeriodic ) action->getPntrToArgument(0)->getDomain( str_min, str_max );
+  if( isPeriodic ) {
+    action->getPntrToArgument(0)->getDomain( str_min, str_max );
+  }
 
-  std::string hinput; action->parse("SWITCH",hinput);
+  std::string hinput;
+  action->parse("SWITCH",hinput);
   if(hinput.length()==0) {
     std::string low, up, sme;
-    action->parse("LOWER",low); action->parse("UPPER",up); action->parse("SMEAR",sme);
+    action->parse("LOWER",low);
+    action->parse("UPPER",up);
+    action->parse("SMEAR",sme);
     hinput = "GAUSSIAN LOWER=" + low + " UPPER=" + up + " SMEAR=" + sme;
   }
-  std::string errors; hist.set( hinput, errors );
-  if( errors.size()!=0 ) action->error( errors );
+  std::string errors;
+  hist.set( hinput, errors );
+  if( errors.size()!=0 ) {
+    action->error( errors );
+  }
   action->log.printf("  %s \n", hist.description().c_str() );
 
-  if( !isPeriodic ) hist.isNotPeriodic();
-  else {
-    double min; Tools::convert( str_min, min );
-    double max; Tools::convert( str_max, max );
+  if( !isPeriodic ) {
+    hist.isNotPeriodic();
+  } else {
+    double min;
+    Tools::convert( str_min, min );
+    double max;
+    Tools::convert( str_max, max );
     hist.isPeriodic( min, max );
   }
 }
 
 void Between::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
-  plumed_dbg_assert( args.size()==1 ); vals[0] = hist.calculate( args[0], derivatives(0,0) );
+  plumed_dbg_assert( args.size()==1 );
+  vals[0] = hist.calculate( args[0], derivatives(0,0) );
 }
 
 }
diff --git a/src/function/Between.h b/src/function/Between.h
index 4375398751..7e95496e9f 100644
--- a/src/function/Between.h
+++ b/src/function/Between.h
@@ -33,7 +33,9 @@ class Between : public FunctionTemplateBase {
 public:
   void registerKeywords( Keywords& keys ) override;
   void read( ActionWithArguments* action ) override;
-  bool getDerivativeZeroIfValueIsZero() const override { return true; }
+  bool getDerivativeZeroIfValueIsZero() const override {
+    return true;
+  }
   void calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const override;
 };
 
diff --git a/src/function/Combine.cpp b/src/function/Combine.cpp
index 72f9a3961f..3e59f2b198 100644
--- a/src/function/Combine.cpp
+++ b/src/function/Combine.cpp
@@ -123,26 +123,45 @@ void Combine::registerKeywords(Keywords& keys) {
 }
 
 void Combine::read( ActionWithArguments* action ) {
-  coefficients.resize( action->getNumberOfArguments() ); parameters.resize( action->getNumberOfArguments() ); powers.resize( action->getNumberOfArguments() );
+  coefficients.resize( action->getNumberOfArguments() );
+  parameters.resize( action->getNumberOfArguments() );
+  powers.resize( action->getNumberOfArguments() );
   parseVector(action,"COEFFICIENTS",coefficients);
-  if(coefficients.size()!=static_cast<unsigned>(action->getNumberOfArguments())) action->error("Size of COEFFICIENTS array should be the same as number for arguments");
+  if(coefficients.size()!=static_cast<unsigned>(action->getNumberOfArguments())) {
+    action->error("Size of COEFFICIENTS array should be the same as number for arguments");
+  }
   parseVector(action,"PARAMETERS",parameters);
-  if(parameters.size()!=static_cast<unsigned>(action->getNumberOfArguments())) action->error("Size of PARAMETERS array should be the same as number for arguments");
-  parseVector(action,"POWERS",powers); if(powers.size()!=static_cast<unsigned>(action->getNumberOfArguments())) action->error("Size of POWERS array should be the same as number for arguments");
+  if(parameters.size()!=static_cast<unsigned>(action->getNumberOfArguments())) {
+    action->error("Size of PARAMETERS array should be the same as number for arguments");
+  }
+  parseVector(action,"POWERS",powers);
+  if(powers.size()!=static_cast<unsigned>(action->getNumberOfArguments())) {
+    action->error("Size of POWERS array should be the same as number for arguments");
+  }
 
   parseFlag(action,"NORMALIZE",normalize);
   if(normalize) {
     double n=0.0;
-    for(unsigned i=0; i<coefficients.size(); i++) n+=coefficients[i];
-    for(unsigned i=0; i<coefficients.size(); i++) coefficients[i]*=(1.0/n);
+    for(unsigned i=0; i<coefficients.size(); i++) {
+      n+=coefficients[i];
+    }
+    for(unsigned i=0; i<coefficients.size(); i++) {
+      coefficients[i]*=(1.0/n);
+    }
   }
 
   action->log.printf("  with coefficients:");
-  for(unsigned i=0; i<coefficients.size(); i++) action->log.printf(" %f",coefficients[i]);
+  for(unsigned i=0; i<coefficients.size(); i++) {
+    action->log.printf(" %f",coefficients[i]);
+  }
   action->log.printf("\n  with parameters:");
-  for(unsigned i=0; i<parameters.size(); i++) action->log.printf(" %f",parameters[i]);
+  for(unsigned i=0; i<parameters.size(); i++) {
+    action->log.printf(" %f",parameters[i]);
+  }
   action->log.printf("\n  and powers:");
-  for(unsigned i=0; i<powers.size(); i++) action->log.printf(" %f",powers[i]);
+  for(unsigned i=0; i<powers.size(); i++) {
+    action->log.printf(" %f",powers[i]);
+  }
   action->log.printf("\n");
 }
 
diff --git a/src/function/Combine.h b/src/function/Combine.h
index e93f384abb..35ce2a5407 100644
--- a/src/function/Combine.h
+++ b/src/function/Combine.h
@@ -27,8 +27,7 @@
 namespace PLMD {
 namespace function {
 
-class Combine : public FunctionTemplateBase
-{
+class Combine : public FunctionTemplateBase {
   bool normalize;
   std::vector<double> coefficients;
   std::vector<double> parameters;
diff --git a/src/function/Custom.cpp b/src/function/Custom.cpp
index 85e20a3579..cd15d9676c 100644
--- a/src/function/Custom.cpp
+++ b/src/function/Custom.cpp
@@ -273,43 +273,73 @@ void Custom::registerKeywords(Keywords& keys) {
 
 void Custom::read( ActionWithArguments* action ) {
   // Read in the variables
-  std::vector<std::string> var; parseVector(action,"VAR",var); parse(action,"FUNC",func);
+  std::vector<std::string> var;
+  parseVector(action,"VAR",var);
+  parse(action,"FUNC",func);
   if(var.size()==0) {
     var.resize(action->getNumberOfArguments());
-    if(var.size()>3) action->error("Using more than 3 arguments you should explicitly write their names with VAR");
-    if(var.size()>0) var[0]="x";
-    if(var.size()>1) var[1]="y";
-    if(var.size()>2) var[2]="z";
+    if(var.size()>3) {
+      action->error("Using more than 3 arguments you should explicitly write their names with VAR");
+    }
+    if(var.size()>0) {
+      var[0]="x";
+    }
+    if(var.size()>1) {
+      var[1]="y";
+    }
+    if(var.size()>2) {
+      var[2]="z";
+    }
+  }
+  if(var.size()!=action->getNumberOfArguments()) {
+    action->error("Size of VAR array should be the same as number of arguments");
   }
-  if(var.size()!=action->getNumberOfArguments()) action->error("Size of VAR array should be the same as number of arguments");
   // Check for operations that are not multiplication (this can probably be done much more cleverly)
   bool onlymultiplication = func.find("*")!=std::string::npos;
   // Find first bracket in expression
   if( func.find("(")!=std::string::npos ) {
-    std::size_t br = func.find_first_of("("); std::string subexpr=func.substr(0,br); onlymultiplication = func.find("*")!=std::string::npos;
-    if( subexpr.find("/")!=std::string::npos ) { std::size_t sl = func.find_first_of("/"); std::string aa = subexpr.substr(0,sl); subexpr=aa; }
-    if( subexpr.find("+")!=std::string::npos || subexpr.find("-")!=std::string::npos ) onlymultiplication=false;
+    std::size_t br = func.find_first_of("(");
+    std::string subexpr=func.substr(0,br);
+    onlymultiplication = func.find("*")!=std::string::npos;
+    if( subexpr.find("/")!=std::string::npos ) {
+      std::size_t sl = func.find_first_of("/");
+      std::string aa = subexpr.substr(0,sl);
+      subexpr=aa;
+    }
+    if( subexpr.find("+")!=std::string::npos || subexpr.find("-")!=std::string::npos ) {
+      onlymultiplication=false;
+    }
     // Now work out which vars are in multiplication
     if( onlymultiplication ) {
       for(unsigned i=0; i<var.size(); ++i) {
         if( subexpr.find(var[i])!=std::string::npos &&
-            action->getPntrToArgument(i)->isDerivativeZeroWhenValueIsZero() ) check_multiplication_vars.push_back(i);
+            action->getPntrToArgument(i)->isDerivativeZeroWhenValueIsZero() ) {
+          check_multiplication_vars.push_back(i);
+        }
       }
     }
   } else if( func.find("/")!=std::string::npos ) {
-    onlymultiplication=true; if( func.find("+")!=std::string::npos || func.find("-")!=std::string::npos ) onlymultiplication=false;
+    onlymultiplication=true;
+    if( func.find("+")!=std::string::npos || func.find("-")!=std::string::npos ) {
+      onlymultiplication=false;
+    }
     if( onlymultiplication ) {
-      std::size_t br = func.find_first_of("/"); std::string subexpr=func.substr(0,br);
+      std::size_t br = func.find_first_of("/");
+      std::string subexpr=func.substr(0,br);
       for(unsigned i=0; i<var.size(); ++i) {
         if( subexpr.find(var[i])!=std::string::npos &&
-            action->getPntrToArgument(i)->isDerivativeZeroWhenValueIsZero() ) check_multiplication_vars.push_back(i);
+            action->getPntrToArgument(i)->isDerivativeZeroWhenValueIsZero() ) {
+          check_multiplication_vars.push_back(i);
+        }
       }
     }
   } else if( func.find("+")!=std::string::npos || func.find("-")!=std::string::npos ) {
     onlymultiplication=false;
   } else {
     for(unsigned i=0; i<var.size(); ++i) {
-      if( action->getPntrToArgument(i)->isDerivativeZeroWhenValueIsZero() ) check_multiplication_vars.push_back(i);
+      if( action->getPntrToArgument(i)->isDerivativeZeroWhenValueIsZero() ) {
+        check_multiplication_vars.push_back(i);
+      }
     }
   }
   if( check_multiplication_vars.size()>0 ) {
@@ -318,11 +348,17 @@ void Custom::read( ActionWithArguments* action ) {
 
   action->log.printf("  with function : %s\n",func.c_str());
   action->log.printf("  with variables :");
-  for(unsigned i=0; i<var.size(); i++) action->log.printf(" %s",var[i].c_str());
-  action->log.printf("\n"); function.set( func, var, action );
-  std::vector<double> zeros( action->getNumberOfArguments(), 0 ); double fval = abs(function.evaluate(zeros));
+  for(unsigned i=0; i<var.size(); i++) {
+    action->log.printf(" %s",var[i].c_str());
+  }
+  action->log.printf("\n");
+  function.set( func, var, action );
+  std::vector<double> zeros( action->getNumberOfArguments(), 0 );
+  double fval = abs(function.evaluate(zeros));
   zerowhenallzero=(fval<epsilon );
-  if( zerowhenallzero ) action->log.printf("  not calculating when all arguments are zero \n");
+  if( zerowhenallzero ) {
+    action->log.printf("  not calculating when all arguments are zero \n");
+  }
 }
 
 std::string Custom::getGraphInfo( const std::string& name ) const {
@@ -335,7 +371,9 @@ bool Custom::getDerivativeZeroIfValueIsZero() const {
 
 std::vector<Value*> Custom::getArgumentsToCheck( const std::vector<Value*>& args ) {
   std::vector<Value*> fargs( check_multiplication_vars.size() );
-  for(unsigned i=0; i<check_multiplication_vars.size(); ++i) fargs[i] = args[check_multiplication_vars[i]];
+  for(unsigned i=0; i<check_multiplication_vars.size(); ++i) {
+    fargs[i] = args[check_multiplication_vars[i]];
+  }
   return fargs;
 }
 
@@ -344,22 +382,33 @@ void Custom::calc( const ActionWithArguments* action, const std::vector<double>&
     bool allzero=false;
     if( check_multiplication_vars.size()>0 ) {
       for(unsigned i=0; i<check_multiplication_vars.size(); ++i) {
-        if( fabs(args[check_multiplication_vars[i]])<epsilon ) { allzero=true; break; }
+        if( fabs(args[check_multiplication_vars[i]])<epsilon ) {
+          allzero=true;
+          break;
+        }
       }
     } else if( zerowhenallzero ) {
       allzero=(fabs(args[0])<epsilon);
       for(unsigned i=1; i<args.size(); ++i) {
-        if( fabs(args[i])>epsilon ) { allzero=false; break; }
+        if( fabs(args[i])>epsilon ) {
+          allzero=false;
+          break;
+        }
       }
     }
     if( allzero ) {
-      vals[0]=0; for(unsigned i=0; i<args.size(); i++) derivatives(0,i) = 0.0;
+      vals[0]=0;
+      for(unsigned i=0; i<args.size(); i++) {
+        derivatives(0,i) = 0.0;
+      }
       return;
     }
   }
   vals[0] = function.evaluate( args );
   if( !noderiv ) {
-    for(unsigned i=0; i<args.size(); i++) derivatives(0,i) = function.evaluateDeriv( i, args );
+    for(unsigned i=0; i<args.size(); i++) {
+      derivatives(0,i) = function.evaluateDeriv( i, args );
+    }
   }
 }
 
diff --git a/src/function/Ensemble.cpp b/src/function/Ensemble.cpp
index 137dc77ab8..7d5cbcd8a3 100644
--- a/src/function/Ensemble.cpp
+++ b/src/function/Ensemble.cpp
@@ -48,8 +48,7 @@ PRINT ARG=dist,ens.dist
 
 
 class Ensemble :
-  public Function
-{
+  public Function {
   unsigned ens_dim;
   unsigned my_repl;
   unsigned narg;
@@ -91,23 +90,37 @@ Ensemble::Ensemble(const ActionOptions&ao):
   do_powers(false),
   kbt(-1.0),
   moment(0),
-  power(0)
-{
+  power(0) {
   parseFlag("REWEIGHT", do_reweight);
   if(do_reweight) {
     kbt=getkBT();
-    if(kbt==0.0) error("Unless the MD engine passes the temperature to plumed, with REWEIGHT you must specify TEMP");
-  } else { double temp=0.0; parse("TEMP",temp); }
+    if(kbt==0.0) {
+      error("Unless the MD engine passes the temperature to plumed, with REWEIGHT you must specify TEMP");
+    }
+  } else {
+    double temp=0.0;
+    parse("TEMP",temp);
+  }
 
   parse("MOMENT",moment);
-  if(moment==1) error("MOMENT can be any number but for 0 and 1");
-  if(moment!=0) do_moments=true;
+  if(moment==1) {
+    error("MOMENT can be any number but for 0 and 1");
+  }
+  if(moment!=0) {
+    do_moments=true;
+  }
   parseFlag("CENTRAL", do_central);
-  if(!do_moments&&do_central) error("To calculate a CENTRAL moment you need to define for which MOMENT");
+  if(!do_moments&&do_central) {
+    error("To calculate a CENTRAL moment you need to define for which MOMENT");
+  }
 
   parse("POWER",power);
-  if(power==1) error("POWER can be any number but for 0 and 1");
-  if(power!=0) do_powers=true;
+  if(power==1) {
+    error("POWER can be any number but for 0 and 1");
+  }
+  if(power!=0) {
+    do_powers=true;
+  }
 
   checkRead();
 
@@ -120,11 +133,15 @@ Ensemble::Ensemble(const ActionOptions&ao):
   }
   comm.Bcast(ens_dim,0);
   comm.Bcast(my_repl,0);
-  if(ens_dim<2) log.printf("WARNING: ENSEMBLE with one replica is not doing any averaging!\n");
+  if(ens_dim<2) {
+    log.printf("WARNING: ENSEMBLE with one replica is not doing any averaging!\n");
+  }
 
   // prepare output components, the number depending on reweighing or not
   narg = getNumberOfArguments();
-  if(do_reweight) narg--;
+  if(do_reweight) {
+    narg--;
+  }
 
   // these are the averages
   for(unsigned i=0; i<narg; i++) {
@@ -142,18 +159,31 @@ Ensemble::Ensemble(const ActionOptions&ao):
   }
 
   log.printf("  averaging over %u replicas.\n", ens_dim);
-  if(do_reweight) log.printf("  doing simple REWEIGHT using the latest ARGUMENT as energy.\n");
-  if(do_moments&&!do_central)  log.printf("  calculating also the %lf standard moment\n", moment);
-  if(do_moments&&do_central)   log.printf("  calculating also the %lf central moment\n", moment);
-  if(do_powers)                log.printf("  calculating the %lf power of the mean (and moment)\n", power);
+  if(do_reweight) {
+    log.printf("  doing simple REWEIGHT using the latest ARGUMENT as energy.\n");
+  }
+  if(do_moments&&!do_central) {
+    log.printf("  calculating also the %lf standard moment\n", moment);
+  }
+  if(do_moments&&do_central) {
+    log.printf("  calculating also the %lf central moment\n", moment);
+  }
+  if(do_powers) {
+    log.printf("  calculating the %lf power of the mean (and moment)\n", power);
+  }
 }
 
 std::string Ensemble::getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const {
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( cname==getPntrToArgument(i)->getName() ) return "the average for argument " + cname;
-    if( cname==getPntrToArgument(i)->getName() + "_m" ) return "the moment for argument " + cname;
+    if( cname==getPntrToArgument(i)->getName() ) {
+      return "the average for argument " + cname;
+    }
+    if( cname==getPntrToArgument(i)->getName() + "_m" ) {
+      return "the moment for argument " + cname;
+    }
   }
-  plumed_error(); return "";
+  plumed_error();
+  return "";
 }
 
 
@@ -167,7 +197,9 @@ void Ensemble::calculate() {
     bias.resize(ens_dim);
     if(master) {
       bias[my_repl] = getArgument(narg);
-      if(ens_dim>1) multi_sim_comm.Sum(&bias[0], ens_dim);
+      if(ens_dim>1) {
+        multi_sim_comm.Sum(&bias[0], ens_dim);
+      }
     }
     comm.Sum(&bias[0], ens_dim);
     const double maxbias = *(std::max_element(bias.begin(), bias.end()));
@@ -188,8 +220,12 @@ void Ensemble::calculate() {
   std::vector<double> dmean(narg,fact);
   // calculate the mean
   if(master) {
-    for(unsigned i=0; i<narg; ++i) mean[i] = fact*getArgument(i);
-    if(ens_dim>1) multi_sim_comm.Sum(&mean[0], narg);
+    for(unsigned i=0; i<narg; ++i) {
+      mean[i] = fact*getArgument(i);
+    }
+    if(ens_dim>1) {
+      multi_sim_comm.Sum(&mean[0], narg);
+    }
   }
   comm.Sum(&mean[0], narg);
 
@@ -206,7 +242,9 @@ void Ensemble::calculate() {
           v_moment[i]      = tmp*getArgument(i);
           dv_moment[i]     = moment*tmp;
         }
-        if(ens_dim>1) multi_sim_comm.Sum(&v_moment[0], narg);
+        if(ens_dim>1) {
+          multi_sim_comm.Sum(&v_moment[0], narg);
+        }
       } else {
         for(unsigned i=0; i<narg; ++i) {
           const double tmp = fact*std::pow(getArgument(i),moment-1);
@@ -221,7 +259,9 @@ void Ensemble::calculate() {
           v_moment[i]      = fact*tmp*(getArgument(i)-mean[i]);
           dv_moment[i]     = moment*tmp*(fact-fact/norm);
         }
-        if(ens_dim>1) multi_sim_comm.Sum(&v_moment[0], narg);
+        if(ens_dim>1) {
+          multi_sim_comm.Sum(&v_moment[0], narg);
+        }
       } else {
         for(unsigned i=0; i<narg; ++i) {
           const double tmp = std::pow(getArgument(i)-mean[i],moment-1);
diff --git a/src/function/FuncPathGeneral.cpp b/src/function/FuncPathGeneral.cpp
index 4df3422894..68ce295a12 100644
--- a/src/function/FuncPathGeneral.cpp
+++ b/src/function/FuncPathGeneral.cpp
@@ -128,23 +128,24 @@ PLUMED_REGISTER_ACTION(FuncPathGeneral, "FUNCPATHGENERAL")
 void FuncPathGeneral::loadReference() {
   IFile input;
   input.open(reference);
-  if (!input)
+  if (!input) {
     plumed_merror("Could not open the reference file!");
-  while (input)
-  {
+  }
+  while (input) {
     std::vector<std::string> strings;
     Tools::getParsedLine(input, strings);
-    if (strings.empty())
+    if (strings.empty()) {
       continue;
+    }
     std::vector<double> colvarLine;
     double value;
     int max = columns.empty() ? strings.size() : columns.size();
-    for (int i = 0; i < max; ++i)
-    {
+    for (int i = 0; i < max; ++i) {
       int col = columns.empty() ? i : columns[i];
       // If no columns have been entered, ignore the first (time) and take the rest
-      if (columns.empty() && i == 0)
+      if (columns.empty() && i == 0) {
         continue;
+      }
 
       Tools::convert(strings[col], value);
       colvarLine.push_back(value);
@@ -170,8 +171,7 @@ FuncPathGeneral::FuncPathGeneral(const ActionOptions&ao):
   Action(ao),
   Function(ao),
   neigh_size(-1),
-  neigh_stride(-1.)
-{
+  neigh_stride(-1.) {
   parse("LAMBDA", lambda);
   parse("NEIGH_SIZE", neigh_size);
   parse("NEIGH_STRIDE", neigh_stride);
@@ -180,11 +180,13 @@ FuncPathGeneral::FuncPathGeneral(const ActionOptions&ao):
   parseVector("COLUMNS", columns);
   checkRead();
   log.printf("  lambda is %f\n", lambda);
-  if (getNumberOfArguments() != coefficients.size())
+  if (getNumberOfArguments() != coefficients.size()) {
     plumed_merror("The numbers of coefficients and CVs are different!");
+  }
   if (!columns.empty()) {
-    if (columns.size() != coefficients.size())
+    if (columns.size() != coefficients.size()) {
       plumed_merror("The numbers of coefficients and columns are different!");
+    }
   }
   log.printf("  Consistency check completed! Your path cvs look good!\n");
 
@@ -204,8 +206,10 @@ FuncPathGeneral::FuncPathGeneral(const ActionOptions&ao):
     log.printf("  Neighbour list NOT enabled \n");
   }
 
-  addComponentWithDerivatives("s"); componentIsNotPeriodic("s");
-  addComponentWithDerivatives("z"); componentIsNotPeriodic("z");
+  addComponentWithDerivatives("s");
+  componentIsNotPeriodic("s");
+  addComponentWithDerivatives("z");
+  componentIsNotPeriodic("z");
 
   // Initialise vectors
   std::vector<double> temp (coefficients.size());
@@ -217,8 +221,9 @@ FuncPathGeneral::FuncPathGeneral(const ActionOptions&ao):
   }
 
   // Store the arguments
-  for (unsigned i=0; i<getNumberOfArguments(); i++)
+  for (unsigned i=0; i<getNumberOfArguments(); i++) {
     allArguments.push_back(getPntrToArgument(i));
+  }
 
   // Get periodic domains, negative for not periodic, stores half the domain length (maximum difference)
   for (unsigned i = 0; i < allArguments.size(); ++i) {
@@ -226,9 +231,9 @@ FuncPathGeneral::FuncPathGeneral(const ActionOptions&ao):
       double min_lim, max_lim;
       allArguments[i]->getDomain(min_lim, max_lim);
       domains.push_back((max_lim - min_lim) / 2);
-    }
-    else
+    } else {
       domains.push_back(-1.);
+    }
   }
 }
 
@@ -248,8 +253,9 @@ void FuncPathGeneral::calculate() {
   if (neighpair.empty()) {
     // Resize at the first step
     neighpair.resize(path_cv_values.size());
-    for (unsigned i = 0; i < path_cv_values.size(); ++i)
+    for (unsigned i = 0; i < path_cv_values.size(); ++i) {
       neighpair[i].first = i;
+    }
   }
 
   Value* val_s_path=getPntrToComponent("s");
@@ -260,10 +266,12 @@ void FuncPathGeneral::calculate() {
     for (pairiter it = neighpair.begin(); it != neighpair.end(); ++it) {
       diff = (value - path_cv_values[(*it).first][j]);
       if (domains[j] > 0) {
-        if (diff > domains[j])
+        if (diff > domains[j]) {
           diff -= 2 * domains[j];
-        if (diff < -domains[j])
+        }
+        if (diff < -domains[j]) {
           diff += 2 * domains[j];
+        }
       }
       (*it).second += Tools::fastpow(coefficients[j] * diff, 2);
       numerators[(*it).first][j] = 2 * Tools::fastpow(coefficients[j], 2) * diff;
@@ -277,7 +285,9 @@ void FuncPathGeneral::calculate() {
     partition += expdist;
   }
 
-  if(partition==0.0) partition=std::numeric_limits<double>::min();
+  if(partition==0.0) {
+    partition=std::numeric_limits<double>::min();
+  }
 
   s_path /= partition;
   val_s_path->set(s_path);
@@ -320,15 +330,17 @@ void FuncPathGeneral::prepare() {
       // Resize the effective list
       neighpair.resize(neigh_size);
       log.printf("  NEIGHBOUR LIST NOW INCLUDES INDICES: ");
-      for (int i = 0; i < neigh_size; ++i)
+      for (int i = 0; i < neigh_size; ++i) {
         log.printf(" %i ",neighpair[i].first);
+      }
       log.printf(" \n");
     } else {
       if (int(getStep()) % int(neigh_stride / getTimeStep()) == 0) {
         log.printf(" Time %f : recalculating full neighbour list \n", getStep() * getTimeStep());
         neighpair.resize(path_cv_values.size());
-        for (unsigned i = 0; i < path_cv_values.size(); ++i)
+        for (unsigned i = 0; i < path_cv_values.size(); ++i) {
           neighpair[i].first = i;
+        }
       }
     }
   }
diff --git a/src/function/FuncPathMSD.cpp b/src/function/FuncPathMSD.cpp
index 88f823afe3..0e1ea76cfa 100644
--- a/src/function/FuncPathMSD.cpp
+++ b/src/function/FuncPathMSD.cpp
@@ -192,9 +192,11 @@ class FuncPathMSD : public Function {
     }
     // now sort according the second value
     std::sort(order.begin(), order.end(), ordering());
-    std::vector<int> vv(v.size()); n=0;
+    std::vector<int> vv(v.size());
+    n=0;
     for (const auto & it : order) {
-      vv[n]=it.first; n++;
+      vv[n]=it.first;
+      n++;
     }
     return vv;
   }
@@ -230,8 +232,7 @@ FuncPathMSD::FuncPathMSD(const ActionOptions&ao):
   Action(ao),
   Function(ao),
   neigh_size(-1),
-  neigh_stride(-1.)
-{
+  neigh_stride(-1.) {
 
   parse("LAMBDA",lambda);
   parse("NEIGH_SIZE",neigh_size);
@@ -240,10 +241,14 @@ FuncPathMSD::FuncPathMSD(const ActionOptions&ao):
   log.printf("  lambda is %f\n",lambda);
   // list the action involved and check the type
   std::string myname=getPntrToArgument(0)->getPntrToAction()->getName();
-  if(myname!="RMSD_SCALAR"&&myname!="CONTACTMAP"&&myname!="DISTANCE"&&myname!="PIV") error("One or more of your arguments is not of RMSD/CONTACTMAP/DISTANCE/PIV type!!!");
+  if(myname!="RMSD_SCALAR"&&myname!="CONTACTMAP"&&myname!="DISTANCE"&&myname!="PIV") {
+    error("One or more of your arguments is not of RMSD/CONTACTMAP/DISTANCE/PIV type!!!");
+  }
   for(unsigned i=1; i<getNumberOfArguments(); i++) {
     // for each value get the name and the label of the corresponding action
-    if( getPntrToArgument(i)->getPntrToAction()->getName()!=myname ) error("mismatch between the types of arguments");
+    if( getPntrToArgument(i)->getPntrToAction()->getName()!=myname ) {
+      error("mismatch between the types of arguments");
+    }
   }
   log.printf("  Consistency check completed! Your path cvs look good!\n");
   // do some neighbor printout
@@ -259,14 +264,19 @@ FuncPathMSD::FuncPathMSD(const ActionOptions&ao):
     log.printf("  Neighbor list NOT enabled \n");
   }
 
-  addComponentWithDerivatives("s"); componentIsNotPeriodic("s");
-  addComponentWithDerivatives("z"); componentIsNotPeriodic("z");
+  addComponentWithDerivatives("s");
+  componentIsNotPeriodic("s");
+  addComponentWithDerivatives("z");
+  componentIsNotPeriodic("z");
 
   // now backup the arguments
-  for(unsigned i=0; i<getNumberOfArguments(); i++)allArguments.push_back(getPntrToArgument(i));
+  for(unsigned i=0; i<getNumberOfArguments(); i++) {
+    allArguments.push_back(getPntrToArgument(i));
+  }
   double i=1.;
   for(const auto & it : allArguments) {
-    indexmap[it]=i; i+=1.;
+    indexmap[it]=i;
+    i+=1.;
   }
 
 }
@@ -277,7 +287,9 @@ void FuncPathMSD::calculate() {
   double partition=0.;
   if(neighpair.empty()) { // at first step, resize it
     neighpair.resize(allArguments.size());
-    for(unsigned i=0; i<allArguments.size(); i++)neighpair[i].first=allArguments[i];
+    for(unsigned i=0; i<allArguments.size(); i++) {
+      neighpair[i].first=allArguments[i];
+    }
   }
 
   Value* val_s_path=getPntrToComponent("s");
@@ -322,18 +334,25 @@ void FuncPathMSD::prepare() {
       // resize the effective list
       neighpair.resize(neigh_size);
       log.printf("  NEIGH LIST NOW INCLUDE INDEXES: ");
-      for(int i=0; i<neigh_size; ++i) {log.printf(" %f ",indexmap[neighpair[i].first]);} log.printf(" \n");
+      for(int i=0; i<neigh_size; ++i) {
+        log.printf(" %f ",indexmap[neighpair[i].first]);
+      }
+      log.printf(" \n");
     } else {
       if( int(getStep())%int(neigh_stride/getTimeStep())==0 ) {
         log.printf(" Time %f : recalculating full neighlist \n",getStep()*getTimeStep());
         neighpair.resize(allArguments.size());
-        for(unsigned i=0; i<allArguments.size(); i++)neighpair[i].first=allArguments[i];
+        for(unsigned i=0; i<allArguments.size(); i++) {
+          neighpair[i].first=allArguments[i];
+        }
       }
     }
   } else {
     if( int(getStep())==0) {
       neighpair.resize(allArguments.size());
-      for(unsigned i=0; i<allArguments.size(); i++)neighpair[i].first=allArguments[i];
+      for(unsigned i=0; i<allArguments.size(); i++) {
+        neighpair[i].first=allArguments[i];
+      }
     }
   }
   std::vector<Value*> argstocall;
diff --git a/src/function/FuncSumHills.cpp b/src/function/FuncSumHills.cpp
index 65eef4238c..f69d5fc616 100644
--- a/src/function/FuncSumHills.cpp
+++ b/src/function/FuncSumHills.cpp
@@ -77,7 +77,8 @@ FilesHandler::FilesHandler(const std::vector<std::string> &filenames, const bool
 // note that the FileHandler is completely transparent respect to the biasrepresentation
 // no check are made at this level
 bool FilesHandler::readBunch(BiasRepresentation *br, int stride = -1) {
-  bool morefiles; morefiles=true;
+  bool morefiles;
+  morefiles=true;
   if(parallelread) {
     (*log)<<"  doing parallelread \n";
     plumed_merror("parallelread is not yet implemented !!!");
@@ -89,7 +90,8 @@ bool FilesHandler::readBunch(BiasRepresentation *br, int stride = -1) {
     ff=ifiles[beingread].get();
     if(!isopen) {
       (*log)<<"  opening file "<<filenames[beingread]<<"\n";
-      ff->open(filenames[beingread]); isopen=true;
+      ff->open(filenames[beingread]);
+      isopen=true;
     }
     int n=0;
     while(true) {
@@ -110,7 +112,8 @@ bool FilesHandler::readBunch(BiasRepresentation *br, int stride = -1) {
         (*log)<<"  now total "<<br->getNumberOfKernels()<<" kernels \n";
         beingread++;
         if(beingread<ifiles.size()) {
-          ff=ifiles[beingread].get(); ff->open(filenames[beingread]);
+          ff=ifiles[beingread].get();
+          ff->open(filenames[beingread]);
           (*log)<<"  opening file "<<filenames[beingread]<<"\n";
           isopen=true;
         } else {
@@ -120,10 +123,14 @@ bool FilesHandler::readBunch(BiasRepresentation *br, int stride = -1) {
         }
       }
       // if there are no more files to read and this file is over then quit
-      if(fileisover && !morefiles) {break;}
+      if(fileisover && !morefiles) {
+        break;
+      }
       // if you are in the middle of a file and you are here
       // then means that you read what you need to read
-      if(!fileisover ) {break;}
+      if(!fileisover ) {
+        break;
+      }
     }
   }
   return morefiles;
@@ -148,12 +155,18 @@ bool FilesHandler::scanOneHill(BiasRepresentation *br, IFile *ifile ) {
   double dummy;
   if(ifile->scanField("time",dummy)) {
     //(*log)<<"   scanning one hill: "<<dummy<<" \n";
-    if(ifile->FieldExist("biasf")) ifile->scanField("biasf",dummy);
-    if(ifile->FieldExist("clock")) ifile->scanField("clock",dummy);
+    if(ifile->FieldExist("biasf")) {
+      ifile->scanField("biasf",dummy);
+    }
+    if(ifile->FieldExist("clock")) {
+      ifile->scanField("clock",dummy);
+    }
     // keep this intermediate function in case you need to parse more data in the future
     br->pushKernel(ifile);
     //(*log)<<"  read hill\n";
-    if(br->hasSigmaInInput())ifile->allowIgnoredFields();
+    if(br->hasSigmaInInput()) {
+      ifile->allowIgnoredFields();
+    }
     ifile->scanField();
     return true;
   } else {
@@ -173,8 +186,7 @@ double  mylogder( double v1 ) {
 
 
 class FuncSumHills :
-  public Function
-{
+  public Function {
   std::vector<std::string> hillsFiles,histoFiles;
   std::vector<std::string> proj;
   int initstride;
@@ -239,8 +251,7 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
   lowI_(-1.),
   uppI_(-1.),
   beta(-1.),
-  fmt("%14.9f")
-{
+  fmt("%14.9f") {
 
   // format
   parse("FMT",fmt);
@@ -249,44 +260,62 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
   // Grid Stuff
   std::vector<std::string> gmin;
   parseVector("GRID_MIN",gmin);
-  if(gmin.size()!=getNumberOfArguments() && gmin.size()!=0) error("not enough values for GRID_MIN");
+  if(gmin.size()!=getNumberOfArguments() && gmin.size()!=0) {
+    error("not enough values for GRID_MIN");
+  }
   plumed_massert(gmin.size()==getNumberOfArguments() || gmin.size()==0,"need GRID_MIN argument for this") ;
   std::vector<std::string> gmax;
   parseVector("GRID_MAX",gmax);
-  if(gmax.size()!=getNumberOfArguments() && gmax.size()!=0) error("not enough values for GRID_MAX");
+  if(gmax.size()!=getNumberOfArguments() && gmax.size()!=0) {
+    error("not enough values for GRID_MAX");
+  }
   plumed_massert(gmax.size()==getNumberOfArguments() || gmax.size()==0,"need GRID_MAX argument for this") ;
   std::vector<unsigned> gbin;
   std::vector<double>   gspacing;
   parseVector("GRID_BIN",gbin);
   plumed_massert(gbin.size()==getNumberOfArguments() || gbin.size()==0,"need GRID_BIN argument for this") ;
-  if(gbin.size()!=getNumberOfArguments() && gbin.size()!=0) error("not enough values for GRID_BIN");
+  if(gbin.size()!=getNumberOfArguments() && gbin.size()!=0) {
+    error("not enough values for GRID_BIN");
+  }
   parseVector("GRID_SPACING",gspacing);
   plumed_massert(gspacing.size()==getNumberOfArguments() || gspacing.size()==0,"need GRID_SPACING argument for this") ;
-  if(gspacing.size()!=getNumberOfArguments() && gspacing.size()!=0) error("not enough values for GRID_SPACING");
+  if(gspacing.size()!=getNumberOfArguments() && gspacing.size()!=0) {
+    error("not enough values for GRID_SPACING");
+  }
   if(gspacing.size()!=0 && gbin.size()==0) {
     log<<"  The number of bins will be estimated from GRID_SPACING\n";
   } else if(gspacing.size()!=0 && gbin.size()!=0) {
     log<<"  You specified both GRID_BIN and GRID_SPACING\n";
     log<<"  The more conservative (highest) number of bins will be used for each variable\n";
   }
-  if(gspacing.size()!=0) for(unsigned i=0; i<getNumberOfArguments(); i++) {
-      if(gbin.size()==0) gbin.assign(getNumberOfArguments(),1);
+  if(gspacing.size()!=0)
+    for(unsigned i=0; i<getNumberOfArguments(); i++) {
+      if(gbin.size()==0) {
+        gbin.assign(getNumberOfArguments(),1);
+      }
       double a,b;
       Tools::convert(gmin[i],a);
       Tools::convert(gmax[i],b);
       unsigned n=std::ceil((b-a)/gspacing[i]);
-      if(gbin[i]<n) gbin[i]=n;
+      if(gbin[i]<n) {
+        gbin[i]=n;
+      }
     }
 
   // Inteval keyword
   std::vector<double> tmpI(2);
   parseVector("INTERVAL",tmpI);
-  if(tmpI.size()!=2&&tmpI.size()!=0) error("both a lower and an upper limits must be provided with INTERVAL");
-  else if(tmpI.size()==2) {
+  if(tmpI.size()!=2&&tmpI.size()!=0) {
+    error("both a lower and an upper limits must be provided with INTERVAL");
+  } else if(tmpI.size()==2) {
     lowI_=tmpI.at(0);
     uppI_=tmpI.at(1);
-    if(getNumberOfArguments()!=1) error("INTERVAL limits correction works only for monodimensional metadynamics!");
-    if(uppI_<lowI_) error("The Upper limit must be greater than the Lower limit!");
+    if(getNumberOfArguments()!=1) {
+      error("INTERVAL limits correction works only for monodimensional metadynamics!");
+    }
+    if(uppI_<lowI_) {
+      error("The Upper limit must be greater than the Lower limit!");
+    }
     doInt=true;
   }
   if(doInt) {
@@ -295,9 +324,15 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
     std::ostringstream strsmin, strsmax;
     strsmin << lowI_;
     strsmax << uppI_;
-    if(gmin.size()==0) gmin.push_back(strsmin.str());
-    if(gmax.size()==0) gmax.push_back(strsmax.str());
-    if(gbin.size()==0) gbin.push_back(200);
+    if(gmin.size()==0) {
+      gmin.push_back(strsmin.str());
+    }
+    if(gmax.size()==0) {
+      gmax.push_back(strsmax.str());
+    }
+    if(gbin.size()==0) {
+      gbin.push_back(200);
+    }
   }
 
 
@@ -307,7 +342,9 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
     integratehills=false; // default behaviour
   } else {
     integratehills=true;
-    for(unsigned i=0; i<hillsFiles.size(); i++) log<<"  hillsfile  : "<<hillsFiles[i]<<"\n";
+    for(unsigned i=0; i<hillsFiles.size(); i++) {
+      log<<"  hillsfile  : "<<hillsFiles[i]<<"\n";
+    }
   }
   // histo file:
   parseVector("HISTOFILES",histoFiles);
@@ -315,12 +352,16 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
     integratehisto=false;
   } else {
     integratehisto=true;
-    for(unsigned i=0; i<histoFiles.size(); i++) log<<"  histofile  : "<<histoFiles[i]<<"\n";
+    for(unsigned i=0; i<histoFiles.size(); i++) {
+      log<<"  histofile  : "<<histoFiles[i]<<"\n";
+    }
   }
   std::vector<double> histoSigma;
   if(integratehisto) {
     parseVector("HISTOSIGMA",histoSigma);
-    for(unsigned i=0; i<histoSigma.size(); i++) log<<"  histosigma  : "<<histoSigma[i]<<"\n";
+    for(unsigned i=0; i<histoSigma.size(); i++) {
+      log<<"  histosigma  : "<<histoSigma[i]<<"\n";
+    }
   }
 
   // needs a projection?
@@ -333,7 +374,9 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
     plumed_massert(proj.size()<=getNumberOfArguments()," The number of projection must be less or equal to the full list of arguments ");
   }
   if(integratehisto&&proj.size()==0) {
-    for(unsigned i=0; i<getNumberOfArguments(); i++) proj.push_back(getPntrToArgument(i)->getName());
+    for(unsigned i=0; i<getNumberOfArguments(); i++) {
+      proj.push_back(getPntrToArgument(i)->getName());
+    }
   }
 
   // add some automatic hills width: not in case stride is defined
@@ -343,13 +386,17 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
     log<<"  No boundaries defined: need to do a prescreening of hills \n";
     std::vector<Value*> tmphillsvalues, tmphistovalues;
     if(integratehills) {
-      for(unsigned i=0; i<getNumberOfArguments(); i++)tmphillsvalues.push_back( getPntrToArgument(i) );
+      for(unsigned i=0; i<getNumberOfArguments(); i++) {
+        tmphillsvalues.push_back( getPntrToArgument(i) );
+      }
     }
     if(integratehisto) {
       for(unsigned i=0; i<getNumberOfArguments(); i++) {
         std::string ss = getPntrToArgument(i)->getName();
         for(unsigned j=0; j<proj.size(); j++) {
-          if(proj[j]==ss) tmphistovalues.push_back( getPntrToArgument(i) );
+          if(proj[j]==ss) {
+            tmphistovalues.push_back( getPntrToArgument(i) );
+          }
         }
       }
     }
@@ -400,7 +447,9 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
 
   if( proj.size() != 0 || integratehisto==true  ) {
     parse("KT",beta);
-    for(unsigned i=0; i<proj.size(); i++) log<<"  projection "<<i<<" : "<<proj[i]<<"\n";
+    for(unsigned i=0; i<proj.size(); i++) {
+      log<<"  projection "<<i<<" : "<<proj[i]<<"\n";
+    }
     // this should be only for projection or free energy from histograms
     plumed_massert(beta>0.,"if you make a projection or a histogram correction then you need KT flag!");
     beta=1./beta;
@@ -417,16 +466,21 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
   // output suffix or names
   if(initstride<0) {
     log<<"  Doing only one integration: no stride \n";
-    outhills="fes.dat"; outhisto="histo.dat";
-  }
-  else {
-    outhills="fes_"; outhisto="histo_";
+    outhills="fes.dat";
+    outhisto="histo.dat";
+  } else {
+    outhills="fes_";
+    outhisto="histo_";
     log<<"  Doing integration slices every "<<initstride<<" kernels\n";
     parseFlag("NOHISTORY",nohistory);
-    if(nohistory)log<<"  nohistory: each stride block has no memory of the previous block\n";
+    if(nohistory) {
+      log<<"  nohistory: each stride block has no memory of the previous block\n";
+    }
   }
   parseFlag("MINTOZERO",minTOzero);
-  if(minTOzero)log<<"  mintozero: bias/histogram will be translated to have the minimum value equal to zero\n";
+  if(minTOzero) {
+    log<<"  mintozero: bias/histogram will be translated to have the minimum value equal to zero\n";
+  }
   //what might it be this?
   // here start
   // want something right now?? do it and return
@@ -447,7 +501,9 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
       for(unsigned i=0; i<getNumberOfArguments(); i++) {
         std::string ss = getPntrToArgument(i)->getName();
         for(unsigned j=0; j<proj.size(); j++) {
-          if(proj[j]==ss) tmphistovalues.push_back( getPntrToArgument(i) );
+          if(proj[j]==ss) {
+            tmphistovalues.push_back( getPntrToArgument(i) );
+          }
         }
       }
     }
@@ -459,15 +515,22 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
       if(negativebias) {
         biasrep->setRescaledToBias(true);
         log<<"  required the -bias instead of the free energy \n";
-        if(initstride<0) {outhills="negativebias.dat";}
-        else {outhills="negativebias_";}
+        if(initstride<0) {
+          outhills="negativebias.dat";
+        } else {
+          outhills="negativebias_";
+        }
       }
     }
 
     parse("OUTHILLS",outhills);
     parse("OUTHISTO",outhisto);
-    if(integratehills)log<<"  output file for fes/bias  is :  "<<outhills<<"\n";
-    if(integratehisto)log<<"  output file for histogram is :  "<<outhisto<<"\n";
+    if(integratehills) {
+      log<<"  output file for fes/bias  is :  "<<outhills<<"\n";
+    }
+    if(integratehisto) {
+      log<<"  output file for histogram is :  "<<outhisto<<"\n";
+    }
     checkRead();
 
     log<<"\n";
@@ -491,8 +554,12 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
     std::unique_ptr<FilesHandler> hillsHandler;
     std::unique_ptr<FilesHandler> histoHandler;
 
-    if(integratehills)	hillsHandler=Tools::make_unique<FilesHandler>(hillsFiles,parallelread,*this, log);
-    if(integratehisto)	histoHandler=Tools::make_unique<FilesHandler>(histoFiles,parallelread,*this, log);
+    if(integratehills)	{
+      hillsHandler=Tools::make_unique<FilesHandler>(hillsFiles,parallelread,*this, log);
+    }
+    if(integratehisto)	{
+      histoHandler=Tools::make_unique<FilesHandler>(histoFiles,parallelread,*this, log);
+    }
 
 // Stopwatch is logged when it goes out of scope
     Stopwatch sw(log);
@@ -502,18 +569,27 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
 
     // read a number of hills and put in the bias representation
     int nfiles=0;
-    bool ibias=integratehills; bool ihisto=integratehisto;
+    bool ibias=integratehills;
+    bool ihisto=integratehisto;
     while(true) {
       if(  integratehills  && ibias  ) {
-        if(nohistory) {biasrep->clear(); log<<"  clearing history before reading a new block\n";};
+        if(nohistory) {
+          biasrep->clear();
+          log<<"  clearing history before reading a new block\n";
+        };
         log<<"  reading hills: \n";
-        ibias=hillsHandler->readBunch(biasrep.get(),initstride) ; log<<"\n";
+        ibias=hillsHandler->readBunch(biasrep.get(),initstride) ;
+        log<<"\n";
       }
 
       if(  integratehisto  && ihisto ) {
-        if(nohistory) {historep->clear(); log<<"  clearing history before reading a new block\n";};
+        if(nohistory) {
+          historep->clear();
+          log<<"  clearing history before reading a new block\n";
+        };
         log<<"  reading histogram: \n";
-        ihisto=histoHandler->readBunch(historep.get(),initstride) ;  log<<"\n";
+        ihisto=histoHandler->readBunch(historep.get(),initstride) ;
+        log<<"\n";
       }
 
       // dump: need to project?
@@ -525,17 +601,27 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
           BiasWeight Bw(beta);
           Grid biasGrid=*(biasrep->getGridPtr());
           Grid smallGrid=biasGrid.project(proj,&Bw);
-          OFile gridfile; gridfile.link(*this);
-          std::ostringstream ostr; ostr<<nfiles;
+          OFile gridfile;
+          gridfile.link(*this);
+          std::ostringstream ostr;
+          ostr<<nfiles;
           std::string myout;
-          if(initstride>0) { myout=outhills+ostr.str()+".dat" ;} else {myout=outhills;}
+          if(initstride>0) {
+            myout=outhills+ostr.str()+".dat" ;
+          } else {
+            myout=outhills;
+          }
           log<<"  Bias: Writing subgrid on file "<<myout<<" \n";
           gridfile.open(myout);
-          if(minTOzero) smallGrid.setMinToZero();
+          if(minTOzero) {
+            smallGrid.setMinToZero();
+          }
           smallGrid.setOutputFmt(fmt);
           smallGrid.writeToFile(gridfile);
           gridfile.close();
-          if(!ibias)integratehills=false;// once you get to the final bunch just give up
+          if(!ibias) {
+            integratehills=false;  // once you get to the final bunch just give up
+          }
         }
         // this should be removed
         if(integratehisto) {
@@ -543,20 +629,30 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
           log<<"  Histo: Projecting on subgrid... \n";
           Grid histoGrid=*(historep->getGridPtr());
 
-          OFile gridfile; gridfile.link(*this);
-          std::ostringstream ostr; ostr<<nfiles;
+          OFile gridfile;
+          gridfile.link(*this);
+          std::ostringstream ostr;
+          ostr<<nfiles;
           std::string myout;
-          if(initstride>0) { myout=outhisto+ostr.str()+".dat" ;} else {myout=outhisto;}
+          if(initstride>0) {
+            myout=outhisto+ostr.str()+".dat" ;
+          } else {
+            myout=outhisto;
+          }
           log<<"  Histo: Writing subgrid on file "<<myout<<" \n";
           gridfile.open(myout);
 
           histoGrid.applyFunctionAllValuesAndDerivatives(&mylog,&mylogder);
           histoGrid.scaleAllValuesAndDerivatives(-1./beta);
-          if(minTOzero) histoGrid.setMinToZero();
+          if(minTOzero) {
+            histoGrid.setMinToZero();
+          }
           histoGrid.setOutputFmt(fmt);
           histoGrid.writeToFile(gridfile);
 
-          if(!ihisto)integratehisto=false;// once you get to the final bunch just give up
+          if(!ihisto) {
+            integratehisto=false;  // once you get to the final bunch just give up
+          }
         }
 
       } else {
@@ -566,18 +662,28 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
           Grid biasGrid=*(biasrep->getGridPtr());
           biasGrid.scaleAllValuesAndDerivatives(-1.);
 
-          OFile gridfile; gridfile.link(*this);
-          std::ostringstream ostr; ostr<<nfiles;
+          OFile gridfile;
+          gridfile.link(*this);
+          std::ostringstream ostr;
+          ostr<<nfiles;
           std::string myout;
-          if(initstride>0) { myout=outhills+ostr.str()+".dat" ;} else {myout=outhills;}
+          if(initstride>0) {
+            myout=outhills+ostr.str()+".dat" ;
+          } else {
+            myout=outhills;
+          }
           log<<"  Writing full grid on file "<<myout<<" \n";
           gridfile.open(myout);
 
-          if(minTOzero) biasGrid.setMinToZero();
+          if(minTOzero) {
+            biasGrid.setMinToZero();
+          }
           biasGrid.setOutputFmt(fmt);
           biasGrid.writeToFile(gridfile);
           // rescale back prior to accumulate
-          if(!ibias)integratehills=false;// once you get to the final bunch just give up
+          if(!ibias) {
+            integratehills=false;  // once you get to the final bunch just give up
+          }
         }
         if(integratehisto) {
 
@@ -586,22 +692,34 @@ FuncSumHills::FuncSumHills(const ActionOptions&ao):
           histoGrid.applyFunctionAllValuesAndDerivatives(&mylog,&mylogder);
           histoGrid.scaleAllValuesAndDerivatives(-1./beta);
 
-          OFile gridfile; gridfile.link(*this);
-          std::ostringstream ostr; ostr<<nfiles;
+          OFile gridfile;
+          gridfile.link(*this);
+          std::ostringstream ostr;
+          ostr<<nfiles;
           std::string myout;
-          if(initstride>0) { myout=outhisto+ostr.str()+".dat" ;} else {myout=outhisto;}
+          if(initstride>0) {
+            myout=outhisto+ostr.str()+".dat" ;
+          } else {
+            myout=outhisto;
+          }
           log<<"  Writing full grid on file "<<myout<<" \n";
           gridfile.open(myout);
 
           // also this is useful only for free energy
-          if(minTOzero) histoGrid.setMinToZero();
+          if(minTOzero) {
+            histoGrid.setMinToZero();
+          }
           histoGrid.setOutputFmt(fmt);
           histoGrid.writeToFile(gridfile);
 
-          if(!ihisto)integratehisto=false; // once you get to the final bunch just give up
+          if(!ihisto) {
+            integratehisto=false;  // once you get to the final bunch just give up
+          }
         }
       }
-      if ( !ibias && !ihisto) break; //when both are over then just quit
+      if ( !ibias && !ihisto) {
+        break;  //when both are over then just quit
+      }
 
       nfiles++;
     }
diff --git a/src/function/Function.cpp b/src/function/Function.cpp
index 053c4a9943..7c52ddf35e 100644
--- a/src/function/Function.cpp
+++ b/src/function/Function.cpp
@@ -36,8 +36,7 @@ void Function::registerKeywords(Keywords& keys) {
 Function::Function(const ActionOptions&ao):
   Action(ao),
   ActionWithValue(ao),
-  ActionWithArguments(ao)
-{
+  ActionWithArguments(ao) {
 }
 
 void Function::addValueWithDerivatives() {
@@ -52,10 +51,12 @@ void Function::addComponentWithDerivatives( const std::string& name ) {
   getPntrToComponent(name)->resizeDerivatives(getNumberOfArguments());
 }
 
-void Function::apply()
-{
-  if( !checkForForces() ) return;
-  unsigned ind=0; addForcesOnArguments( 0, getForcesToApply(), ind, getLabel() );
+void Function::apply() {
+  if( !checkForForces() ) {
+    return;
+  }
+  unsigned ind=0;
+  addForcesOnArguments( 0, getForcesToApply(), ind, getLabel() );
 }
 
 }
diff --git a/src/function/Function.h b/src/function/Function.h
index 2074a66410..6fa6a8be59 100644
--- a/src/function/Function.h
+++ b/src/function/Function.h
@@ -36,8 +36,7 @@ This is the abstract base class to use for implementing new CV function, within
 
 class Function:
   public ActionWithValue,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
 protected:
   void setDerivative(int,double);
   void setDerivative(Value*,int,double);
@@ -66,7 +65,9 @@ inline
 unsigned Function::getNumberOfDerivatives() {
   unsigned narg=0;
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->getRank()==0 ) narg++;
+    if( getPntrToArgument(i)->getRank()==0 ) {
+      narg++;
+    }
   }
   return narg;
 }
diff --git a/src/function/FunctionOfMatrix.h b/src/function/FunctionOfMatrix.h
index 067e83c4b8..ee252e10b4 100644
--- a/src/function/FunctionOfMatrix.h
+++ b/src/function/FunctionOfMatrix.h
@@ -51,7 +51,9 @@ class FunctionOfMatrix : public ActionWithMatrix {
   static void registerKeywords(Keywords&);
   explicit FunctionOfMatrix(const ActionOptions&);
 /// Get the label to write in the graph
-  std::string writeInGraph() const override { return myfunc.getGraphInfo( getName() ); }
+  std::string writeInGraph() const override {
+    return myfunc.getGraphInfo( getName() );
+  }
 /// Make sure the derivatives are turned on
   void turnOnDerivatives() override;
 /// Get the number of derivatives for this action
@@ -75,11 +77,15 @@ class FunctionOfMatrix : public ActionWithMatrix {
 
 template <class T>
 void FunctionOfMatrix<T>::registerKeywords(Keywords& keys ) {
-  ActionWithMatrix::registerKeywords(keys); keys.use("ARG"); std::string name = keys.getDisplayName();
-  std::size_t und=name.find("_MATRIX"); keys.setDisplayName( name.substr(0,und) );
+  ActionWithMatrix::registerKeywords(keys);
+  keys.use("ARG");
+  std::string name = keys.getDisplayName();
+  std::size_t und=name.find("_MATRIX");
+  keys.setDisplayName( name.substr(0,und) );
   keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
   keys.reserve("compulsory","PERIODIC","if the output of your function is periodic then you should specify the periodicity of the function.  If the output is not periodic you must state this using PERIODIC=NO");
-  T tfunc; tfunc.registerKeywords( keys );
+  T tfunc;
+  tfunc.registerKeywords( keys );
   if( keys.getDisplayName()=="SUM" ) {
     keys.setValueDescription("the sum of all the elements in the input matrix");
   } else if( keys.getDisplayName()=="HIGHEST" ) {
@@ -95,31 +101,42 @@ template <class T>
 FunctionOfMatrix<T>::FunctionOfMatrix(const ActionOptions&ao):
   Action(ao),
   ActionWithMatrix(ao),
-  firststep(true)
-{
-  if( myfunc.getArgStart()>0 ) error("this has not beeen implemented -- if you are interested email gareth.tribello@gmail.com");
+  firststep(true) {
+  if( myfunc.getArgStart()>0 ) {
+    error("this has not beeen implemented -- if you are interested email gareth.tribello@gmail.com");
+  }
   // Get the shape of the output
   std::vector<unsigned> shape( getValueShapeFromArguments() );
   // Check if the output matrix is symmetric
-  bool symmetric=true; unsigned argstart=myfunc.getArgStart();
+  bool symmetric=true;
+  unsigned argstart=myfunc.getArgStart();
   for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
     if( getPntrToArgument(i)->getRank()==2 ) {
-      if( !getPntrToArgument(i)->isSymmetric() ) { symmetric=false;  }
+      if( !getPntrToArgument(i)->isSymmetric() ) {
+        symmetric=false;
+      }
     }
   }
   // Read the input and do some checks
   myfunc.read( this );
   // Setup to do this in chain if possible
-  if( myfunc.doWithTasks() ) done_in_chain=true;
+  if( myfunc.doWithTasks() ) {
+    done_in_chain=true;
+  }
   // Check we are not calculating a sum
-  if( myfunc.zeroRank() ) shape.resize(0);
+  if( myfunc.zeroRank() ) {
+    shape.resize(0);
+  }
   // Get the names of the components
   std::vector<std::string> components( keywords.getOutputComponents() );
   // Create the values to hold the output
   std::vector<std::string> str_ind( myfunc.getComponentsPerLabel() );
   for(unsigned i=0; i<components.size(); ++i) {
     if( str_ind.size()>0 ) {
-      std::string compstr = components[i]; if( components[i]==".#!value" ) compstr = "";
+      std::string compstr = components[i];
+      if( components[i]==".#!value" ) {
+        compstr = "";
+      }
       for(unsigned j=0; j<str_ind.size(); ++j) {
         if( myfunc.zeroRank() ) {
           addComponentWithDerivatives( compstr + str_ind[j], shape );
@@ -131,43 +148,67 @@ FunctionOfMatrix<T>::FunctionOfMatrix(const ActionOptions&ao):
     } else if( components[i]==".#!value" && myfunc.zeroRank() ) {
       addValueWithDerivatives( shape );
     } else if( components[i]==".#!value" ) {
-      addValue( shape ); getPntrToComponent(0)->setSymmetric( symmetric );
+      addValue( shape );
+      getPntrToComponent(0)->setSymmetric( symmetric );
     } else if( components[i].find_first_of("_")!=std::string::npos ) {
-      if( getNumberOfArguments()-argstart==1 ) { addValue( shape ); getPntrToComponent(0)->setSymmetric( symmetric ); }
-      else {
+      if( getNumberOfArguments()-argstart==1 ) {
+        addValue( shape );
+        getPntrToComponent(0)->setSymmetric( symmetric );
+      } else {
         for(unsigned j=argstart; j<getNumberOfArguments(); ++j) {
           addComponent( getPntrToArgument(j)->getName() + components[i], shape );
           getPntrToComponent(i*(getNumberOfArguments()-argstart)+j-argstart)->setSymmetric( symmetric );
         }
       }
-    } else { addComponent( components[i], shape ); getPntrToComponent(i)->setSymmetric( symmetric ); }
+    } else {
+      addComponent( components[i], shape );
+      getPntrToComponent(i)->setSymmetric( symmetric );
+    }
   }
   // Check if this can be sped up
   if( myfunc.getDerivativeZeroIfValueIsZero() )  {
-    for(int i=0; i<getNumberOfComponents(); ++i) getPntrToComponent(i)->setDerivativeIsZeroWhenValueIsZero();
+    for(int i=0; i<getNumberOfComponents(); ++i) {
+      getPntrToComponent(i)->setDerivativeIsZeroWhenValueIsZero();
+    }
   }
   // Set the periodicities of the output components
   myfunc.setPeriodicityForOutputs( this );
   // We can't do this with if we are dividing a stack by some a product v.v^T product as we need to store the vector
   // In order to do this type of calculation.  There should be a neater fix than this but I can't see it.
-  bool foundneigh=false; const ActionWithMatrix* chainstart = NULL;
+  bool foundneigh=false;
+  const ActionWithMatrix* chainstart = NULL;
   for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->isConstant() && getNumberOfArguments()>1 ) continue ;
+    if( getPntrToArgument(i)->isConstant() && getNumberOfArguments()>1 ) {
+      continue ;
+    }
     std::string argname=(getPntrToArgument(i)->getPntrToAction())->getName();
-    if( argname=="NEIGHBORS" ) { foundneigh=true; break; }
+    if( argname=="NEIGHBORS" ) {
+      foundneigh=true;
+      break;
+    }
     ActionWithVector* av=dynamic_cast<ActionWithVector*>( getPntrToArgument(i)->getPntrToAction() );
-    if( !av ) done_in_chain=false;
+    if( !av ) {
+      done_in_chain=false;
+    }
     if( getPntrToArgument(i)->getRank()==0 ) {
       function::FunctionOfVector<function::Sum>* as = dynamic_cast<function::FunctionOfVector<function::Sum>*>( getPntrToArgument(i)->getPntrToAction() );
-      if(as) done_in_chain=false;
+      if(as) {
+        done_in_chain=false;
+      }
     } else if( getPntrToArgument(i)->ignoreStoredValue( getLabel() ) ) {
       // This option deals with the case when you have two adjacency matrices, A_ij and B_ij, multiplied together.  This cannot be done in the chain as the rows
       // of the two adjacency matrix are run over separately.  The value A_ij is thus not available when B_ij is calculated.
       ActionWithMatrix* am = dynamic_cast<ActionWithMatrix*>( getPntrToArgument(i)->getPntrToAction() );
-      plumed_assert( am ); const ActionWithMatrix* thischain = am->getFirstMatrixInChain();
-      if( !thischain->isAdjacencyMatrix() && thischain->getName()!="VSTACK" ) continue;
-      if( !chainstart ) chainstart = thischain;
-      else if( thischain!=chainstart ) done_in_chain=false;
+      plumed_assert( am );
+      const ActionWithMatrix* thischain = am->getFirstMatrixInChain();
+      if( !thischain->isAdjacencyMatrix() && thischain->getName()!="VSTACK" ) {
+        continue;
+      }
+      if( !chainstart ) {
+        chainstart = thischain;
+      } else if( thischain!=chainstart ) {
+        done_in_chain=false;
+      }
     }
   }
   // If we are working with neighbors we trick PLUMED into storing ALL the components of the other arguments
@@ -177,7 +218,9 @@ FunctionOfMatrix<T>::FunctionOfMatrix(const ActionOptions&ao):
     for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
       ActionWithValue* av=getPntrToArgument(i)->getPntrToAction();
       if( av->getName()!="NEIGHBORS" ) {
-        for(int i=0; i<av->getNumberOfComponents(); ++i) (av->copyOutput(i))->buildDataStore();
+        for(int i=0; i<av->getNumberOfComponents(); ++i) {
+          (av->copyOutput(i))->buildDataStore();
+        }
       }
     }
   }
@@ -187,8 +230,11 @@ FunctionOfMatrix<T>::FunctionOfMatrix(const ActionOptions&ao):
 
 template <class T>
 void FunctionOfMatrix<T>::turnOnDerivatives() {
-  if( !myfunc.derivativesImplemented() ) error("derivatives have not been implemended for " + getName() );
-  ActionWithValue::turnOnDerivatives(); myfunc.setup(this);
+  if( !myfunc.derivativesImplemented() ) {
+    error("derivatives have not been implemended for " + getName() );
+  }
+  ActionWithValue::turnOnDerivatives();
+  myfunc.setup(this);
 }
 
 template <class T>
@@ -198,7 +244,8 @@ unsigned FunctionOfMatrix<T>::getNumberOfDerivatives() {
 
 template <class T>
 void FunctionOfMatrix<T>::prepare() {
-  unsigned argstart = myfunc.getArgStart(); std::vector<unsigned> shape(2);
+  unsigned argstart = myfunc.getArgStart();
+  std::vector<unsigned> shape(2);
   for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
     if( getPntrToArgument(i)->getRank()==2 ) {
       shape[0] = getPntrToArgument(i)->getShape()[0];
@@ -209,7 +256,10 @@ void FunctionOfMatrix<T>::prepare() {
   for(unsigned i=0; i<getNumberOfComponents(); ++i) {
     Value* myval = getPntrToComponent(i);
     if( myval->getRank()==2 && (myval->getShape()[0]!=shape[0] || myval->getShape()[1]!=shape[1]) ) {
-      myval->setShape(shape); if( myval->valueIsStored() ) myval->reshapeMatrixStore( shape[1] );
+      myval->setShape(shape);
+      if( myval->valueIsStored() ) {
+        myval->reshapeMatrixStore( shape[1] );
+      }
     }
   }
   ActionWithVector::prepare();
@@ -222,20 +272,29 @@ unsigned FunctionOfMatrix<T>::getNumberOfColumns() const {
     for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
       if( getPntrToArgument(i)->getRank()==2 ) {
         ActionWithMatrix* am=dynamic_cast<ActionWithMatrix*>( getPntrToArgument(i)->getPntrToAction() );
-        if( am ) return am->getNumberOfColumns();
+        if( am ) {
+          return am->getNumberOfColumns();
+        }
         return getPntrToArgument(i)->getShape()[1];
       }
     }
   }
-  plumed_error(); return 0;
+  plumed_error();
+  return 0;
 }
 
 template <class T>
 void FunctionOfMatrix<T>::setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const {
-  for(unsigned i=0; i<getNumberOfArguments(); ++i) plumed_assert( getPntrToArgument(i)->getRank()==2 );
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    plumed_assert( getPntrToArgument(i)->getRank()==2 );
+  }
   unsigned start_n = getPntrToArgument(0)->getShape()[0], size_v = getPntrToArgument(0)->getShape()[1];
-  if( indices.size()!=size_v+1 ) indices.resize( size_v+1 );
-  for(unsigned i=0; i<size_v; ++i) indices[i+1] = start_n + i;
+  if( indices.size()!=size_v+1 ) {
+    indices.resize( size_v+1 );
+  }
+  for(unsigned i=0; i<size_v; ++i) {
+    indices[i+1] = start_n + i;
+  }
   myvals.setSplitIndex( size_v + 1 );
 }
 
@@ -255,8 +314,11 @@ void FunctionOfMatrix<T>::setupStreamedComponents( const std::string& headstr, u
     std::string control = getFirstActionInChain()->getLabel();
     for(unsigned i=0; i<stored_arguments.size(); ++i) {
       stored_arguments[i] = !getPntrToArgument(i)->ignoreStoredValue( control );
-      if( !stored_arguments[i] ) update_arguments[i] = true;
-      else update_arguments[i] = !argumentDependsOn( headstr, this, getPntrToArgument(i) );
+      if( !stored_arguments[i] ) {
+        update_arguments[i] = true;
+      } else {
+        update_arguments[i] = !argumentDependsOn( headstr, this, getPntrToArgument(i) );
+      }
     }
     firststep=false;
   }
@@ -265,29 +327,45 @@ void FunctionOfMatrix<T>::setupStreamedComponents( const std::string& headstr, u
 
 template <class T>
 void FunctionOfMatrix<T>::performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const {
-  unsigned argstart=myfunc.getArgStart(); std::vector<double> args( getNumberOfArguments() - argstart );
+  unsigned argstart=myfunc.getArgStart();
+  std::vector<double> args( getNumberOfArguments() - argstart );
   unsigned ind2 = index2;
-  if( getConstPntrToComponent(0)->getRank()==2 && index2>=getConstPntrToComponent(0)->getShape()[0] ) ind2 = index2 - getConstPntrToComponent(0)->getShape()[0];
-  else if( index2>=getPntrToArgument(0)->getShape()[0] ) ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  if( getConstPntrToComponent(0)->getRank()==2 && index2>=getConstPntrToComponent(0)->getShape()[0] ) {
+    ind2 = index2 - getConstPntrToComponent(0)->getShape()[0];
+  } else if( index2>=getPntrToArgument(0)->getShape()[0] ) {
+    ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  }
   if( actionInChain() ) {
     for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-      if( getPntrToArgument(i)->getRank()==0 ) args[i-argstart] = getPntrToArgument(i)->get();
-      else if( !getPntrToArgument(i)->valueHasBeenSet() ) args[i-argstart] = myvals.get( getPntrToArgument(i)->getPositionInStream() );
-      else args[i-argstart] = getPntrToArgument(i)->get( getPntrToArgument(i)->getShape()[1]*index1 + ind2 );
+      if( getPntrToArgument(i)->getRank()==0 ) {
+        args[i-argstart] = getPntrToArgument(i)->get();
+      } else if( !getPntrToArgument(i)->valueHasBeenSet() ) {
+        args[i-argstart] = myvals.get( getPntrToArgument(i)->getPositionInStream() );
+      } else {
+        args[i-argstart] = getPntrToArgument(i)->get( getPntrToArgument(i)->getShape()[1]*index1 + ind2 );
+      }
     }
   } else {
     for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-      if( getPntrToArgument(i)->getRank()==2 ) args[i-argstart]=getPntrToArgument(i)->get( getPntrToArgument(i)->getShape()[1]*index1 + ind2 );
-      else args[i-argstart] = getPntrToArgument(i)->get();
+      if( getPntrToArgument(i)->getRank()==2 ) {
+        args[i-argstart]=getPntrToArgument(i)->get( getPntrToArgument(i)->getShape()[1]*index1 + ind2 );
+      } else {
+        args[i-argstart] = getPntrToArgument(i)->get();
+      }
     }
   }
   // Calculate the function and its derivatives
-  std::vector<double> vals( getNumberOfComponents() ); Matrix<double> derivatives( getNumberOfComponents(), getNumberOfArguments()-argstart );
+  std::vector<double> vals( getNumberOfComponents() );
+  Matrix<double> derivatives( getNumberOfComponents(), getNumberOfArguments()-argstart );
   myfunc.calc( this, args, vals, derivatives );
   // And set the values
-  for(unsigned i=0; i<vals.size(); ++i) myvals.addValue( getConstPntrToComponent(i)->getPositionInStream(), vals[i] );
+  for(unsigned i=0; i<vals.size(); ++i) {
+    myvals.addValue( getConstPntrToComponent(i)->getPositionInStream(), vals[i] );
+  }
   // Return if we are not computing derivatives
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
 
   if( actionInChain() ) {
     for(int i=0; i<getNumberOfComponents(); ++i) {
@@ -297,7 +375,9 @@ void FunctionOfMatrix<T>::performTask( const std::string& controller, const unsi
           unsigned istrn = getPntrToArgument(j)->getPositionInStream();
           if( stored_arguments[j] ) {
             unsigned task_index = getPntrToArgument(i)->getShape()[1]*index1 + ind2;
-            myvals.clearDerivatives(istrn); myvals.addDerivative( istrn, task_index, 1.0 ); myvals.updateIndex( istrn, task_index );
+            myvals.clearDerivatives(istrn);
+            myvals.addDerivative( istrn, task_index, 1.0 );
+            myvals.updateIndex( istrn, task_index );
           }
           for(unsigned k=0; k<myvals.getNumberActive(istrn); ++k) {
             unsigned kind=myvals.getActiveIndex(istrn,k);
@@ -311,13 +391,20 @@ void FunctionOfMatrix<T>::performTask( const std::string& controller, const unsi
       for(int i=0; i<getNumberOfComponents(); ++i) {
         unsigned ostrn=getConstPntrToComponent(i)->getPositionInStream();
         for(unsigned j=argstart; j<getNumberOfArguments(); ++j) {
-          if( !update_arguments[j] || getPntrToArgument(j)->getRank()==0 ) continue ;
+          if( !update_arguments[j] || getPntrToArgument(j)->getRank()==0 ) {
+            continue ;
+          }
           // Ensure we only store one lot of derivative indices
           bool found=false;
           for(unsigned k=0; k<j; ++k) {
-            if( arg_deriv_starts[k]==arg_deriv_starts[j] ) { found=true; break; }
+            if( arg_deriv_starts[k]==arg_deriv_starts[j] ) {
+              found=true;
+              break;
+            }
+          }
+          if( found ) {
+            continue;
           }
-          if( found ) continue;
           unsigned istrn = getPntrToArgument(j)->getPositionInStream();
           for(unsigned k=0; k<myvals.getNumberActive(istrn); ++k) {
             unsigned kind=myvals.getActiveIndex(istrn,k);
@@ -327,10 +414,15 @@ void FunctionOfMatrix<T>::performTask( const std::string& controller, const unsi
       }
     }
   } else {
-    unsigned base=0; ind2 = index2;
+    unsigned base=0;
+    ind2 = index2;
     for(unsigned j=argstart; j<getNumberOfArguments(); ++j) {
-      if( getPntrToArgument(j)->getRank()!=2 ) continue ;
-      if( index2>=getPntrToArgument(j)->getShape()[0] ) ind2 = index2 - getPntrToArgument(j)->getShape()[0];
+      if( getPntrToArgument(j)->getRank()!=2 ) {
+        continue ;
+      }
+      if( index2>=getPntrToArgument(j)->getShape()[0] ) {
+        ind2 = index2 - getPntrToArgument(j)->getShape()[0];
+      }
       break;
     }
     for(unsigned j=argstart; j<getNumberOfArguments(); ++j) {
@@ -355,23 +447,35 @@ void FunctionOfMatrix<T>::performTask( const std::string& controller, const unsi
 
 template <class T>
 void FunctionOfMatrix<T>::runEndOfRowJobs( const unsigned& ind, const std::vector<unsigned> & indices, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
 
   unsigned argstart=myfunc.getArgStart();
   if( actionInChain() && getConstPntrToComponent(0)->getRank()==2 ) {
     // This is triggered if we are outputting a matrix
     for(int vv=0; vv<getNumberOfComponents(); ++vv) {
       unsigned nmat = getConstPntrToComponent(vv)->getPositionInMatrixStash();
-      std::vector<unsigned>& mat_indices( myvals.getMatrixRowDerivativeIndices( nmat ) ); unsigned ntot_mat=0;
-      if( mat_indices.size()<nderivatives ) mat_indices.resize( nderivatives );
+      std::vector<unsigned>& mat_indices( myvals.getMatrixRowDerivativeIndices( nmat ) );
+      unsigned ntot_mat=0;
+      if( mat_indices.size()<nderivatives ) {
+        mat_indices.resize( nderivatives );
+      }
       for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-        if( !update_arguments[i] || getPntrToArgument(i)->getRank()==0 ) continue ;
+        if( !update_arguments[i] || getPntrToArgument(i)->getRank()==0 ) {
+          continue ;
+        }
         // Ensure we only store one lot of derivative indices
         bool found=false;
         for(unsigned j=0; j<i; ++j) {
-          if( arg_deriv_starts[j]==arg_deriv_starts[i] ) { found=true; break; }
+          if( arg_deriv_starts[j]==arg_deriv_starts[i] ) {
+            found=true;
+            break;
+          }
+        }
+        if( found ) {
+          continue;
         }
-        if( found ) continue;
 
         if( stored_arguments[i] ) {
           unsigned tbase = getPntrToArgument(i)->getShape()[1]*ind;
@@ -383,7 +487,9 @@ void FunctionOfMatrix<T>::runEndOfRowJobs( const unsigned& ind, const std::vecto
         } else {
           unsigned istrn = getPntrToArgument(i)->getPositionInMatrixStash();
           std::vector<unsigned>& imat_indices( myvals.getMatrixRowDerivativeIndices( istrn ) );
-          for(unsigned k=0; k<myvals.getNumberOfMatrixRowDerivatives( istrn ); ++k) mat_indices[ntot_mat + k] = arg_deriv_starts[i] + imat_indices[k];
+          for(unsigned k=0; k<myvals.getNumberOfMatrixRowDerivatives( istrn ); ++k) {
+            mat_indices[ntot_mat + k] = arg_deriv_starts[i] + imat_indices[k];
+          }
           ntot_mat += myvals.getNumberOfMatrixRowDerivatives( istrn );
         }
       }
@@ -394,9 +500,14 @@ void FunctionOfMatrix<T>::runEndOfRowJobs( const unsigned& ind, const std::vecto
     for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
       bool found=false;
       for(unsigned j=0; j<i; ++j) {
-        if( arg_deriv_starts[j]==arg_deriv_starts[i] ) { found=true; break; }
+        if( arg_deriv_starts[j]==arg_deriv_starts[i] ) {
+          found=true;
+          break;
+        }
+      }
+      if( found ) {
+        continue;
       }
-      if( found ) continue;
       unsigned istrn = getPntrToArgument(i)->getPositionInMatrixStash();
       std::vector<unsigned>& mat_indices( myvals.getMatrixRowDerivativeIndices( istrn ) );
       for(unsigned k=0; k<myvals.getNumberOfMatrixRowDerivatives( istrn ); ++k) {
@@ -409,13 +520,23 @@ void FunctionOfMatrix<T>::runEndOfRowJobs( const unsigned& ind, const std::vecto
   } else if( getConstPntrToComponent(0)->getRank()==2 ) {
     for(int vv=0; vv<getNumberOfComponents(); ++vv) {
       unsigned nmat = getConstPntrToComponent(vv)->getPositionInMatrixStash();
-      std::vector<unsigned>& mat_indices( myvals.getMatrixRowDerivativeIndices( nmat ) ); unsigned ntot_mat=0;
-      if( mat_indices.size()<nderivatives ) mat_indices.resize( nderivatives ); unsigned matderbase = 0;
+      std::vector<unsigned>& mat_indices( myvals.getMatrixRowDerivativeIndices( nmat ) );
+      unsigned ntot_mat=0;
+      if( mat_indices.size()<nderivatives ) {
+        mat_indices.resize( nderivatives );
+      }
+      unsigned matderbase = 0;
       for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-        if( getPntrToArgument(i)->getRank()==0 ) continue ;
-        unsigned ss = getPntrToArgument(i)->getShape()[1]; unsigned tbase = matderbase + ss*myvals.getTaskIndex();
-        for(unsigned k=0; k<ss; ++k) mat_indices[ntot_mat + k] = tbase + k;
-        ntot_mat += ss; matderbase += getPntrToArgument(i)->getNumberOfValues();
+        if( getPntrToArgument(i)->getRank()==0 ) {
+          continue ;
+        }
+        unsigned ss = getPntrToArgument(i)->getShape()[1];
+        unsigned tbase = matderbase + ss*myvals.getTaskIndex();
+        for(unsigned k=0; k<ss; ++k) {
+          mat_indices[ntot_mat + k] = tbase + k;
+        }
+        ntot_mat += ss;
+        matderbase += getPntrToArgument(i)->getNumberOfValues();
       }
       myvals.setNumberOfMatrixRowDerivatives( nmat, ntot_mat );
     }
@@ -424,16 +545,23 @@ void FunctionOfMatrix<T>::runEndOfRowJobs( const unsigned& ind, const std::vecto
 
 template <class T>
 std::vector<unsigned> FunctionOfMatrix<T>::getValueShapeFromArguments() {
-  unsigned argstart=myfunc.getArgStart(); std::vector<unsigned> shape(2); shape[0]=shape[1]=0;
+  unsigned argstart=myfunc.getArgStart();
+  std::vector<unsigned> shape(2);
+  shape[0]=shape[1]=0;
   for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
     plumed_assert( getPntrToArgument(i)->getRank()==2 || getPntrToArgument(i)->getRank()==0 );
     if( getPntrToArgument(i)->getRank()==2 ) {
-      if( shape[0]>0 && (getPntrToArgument(i)->getShape()[0]!=shape[0] || getPntrToArgument(i)->getShape()[1]!=shape[1]) ) error("all matrices input should have the same shape");
-      else if( shape[0]==0 ) { shape[0]=getPntrToArgument(i)->getShape()[0]; shape[1]=getPntrToArgument(i)->getShape()[1]; }
+      if( shape[0]>0 && (getPntrToArgument(i)->getShape()[0]!=shape[0] || getPntrToArgument(i)->getShape()[1]!=shape[1]) ) {
+        error("all matrices input should have the same shape");
+      } else if( shape[0]==0 ) {
+        shape[0]=getPntrToArgument(i)->getShape()[0];
+        shape[1]=getPntrToArgument(i)->getShape()[1];
+      }
       plumed_assert( !getPntrToArgument(i)->hasDerivatives() );
     }
   }
-  myfunc.setPrefactor( this, 1.0 ); return shape;
+  myfunc.setPrefactor( this, 1.0 );
+  return shape;
 }
 
 }
diff --git a/src/function/FunctionOfScalar.h b/src/function/FunctionOfScalar.h
index 00ab91197e..c7b909993f 100644
--- a/src/function/FunctionOfScalar.h
+++ b/src/function/FunctionOfScalar.h
@@ -45,7 +45,9 @@ class FunctionOfScalar : public Function {
   explicit FunctionOfScalar(const ActionOptions&);
   virtual ~FunctionOfScalar() {}
 /// Get the label to write in the graph
-  std::string writeInGraph() const override { return myfunc.getGraphInfo( getName() ); }
+  std::string writeInGraph() const override {
+    return myfunc.getGraphInfo( getName() );
+  }
   std::string getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const override ;
   void calculate() override;
   static void registerKeywords(Keywords&);
@@ -54,20 +56,26 @@ class FunctionOfScalar : public Function {
 
 template <class T>
 void FunctionOfScalar<T>::registerKeywords(Keywords& keys) {
-  Function::registerKeywords(keys); keys.use("ARG"); std::string name = keys.getDisplayName();
-  std::size_t und=name.find("_SCALAR"); keys.setDisplayName( name.substr(0,und) );
+  Function::registerKeywords(keys);
+  keys.use("ARG");
+  std::string name = keys.getDisplayName();
+  std::size_t und=name.find("_SCALAR");
+  keys.setDisplayName( name.substr(0,und) );
   keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
-  T tfunc; tfunc.registerKeywords( keys );
-  if( keys.getDisplayName()=="SUM" ) keys.setValueDescription("the sum of all the input arguments");
-  else if( keys.getDisplayName()=="MEAN" ) keys.setValueDescription("the mean of all the input arguments");
+  T tfunc;
+  tfunc.registerKeywords( keys );
+  if( keys.getDisplayName()=="SUM" ) {
+    keys.setValueDescription("the sum of all the input arguments");
+  } else if( keys.getDisplayName()=="MEAN" ) {
+    keys.setValueDescription("the mean of all the input arguments");
+  }
 }
 
 template <class T>
 FunctionOfScalar<T>::FunctionOfScalar(const ActionOptions&ao):
   Action(ao),
   Function(ao),
-  firststep(true)
-{
+  firststep(true) {
   myfunc.read( this );
   // Get the names of the components
   std::vector<std::string> components( keywords.getOutputComponents() );
@@ -75,42 +83,74 @@ FunctionOfScalar<T>::FunctionOfScalar(const ActionOptions&ao):
   std::vector<std::string> str_ind( myfunc.getComponentsPerLabel() );
   for(unsigned i=0; i<components.size(); ++i) {
     if( str_ind.size()>0 ) {
-      std::string compstr = components[i]; if( compstr==".#!value" ) compstr = "";
-      for(unsigned j=0; j<str_ind.size(); ++j) addComponentWithDerivatives( compstr + str_ind[j] );
-    } else if( components[i]==".#!value" ) addValueWithDerivatives();
-    else if( components[i].find_first_of("_")!=std::string::npos ) {
-      if( getNumberOfArguments()==1 ) addValueWithDerivatives();
-      else { for(unsigned j=0; j<getNumberOfArguments(); ++j) addComponentWithDerivatives( getPntrToArgument(j)->getName() + components[i] ); }
-    } else addComponentWithDerivatives( components[i] );
+      std::string compstr = components[i];
+      if( compstr==".#!value" ) {
+        compstr = "";
+      }
+      for(unsigned j=0; j<str_ind.size(); ++j) {
+        addComponentWithDerivatives( compstr + str_ind[j] );
+      }
+    } else if( components[i]==".#!value" ) {
+      addValueWithDerivatives();
+    } else if( components[i].find_first_of("_")!=std::string::npos ) {
+      if( getNumberOfArguments()==1 ) {
+        addValueWithDerivatives();
+      } else {
+        for(unsigned j=0; j<getNumberOfArguments(); ++j) {
+          addComponentWithDerivatives( getPntrToArgument(j)->getName() + components[i] );
+        }
+      }
+    } else {
+      addComponentWithDerivatives( components[i] );
+    }
   }
   // Set the periodicities of the output components
-  myfunc.setPeriodicityForOutputs( this ); myfunc.setPrefactor( this, 1.0 );
+  myfunc.setPeriodicityForOutputs( this );
+  myfunc.setPrefactor( this, 1.0 );
 }
 
 template <class T>
 std::string FunctionOfScalar<T>::getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const {
-  if( getName().find("SORT")==std::string::npos ) return ActionWithValue::getOutputComponentDescription( cname, keys );
+  if( getName().find("SORT")==std::string::npos ) {
+    return ActionWithValue::getOutputComponentDescription( cname, keys );
+  }
   return "the " + cname + "th largest of the input scalars";
 }
 
 template <class T>
 void FunctionOfScalar<T>::turnOnDerivatives() {
-  if( !myfunc.derivativesImplemented() ) error("derivatives have not been implemended for " + getName() );
+  if( !myfunc.derivativesImplemented() ) {
+    error("derivatives have not been implemended for " + getName() );
+  }
   ActionWithValue::turnOnDerivatives();
 }
 
 template <class T>
 void FunctionOfScalar<T>::calculate() {
-  if( firststep ) { myfunc.setup( this ); firststep=false; } unsigned argstart = myfunc.getArgStart();
-  std::vector<double> args( getNumberOfArguments() - argstart ); for(unsigned i=argstart; i<getNumberOfArguments(); ++i) args[i-argstart]=getPntrToArgument(i)->get();
-  std::vector<double> vals( getNumberOfComponents() ); Matrix<double> derivatives( getNumberOfComponents(), args.size() );
+  if( firststep ) {
+    myfunc.setup( this );
+    firststep=false;
+  }
+  unsigned argstart = myfunc.getArgStart();
+  std::vector<double> args( getNumberOfArguments() - argstart );
+  for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
+    args[i-argstart]=getPntrToArgument(i)->get();
+  }
+  std::vector<double> vals( getNumberOfComponents() );
+  Matrix<double> derivatives( getNumberOfComponents(), args.size() );
   myfunc.calc( this, args, vals, derivatives );
-  for(unsigned i=0; i<vals.size(); ++i) copyOutput(i)->set(vals[i]);
-  if( doNotCalculateDerivatives() ) return;
+  for(unsigned i=0; i<vals.size(); ++i) {
+    copyOutput(i)->set(vals[i]);
+  }
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
 
   for(unsigned i=0; i<vals.size(); ++i) {
     Value* val = getPntrToComponent(i);
-    for(unsigned j=0; j<args.size(); ++j) setDerivative( val, j, derivatives(i,j) );
+    for(unsigned j=0; j<args.size(); ++j) {
+      setDerivative( val, j, derivatives(i,j) );
+    }
   }
 }
 
diff --git a/src/function/FunctionOfVector.h b/src/function/FunctionOfVector.h
index bb962cf924..3ad9d4d926 100644
--- a/src/function/FunctionOfVector.h
+++ b/src/function/FunctionOfVector.h
@@ -63,7 +63,9 @@ class FunctionOfVector : public ActionWithVector {
 /// Check if all he actions are required
   void areAllTasksRequired( std::vector<ActionWithVector*>& task_reducing_actions );
 /// Get the label to write in the graph
-  std::string writeInGraph() const override { return myfunc.getGraphInfo( getName() ); }
+  std::string writeInGraph() const override {
+    return myfunc.getGraphInfo( getName() );
+  }
 /// This builds the task list for the action
   void calculate() override;
 /// This ensures that we create some bookeeping stuff during the first step
@@ -74,11 +76,17 @@ class FunctionOfVector : public ActionWithVector {
 
 template <class T>
 void FunctionOfVector<T>::registerKeywords(Keywords& keys ) {
-  Action::registerKeywords(keys); ActionWithValue::registerKeywords(keys); ActionWithArguments::registerKeywords(keys); keys.use("ARG");
-  std::string name = keys.getDisplayName(); std::size_t und=name.find("_VECTOR"); keys.setDisplayName( name.substr(0,und) );
+  Action::registerKeywords(keys);
+  ActionWithValue::registerKeywords(keys);
+  ActionWithArguments::registerKeywords(keys);
+  keys.use("ARG");
+  std::string name = keys.getDisplayName();
+  std::size_t und=name.find("_VECTOR");
+  keys.setDisplayName( name.substr(0,und) );
   keys.reserve("compulsory","PERIODIC","if the output of your function is periodic then you should specify the periodicity of the function.  If the output is not periodic you must state this using PERIODIC=NO");
   keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
-  T tfunc; tfunc.registerKeywords( keys );
+  T tfunc;
+  tfunc.registerKeywords( keys );
   if( keys.getDisplayName()=="SUM" ) {
     keys.setValueDescription("the sum of all the elements in the input vector");
   } else if( keys.getDisplayName()=="MEAN" ) {
@@ -100,45 +108,70 @@ FunctionOfVector<T>::FunctionOfVector(const ActionOptions&ao):
   ActionWithVector(ao),
   doAtEnd(true),
   firststep(true),
-  nderivatives(0)
-{
+  nderivatives(0) {
   // Get the shape of the output
-  std::vector<unsigned> shape(1); shape[0]=getNumberOfFinalTasks();
+  std::vector<unsigned> shape(1);
+  shape[0]=getNumberOfFinalTasks();
   // Read the input and do some checks
   myfunc.read( this );
   // Create the task list
   if( myfunc.doWithTasks() ) {
-    doAtEnd=false; if( shape[0]>0 ) done_in_chain=true;
-  } else { plumed_assert( getNumberOfArguments()==1 ); done_in_chain=false; getPntrToArgument(0)->buildDataStore(); }
+    doAtEnd=false;
+    if( shape[0]>0 ) {
+      done_in_chain=true;
+    }
+  } else {
+    plumed_assert( getNumberOfArguments()==1 );
+    done_in_chain=false;
+    getPntrToArgument(0)->buildDataStore();
+  }
   // Get the names of the components
   std::vector<std::string> components( keywords.getOutputComponents() );
   // Create the values to hold the output
   std::vector<std::string> str_ind( myfunc.getComponentsPerLabel() );
   for(unsigned i=0; i<components.size(); ++i) {
     if( str_ind.size()>0 ) {
-      std::string strcompn = components[i]; if( components[i]==".#!value" ) strcompn = "";
+      std::string strcompn = components[i];
+      if( components[i]==".#!value" ) {
+        strcompn = "";
+      }
       for(unsigned j=0; j<str_ind.size(); ++j) {
-        if( myfunc.zeroRank() ) addComponentWithDerivatives( strcompn + str_ind[j] );
-        else addComponent( strcompn + str_ind[j], shape );
+        if( myfunc.zeroRank() ) {
+          addComponentWithDerivatives( strcompn + str_ind[j] );
+        } else {
+          addComponent( strcompn + str_ind[j], shape );
+        }
       }
     } else if( components[i].find_first_of("_")!=std::string::npos ) {
-      if( getNumberOfArguments()==1 && myfunc.zeroRank() ) addValueWithDerivatives();
-      else if( getNumberOfArguments()==1 ) addValue( shape );
-      else {
+      if( getNumberOfArguments()==1 && myfunc.zeroRank() ) {
+        addValueWithDerivatives();
+      } else if( getNumberOfArguments()==1 ) {
+        addValue( shape );
+      } else {
         unsigned argstart=myfunc.getArgStart();
         for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-          if( myfunc.zeroRank() ) addComponentWithDerivatives( getPntrToArgument(i)->getName() + components[i] );
-          else addComponent( getPntrToArgument(i)->getName() + components[i], shape );
+          if( myfunc.zeroRank() ) {
+            addComponentWithDerivatives( getPntrToArgument(i)->getName() + components[i] );
+          } else {
+            addComponent( getPntrToArgument(i)->getName() + components[i], shape );
+          }
         }
       }
-    } else if( components[i]==".#!value" && myfunc.zeroRank() ) addValueWithDerivatives();
-    else if( components[i]==".#!value" ) addValue(shape);
-    else if( myfunc.zeroRank() ) addComponentWithDerivatives( components[i] );
-    else addComponent( components[i], shape );
+    } else if( components[i]==".#!value" && myfunc.zeroRank() ) {
+      addValueWithDerivatives();
+    } else if( components[i]==".#!value" ) {
+      addValue(shape);
+    } else if( myfunc.zeroRank() ) {
+      addComponentWithDerivatives( components[i] );
+    } else {
+      addComponent( components[i], shape );
+    }
   }
   // Check if we can turn off the derivatives when they are zero
   if( myfunc.getDerivativeZeroIfValueIsZero() )  {
-    for(int i=0; i<getNumberOfComponents(); ++i) getPntrToComponent(i)->setDerivativeIsZeroWhenValueIsZero();
+    for(int i=0; i<getNumberOfComponents(); ++i) {
+      getPntrToComponent(i)->setDerivativeIsZeroWhenValueIsZero();
+    }
   }
   // Check if this is a timeseries
   unsigned argstart=myfunc.getArgStart();
@@ -157,32 +190,48 @@ FunctionOfVector<T>::FunctionOfVector(const ActionOptions&ao):
     // No chains if we are using a sum or a mean
     if( getPntrToArgument(i)->getRank()==0 ) {
       FunctionOfVector<Sum>* as = dynamic_cast<FunctionOfVector<Sum>*>( getPntrToArgument(i)->getPntrToAction() );
-      if(as) done_in_chain=false;
+      if(as) {
+        done_in_chain=false;
+      }
     } else {
       ActionWithVector* av=dynamic_cast<ActionWithVector*>( getPntrToArgument(i)->getPntrToAction() );
-      if( !av ) done_in_chain=false;
+      if( !av ) {
+        done_in_chain=false;
+      }
     }
   }
   // Don't need to do the calculation in a chain if the input is constant
   bool allconstant=true;
   for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-    if( !getPntrToArgument(i)->isConstant() ) { allconstant=false; break; }
+    if( !getPntrToArgument(i)->isConstant() ) {
+      allconstant=false;
+      break;
+    }
+  }
+  if( allconstant ) {
+    done_in_chain=false;
   }
-  if( allconstant ) done_in_chain=false;
   nderivatives = buildArgumentStore(myfunc.getArgStart());
 }
 
 template <class T>
 std::string FunctionOfVector<T>::getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const {
-  if( getName().find("SORT")==std::string::npos ) return ActionWithValue::getOutputComponentDescription( cname, keys );
-  if( getNumberOfArguments()==1 ) return "the " + cname + "th largest element of the vector " + getPntrToArgument(0)->getName();
+  if( getName().find("SORT")==std::string::npos ) {
+    return ActionWithValue::getOutputComponentDescription( cname, keys );
+  }
+  if( getNumberOfArguments()==1 ) {
+    return "the " + cname + "th largest element of the vector " + getPntrToArgument(0)->getName();
+  }
   return "the " + cname + "th largest element in the input vectors";
 }
 
 template <class T>
 void FunctionOfVector<T>::turnOnDerivatives() {
-  if( !getPntrToComponent(0)->isConstant() && !myfunc.derivativesImplemented() ) error("derivatives have not been implemended for " + getName() );
-  ActionWithValue::turnOnDerivatives(); myfunc.setup(this );
+  if( !getPntrToComponent(0)->isConstant() && !myfunc.derivativesImplemented() ) {
+    error("derivatives have not been implemended for " + getName() );
+  }
+  ActionWithValue::turnOnDerivatives();
+  myfunc.setup(this );
 }
 
 template <class T>
@@ -192,15 +241,19 @@ unsigned FunctionOfVector<T>::getNumberOfDerivatives() {
 
 template <class T>
 void FunctionOfVector<T>::prepare() {
-  unsigned argstart = myfunc.getArgStart(); std::vector<unsigned> shape(1);
+  unsigned argstart = myfunc.getArgStart();
+  std::vector<unsigned> shape(1);
   for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
     if( getPntrToArgument(i)->getRank()==1 ) {
-      shape[0] = getPntrToArgument(i)->getShape()[0]; break;
+      shape[0] = getPntrToArgument(i)->getShape()[0];
+      break;
     }
   }
   for(unsigned i=0; i<getNumberOfComponents(); ++i) {
     Value* myval = getPntrToComponent(i);
-    if( myval->getRank()==1 && myval->getShape()[0]!=shape[0] ) { myval->setShape(shape); }
+    if( myval->getRank()==1 && myval->getShape()[0]!=shape[0] ) {
+      myval->setShape(shape);
+    }
   }
   ActionWithVector::prepare();
 }
@@ -211,8 +264,11 @@ void FunctionOfVector<T>::setupStreamedComponents( const std::string& headstr, u
     stored_arguments.resize( getNumberOfArguments() );
     std::string control = getFirstActionInChain()->getLabel();
     for(unsigned i=0; i<stored_arguments.size(); ++i) {
-      if( getPntrToArgument(i)->isConstant() ) stored_arguments[i]=false;
-      else stored_arguments[i] = !getPntrToArgument(i)->ignoreStoredValue( control );
+      if( getPntrToArgument(i)->isConstant() ) {
+        stored_arguments[i]=false;
+      } else {
+        stored_arguments[i] = !getPntrToArgument(i)->ignoreStoredValue( control );
+      }
     }
     firststep=false;
   }
@@ -221,26 +277,39 @@ void FunctionOfVector<T>::setupStreamedComponents( const std::string& headstr, u
 
 template <class T>
 void FunctionOfVector<T>::performTask( const unsigned& current, MultiValue& myvals ) const {
-  unsigned argstart=myfunc.getArgStart(); std::vector<double> args( getNumberOfArguments()-argstart);
+  unsigned argstart=myfunc.getArgStart();
+  std::vector<double> args( getNumberOfArguments()-argstart);
   if( actionInChain() ) {
     for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-      if(  getPntrToArgument(i)->getRank()==0 ) args[i-argstart] = getPntrToArgument(i)->get();
-      else if( !getPntrToArgument(i)->valueHasBeenSet() ) args[i-argstart] = myvals.get( getPntrToArgument(i)->getPositionInStream() );
-      else args[i-argstart] = getPntrToArgument(i)->get( myvals.getTaskIndex() );
+      if(  getPntrToArgument(i)->getRank()==0 ) {
+        args[i-argstart] = getPntrToArgument(i)->get();
+      } else if( !getPntrToArgument(i)->valueHasBeenSet() ) {
+        args[i-argstart] = myvals.get( getPntrToArgument(i)->getPositionInStream() );
+      } else {
+        args[i-argstart] = getPntrToArgument(i)->get( myvals.getTaskIndex() );
+      }
     }
   } else {
     for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-      if( getPntrToArgument(i)->getRank()==1 ) args[i-argstart]=getPntrToArgument(i)->get(current);
-      else args[i-argstart] = getPntrToArgument(i)->get();
+      if( getPntrToArgument(i)->getRank()==1 ) {
+        args[i-argstart]=getPntrToArgument(i)->get(current);
+      } else {
+        args[i-argstart] = getPntrToArgument(i)->get();
+      }
     }
   }
   // Calculate the function and its derivatives
-  std::vector<double> vals( getNumberOfComponents() ); Matrix<double> derivatives( getNumberOfComponents(), args.size() );
+  std::vector<double> vals( getNumberOfComponents() );
+  Matrix<double> derivatives( getNumberOfComponents(), args.size() );
   myfunc.calc( this, args, vals, derivatives );
   // And set the values
-  for(unsigned i=0; i<vals.size(); ++i) myvals.addValue( getConstPntrToComponent(i)->getPositionInStream(), vals[i] );
+  for(unsigned i=0; i<vals.size(); ++i) {
+    myvals.addValue( getConstPntrToComponent(i)->getPositionInStream(), vals[i] );
+  }
   // Return if we are not computing derivatives
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
   // And now compute the derivatives
   // Second condition here is only not true if actionInChain()==True if
   // input arguments the only non-constant objects in input are scalars.
@@ -250,8 +319,12 @@ void FunctionOfVector<T>::performTask( const unsigned& current, MultiValue& myva
     for(unsigned j=0; j<args.size(); ++j) {
       unsigned istrn = getPntrToArgument(argstart+j)->getPositionInStream();
       if( stored_arguments[argstart+j] ) {
-        unsigned task_index = myvals.getTaskIndex(); if( getPntrToArgument(argstart+j)->getRank()==0 ) task_index=0;
-        myvals.addDerivative( istrn, task_index, 1.0 ); myvals.updateIndex( istrn, task_index );
+        unsigned task_index = myvals.getTaskIndex();
+        if( getPntrToArgument(argstart+j)->getRank()==0 ) {
+          task_index=0;
+        }
+        myvals.addDerivative( istrn, task_index, 1.0 );
+        myvals.updateIndex( istrn, task_index );
       }
       unsigned arg_deriv_s = arg_deriv_starts[argstart+j];
       for(unsigned k=0; k<myvals.getNumberActive(istrn); ++k) {
@@ -262,19 +335,25 @@ void FunctionOfVector<T>::performTask( const unsigned& current, MultiValue& myva
         }
       }
       // Ensure we only store one lot of derivative indices
-      bool found=false; ActionWithValue* aav=getPntrToArgument(argstart+j)->getPntrToAction();
+      bool found=false;
+      ActionWithValue* aav=getPntrToArgument(argstart+j)->getPntrToAction();
       for(unsigned k=0; k<j; ++k) {
         if( arg_deriv_starts[argstart+k]==arg_deriv_s ) {
           if( getPntrToArgument(argstart+k)->getPntrToAction()!=aav ) {
             ActionWithVector* av = dynamic_cast<ActionWithVector*>( getPntrToArgument(argstart+j)->getPntrToAction() );
             if( av ) {
-              for(int i=0; i<getNumberOfComponents(); ++i) av->updateAdditionalIndices( getConstPntrToComponent(i)->getPositionInStream(), myvals );
+              for(int i=0; i<getNumberOfComponents(); ++i) {
+                av->updateAdditionalIndices( getConstPntrToComponent(i)->getPositionInStream(), myvals );
+              }
             }
           }
-          found=true; break;
+          found=true;
+          break;
         }
       }
-      if( found ) continue;
+      if( found ) {
+        continue;
+      }
       for(unsigned k=0; k<myvals.getNumberActive(istrn); ++k) {
         unsigned kind=myvals.getActiveIndex(istrn,k);
         for(int i=0; i<getNumberOfComponents(); ++i) {
@@ -313,8 +392,12 @@ unsigned FunctionOfVector<T>::getNumberOfFinalTasks() {
       if( nelements>0 ) {
         // if( getPntrToArgument(i)->isTimeSeries() && getPntrToArgument(i)->getShape()[0]<nelements ) nelements=getPntrToArgument(i)->isTimeSeries();
         // else
-        if(getPntrToArgument(i)->getShape()[0]!=nelements ) error("all vectors input should have the same length");
-      } else if( nelements==0 ) nelements=getPntrToArgument(i)->getShape()[0];
+        if(getPntrToArgument(i)->getShape()[0]!=nelements ) {
+          error("all vectors input should have the same length");
+        }
+      } else if( nelements==0 ) {
+        nelements=getPntrToArgument(i)->getShape()[0];
+      }
       plumed_assert( !getPntrToArgument(i)->hasDerivatives() );
     }
   }
@@ -325,34 +408,56 @@ unsigned FunctionOfVector<T>::getNumberOfFinalTasks() {
 
 template <class T>
 void FunctionOfVector<T>::areAllTasksRequired( std::vector<ActionWithVector*>& task_reducing_actions ) {
-  if( task_reducing_actions.size()==0 ) return;
-  if( !myfunc.allComponentsRequired( getArguments(), task_reducing_actions ) ) task_reducing_actions.push_back(this);
+  if( task_reducing_actions.size()==0 ) {
+    return;
+  }
+  if( !myfunc.allComponentsRequired( getArguments(), task_reducing_actions ) ) {
+    task_reducing_actions.push_back(this);
+  }
 }
 
 template <class T>
 void FunctionOfVector<T>::runSingleTaskCalculation( const Value* arg, ActionWithValue* action, T& f ) {
   // This is used if we are doing sorting actions on a single vector
-  unsigned nv = arg->getNumberOfValues(); std::vector<double> args( nv );
-  for(unsigned i=0; i<nv; ++i) args[i] = arg->get(i);
-  std::vector<double> vals( action->getNumberOfComponents() ); Matrix<double> derivatives( action->getNumberOfComponents(), nv );
-  ActionWithArguments* aa=dynamic_cast<ActionWithArguments*>(action); plumed_assert( aa ); f.calc( aa, args, vals, derivatives );
-  for(unsigned i=0; i<vals.size(); ++i) action->copyOutput(i)->set( vals[i] );
+  unsigned nv = arg->getNumberOfValues();
+  std::vector<double> args( nv );
+  for(unsigned i=0; i<nv; ++i) {
+    args[i] = arg->get(i);
+  }
+  std::vector<double> vals( action->getNumberOfComponents() );
+  Matrix<double> derivatives( action->getNumberOfComponents(), nv );
+  ActionWithArguments* aa=dynamic_cast<ActionWithArguments*>(action);
+  plumed_assert( aa );
+  f.calc( aa, args, vals, derivatives );
+  for(unsigned i=0; i<vals.size(); ++i) {
+    action->copyOutput(i)->set( vals[i] );
+  }
   // Return if we are not computing derivatives
-  if( action->doNotCalculateDerivatives() ) return;
+  if( action->doNotCalculateDerivatives() ) {
+    return;
+  }
   // Now set the derivatives
   for(unsigned j=0; j<nv; ++j) {
-    for(unsigned i=0; i<vals.size(); ++i) action->copyOutput(i)->setDerivative( j, derivatives(i,j) );
+    for(unsigned i=0; i<vals.size(); ++i) {
+      action->copyOutput(i)->setDerivative( j, derivatives(i,j) );
+    }
   }
 }
 
 template <class T>
 void FunctionOfVector<T>::calculate() {
   // Everything is done elsewhere
-  if( actionInChain() ) return;
+  if( actionInChain() ) {
+    return;
+  }
   // This is done if we are calculating a function of multiple cvs
-  if( !doAtEnd ) runAllTasks();
+  if( !doAtEnd ) {
+    runAllTasks();
+  }
   // This is used if we are doing sorting actions on a single vector
-  else if( !myfunc.doWithTasks() ) runSingleTaskCalculation( getPntrToArgument(0), this, myfunc );
+  else if( !myfunc.doWithTasks() ) {
+    runSingleTaskCalculation( getPntrToArgument(0), this, myfunc );
+  }
 }
 
 }
diff --git a/src/function/FunctionShortcut.h b/src/function/FunctionShortcut.h
index 7a730dbddb..9a2ac9b89c 100644
--- a/src/function/FunctionShortcut.h
+++ b/src/function/FunctionShortcut.h
@@ -48,42 +48,71 @@ void FunctionShortcut<T>::registerKeywords(Keywords& keys ) {
   ActionShortcut::registerKeywords( keys );
   keys.add("numbered","ARG","the input to this function");
   keys.reserve("compulsory","PERIODIC","if the output of your function is periodic then you should specify the periodicity of the function.  If the output is not periodic you must state this using PERIODIC=NO");
-  keys.addActionNameSuffix("_SCALAR"); keys.addActionNameSuffix("_VECTOR"); keys.addActionNameSuffix("_MATRIX"); keys.addActionNameSuffix("_GRID");
-  T tfunc; tfunc.registerKeywords( keys );
+  keys.addActionNameSuffix("_SCALAR");
+  keys.addActionNameSuffix("_VECTOR");
+  keys.addActionNameSuffix("_MATRIX");
+  keys.addActionNameSuffix("_GRID");
+  T tfunc;
+  tfunc.registerKeywords( keys );
 }
 
 template <class T>
 FunctionShortcut<T>::FunctionShortcut(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::vector<std::string> args; parseVector("ARG",args);
-  std::string allargs=args[0]; for(unsigned i=1; i<args.size(); ++i) allargs += "," + args[i];
-  std::vector<Value*> vals; ActionWithArguments::interpretArgumentList( args, plumed.getActionSet(), this, vals );
-  if( vals.size()==0 ) error("found no input arguments to function");
+  ActionShortcut(ao) {
+  std::vector<std::string> args;
+  parseVector("ARG",args);
+  std::string allargs=args[0];
+  for(unsigned i=1; i<args.size(); ++i) {
+    allargs += "," + args[i];
+  }
+  std::vector<Value*> vals;
+  ActionWithArguments::interpretArgumentList( args, plumed.getActionSet(), this, vals );
+  if( vals.size()==0 ) {
+    error("found no input arguments to function");
+  }
   createAction( this, vals, allargs );
 }
 
 template <class T>
 void FunctionShortcut<T>::createAction( ActionShortcut* action, const std::vector<Value*>& vals, const std::string& allargs ) {
-  unsigned maxrank=vals[0]->getRank(); bool isgrid=false;
+  unsigned maxrank=vals[0]->getRank();
+  bool isgrid=false;
   for(unsigned i=0; i<vals.size(); ++i) {
-    if( vals[i]->getRank()>0 && vals[i]->hasDerivatives() ) isgrid=true;
-    if( vals[i]->getRank()>maxrank ) maxrank=vals[i]->getRank();
+    if( vals[i]->getRank()>0 && vals[i]->hasDerivatives() ) {
+      isgrid=true;
+    }
+    if( vals[i]->getRank()>maxrank ) {
+      maxrank=vals[i]->getRank();
+    }
   }
   if( isgrid ) {
-    if( actionRegister().check( action->getName() + "_GRID") ) action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_GRID ARG=" + allargs + " " + action->convertInputLineToString() );
-    else plumed_merror("there is no action registered that allows you to do " + action->getName() + " with functions on a grid");
+    if( actionRegister().check( action->getName() + "_GRID") ) {
+      action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_GRID ARG=" + allargs + " " + action->convertInputLineToString() );
+    } else {
+      plumed_merror("there is no action registered that allows you to do " + action->getName() + " with functions on a grid");
+    }
   } else if( maxrank==0 ) {
-    if( actionRegister().check( action->getName() + "_SCALAR") ) action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_SCALAR ARG=" + allargs + " " + action->convertInputLineToString() );
-    else plumed_merror("there is no action registered that allows you to do " + action->getName() + " with scalars");
+    if( actionRegister().check( action->getName() + "_SCALAR") ) {
+      action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_SCALAR ARG=" + allargs + " " + action->convertInputLineToString() );
+    } else {
+      plumed_merror("there is no action registered that allows you to do " + action->getName() + " with scalars");
+    }
   } else if( maxrank==1 ) {
-    if( actionRegister().check( action->getName() + "_VECTOR") ) action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_VECTOR ARG=" + allargs + " " + action->convertInputLineToString() );
-    else plumed_merror("there is no action registered that allows you to do " + action->getName() + " with vectors");
+    if( actionRegister().check( action->getName() + "_VECTOR") ) {
+      action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_VECTOR ARG=" + allargs + " " + action->convertInputLineToString() );
+    } else {
+      plumed_merror("there is no action registered that allows you to do " + action->getName() + " with vectors");
+    }
   } else if( maxrank==2  ) {
-    if( actionRegister().check( action->getName() + "_MATRIX") ) action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_MATRIX ARG=" + allargs + " " + action->convertInputLineToString() );
-    else plumed_merror("there is no action registered that allows you to do " + action->getName() + " with matrices");
-  } else plumed_error();
+    if( actionRegister().check( action->getName() + "_MATRIX") ) {
+      action->readInputLine( action->getShortcutLabel() + ": " + action->getName() + "_MATRIX ARG=" + allargs + " " + action->convertInputLineToString() );
+    } else {
+      plumed_merror("there is no action registered that allows you to do " + action->getName() + " with matrices");
+    }
+  } else {
+    plumed_error();
+  }
 }
 
 }
diff --git a/src/function/FunctionTemplateBase.h b/src/function/FunctionTemplateBase.h
index 27bd657feb..ab723d97e3 100644
--- a/src/function/FunctionTemplateBase.h
+++ b/src/function/FunctionTemplateBase.h
@@ -44,20 +44,30 @@ class FunctionTemplateBase {
   void parseFlag( Action* action, const std::string&key, bool&t );
 public:
 /// Override this function if you have not implemented the derivatives
-  virtual bool derivativesImplemented() { return true; }
+  virtual bool derivativesImplemented() {
+    return true;
+  }
 ////
   virtual std::vector<std::string> getComponentsPerLabel() const ;
-  virtual bool getDerivativeZeroIfValueIsZero() const { return false; }
+  virtual bool getDerivativeZeroIfValueIsZero() const {
+    return false;
+  }
   virtual std::string getGraphInfo( const std::string& lab ) const ;
   virtual void registerKeywords( Keywords& keys ) = 0;
   virtual void read( ActionWithArguments* action ) = 0;
-  virtual bool doWithTasks() const { return true; }
+  virtual bool doWithTasks() const {
+    return true;
+  }
   virtual std::vector<Value*> getArgumentsToCheck( const std::vector<Value*>& args );
   bool allComponentsRequired( const std::vector<Value*>& args, const std::vector<ActionWithVector*>& actions );
-  virtual bool zeroRank() const { return false; }
+  virtual bool zeroRank() const {
+    return false;
+  }
   virtual void setPeriodicityForOutputs( ActionWithValue* action );
   virtual void setPrefactor( ActionWithArguments* action, const double pref ) {}
-  virtual unsigned getArgStart() const { return 0; }
+  virtual unsigned getArgStart() const {
+    return 0;
+  }
   virtual void setup( ActionWithValue* action );
   virtual void calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const = 0;
 };
@@ -79,16 +89,21 @@ void FunctionTemplateBase::parseFlag( Action* action, const std::string&key, boo
 
 inline
 std::vector<std::string> FunctionTemplateBase::getComponentsPerLabel() const {
-  std::vector<std::string> comps; return comps;
+  std::vector<std::string> comps;
+  return comps;
 }
 
 inline
 void FunctionTemplateBase::setup( ActionWithValue* action ) {
   noderiv=action->doNotCalculateDerivatives();
   // Check for grids in input
-  ActionWithArguments* aarg=dynamic_cast<ActionWithArguments*>( action ); plumed_assert( aarg );
+  ActionWithArguments* aarg=dynamic_cast<ActionWithArguments*>( action );
+  plumed_assert( aarg );
   for(unsigned i=0; i<aarg->getNumberOfArguments(); ++i) {
-    if( aarg->getPntrToArgument(i)->getRank()>0 && aarg->getPntrToArgument(i)->hasDerivatives() ) { noderiv=false; break; }
+    if( aarg->getPntrToArgument(i)->getRank()>0 && aarg->getPntrToArgument(i)->hasDerivatives() ) {
+      noderiv=false;
+      break;
+    }
   }
 }
 
@@ -96,13 +111,21 @@ inline
 void FunctionTemplateBase::setPeriodicityForOutputs( ActionWithValue* action ) {
   plumed_massert( action->getNumberOfComponents()==1,"you must defined a setPeriodicityForOutputs function in your function class");
   if( action->keywords.exists("PERIODIC") ) {
-    std::vector<std::string> period; parseVector(action,"PERIODIC",period);
+    std::vector<std::string> period;
+    parseVector(action,"PERIODIC",period);
     if( period.size()==1 ) {
-      if( period[0]!="NO") action->error("input to PERIODIC keyword does not make sense");
-      action->setNotPeriodic(); return;
-    } else if( period.size()!=2 ) action->error("input to PERIODIC keyword does not make sense");
+      if( period[0]!="NO") {
+        action->error("input to PERIODIC keyword does not make sense");
+      }
+      action->setNotPeriodic();
+      return;
+    } else if( period.size()!=2 ) {
+      action->error("input to PERIODIC keyword does not make sense");
+    }
     action->setPeriodic( period[0], period[1] );
-  } else action->setNotPeriodic();
+  } else {
+    action->setNotPeriodic();
+  }
 }
 
 inline
@@ -115,19 +138,27 @@ bool FunctionTemplateBase::allComponentsRequired( const std::vector<Value*>& arg
   std::vector<Value*> checkArgs = getArgumentsToCheck( args );
   for(unsigned i=0; i<checkArgs.size(); ++i ) {
     ActionWithVector* av = dynamic_cast<ActionWithVector*>( checkArgs[i]->getPntrToAction() );
-    if( !av ) return false;
+    if( !av ) {
+      return false;
+    }
     bool found=false;
     for(unsigned j=0; j<actions.size(); ++j) {
-      if( actions[j]==av ) { found=true; break; }
+      if( actions[j]==av ) {
+        found=true;
+        break;
+      }
+    }
+    if( !found ) {
+      return true;
     }
-    if( !found ) return true;
   }
   return false;
 }
 
 inline
 std::string FunctionTemplateBase::getGraphInfo( const std::string& name ) const {
-  std::size_t und = name.find_last_of("_"); return name.substr(0,und);
+  std::size_t und = name.find_last_of("_");
+  return name.substr(0,und);
 }
 
 }
diff --git a/src/function/Highest.cpp b/src/function/Highest.cpp
index c66ddfa6b7..7ea6cc9a62 100644
--- a/src/function/Highest.cpp
+++ b/src/function/Highest.cpp
@@ -88,8 +88,12 @@ class Highest : public FunctionTemplateBase {
 public:
   void registerKeywords( Keywords& keys ) override ;
   void read( ActionWithArguments* action ) override;
-  bool zeroRank() const override { return scalar_out; }
-  bool doWithTasks() const override { return !scalar_out; }
+  bool zeroRank() const override {
+    return scalar_out;
+  }
+  bool doWithTasks() const override {
+    return !scalar_out;
+  }
   void calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const override;
 };
 
@@ -104,17 +108,27 @@ PLUMED_REGISTER_ACTION(VectorHighest,"HIGHEST_VECTOR")
 PLUMED_REGISTER_ACTION(VectorHighest,"LOWEST_VECTOR")
 
 void Highest::registerKeywords( Keywords& keys ) {
-  if( keys.getDisplayName().find("LOWEST") ) keys.setValueDescription("the lowest of the input values");
-  else keys.setValueDescription("the highest of the input values");
+  if( keys.getDisplayName().find("LOWEST") ) {
+    keys.setValueDescription("the lowest of the input values");
+  } else {
+    keys.setValueDescription("the highest of the input values");
+  }
 }
 
 void Highest::read( ActionWithArguments* action ) {
-  min=action->getName().find("LOWEST")!=std::string::npos; if( !min ) plumed_assert( action->getName().find("HIGHEST")!=std::string::npos );
+  min=action->getName().find("LOWEST")!=std::string::npos;
+  if( !min ) {
+    plumed_assert( action->getName().find("HIGHEST")!=std::string::npos );
+  }
   for(unsigned i=0; i<action->getNumberOfArguments(); ++i) {
-    if( action->getPntrToArgument(i)->isPeriodic() ) action->error("Cannot sort periodic values (check argument "+ action->getPntrToArgument(i)->getName() +")");
+    if( action->getPntrToArgument(i)->isPeriodic() ) {
+      action->error("Cannot sort periodic values (check argument "+ action->getPntrToArgument(i)->getName() +")");
+    }
   }
   scalar_out = action->getNumberOfArguments()==1;
-  if( scalar_out && action->getPntrToArgument(0)->getRank()==0 ) action->error("sorting a single scalar is trivial");
+  if( scalar_out && action->getPntrToArgument(0)->getRank()==0 ) {
+    action->error("sorting a single scalar is trivial");
+  }
 }
 
 void Highest::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
diff --git a/src/function/LessThan.cpp b/src/function/LessThan.cpp
index 780ae9a6e1..a544a2cad0 100644
--- a/src/function/LessThan.cpp
+++ b/src/function/LessThan.cpp
@@ -77,30 +77,49 @@ void LessThan::registerKeywords(Keywords& keys) {
 }
 
 void LessThan::read( ActionWithArguments* action ) {
-  if( action->getNumberOfArguments()!=1 ) action->error("should only be one argument to less_than actions");
-  if( action->getPntrToArgument(0)->isPeriodic() ) action->error("cannot use this function on periodic functions");
+  if( action->getNumberOfArguments()!=1 ) {
+    action->error("should only be one argument to less_than actions");
+  }
+  if( action->getPntrToArgument(0)->isPeriodic() ) {
+    action->error("cannot use this function on periodic functions");
+  }
 
 
   std::string sw,errors;
   action->parse("SWITCH",sw);
   if(sw.length()>0) {
     switchingFunction.set(sw,errors);
-    if( errors.length()!=0 ) action->error("problem reading SWITCH keyword : " + errors );
+    if( errors.length()!=0 ) {
+      action->error("problem reading SWITCH keyword : " + errors );
+    }
   } else {
-    int nn=6; int mm=0; double d0=0.0; double r0=0.0; action->parse("R_0",r0);
-    if(r0<=0.0) action->error("R_0 should be explicitly specified and positive");
-    action->parse("D_0",d0); action->parse("NN",nn); action->parse("MM",mm);
+    int nn=6;
+    int mm=0;
+    double d0=0.0;
+    double r0=0.0;
+    action->parse("R_0",r0);
+    if(r0<=0.0) {
+      action->error("R_0 should be explicitly specified and positive");
+    }
+    action->parse("D_0",d0);
+    action->parse("NN",nn);
+    action->parse("MM",mm);
     switchingFunction.set(nn,mm,r0,d0);
   }
   action->log<<"  using switching function with cutoff "<<switchingFunction.description()<<"\n";
   action->parseFlag("SQUARED",squared);
-  if( squared ) action->log<<"  input quantity is square of quantity that switching function acts upon\n";
+  if( squared ) {
+    action->log<<"  input quantity is square of quantity that switching function acts upon\n";
+  }
 }
 
 void LessThan::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
   plumed_dbg_assert( args.size()==1 );
-  if( squared ) vals[0] = switchingFunction.calculateSqr( args[0], derivatives(0,0) );
-  else vals[0] = switchingFunction.calculate( args[0], derivatives(0,0) );
+  if( squared ) {
+    vals[0] = switchingFunction.calculateSqr( args[0], derivatives(0,0) );
+  } else {
+    vals[0] = switchingFunction.calculate( args[0], derivatives(0,0) );
+  }
   derivatives(0,0) = args[0]*derivatives(0,0);
 }
 
diff --git a/src/function/LessThan.h b/src/function/LessThan.h
index 5c342f2220..6a425cf835 100644
--- a/src/function/LessThan.h
+++ b/src/function/LessThan.h
@@ -34,7 +34,9 @@ class LessThan : public FunctionTemplateBase {
 public:
   void registerKeywords( Keywords& keys ) override;
   void read( ActionWithArguments* action ) override;
-  bool getDerivativeZeroIfValueIsZero() const override { return true; }
+  bool getDerivativeZeroIfValueIsZero() const override {
+    return true;
+  }
   void calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const override;
 };
 
diff --git a/src/function/LocalEnsemble.cpp b/src/function/LocalEnsemble.cpp
index f417f3fb8c..1f8d548834 100644
--- a/src/function/LocalEnsemble.cpp
+++ b/src/function/LocalEnsemble.cpp
@@ -74,8 +74,7 @@ res: RESTRAINT ARG=stca.*,stcb.*,stco.*,sthn.*,stnh.* AT=0.,0.,0.,0.,0. KAPPA=0.
 
 
 class LocalEnsemble :
-  public Function
-{
+  public Function {
   unsigned ens_dim;
   unsigned narg;
 public:
@@ -98,22 +97,31 @@ void LocalEnsemble::registerKeywords(Keywords& keys) {
 LocalEnsemble::LocalEnsemble(const ActionOptions&ao):
   Action(ao),
   Function(ao),
-  ens_dim(0)
-{
+  ens_dim(0) {
   parse("NUM",ens_dim);
-  if(ens_dim==0) error("NUM should be greater or equal to 1");
+  if(ens_dim==0) {
+    error("NUM should be greater or equal to 1");
+  }
 
   std::vector<Value*> arg;
   int oldsize=-1;
   for(unsigned i=1; i<=ens_dim; ++i ) {
     std::vector<Value*> larg;
-    if(!parseArgumentList("ARG",i,larg)) break;
-    for(unsigned j=0; j<larg.size(); j++) arg.push_back(larg[j]);
-    if(oldsize!=-1&&oldsize!=static_cast<int>(larg.size())) error("In LOCALENSEMBLE you should have the same number of arguments for each ARG keyword");
+    if(!parseArgumentList("ARG",i,larg)) {
+      break;
+    }
+    for(unsigned j=0; j<larg.size(); j++) {
+      arg.push_back(larg[j]);
+    }
+    if(oldsize!=-1&&oldsize!=static_cast<int>(larg.size())) {
+      error("In LOCALENSEMBLE you should have the same number of arguments for each ARG keyword");
+    }
     oldsize = larg.size();
     if(!larg.empty()) {
       log.printf("  with arguments %u: ", i);
-      for(unsigned j=0; j<larg.size(); j++) log.printf(" %s",larg[j]->getName().c_str());
+      for(unsigned j=0; j<larg.size(); j++) {
+        log.printf(" %s",larg[j]->getName().c_str());
+      }
       log.printf("\n");
     }
   }
@@ -134,8 +142,7 @@ std::string LocalEnsemble::getOutputComponentDescription( const std::string& cna
   return "the average for argument named " + cname;
 }
 
-void LocalEnsemble::calculate()
-{
+void LocalEnsemble::calculate() {
   const double fact = 1.0/static_cast<double>(ens_dim);
   #pragma omp parallel for num_threads(OpenMP::getNumThreads())
   for(unsigned i=0; i<narg; ++i) {
diff --git a/src/function/Moments.cpp b/src/function/Moments.cpp
index cfd2ed3118..ff0ae04e4b 100644
--- a/src/function/Moments.cpp
+++ b/src/function/Moments.cpp
@@ -64,8 +64,12 @@ class Moments : public FunctionTemplateBase {
 public:
   void registerKeywords(Keywords& keys) override;
   void read( ActionWithArguments* action ) override;
-  bool zeroRank() const override { return scalar_out; }
-  bool doWithTasks() const override { return !scalar_out; }
+  bool zeroRank() const override {
+    return scalar_out;
+  }
+  bool doWithTasks() const override {
+    return !scalar_out;
+  }
   std::vector<std::string> getComponentsPerLabel() const override ;
   void setPeriodicityForOutputs( ActionWithValue* action ) override;
   void calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const override;
@@ -90,61 +94,93 @@ void Moments::registerKeywords(Keywords& keys) {
 
 void Moments::read( ActionWithArguments* action ) {
   scalar_out = action->getNumberOfArguments()==1;
-  if( scalar_out && action->getPntrToArgument(0)->getRank()==0 ) action->error("cannot calculate moments if only given one variable");
+  if( scalar_out && action->getPntrToArgument(0)->getRank()==0 ) {
+    action->error("cannot calculate moments if only given one variable");
+  }
 
   isperiodic = (action->getPntrToArgument(0))->isPeriodic();
   if( isperiodic ) {
-    std::string str_min, str_max; (action->getPntrToArgument(0))->getDomain( str_min, str_max );
+    std::string str_min, str_max;
+    (action->getPntrToArgument(0))->getDomain( str_min, str_max );
     for(unsigned i=1; i<action->getNumberOfArguments(); ++i) {
-      if( !(action->getPntrToArgument(i))->isPeriodic() ) action->error("cannot mix periodic and non periodic variables when calculating moments");
-      std::string str_min2, str_max2; (action->getPntrToArgument(i))->getDomain( str_min2, str_max2);
-      if( str_min!=str_min2 || str_max!=str_max2 ) action->error("all input arguments should have same domain when calculating moments");
+      if( !(action->getPntrToArgument(i))->isPeriodic() ) {
+        action->error("cannot mix periodic and non periodic variables when calculating moments");
+      }
+      std::string str_min2, str_max2;
+      (action->getPntrToArgument(i))->getDomain( str_min2, str_max2);
+      if( str_min!=str_min2 || str_max!=str_max2 ) {
+        action->error("all input arguments should have same domain when calculating moments");
+      }
     }
-    Tools::convert(str_min,min); Tools::convert(str_max,max); pfactor = 2*pi / ( max-min );
+    Tools::convert(str_min,min);
+    Tools::convert(str_max,max);
+    pfactor = 2*pi / ( max-min );
   } else {
     for(unsigned i=1; i<action->getNumberOfArguments(); ++i) {
-      if( (action->getPntrToArgument(i))->isPeriodic() ) action->error("cannot mix periodic and non periodic variables when calculating moments");
+      if( (action->getPntrToArgument(i))->isPeriodic() ) {
+        action->error("cannot mix periodic and non periodic variables when calculating moments");
+      }
     }
   }
 
   parseVector(action,"POWERS",powers);
   for(unsigned i=0; i<powers.size(); ++i) {
-    if( powers[i]<2 ) action->error("first central moment is zero do you really need to calculate that");
+    if( powers[i]<2 ) {
+      action->error("first central moment is zero do you really need to calculate that");
+    }
     action->log.printf("  computing %dth central moment of distribution of input cvs \n", powers[i]);
   }
 }
 
 std::vector<std::string> Moments::getComponentsPerLabel() const {
-  std::vector<std::string> comp; std::string num;
+  std::vector<std::string> comp;
+  std::string num;
   for(unsigned i=0; i<powers.size(); ++i) {
-    Tools::convert(powers[i],num); comp.push_back( "-" + num );
+    Tools::convert(powers[i],num);
+    comp.push_back( "-" + num );
   }
   return comp;
 }
 
 void Moments::setPeriodicityForOutputs( ActionWithValue* action ) {
-  for(unsigned i=0; i<powers.size(); ++i) { std::string num; Tools::convert(powers[i],num); action->componentIsNotPeriodic("moment-" + num); }
+  for(unsigned i=0; i<powers.size(); ++i) {
+    std::string num;
+    Tools::convert(powers[i],num);
+    action->componentIsNotPeriodic("moment-" + num);
+  }
 }
 
 void Moments::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
-  double mean=0; double inorm = 1.0 / static_cast<double>( args.size() );
+  double mean=0;
+  double inorm = 1.0 / static_cast<double>( args.size() );
   if( isperiodic ) {
     double sinsum=0, cossum=0, val;
-    for(unsigned i=0; i<args.size(); ++i) { val=pfactor*( args[i] - min ); sinsum+=sin(val); cossum+=cos(val); }
+    for(unsigned i=0; i<args.size(); ++i) {
+      val=pfactor*( args[i] - min );
+      sinsum+=sin(val);
+      cossum+=cos(val);
+    }
     mean = 0.5 + atan2( inorm*sinsum, inorm*cossum ) / (2*pi);
     mean = min + (max-min)*mean;
   } else {
-    for(unsigned i=0; i<args.size(); ++i) mean+=args[i];
+    for(unsigned i=0; i<args.size(); ++i) {
+      mean+=args[i];
+    }
     mean *= inorm;
   }
 
   Value* arg0 = action->getPntrToArgument(0);
   for(unsigned npow=0; npow<powers.size(); ++npow) {
     double dev1=0;
-    for(unsigned i=0; i<args.size(); ++i) dev1+=pow( arg0->difference( mean, args[i] ), powers[npow] - 1 );
-    dev1*=inorm; vals[npow] = 0; double prefactor = powers[npow]*inorm;
     for(unsigned i=0; i<args.size(); ++i) {
-      double tmp=arg0->difference( mean, args[i] ); vals[npow] += inorm*pow( tmp, powers[npow] );
+      dev1+=pow( arg0->difference( mean, args[i] ), powers[npow] - 1 );
+    }
+    dev1*=inorm;
+    vals[npow] = 0;
+    double prefactor = powers[npow]*inorm;
+    for(unsigned i=0; i<args.size(); ++i) {
+      double tmp=arg0->difference( mean, args[i] );
+      vals[npow] += inorm*pow( tmp, powers[npow] );
       derivatives(npow,i) = prefactor*(pow( tmp, powers[npow] - 1 ) - dev1);
     }
   }
diff --git a/src/function/MoreThan.cpp b/src/function/MoreThan.cpp
index f8ddb55324..1ff0d56a7e 100644
--- a/src/function/MoreThan.cpp
+++ b/src/function/MoreThan.cpp
@@ -77,30 +77,49 @@ void MoreThan::registerKeywords(Keywords& keys) {
 }
 
 void MoreThan::read( ActionWithArguments* action ) {
-  if( action->getNumberOfArguments()!=1 ) action->error("should only be one argument to more_than actions");
-  if( action->getPntrToArgument(0)->isPeriodic() ) action->error("cannot use this function on periodic functions");
+  if( action->getNumberOfArguments()!=1 ) {
+    action->error("should only be one argument to more_than actions");
+  }
+  if( action->getPntrToArgument(0)->isPeriodic() ) {
+    action->error("cannot use this function on periodic functions");
+  }
 
 
   std::string sw,errors;
   action->parse("SWITCH",sw);
   if(sw.length()>0) {
     switchingFunction.set(sw,errors);
-    if( errors.length()!=0 ) action->error("problem reading SWITCH keyword : " + errors );
+    if( errors.length()!=0 ) {
+      action->error("problem reading SWITCH keyword : " + errors );
+    }
   } else {
-    int nn=6; int mm=0; double d0=0.0; double r0=0.0; action->parse("R_0",r0);
-    if(r0<=0.0) action->error("R_0 should be explicitly specified and positive");
-    action->parse("D_0",d0); action->parse("NN",nn); action->parse("MM",mm);
+    int nn=6;
+    int mm=0;
+    double d0=0.0;
+    double r0=0.0;
+    action->parse("R_0",r0);
+    if(r0<=0.0) {
+      action->error("R_0 should be explicitly specified and positive");
+    }
+    action->parse("D_0",d0);
+    action->parse("NN",nn);
+    action->parse("MM",mm);
     switchingFunction.set(nn,mm,r0,d0);
   }
   action->log<<"  using switching function with cutoff "<<switchingFunction.description()<<"\n";
   action->parseFlag("SQUARED",squared);
-  if( squared ) action->log<<"  input quantity is square of quantity that switching function acts upon\n";
+  if( squared ) {
+    action->log<<"  input quantity is square of quantity that switching function acts upon\n";
+  }
 }
 
 void MoreThan::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
   plumed_dbg_assert( args.size()==1 );
-  if( squared ) vals[0] = 1.0 - switchingFunction.calculateSqr( args[0], derivatives(0,0) );
-  else vals[0] = 1.0 - switchingFunction.calculate( args[0], derivatives(0,0) );
+  if( squared ) {
+    vals[0] = 1.0 - switchingFunction.calculateSqr( args[0], derivatives(0,0) );
+  } else {
+    vals[0] = 1.0 - switchingFunction.calculate( args[0], derivatives(0,0) );
+  }
   derivatives(0,0) = -args[0]*derivatives(0,0);
 }
 
diff --git a/src/function/MoreThan.h b/src/function/MoreThan.h
index f5e84f273d..0bf2137b03 100644
--- a/src/function/MoreThan.h
+++ b/src/function/MoreThan.h
@@ -34,7 +34,9 @@ class MoreThan : public FunctionTemplateBase {
 public:
   void registerKeywords( Keywords& keys ) override;
   void read( ActionWithArguments* action ) override;
-  bool getDerivativeZeroIfValueIsZero() const override { return true; }
+  bool getDerivativeZeroIfValueIsZero() const override {
+    return true;
+  }
   void calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const override;
 };
 
diff --git a/src/function/Piecewise.cpp b/src/function/Piecewise.cpp
index 221bfb9243..e71412b884 100644
--- a/src/function/Piecewise.cpp
+++ b/src/function/Piecewise.cpp
@@ -102,29 +102,43 @@ void Piecewise::registerKeywords(Keywords& keys) {
 void Piecewise::read( ActionWithArguments* action ) {
   for(int i=0;; i++) {
     std::vector<double> pp;
-    if(!action->parseNumberedVector("POINT",i,pp) ) break;
-    if(pp.size()!=2) action->error("points should be in x,y format");
+    if(!action->parseNumberedVector("POINT",i,pp) ) {
+      break;
+    }
+    if(pp.size()!=2) {
+      action->error("points should be in x,y format");
+    }
     points.push_back(std::pair<double,double>(pp[0],pp[1]));
-    if(i>0 && points[i].first<=points[i-1].first) action->error("points abscissas should be monotonously increasing");
+    if(i>0 && points[i].first<=points[i-1].first) {
+      action->error("points abscissas should be monotonously increasing");
+    }
   }
 
   for(unsigned i=0; i<action->getNumberOfArguments(); i++) {
-    if(action->getPntrToArgument(i)->isPeriodic()) action->error("Cannot use PIECEWISE on periodic arguments");
+    if(action->getPntrToArgument(i)->isPeriodic()) {
+      action->error("Cannot use PIECEWISE on periodic arguments");
+    }
   }
   action->log.printf("  on points:");
-  for(unsigned i=0; i<points.size(); i++) action->log.printf("   (%f,%f)",points[i].first,points[i].second);
+  for(unsigned i=0; i<points.size(); i++) {
+    action->log.printf("   (%f,%f)",points[i].first,points[i].second);
+  }
   action->log.printf("\n");
 }
 
 void Piecewise::setPeriodicityForOutputs( ActionWithValue* action ) {
-  for(unsigned i=0; i<action->getNumberOfComponents(); ++i) action->copyOutput(i)->setNotPeriodic();
+  for(unsigned i=0; i<action->getNumberOfComponents(); ++i) {
+    action->copyOutput(i)->setNotPeriodic();
+  }
 }
 
 void Piecewise::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
   for(unsigned i=0; i<args.size(); i++) {
     unsigned p=0;
     for(; p<points.size(); p++) {
-      if(args[i]<points[p].first) break;
+      if(args[i]<points[p].first) {
+        break;
+      }
     }
     if(p==0) {
       vals[i]=points[0].second;
diff --git a/src/function/Product.cpp b/src/function/Product.cpp
index 283fedb53b..b074dd1551 100644
--- a/src/function/Product.cpp
+++ b/src/function/Product.cpp
@@ -46,14 +46,16 @@ void Product::registerKeywords( Keywords& keys ) {
   ActionShortcut::registerKeywords(keys);
   keys.add("compulsory","ARG","The point that we are calculating the distance from");
   keys.setValueDescription("the product of all the elements in the input vector");
-  keys.needsAction("CONCATENATE"); keys.needsAction("CUSTOM"); keys.needsAction("SUM");
+  keys.needsAction("CONCATENATE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("SUM");
 }
 
 Product::Product( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string arg; parse("ARG",arg);
+  ActionShortcut(ao) {
+  std::string arg;
+  parse("ARG",arg);
   readInputLine( getShortcutLabel() + "_vec: CONCATENATE ARG=" + arg );
   readInputLine( getShortcutLabel() + "_logs: CUSTOM ARG=" + getShortcutLabel() + "_vec FUNC=log(x) PERIODIC=NO");
   readInputLine( getShortcutLabel() + "_logsum: SUM ARG=" + getShortcutLabel() + "_logs PERIODIC=NO");
diff --git a/src/function/Sort.cpp b/src/function/Sort.cpp
index ce2093f460..a36bba987e 100644
--- a/src/function/Sort.cpp
+++ b/src/function/Sort.cpp
@@ -78,8 +78,12 @@ class Sort : public FunctionTemplateBase {
 public:
   void registerKeywords(Keywords& keys) override ;
   void read( ActionWithArguments* action ) override;
-  bool zeroRank() const override { return true; }
-  bool doWithTasks() const override { return !scalar_out; }
+  bool zeroRank() const override {
+    return true;
+  }
+  bool doWithTasks() const override {
+    return !scalar_out;
+  }
   std::vector<std::string> getComponentsPerLabel() const override ;
   void setPeriodicityForOutputs( ActionWithValue* action ) override;
   void calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const override;
@@ -100,23 +104,35 @@ void Sort::registerKeywords(Keywords& keys) {
 
 
 void Sort::read( ActionWithArguments* action ) {
-  scalar_out = action->getNumberOfArguments()==1; nargs = action->getNumberOfArguments(); if( scalar_out ) nargs = action->getPntrToArgument(0)->getNumberOfValues();
+  scalar_out = action->getNumberOfArguments()==1;
+  nargs = action->getNumberOfArguments();
+  if( scalar_out ) {
+    nargs = action->getPntrToArgument(0)->getNumberOfValues();
+  }
 
   for(unsigned i=0; i<action->getNumberOfArguments(); ++i) {
-    if((action->getPntrToArgument(i))->isPeriodic()) action->error("Cannot sort periodic values (check argument "+ (action->getPntrToArgument(i))->getName() +")");
+    if((action->getPntrToArgument(i))->isPeriodic()) {
+      action->error("Cannot sort periodic values (check argument "+ (action->getPntrToArgument(i))->getName() +")");
+    }
   }
 }
 
 std::vector<std::string> Sort::getComponentsPerLabel() const {
-  std::vector<std::string> comp; std::string num;
+  std::vector<std::string> comp;
+  std::string num;
   for(unsigned i=0; i<nargs; ++i) {
-    Tools::convert(i+1,num); comp.push_back( num );
+    Tools::convert(i+1,num);
+    comp.push_back( num );
   }
   return comp;
 }
 
 void Sort::setPeriodicityForOutputs( ActionWithValue* action ) {
-  for(unsigned i=0; i<nargs; ++i) { std::string num; Tools::convert(i+1,num); action->componentIsNotPeriodic( num ); }
+  for(unsigned i=0; i<nargs; ++i) {
+    std::string num;
+    Tools::convert(i+1,num);
+    action->componentIsNotPeriodic( num );
+  }
 }
 
 void Sort::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
@@ -127,8 +143,12 @@ void Sort::calc( const ActionWithArguments* action, const std::vector<double>& a
     data[i].second=i;
   }
 // STL sort sorts based on first element (value) then second (index)
-  std::sort(data.begin(),data.end()); derivatives = 0;
-  for(int i=0; i<vals.size(); ++i) { vals[i] = data[i].first; derivatives(i, data[i].second ) = 1; }
+  std::sort(data.begin(),data.end());
+  derivatives = 0;
+  for(int i=0; i<vals.size(); ++i) {
+    vals[i] = data[i].first;
+    derivatives(i, data[i].second ) = 1;
+  }
 }
 
 }
diff --git a/src/function/Stats.cpp b/src/function/Stats.cpp
index ae2f5c78b8..f84dbf0cf8 100644
--- a/src/function/Stats.cpp
+++ b/src/function/Stats.cpp
@@ -54,8 +54,7 @@ PRINT ARG=d1,d2,d3,st.*
 
 
 class Stats :
-  public Function
-{
+  public Function {
   std::vector<double> parameters;
   bool sqdonly;
   bool components;
@@ -89,46 +88,65 @@ Stats::Stats(const ActionOptions&ao):
   Function(ao),
   sqdonly(false),
   components(false),
-  upperd(false)
-{
+  upperd(false) {
   parseVector("PARAMETERS",parameters);
-  if(parameters.size()!=static_cast<unsigned>(getNumberOfArguments())&&!parameters.empty())
+  if(parameters.size()!=static_cast<unsigned>(getNumberOfArguments())&&!parameters.empty()) {
     error("Size of PARAMETERS array should be either 0 or the same as of the number of arguments in ARG1");
+  }
 
   std::vector<Value*> arg2;
   parseArgumentList("PARARG",arg2);
 
   if(!arg2.empty()) {
-    if(parameters.size()>0) error("It is not possible to use PARARG and PARAMETERS together");
-    if(arg2.size()!=getNumberOfArguments()) error("Size of PARARG array should be the same as number for arguments in ARG");
+    if(parameters.size()>0) {
+      error("It is not possible to use PARARG and PARAMETERS together");
+    }
+    if(arg2.size()!=getNumberOfArguments()) {
+      error("Size of PARARG array should be the same as number for arguments in ARG");
+    }
     for(unsigned i=0; i<arg2.size(); i++) {
       parameters.push_back(arg2[i]->get());
-      if(arg2[i]->hasDerivatives()==true) error("PARARG can only accept arguments without derivatives");
+      if(arg2[i]->hasDerivatives()==true) {
+        error("PARARG can only accept arguments without derivatives");
+      }
     }
   }
 
-  if(parameters.size()!=getNumberOfArguments())
+  if(parameters.size()!=getNumberOfArguments()) {
     error("PARARG or PARAMETERS arrays should include the same number of elements as the arguments in ARG");
+  }
 
-  if(getNumberOfArguments()<2) error("STATS need at least two arguments to be used");
+  if(getNumberOfArguments()<2) {
+    error("STATS need at least two arguments to be used");
+  }
 
   parseFlag("SQDEVSUM",sqdonly);
   parseFlag("SQDEV",components);
   parseFlag("UPPERDISTS",upperd);
 
-  if(sqdonly&&components) error("You cannot used SQDEVSUM and SQDEV at the sametime");
+  if(sqdonly&&components) {
+    error("You cannot used SQDEVSUM and SQDEV at the sametime");
+  }
 
-  if(components) sqdonly = true;
+  if(components) {
+    sqdonly = true;
+  }
 
-  if(!arg2.empty()) log.printf("  using %zu parameters from inactive actions:", arg2.size());
-  else              log.printf("  using %zu parameters:", arg2.size());
-  for(unsigned i=0; i<parameters.size(); i++) log.printf(" %f",parameters[i]);
+  if(!arg2.empty()) {
+    log.printf("  using %zu parameters from inactive actions:", arg2.size());
+  } else {
+    log.printf("  using %zu parameters:", arg2.size());
+  }
+  for(unsigned i=0; i<parameters.size(); i++) {
+    log.printf(" %f",parameters[i]);
+  }
   log.printf("\n");
 
   if(sqdonly) {
     if(components) {
       for(unsigned i=0; i<parameters.size(); i++) {
-        std::string num; Tools::convert(i,num);
+        std::string num;
+        Tools::convert(i,num);
         addComponentWithDerivatives("sqd-"+num);
         componentIsNotPeriodic("sqd-"+num);
       }
@@ -150,16 +168,19 @@ Stats::Stats(const ActionOptions&ao):
   checkRead();
 }
 
-void Stats::calculate()
-{
+void Stats::calculate() {
   if(sqdonly) {
 
     double nsqd = 0.;
     Value* val;
-    if(!components) val=getPntrToComponent("sqdevsum");
+    if(!components) {
+      val=getPntrToComponent("sqdevsum");
+    }
     for(unsigned i=0; i<parameters.size(); ++i) {
       double dev = getArgument(i)-parameters[i];
-      if(upperd&&dev<0) dev=0.;
+      if(upperd&&dev<0) {
+        dev=0.;
+      }
       if(components) {
         val=getPntrToComponent(i);
         val->set(dev*dev);
@@ -168,7 +189,9 @@ void Stats::calculate()
       }
       setDerivative(val,i,2.*dev);
     }
-    if(!components) val->set(nsqd);
+    if(!components) {
+      val->set(nsqd);
+    }
 
   } else {
 
diff --git a/src/function/Sum.cpp b/src/function/Sum.cpp
index fc2cc01e56..ccc4878f1c 100644
--- a/src/function/Sum.cpp
+++ b/src/function/Sum.cpp
@@ -106,16 +106,22 @@ typedef FunctionOfMatrix<Sum> MatrixSum;
 PLUMED_REGISTER_ACTION(MatrixSum,"SUM_MATRIX")
 
 void Sum::registerKeywords( Keywords& keys ) {
-  keys.use("PERIODIC"); keys.setValueDescription("the sum");
+  keys.use("PERIODIC");
+  keys.setValueDescription("the sum");
 }
 
 void Sum::read( ActionWithArguments* action ) {
-  if( action->getNumberOfArguments()!=1 ) action->error("should only be one argument to sum actions");
+  if( action->getNumberOfArguments()!=1 ) {
+    action->error("should only be one argument to sum actions");
+  }
 }
 
 void Sum::setPrefactor( ActionWithArguments* action, const double pref ) {
-  if(action->getName().find("MEAN")!=std::string::npos) prefactor = pref / (action->getPntrToArgument(0))->getNumberOfValues();
-  else prefactor = pref;
+  if(action->getName().find("MEAN")!=std::string::npos) {
+    prefactor = pref / (action->getPntrToArgument(0))->getNumberOfValues();
+  } else {
+    prefactor = pref;
+  }
 }
 
 bool Sum::zeroRank() const {
@@ -123,7 +129,8 @@ bool Sum::zeroRank() const {
 }
 
 void Sum::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
-  vals[0]=prefactor*args[0]; derivatives(0,0)=prefactor;
+  vals[0]=prefactor*args[0];
+  derivatives(0,0)=prefactor;
 }
 
 }
diff --git a/src/funnel/FPS.cpp b/src/funnel/FPS.cpp
index 3ca828b7de..5bb67f4518 100644
--- a/src/funnel/FPS.cpp
+++ b/src/funnel/FPS.cpp
@@ -128,15 +128,15 @@ void FUNNEL_PS::registerKeywords(Keywords& keys) {
 
 FUNNEL_PS::FUNNEL_PS(const ActionOptions&ao):
   PLUMED_COLVAR_INIT(ao),
-  pbc(true),squared(true)
-{
+  pbc(true),squared(true) {
   string reference;
   parse("REFERENCE",reference);
   string type;
   type.assign("OPTIMAL");
   parseAtomList("LIGAND",ligand_com);
-  if(ligand_com.size()!=1)
+  if(ligand_com.size()!=1) {
     error("Number of specified atoms should be one, normally the COM of the ligand");
+  }
   parseVector("POINTS",points);
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
@@ -150,8 +150,9 @@ FUNNEL_PS::FUNNEL_PS(const ActionOptions&ao):
   checkRead();
 
   // read everything in ang and transform to nm if we are not in natural units
-  if( !pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength()) )
+  if( !pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength()) ) {
     error("missing input file " + reference );
+  }
 
   bool remove_com=true;
   bool normalize_weights=true;
@@ -177,8 +178,11 @@ FUNNEL_PS::FUNNEL_PS(const ActionOptions&ao):
   log.printf("  average from file %s\n",reference.c_str());
   log.printf("  method for alignment : %s \n",type.c_str() );
 
-  if(pbc) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
 
   addComponentWithDerivatives("lp");
   componentIsNotPeriodic("lp");
@@ -192,7 +196,9 @@ FUNNEL_PS::FUNNEL_PS(const ActionOptions&ao):
 // calculator
 void FUNNEL_PS::calculate() {
 
-  if(pbc) makeWhole();
+  if(pbc) {
+    makeWhole();
+  }
 
   Tensor Rotation;
   Matrix<std::vector<Vector> > drotdpos(3,3);
diff --git a/src/funnel/Funnel.cpp b/src/funnel/Funnel.cpp
index 7a9c83b851..b5ebd30bbf 100644
--- a/src/funnel/Funnel.cpp
+++ b/src/funnel/Funnel.cpp
@@ -202,7 +202,9 @@ Funnel::Funnel(const ActionOptions& ao):
   parse("SAFETY",safety);
   string file;
   parse("FILE",file);
-  if( file.length()==0 ) error("No funnel file name was specified");
+  if( file.length()==0 ) {
+    error("No funnel file name was specified");
+  }
   parse("SCALE",scale_);
 
   //Reading optional arguments
@@ -275,12 +277,18 @@ Funnel::Funnel(const ActionOptions& ao):
   gridfile.open(file);
   BiasGrid_=Grid::create(funcl,getArguments(),gridfile,sparsegrid,spline,true);
 //not necessary anymore?  gridfile.close();
-  if(BiasGrid_->getDimension()!=getNumberOfArguments()) error("mismatch between dimensionality of input grid and number of arguments");
+  if(BiasGrid_->getDimension()!=getNumberOfArguments()) {
+    error("mismatch between dimensionality of input grid and number of arguments");
+  }
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->isPeriodic()!=BiasGrid_->getIsPeriodic()[i] ) error("periodicity mismatch between arguments and input bias");
+    if( getPntrToArgument(i)->isPeriodic()!=BiasGrid_->getIsPeriodic()[i] ) {
+      error("periodicity mismatch between arguments and input bias");
+    }
   }
   comm.Barrier();
-  if(comm.Get_rank()==0 && walkers_mpi) multi_sim_comm.Barrier();
+  if(comm.Get_rank()==0 && walkers_mpi) {
+    multi_sim_comm.Barrier();
+  }
   log<<"  Bibliography "<<plumed.cite("Limongelli, Bonomi, and Parrinello, PNAS 110, 6358 (2013)")<<"\n";
 }
 
@@ -301,8 +309,7 @@ void Funnel::createBIAS(const double& R_cyl, const double& z_cc, const double& a
   double MAX_Z;
   if (sphere==false) {
     MAX_Z=R_cyl + tg_alpha * (z_cc - MIN_S);
-  }
-  else {
+  } else {
     MAX_Z=z_cc+safety;
   }
 
@@ -311,8 +318,7 @@ void Funnel::createBIAS(const double& R_cyl, const double& z_cc, const double& a
   double DX_S;
   if (sphere==false) {
     DX_S=(MAX_S - MIN_S) / NBIN_S;
-  }
-  else {
+  } else {
     DX_S=(MAX_S + z_cc + safety)/NBIN_S;
   }
 
@@ -324,8 +330,11 @@ void Funnel::createBIAS(const double& R_cyl, const double& z_cc, const double& a
 
   //Write the header
   pof.printf("#! FIELDS %s %s %s der_%s der_%s \n", getPntrToArgument(0)->getName().c_str(), getPntrToArgument(1)->getName().c_str(), funcl.c_str(), getPntrToArgument(0)->getName().c_str(), getPntrToArgument(1)->getName().c_str());
-  if (sphere==false) pof.printf("#! SET min_%s %f\n", getPntrToArgument(0)->getName().c_str(), MIN_S);
-  else pof.printf("#! SET min_%s %f\n", getPntrToArgument(0)->getName().c_str(), -z_cc-safety);
+  if (sphere==false) {
+    pof.printf("#! SET min_%s %f\n", getPntrToArgument(0)->getName().c_str(), MIN_S);
+  } else {
+    pof.printf("#! SET min_%s %f\n", getPntrToArgument(0)->getName().c_str(), -z_cc-safety);
+  }
   pof.printf("#! SET max_%s %f\n", getPntrToArgument(0)->getName().c_str(), MAX_S);
   pof.printf("#! SET nbins_%s %f\n", getPntrToArgument(0)->getName().c_str(), NBIN_S);
   pof.printf("#! SET periodic_%s false\n", getPntrToArgument(0)->getName().c_str());
@@ -340,76 +349,75 @@ void Funnel::createBIAS(const double& R_cyl, const double& z_cc, const double& a
   for(int is=0; is <= NBIN_S; is++) {
     if (sphere==false) {
       SS = MIN_S + is * DX_S;
-    }
-    else {
+    } else {
       SS = - z_cc - safety + is * DX_S;
     }
     bool cone = false;
     if (sphere==false) {
-      if(SS <= z_cc) cone = true;
-    }
-    else {
-      if (SS <= sqrt(pow(z_cc,2)-pow(R_cyl,2))) cone = true;
+      if(SS <= z_cc) {
+        cone = true;
+      }
+    } else {
+      if (SS <= sqrt(pow(z_cc,2)-pow(R_cyl,2))) {
+        cone = true;
+      }
     }
     //Set wall boundaries properly
     if(cone == true) {
       if(sphere==false) {
         Zmax = R_cyl + (z_cc - SS) * tg_alpha;
-      }
-      else {
+      } else {
         if (SS > -z_cc) {
           Zmax = sqrt(pow(z_cc,2) - pow(SS,2));
-        }
-        else {
+        } else {
           Zmax = 0;
         }
       }
+    } else {
+      Zmax = R_cyl;
     }
-    else Zmax = R_cyl;
 
     for(int iz=0; iz <= NBIN_Z; iz++) {
       ZZ = MIN_Z + iz * DX_Z;
 
       //Inside or outside?
       bool inside;
-      if(ZZ < Zmax) inside = true;
-      else inside = false;
+      if(ZZ < Zmax) {
+        inside = true;
+      } else {
+        inside = false;
+      }
 
       if(inside == true) {
         POT = 0;
         FS = 0;
         FZ = 0;
-      }
-      else {
+      } else {
         if(cone == true) {
           if(sphere==false) {
             POT = 0.5 * KAPPA * (ZZ - Zmax) * (ZZ - Zmax);
             FZ = - KAPPA * (ZZ - Zmax);
             FS = - KAPPA * (ZZ - Zmax) * tg_alpha;
-          }
-          else {
+          } else {
             D = sqrt(pow(ZZ,2)+pow(SS,2));
             d = D - z_cc;
             POT = 0.5 * KAPPA * pow(d,2);
             FZ = - KAPPA * d * ZZ / D;
             FS = - KAPPA * d * SS / D;
           }
-        }
-        else {
+        } else {
           if(sphere==false) {
             POT = 0.5 * KAPPA * (ZZ - Zmax) * (ZZ - Zmax);
             FZ = - KAPPA * (ZZ - Zmax);
             FS = 0;
-          }
-          else {
+          } else {
             D = sqrt(pow(ZZ,2)+pow(SS,2));
             d = D - z_cc;
             if(ZZ>=R_cyl+slope*(SS-z_cc)) {
               POT = 0.5 * KAPPA * pow(d,2);
               FZ = - KAPPA * d * ZZ / D;
               FS = - KAPPA * d * SS / D;
-            }
-            else {
+            } else {
               POT = 0.5 * KAPPA * pow(sqrt(pow((ZZ+slope*z_cc-R_cyl)/slope,2)+pow(ZZ,2))-
                                       z_cc,2);
               FZ = - KAPPA*(sqrt(pow((ZZ+slope*z_cc-R_cyl)/slope,2)+pow(ZZ,2))-z_cc)*
@@ -426,8 +434,7 @@ void Funnel::createBIAS(const double& R_cyl, const double& z_cc, const double& a
   pof.close();
 }
 
-void Funnel::calculate()
-{
+void Funnel::calculate() {
   unsigned ncv=getNumberOfArguments();
   vector<double> cv(ncv), der(ncv);
 
diff --git a/src/generic/Accumulate.cpp b/src/generic/Accumulate.cpp
index a6fd3bedb4..2032e13e79 100644
--- a/src/generic/Accumulate.cpp
+++ b/src/generic/Accumulate.cpp
@@ -41,8 +41,7 @@ namespace generic {
 class Accumulate :
   public ActionWithValue,
   public ActionWithArguments,
-  public ActionPilot
-{
+  public ActionPilot {
 private:
   bool clearnextstep;
   unsigned clearstride;
@@ -50,8 +49,12 @@ class Accumulate :
   static void registerKeywords( Keywords& keys );
   Accumulate( const ActionOptions& );
   unsigned getNumberOfDerivatives();
-  bool calculateOnUpdate() override { return false; }
-  bool calculateConstantValues( const bool& have_atoms ) override { return false; }
+  bool calculateOnUpdate() override {
+    return false;
+  }
+  bool calculateConstantValues( const bool& have_atoms ) override {
+    return false;
+  }
   void calculate() override {}
   void apply() override {}
   void update() override ;
@@ -60,9 +63,13 @@ class Accumulate :
 PLUMED_REGISTER_ACTION(Accumulate,"ACCUMULATE")
 
 void Accumulate::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); ActionPilot::registerKeywords( keys );
-  keys.use("ARG"); keys.use("UPDATE_FROM"); keys.use("UPDATE_UNTIL");
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  ActionPilot::registerKeywords( keys );
+  keys.use("ARG");
+  keys.use("UPDATE_FROM");
+  keys.use("UPDATE_UNTIL");
   keys.add("compulsory","STRIDE","1","the frequency with which the data should be collected and added to the quantity being averaged");
   keys.add("compulsory","CLEAR","0","the frequency with which to clear all the accumulated data.  The default value "
            "of 0 implies that all the data will be used and that the grid will never be cleared");
@@ -74,23 +81,33 @@ Accumulate::Accumulate( const ActionOptions& ao ):
   ActionWithValue(ao),
   ActionWithArguments(ao),
   ActionPilot(ao),
-  clearnextstep(true)
-{
-  if( getNumberOfArguments()!=1 ) error("there should only be one argument to this action");
-  if( !getPntrToArgument(0)->hasDerivatives() && getPntrToArgument(0)->getRank()!=0 ) error("input to the accumulate action should be a scalar or a grid");
+  clearnextstep(true) {
+  if( getNumberOfArguments()!=1 ) {
+    error("there should only be one argument to this action");
+  }
+  if( !getPntrToArgument(0)->hasDerivatives() && getPntrToArgument(0)->getRank()!=0 ) {
+    error("input to the accumulate action should be a scalar or a grid");
+  }
 
   parse("CLEAR",clearstride);
   if( clearstride>0 ) {
-    if( clearstride%getStride()!=0 ) error("CLEAR parameter must be a multiple of STRIDE");
+    if( clearstride%getStride()!=0 ) {
+      error("CLEAR parameter must be a multiple of STRIDE");
+    }
     log.printf("  clearing average every %u steps \n",clearstride);
   }
   std::vector<unsigned> shape( getPntrToArgument(0)->getShape() );
-  addValueWithDerivatives( shape ); setNotPeriodic();
-  if( getPntrToArgument(0)->isPeriodic() ) error("you cannot accumulate a periodic quantity");
+  addValueWithDerivatives( shape );
+  setNotPeriodic();
+  if( getPntrToArgument(0)->isPeriodic() ) {
+    error("you cannot accumulate a periodic quantity");
+  }
 }
 
 unsigned Accumulate::getNumberOfDerivatives() {
-  if( getPntrToArgument(0)->getRank()>0 ) return getPntrToArgument(0)->getNumberOfGridDerivatives();
+  if( getPntrToArgument(0)->getRank()>0 ) {
+    return getPntrToArgument(0)->getNumberOfGridDerivatives();
+  }
   return getPntrToArgument(0)->getNumberOfDerivatives();
 }
 
@@ -99,21 +116,32 @@ void Accumulate::update() {
     if( getPntrToComponent(0)->getNumberOfValues()!=getPntrToArgument(0)->getNumberOfValues() ) {
       getPntrToComponent(0)->setShape( getPntrToArgument(0)->getShape() );
     }
-    clearnextstep=false; getPntrToComponent(0)->set(0,0.0); getPntrToComponent(0)->clearDerivatives(true);
+    clearnextstep=false;
+    getPntrToComponent(0)->set(0,0.0);
+    getPntrToComponent(0)->clearDerivatives(true);
+  }
+  if( getStep()==0 ) {
+    return;
   }
-  if( getStep()==0 ) return;
 
-  Value* myarg=getPntrToArgument(0); Value* myout = getPntrToComponent(0);
+  Value* myarg=getPntrToArgument(0);
+  Value* myout = getPntrToComponent(0);
   if( getPntrToArgument(0)->getRank()>0 ) {
     unsigned nvals = myarg->getNumberOfValues(), nder = myarg->getNumberOfGridDerivatives();
     for(unsigned i=0; i<nvals; ++i) {
       myout->set( i, myout->get(i) + myarg->get(i) );
-      for(unsigned j=0; j<nder; ++j) myout->addGridDerivatives( i, j, myarg->getGridDerivative( i, j ) );
+      for(unsigned j=0; j<nder; ++j) {
+        myout->addGridDerivatives( i, j, myarg->getGridDerivative( i, j ) );
+      }
     }
-  } else getPntrToComponent(0)->add( getPntrToArgument(0)->get() );
+  } else {
+    getPntrToComponent(0)->add( getPntrToArgument(0)->get() );
+  }
 
   // Clear if required
-  if( clearstride>0 && getStep()%clearstride==0 ) clearnextstep=true;
+  if( clearstride>0 && getStep()%clearstride==0 ) {
+    clearnextstep=true;
+  }
 }
 
 }
diff --git a/src/generic/Average.cpp b/src/generic/Average.cpp
index 8163b3dcee..57373b11f6 100644
--- a/src/generic/Average.cpp
+++ b/src/generic/Average.cpp
@@ -106,42 +106,63 @@ void Average::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","CLEAR","0","the frequency with whihc to clear the data that is being averaged");
   keys.add("optional","NORMALIZATION","keyword for old version of the code that is there to maintain back compatibility only. Adding this keyword does nothing");
   keys.setValueDescription("the value of the average");
-  keys.needsAction("COMBINE"); keys.needsAction("CUSTOM"); keys.needsAction("ONES"); keys.needsAction("ACCUMULATE");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("ONES");
+  keys.needsAction("ACCUMULATE");
 }
 
 Average::Average( const ActionOptions& ao ):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
 
-  std::string lw; parse("LOGWEIGHTS",lw); std::string stride, clearstride; parse("STRIDE",stride); parse("CLEAR",clearstride);
+  std::string lw;
+  parse("LOGWEIGHTS",lw);
+  std::string stride, clearstride;
+  parse("STRIDE",stride);
+  parse("CLEAR",clearstride);
   if( lw.length()>0 ) {
     readInputLine( getShortcutLabel() + "_wsum: COMBINE ARG=" + lw + " PERIODIC=NO");
     readInputLine( getShortcutLabel() + "_weight: CUSTOM ARG=" + getShortcutLabel() + "_wsum FUNC=exp(x) PERIODIC=NO");
-  } else readInputLine( getShortcutLabel() + "_weight: ONES SIZE=1" );
+  } else {
+    readInputLine( getShortcutLabel() + "_weight: ONES SIZE=1" );
+  }
 
-  std::vector<std::string> arg; parseVector("ARG",arg);
-  if( arg.size()!=1 ) error("should only be one argument to this action");
-  std::vector<Value*> vals; ActionWithArguments::interpretArgumentList( arg, plumed.getActionSet(), this, vals );
+  std::vector<std::string> arg;
+  parseVector("ARG",arg);
+  if( arg.size()!=1 ) {
+    error("should only be one argument to this action");
+  }
+  std::vector<Value*> vals;
+  ActionWithArguments::interpretArgumentList( arg, plumed.getActionSet(), this, vals );
 
   readInputLine( getShortcutLabel() + "_denom: ACCUMULATE ARG=" + getShortcutLabel() + "_weight STRIDE=" + stride + " CLEAR=" + clearstride );
   if( vals[0]->isPeriodic() ) {
-    std::string lbound, ubound, pfactor; vals[0]->getDomain( lbound, ubound ); pfactor = "((" + ubound + "-" + lbound + ")/(pi+pi))";
+    std::string lbound, ubound, pfactor;
+    vals[0]->getDomain( lbound, ubound );
+    pfactor = "((" + ubound + "-" + lbound + ")/(pi+pi))";
     readInputLine( getShortcutLabel() + "_sin: CUSTOM ARG=" + arg[0] + "," + getShortcutLabel() + "_weight FUNC=y*sin((x-" + lbound + ")/" + pfactor + ") PERIODIC=NO");
     readInputLine( getShortcutLabel() + "_cos: CUSTOM ARG=" + arg[0] + "," + getShortcutLabel() + "_weight FUNC=y*cos((x-" + lbound + ")/" + pfactor + ") PERIODIC=NO");
     readInputLine( getShortcutLabel() + "_sinsum: ACCUMULATE ARG=" + getShortcutLabel() + "_sin STRIDE=" + stride + " CLEAR=" + clearstride );
     readInputLine( getShortcutLabel() + "_cossum: ACCUMULATE ARG=" + getShortcutLabel() + "_cos STRIDE=" + stride + " CLEAR=" + clearstride );
     readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_sinsum," + getShortcutLabel() + "_cossum," + getShortcutLabel() + "_denom FUNC=" + lbound + "+" + pfactor + "*atan2(x/z,y/z) PERIODIC=" + lbound +"," + ubound);
   } else {
-    std::string normstr; parse("NORMALIZATION",normstr);
-    if( normstr=="true" || normstr=="false" ) warning("NORMALIZATION is deprecated. You are advised to take this out of input files in future and use the new syntax with ACCUMULATE for unormalized data rather than the shortcut AVERAGE");
-    else if( normstr.length()>0 ) error("NORMALIZATION=" + normstr + " is not valid PLUMED input.  If you want an unormalised 'average' use ACCUMULATE");
+    std::string normstr;
+    parse("NORMALIZATION",normstr);
+    if( normstr=="true" || normstr=="false" ) {
+      warning("NORMALIZATION is deprecated. You are advised to take this out of input files in future and use the new syntax with ACCUMULATE for unormalized data rather than the shortcut AVERAGE");
+    } else if( normstr.length()>0 ) {
+      error("NORMALIZATION=" + normstr + " is not valid PLUMED input.  If you want an unormalised 'average' use ACCUMULATE");
+    }
     readInputLine( getShortcutLabel() + "_prod: CUSTOM ARG=" + arg[0] + "," + getShortcutLabel() + "_weight FUNC=x*y PERIODIC=NO");
     if( normstr.length()==0 || normstr=="true" ) {
       readInputLine( getShortcutLabel() + "_numer: ACCUMULATE ARG=" + getShortcutLabel() + "_prod STRIDE=" + stride + " CLEAR=" + clearstride  );
       readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_numer," + getShortcutLabel() + "_denom FUNC=x/y PERIODIC=NO");
-    } else if( normstr=="false" ) readInputLine( getShortcutLabel() + ": ACCUMULATE ARG=" + getShortcutLabel() + "_prod STRIDE=" + stride + " CLEAR=" + clearstride  );
-    else plumed_error();
+    } else if( normstr=="false" ) {
+      readInputLine( getShortcutLabel() + ": ACCUMULATE ARG=" + getShortcutLabel() + "_prod STRIDE=" + stride + " CLEAR=" + clearstride  );
+    } else {
+      plumed_error();
+    }
   }
 }
 
diff --git a/src/generic/Collect.cpp b/src/generic/Collect.cpp
index fe44c0344f..f829b9bbb7 100644
--- a/src/generic/Collect.cpp
+++ b/src/generic/Collect.cpp
@@ -41,8 +41,7 @@ namespace generic {
 class Collect :
   public ActionWithValue,
   public ActionWithArguments,
-  public ActionPilot
-{
+  public ActionPilot {
 private:
   bool usefirstconf;
   unsigned clearstride;
@@ -50,8 +49,12 @@ class Collect :
   static void registerKeywords( Keywords& keys );
   Collect( const ActionOptions& );
   unsigned getNumberOfDerivatives();
-  bool calculateOnUpdate() override { return false; }
-  bool calculateConstantValues( const bool& have_atoms ) override { return false; }
+  bool calculateOnUpdate() override {
+    return false;
+  }
+  bool calculateConstantValues( const bool& have_atoms ) override {
+    return false;
+  }
   void calculate() override {}
   void apply() override {}
   void update() override ;
@@ -60,9 +63,13 @@ class Collect :
 PLUMED_REGISTER_ACTION(Collect,"COLLECT")
 
 void Collect::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); ActionPilot::registerKeywords( keys );
-  keys.use("ARG"); keys.use("UPDATE_FROM"); keys.use("UPDATE_UNTIL");
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  ActionPilot::registerKeywords( keys );
+  keys.use("ARG");
+  keys.use("UPDATE_FROM");
+  keys.use("UPDATE_UNTIL");
   keys.add("compulsory","STRIDE","1","the frequency with which the data should be collected and added to the quantity being averaged");
   keys.add("compulsory","CLEAR","0","the frequency with which to clear all the accumulated data.  The default value "
            "of 0 implies that all the data will be used and that the grid will never be cleared");
@@ -75,37 +82,66 @@ Collect::Collect( const ActionOptions& ao ):
   ActionWithValue(ao),
   ActionWithArguments(ao),
   ActionPilot(ao),
-  usefirstconf(false)
-{
-  if( getNumberOfArguments()!=1 ) error("there should only be one argument to this action");
-  if( getPntrToArgument(0)->getRank()>0 && getPntrToArgument(0)->hasDerivatives() ) error("input to the collect argument cannot be a grid");
+  usefirstconf(false) {
+  if( getNumberOfArguments()!=1 ) {
+    error("there should only be one argument to this action");
+  }
+  if( getPntrToArgument(0)->getRank()>0 && getPntrToArgument(0)->hasDerivatives() ) {
+    error("input to the collect argument cannot be a grid");
+  }
 
-  std::string type; parse("TYPE",type);
-  if( getPntrToArgument(0)->getNumberOfValues()==1 && (type=="auto" || type=="vector") ) type="vector";
-  else if( getPntrToArgument(0)->getNumberOfValues()==1 && type=="matrix" ) error("invalid type specified. Cannot construct a matrix by collecting scalars");
-  else if(  getPntrToArgument(0)->getNumberOfValues()!=1 && type=="auto" ) error("missing TYPE keyword.  TYPE should specify whether data is to be stored as a vector or a matrix");
-  else if( type!="vector" && type!="matrix" ) error("invalid TYPE specified. Should be matrix/scalar found " + type);
+  std::string type;
+  parse("TYPE",type);
+  if( getPntrToArgument(0)->getNumberOfValues()==1 && (type=="auto" || type=="vector") ) {
+    type="vector";
+  } else if( getPntrToArgument(0)->getNumberOfValues()==1 && type=="matrix" ) {
+    error("invalid type specified. Cannot construct a matrix by collecting scalars");
+  } else if(  getPntrToArgument(0)->getNumberOfValues()!=1 && type=="auto" ) {
+    error("missing TYPE keyword.  TYPE should specify whether data is to be stored as a vector or a matrix");
+  } else if( type!="vector" && type!="matrix" ) {
+    error("invalid TYPE specified. Should be matrix/scalar found " + type);
+  }
 
-  if( type=="vector" ) log.printf("  adding %d elements to stored vector each time we collect\n", getPntrToArgument(0)->getNumberOfValues() );
-  else log.printf("  constructing matrix with rows of length %d from input data\n", getPntrToArgument(0)->getNumberOfValues() );
+  if( type=="vector" ) {
+    log.printf("  adding %d elements to stored vector each time we collect\n", getPntrToArgument(0)->getNumberOfValues() );
+  } else {
+    log.printf("  constructing matrix with rows of length %d from input data\n", getPntrToArgument(0)->getNumberOfValues() );
+  }
 
-  parse("CLEAR",clearstride); unsigned nvals=0;
+  parse("CLEAR",clearstride);
+  unsigned nvals=0;
   if( clearstride==getStride() ) {
-    nvals=1; usefirstconf=(getStride()==0);
+    nvals=1;
+    usefirstconf=(getStride()==0);
   } else if( clearstride>0 ) {
-    if( clearstride%getStride()!=0 ) error("CLEAR parameter must be a multiple of STRIDE");
+    if( clearstride%getStride()!=0 ) {
+      error("CLEAR parameter must be a multiple of STRIDE");
+    }
     log.printf("  clearing collected data every %u steps \n",clearstride);
     nvals=(clearstride/getStride());
   }
 
-  std::vector<unsigned> shape(1); shape[0]=nvals; getPntrToArgument(0)->buildDataStore();
-  if( type=="matrix" ) { shape.resize(2); shape[1] = getPntrToArgument(0)->getNumberOfValues(); }
-  if( type=="vector" ) { shape[0] = nvals*getPntrToArgument(0)->getNumberOfValues(); }
-  addValue( shape ); if( shape.size()==2 ) getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+  std::vector<unsigned> shape(1);
+  shape[0]=nvals;
+  getPntrToArgument(0)->buildDataStore();
+  if( type=="matrix" ) {
+    shape.resize(2);
+    shape[1] = getPntrToArgument(0)->getNumberOfValues();
+  }
+  if( type=="vector" ) {
+    shape[0] = nvals*getPntrToArgument(0)->getNumberOfValues();
+  }
+  addValue( shape );
+  if( shape.size()==2 ) {
+    getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+  }
   if( getPntrToArgument(0)->isPeriodic() ) {
-    std::string min, max; getPntrToArgument(0)->getDomain( min, max );
+    std::string min, max;
+    getPntrToArgument(0)->getDomain( min, max );
     setPeriodic( min, max );
-  } else setNotPeriodic();
+  } else {
+    setNotPeriodic();
+  }
 }
 
 unsigned Collect::getNumberOfDerivatives() {
@@ -113,22 +149,34 @@ unsigned Collect::getNumberOfDerivatives() {
 }
 
 void Collect::update() {
-  if( getStep()==0 || (!onStep() && !usefirstconf) ) return ;
+  if( getStep()==0 || (!onStep() && !usefirstconf) ) {
+    return ;
+  }
   usefirstconf=false;
 
   Value* myin=getPntrToArgument(0);
   Value* myout=getPntrToComponent(0);
   unsigned nargs=myin->getNumberOfValues();
   if( clearstride==getStride() ) {
-    for(unsigned i=0; i<nargs; ++i) myout->set( i, myin->get(i) );
+    for(unsigned i=0; i<nargs; ++i) {
+      myout->set( i, myin->get(i) );
+    }
   } else if( clearstride>0 ) {
     unsigned step = getStep() - clearstride*std::floor( getStep() / clearstride );
-    if( getStep()%clearstride==0 ) step = step + clearstride;
+    if( getStep()%clearstride==0 ) {
+      step = step + clearstride;
+    }
     unsigned base = (step/getStride()-1)*nargs;
-    for(unsigned i=0; i<nargs; ++i) myout->set( base+i, myin->get(i) );
+    for(unsigned i=0; i<nargs; ++i) {
+      myout->set( base+i, myin->get(i) );
+    }
   } else {
-    for(unsigned i=0; i<nargs; ++i) myout->push_back( myin->get(i) );
-    if( myout->getRank()==2 ) myout->reshapeMatrixStore( nargs );
+    for(unsigned i=0; i<nargs; ++i) {
+      myout->push_back( myin->get(i) );
+    }
+    if( myout->getRank()==2 ) {
+      myout->reshapeMatrixStore( nargs );
+    }
   }
 }
 
diff --git a/src/generic/Committor.cpp b/src/generic/Committor.cpp
index 20ed416c21..ff9f8e3c0f 100644
--- a/src/generic/Committor.cpp
+++ b/src/generic/Committor.cpp
@@ -56,8 +56,7 @@ COMMITTOR ...
 
 class Committor :
   public ActionPilot,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
 private:
   std::string file;
   OFile ofile;
@@ -83,7 +82,8 @@ void Committor::registerKeywords( Keywords& keys ) {
   keys.use("ARG");
   keys.add("numbered", "BASIN_LL","List of lower limits for basin #");
   keys.add("numbered", "BASIN_UL","List of upper limits for basin #");
-  keys.reset_style("BASIN_LL","compulsory"); keys.reset_style("BASIN_UL","compulsory");
+  keys.reset_style("BASIN_LL","compulsory");
+  keys.reset_style("BASIN_UL","compulsory");
   keys.add("compulsory","STRIDE","1","the frequency with which the CVs are analyzed");
   keys.add("optional","FILE","the name of the file on which to output the reached basin");
   keys.add("optional","FMT","the format that should be used to output real numbers");
@@ -96,8 +96,7 @@ Committor::Committor(const ActionOptions&ao):
   ActionWithArguments(ao),
   fmt("%f"),
   basin(0),
-  doNotStop(false)
-{
+  doNotStop(false) {
   ofile.link(*this);
   parse("FILE",file);
   if(file.length()>0) {
@@ -115,9 +114,15 @@ Committor::Committor(const ActionOptions&ao):
     std::vector<double> tmpl, tmpu;
     parseNumberedVector("BASIN_LL", b, tmpl );
     parseNumberedVector("BASIN_UL", b, tmpu );
-    if( tmpl.empty() && tmpu.empty() ) break;
-    if( tmpl.size()!=getNumberOfArguments()) error("Wrong number of values for BASIN_LL: they should be equal to the number of arguments");
-    if( tmpu.size()!=getNumberOfArguments()) error("Wrong number of values for BASIN_UL: they should be equal to the number of arguments");
+    if( tmpl.empty() && tmpu.empty() ) {
+      break;
+    }
+    if( tmpl.size()!=getNumberOfArguments()) {
+      error("Wrong number of values for BASIN_LL: they should be equal to the number of arguments");
+    }
+    if( tmpu.size()!=getNumberOfArguments()) {
+      error("Wrong number of values for BASIN_UL: they should be equal to the number of arguments");
+    }
     lowerlimits.push_back(tmpl);
     upperlimits.push_back(tmpu);
     nbasins=b;
@@ -131,13 +136,19 @@ Committor::Committor(const ActionOptions&ao):
   for(unsigned b=0; b<nbasins; b++) {
     log.printf("  BASIN %u definition:\n", b+1);
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-      if(lowerlimits[b][i]>upperlimits[b][i]) error("COMMITTOR: UPPER bounds must always be greater than LOWER bounds");
+      if(lowerlimits[b][i]>upperlimits[b][i]) {
+        error("COMMITTOR: UPPER bounds must always be greater than LOWER bounds");
+      }
       log.printf(" %f - %f\n", lowerlimits[b][i], upperlimits[b][i]);
     }
-    if(doNotStop) log.printf(" COMMITOR will keep track of the visited basins without stopping the simulations\n");
+    if(doNotStop) {
+      log.printf(" COMMITOR will keep track of the visited basins without stopping the simulations\n");
+    }
   }
 
-  for(unsigned i=0; i<getNumberOfArguments(); ++i) ofile.setupPrintValue( getPntrToArgument(i) );
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    ofile.setupPrintValue( getPntrToArgument(i) );
+  }
 }
 
 void Committor::calculate() {
@@ -174,11 +185,14 @@ void Committor::calculate() {
       break;
     }
   }
-  if(!inonebasin) basin = 0;
+  if(!inonebasin) {
+    basin = 0;
+  }
 
   // then check if the simulation should be stopped
   if(inonebasin&&(!doNotStop)) {
-    std::string num; Tools::convert( basin, num );
+    std::string num;
+    Tools::convert( basin, num );
     std::string str = "COMMITTED TO BASIN " + num;
     ofile.addConstantField(str);
     ofile.printField();
diff --git a/src/generic/Constant.cpp b/src/generic/Constant.cpp
index fd1e39759f..b9a4f0660e 100644
--- a/src/generic/Constant.cpp
+++ b/src/generic/Constant.cpp
@@ -62,7 +62,9 @@ class Constant : public ActionWithValue {
   static void registerKeywords( Keywords& keys );
   explicit Constant(const ActionOptions&ao);
   void clearDerivatives( const bool& force=false ) {}
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
   void calculate() override {}
   void apply() override {}
 };
@@ -70,7 +72,9 @@ class Constant : public ActionWithValue {
 PLUMED_REGISTER_ACTION(Constant,"CONSTANT")
 
 void Constant::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords(keys); ActionWithValue::registerKeywords(keys); keys.remove("NUMERICAL_DERIVATIVES");
+  Action::registerKeywords(keys);
+  ActionWithValue::registerKeywords(keys);
+  keys.remove("NUMERICAL_DERIVATIVES");
   keys.add("optional","FILE","an input file containing the matrix");
   keys.add("compulsory","NROWS","0","the number of rows in your input matrix");
   keys.add("compulsory","NCOLS","0","the number of columns in your matrix");
@@ -84,15 +88,20 @@ void Constant::registerKeywords( Keywords& keys ) {
 
 Constant::Constant(const ActionOptions&ao):
   Action(ao),
-  ActionWithValue(ao)
-{
-  bool nolog=false; parseFlag("NOLOG",nolog);
-  bool scalars=false; std::string fname, vname; parse("FILE",fname);
-  std::vector<unsigned> shape; std::vector<double> vals;
+  ActionWithValue(ao) {
+  bool nolog=false;
+  parseFlag("NOLOG",nolog);
+  bool scalars=false;
+  std::string fname, vname;
+  parse("FILE",fname);
+  std::vector<unsigned> shape;
+  std::vector<double> vals;
   if( fname.length()>0 ) {
-    IFile mfile; mfile.open(fname);
+    IFile mfile;
+    mfile.open(fname);
     // Read in first line
-    std::vector<std::string> words; unsigned nline=0;
+    std::vector<std::string> words;
+    unsigned nline=0;
     while( nline==0 ) {
       Tools::getParsedLine( mfile, words );
       nline=words.size();
@@ -102,48 +111,87 @@ Constant::Constant(const ActionOptions&ao):
       shape.resize(1);
       error("invalid matrix in input file");
     }
-    shape.resize(2); shape[1]=nline;
+    shape.resize(2);
+    shape[1]=nline;
     std::vector<double> tmpdis( shape[1] );
-    for(unsigned j=0; j<shape[1]; ++j) Tools::convert( words[j], tmpdis[j] );
+    for(unsigned j=0; j<shape[1]; ++j) {
+      Tools::convert( words[j], tmpdis[j] );
+    }
     dissimilarities.push_back( tmpdis );
 
     while( Tools::getParsedLine( mfile, words ) ) {
-      if( words.size()!=nline ) error("bad formatting in matrix file");
-      for(unsigned j=0; j<nline; ++j) Tools::convert( words[j], tmpdis[j] );
+      if( words.size()!=nline ) {
+        error("bad formatting in matrix file");
+      }
+      for(unsigned j=0; j<nline; ++j) {
+        Tools::convert( words[j], tmpdis[j] );
+      }
       dissimilarities.push_back( tmpdis );
     }
-    mfile.close(); shape[0] = dissimilarities.size(); vals.resize(shape[0]);
-    if( shape.size()==2 ) vals.resize( shape[0]*shape[1] );
+    mfile.close();
+    shape[0] = dissimilarities.size();
+    vals.resize(shape[0]);
+    if( shape.size()==2 ) {
+      vals.resize( shape[0]*shape[1] );
+    }
     for(unsigned i=0; i<shape[0]; ++i) {
-      for(unsigned j=0; j<nline; ++j) vals[i*nline+j] = dissimilarities[i][j];
+      for(unsigned j=0; j<nline; ++j) {
+        vals[i*nline+j] = dissimilarities[i][j];
+      }
     }
   } else {
-    unsigned nr, nc; parse("NROWS",nr); parse("NCOLS",nc);
+    unsigned nr, nc;
+    parse("NROWS",nr);
+    parse("NCOLS",nc);
     if( nr>0 && nc>0 ) {
-      shape.resize(2); shape[0]=nr; shape[1]=nc; vals.resize( nr*nc );
+      shape.resize(2);
+      shape[0]=nr;
+      shape[1]=nc;
+      vals.resize( nr*nc );
       log.printf("  reading in %d by %d matrix \n", nr, nc );
-    } else if( nr>0 || nc>0 ) error("makes no sense to set only one of NROWS and NCOLS to a non-zero value");
-    parseVector("VALUES",vals); parseFlag("SCALARS",scalars);
+    } else if( nr>0 || nc>0 ) {
+      error("makes no sense to set only one of NROWS and NCOLS to a non-zero value");
+    }
+    parseVector("VALUES",vals);
+    parseFlag("SCALARS",scalars);
     if( vals.size()==0 ) {
       parseVector("VALUE",vals);
-      if( vals.size()!=1 ) error("VALUE keyword should take a single scalar");
-    } else if( vals.size()==1 ) scalars=false;
+      if( vals.size()!=1 ) {
+        error("VALUE keyword should take a single scalar");
+      }
+    } else if( vals.size()==1 ) {
+      scalars=false;
+    }
 
     log.printf("  read in %d values :", vals.size() );
-    if( !nolog ) { for(unsigned i=0; i<vals.size(); ++i) log.printf(" %f", vals[i] ); }
+    if( !nolog ) {
+      for(unsigned i=0; i<vals.size(); ++i) {
+        log.printf(" %f", vals[i] );
+      }
+    }
     log.printf("\n");
-    if( !scalars && shape.size()==0 && vals.size()>1 ) { shape.resize(1); shape[0] = vals.size(); }
+    if( !scalars && shape.size()==0 && vals.size()>1 ) {
+      shape.resize(1);
+      shape[0] = vals.size();
+    }
   }
   if( !scalars ) {
     // Now set the value
-    addValue( shape ); setNotPeriodic(); getPntrToComponent(0)->setConstant();
-    for(unsigned i=0; i<vals.size(); ++i) getPntrToComponent(0)->set( i, vals[i] );
+    addValue( shape );
+    setNotPeriodic();
+    getPntrToComponent(0)->setConstant();
+    for(unsigned i=0; i<vals.size(); ++i) {
+      getPntrToComponent(0)->set( i, vals[i] );
+    }
   } else {
     for(unsigned i=0; i<vals.size(); i++) {
-      std::string num; Tools::convert(i,num);
-      addComponent("v-"+num); componentIsNotPeriodic("v-"+num);
+      std::string num;
+      Tools::convert(i,num);
+      addComponent("v-"+num);
+      componentIsNotPeriodic("v-"+num);
       Value* comp=getPntrToComponent("v-"+num);
-      comp->setConstant(); comp->set(vals[i]);
+      comp->setConstant();
+      comp->set(vals[i]);
     }
   }
 }
diff --git a/src/generic/CreateMask.cpp b/src/generic/CreateMask.cpp
index 4177567ff3..b86fccfac3 100644
--- a/src/generic/CreateMask.cpp
+++ b/src/generic/CreateMask.cpp
@@ -46,7 +46,9 @@ class CreateMask :
 public:
   static void registerKeywords( Keywords& keys );
   CreateMask( const ActionOptions& );
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
   void prepare() override ;
   void calculate() override ;
   void apply() override {}
@@ -55,8 +57,10 @@ class CreateMask :
 PLUMED_REGISTER_ACTION(CreateMask,"CREATE_MASK")
 
 void CreateMask::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.use("ARG");
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("compulsory","TYPE","the way the zeros are supposed to be set");
   keys.add("compulsory","NZEROS","the number of zeros that you want to put in the mask");
   keys.add("optional","SEED","the seed to use for the random number generator");
@@ -68,59 +72,101 @@ CreateMask::CreateMask( const ActionOptions& ao ) :
   Action(ao),
   ActionWithValue(ao),
   ActionWithArguments(ao),
-  nzeros(0)
-{
-  if( getNumberOfArguments()!=1 ) error("should only be one argument to this action");
-  if( getPntrToArgument(0)->getRank()!=1 ) error("argument should be a vector");
-  std::string stype; parse("TYPE",stype); if( stype!="nomask" ) parse("NZEROS",nzeros);
+  nzeros(0) {
+  if( getNumberOfArguments()!=1 ) {
+    error("should only be one argument to this action");
+  }
+  if( getPntrToArgument(0)->getRank()!=1 ) {
+    error("argument should be a vector");
+  }
+  std::string stype;
+  parse("TYPE",stype);
+  if( stype!="nomask" ) {
+    parse("NZEROS",nzeros);
+  }
 
   if( stype=="nomask" ) {
-    type=nomask; log.printf("  setting all points in output mask to zero \n");
+    type=nomask;
+    log.printf("  setting all points in output mask to zero \n");
   } else if( stype=="stride" ) {
-    type=stride; log.printf("  setting every %d equally spaced points in output mask to zero \n", nzeros );
+    type=stride;
+    log.printf("  setting every %d equally spaced points in output mask to zero \n", nzeros );
   } else if( stype=="random" ) {
-    unsigned seed=230623; parse("SEED",seed); r.setSeed(-seed); getPntrToArgument(0)->buildDataStore();
-    type=random; log.printf("  choosing %d points to set to non-zero in mask in accordance with input weights \n", nzeros );
-  } else error( stype + " is not a valid way input for TYPE");
-  std::vector<unsigned> shape(1); shape[0] = getPntrToArgument(0)->getShape()[0];
-  addValue( shape ); setNotPeriodic(); getPntrToComponent(0)->buildDataStore();
-  for(unsigned i=0; i<shape[0]; ++i) getPntrToComponent(0)->set( i, 1.0 );
+    unsigned seed=230623;
+    parse("SEED",seed);
+    r.setSeed(-seed);
+    getPntrToArgument(0)->buildDataStore();
+    type=random;
+    log.printf("  choosing %d points to set to non-zero in mask in accordance with input weights \n", nzeros );
+  } else {
+    error( stype + " is not a valid way input for TYPE");
+  }
+  std::vector<unsigned> shape(1);
+  shape[0] = getPntrToArgument(0)->getShape()[0];
+  addValue( shape );
+  setNotPeriodic();
+  getPntrToComponent(0)->buildDataStore();
+  for(unsigned i=0; i<shape[0]; ++i) {
+    getPntrToComponent(0)->set( i, 1.0 );
+  }
 }
 
 void CreateMask::prepare() {
-  Value* out=getPntrToComponent(0); Value* arg=getPntrToArgument(0);
+  Value* out=getPntrToComponent(0);
+  Value* arg=getPntrToArgument(0);
   if( out->getShape()[0]!=arg->getShape()[0] ) {
-    std::vector<unsigned> shape(1); shape[0] = arg->getShape()[0]; out->setShape( shape );
+    std::vector<unsigned> shape(1);
+    shape[0] = arg->getShape()[0];
+    out->setShape( shape );
   }
   if( type!=nomask ) {
-    for(unsigned i=nzeros; i<out->getShape()[0]; ++i) out->set( i, 1 );
+    for(unsigned i=nzeros; i<out->getShape()[0]; ++i) {
+      out->set( i, 1 );
+    }
   }
 }
 
 void CreateMask::calculate() {
-  Value* out=getPntrToComponent(0); Value* arg=getPntrToArgument(0);
+  Value* out=getPntrToComponent(0);
+  Value* arg=getPntrToArgument(0);
   unsigned ns = arg->getShape()[0];
-  for(unsigned i=0; i<ns; ++i) out->set( i, 1.0 );
+  for(unsigned i=0; i<ns; ++i) {
+    out->set( i, 1.0 );
+  }
 
   if( type==stride ) {
     std::size_t ss = int( std::floor( ns / nzeros ) );
-    for(unsigned i=0; i<nzeros; ++i) out->set( i*ss, 0.0 );
+    for(unsigned i=0; i<nzeros; ++i) {
+      out->set( i*ss, 0.0 );
+    }
   } else if( type==random ) {
     for(unsigned i=0; i<nzeros; ++i ) {
       double totweights = 0;
       for(unsigned j=0; j<ns; ++j) {
-        if( out->get(j)>0 ) totweights += arg->get(j);
+        if( out->get(j)>0 ) {
+          totweights += arg->get(j);
+        }
       }
-      double rr = r.U01()*totweights; double accum=0;
+      double rr = r.U01()*totweights;
+      double accum=0;
       for(unsigned j=0; j<ns; ++j) {
-        if( out->get(j)>0 ) accum += arg->get(j);
-        if( accum<rr ) continue;
-        out->set( j, 0 ); break;
+        if( out->get(j)>0 ) {
+          accum += arg->get(j);
+        }
+        if( accum<rr ) {
+          continue;
+        }
+        out->set( j, 0 );
+        break;
       }
     }
   } else if( type==nomask ) {
-    for(unsigned i=0; i<ns; ++i) out->set( i, 0.0 );
-  } else error("invalid mask creation type");
+    for(unsigned i=0; i<ns; ++i) {
+      out->set( i, 0.0 );
+    }
+  } else {
+    error("invalid mask creation type");
+  }
 }
 
 }
diff --git a/src/generic/Debug.cpp b/src/generic/Debug.cpp
index e7fe458ef8..722d665e3e 100644
--- a/src/generic/Debug.cpp
+++ b/src/generic/Debug.cpp
@@ -45,8 +45,7 @@ DEBUG logRequestedAtoms STRIDE=2
 */
 //+ENDPLUMEDOC
 class Debug:
-  public ActionPilot
-{
+  public ActionPilot {
   OFile ofile;
   bool logActivity;
   bool logRequestedAtoms;
@@ -80,12 +79,20 @@ Debug::Debug(const ActionOptions&ao):
   logRequestedAtoms(false),
   novirial(false) {
   parseFlag("logActivity",logActivity);
-  if(logActivity) log.printf("  logging activity\n");
+  if(logActivity) {
+    log.printf("  logging activity\n");
+  }
   parseFlag("logRequestedAtoms",logRequestedAtoms);
-  if(logRequestedAtoms) log.printf("  logging requested atoms\n");
+  if(logRequestedAtoms) {
+    log.printf("  logging requested atoms\n");
+  }
   parseFlag("NOVIRIAL",novirial);
-  if(novirial) log.printf("  Switching off virial contribution\n");
-  if(novirial) plumed.novirial=true;
+  if(novirial) {
+    log.printf("  Switching off virial contribution\n");
+  }
+  if(novirial) {
+    plumed.novirial=true;
+  }
   parseFlag("DETAILED_TIMERS",detailedTimers);
   if(detailedTimers) {
     log.printf("  Detailed timing on\n");
@@ -109,15 +116,24 @@ void Debug::apply() {
     const ActionSet&actionSet(plumed.getActionSet());
     int a=0;
     for(const auto & p : actionSet) {
-      if(dynamic_cast<Debug*>(p.get()))continue;
-      if(p->isActive()) a++;
+      if(dynamic_cast<Debug*>(p.get())) {
+        continue;
+      }
+      if(p->isActive()) {
+        a++;
+      }
     };
     if(a>0) {
       ofile<<"activity at step "<<getStep()<<": ";
       for(const auto & p : actionSet) {
-        if(dynamic_cast<Debug*>(p.get()))continue;
-        if(p->isActive()) ofile.printf("+");
-        else                 ofile.printf("-");
+        if(dynamic_cast<Debug*>(p.get())) {
+          continue;
+        }
+        if(p->isActive()) {
+          ofile.printf("+");
+        } else {
+          ofile.printf("-");
+        }
       };
       ofile.printf("\n");
     };
@@ -128,7 +144,9 @@ void Debug::apply() {
     int n;
     plumed.cmd("createFullList",&n);
     plumed.cmd("getFullList",&l);
-    for(int i=0; i<n; i++) ofile.printf(" %d",l[i]);
+    for(int i=0; i<n; i++) {
+      ofile.printf(" %d",l[i]);
+    }
     ofile.printf("\n");
     plumed.cmd("clearFullList");
   }
diff --git a/src/generic/DumpAtoms.cpp b/src/generic/DumpAtoms.cpp
index 3db26f4a9f..1112772a34 100644
--- a/src/generic/DumpAtoms.cpp
+++ b/src/generic/DumpAtoms.cpp
@@ -119,8 +119,7 @@ DUMPATOMS STRIDE=10 FILE=file.xtc ATOMS=1-10,c1 PRECISION=7
 class DumpAtoms:
   public ActionAtomistic,
   public ActionWithArguments,
-  public ActionPilot
-{
+  public ActionPilot {
   OFile of;
   double lenunit;
   int iprecision;
@@ -138,7 +137,9 @@ class DumpAtoms:
   ~DumpAtoms();
   static void registerKeywords( Keywords& keys );
   void calculateNumericalDerivatives( ActionWithValue* a=NULL ) override;
-  bool actionHasForces() override { return false; }
+  bool actionHasForces() override {
+    return false;
+  }
   void lockRequests() override;
   void unlockRequests() override;
   void calculate() override {}
@@ -152,7 +153,8 @@ void DumpAtoms::registerKeywords( Keywords& keys ) {
   Action::registerKeywords( keys );
   ActionPilot::registerKeywords( keys );
   ActionAtomistic::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.use("ARG");
+  ActionWithArguments::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("compulsory","STRIDE","1","the frequency with which the atoms should be output");
   keys.add("atoms", "ATOMS", "the atom indices whose positions you would like to print out");
   keys.add("compulsory", "FILE", "file on which to output coordinates; extension is automatically detected");
@@ -171,12 +173,13 @@ DumpAtoms::DumpAtoms(const ActionOptions&ao):
   ActionAtomistic(ao),
   ActionWithArguments(ao),
   ActionPilot(ao),
-  iprecision(3)
-{
+  iprecision(3) {
   std::vector<AtomNumber> atoms;
   std::string file;
   parse("FILE",file);
-  if(file.length()==0) error("name out output file was not specified");
+  if(file.length()==0) {
+    error("name out output file was not specified");
+  }
   type=Tools::extension(file);
   log<<"  file name "<<file<<"\n";
   if(type=="gro" || type=="xyz" || type=="xtc" || type=="trr") {
@@ -189,7 +192,9 @@ DumpAtoms::DumpAtoms(const ActionOptions&ao):
   parse("TYPE",ntype);
   if(ntype.length()>0) {
     if(ntype!="xyz" && ntype!="gro" && ntype!="xtc" && ntype!="trr"
-      ) error("TYPE cannot be understood");
+      ) {
+      error("TYPE cannot be understood");
+    }
     log<<"  file type enforced to be "<<ntype<<"\n";
     type=ntype;
   }
@@ -213,15 +218,26 @@ DumpAtoms::DumpAtoms(const ActionOptions&ao):
 
   parseAtomList("ATOMS",atoms);
 
-  std::string unitname; parse("UNITS",unitname);
+  std::string unitname;
+  parse("UNITS",unitname);
   if(unitname!="PLUMED") {
-    Units myunit; myunit.setLength(unitname);
-    if(myunit.getLength()!=1.0 && type=="gro") error("gro files should be in nm");
-    if(myunit.getLength()!=1.0 && type=="xtc") error("xtc files should be in nm");
-    if(myunit.getLength()!=1.0 && type=="trr") error("trr files should be in nm");
+    Units myunit;
+    myunit.setLength(unitname);
+    if(myunit.getLength()!=1.0 && type=="gro") {
+      error("gro files should be in nm");
+    }
+    if(myunit.getLength()!=1.0 && type=="xtc") {
+      error("xtc files should be in nm");
+    }
+    if(myunit.getLength()!=1.0 && type=="trr") {
+      error("trr files should be in nm");
+    }
     lenunit=getUnits().getLength()/myunit.getLength();
-  } else if(type=="gro" || type=="xtc" || type=="trr") lenunit=getUnits().getLength();
-  else lenunit=1.0;
+  } else if(type=="gro" || type=="xtc" || type=="trr") {
+    lenunit=getUnits().getLength();
+  } else {
+    lenunit=1.0;
+  }
 
   of.link(*this);
   of.open(file);
@@ -236,22 +252,37 @@ DumpAtoms::DumpAtoms(const ActionOptions&ao):
     xd=xdrfile::xdrfile_open(path.c_str(),mode.c_str());
   }
   log.printf("  printing the following atoms in %s :", unitname.c_str() );
-  for(unsigned i=0; i<atoms.size(); ++i) log.printf(" %d",atoms[i].serial() );
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf(" %d",atoms[i].serial() );
+  }
   log.printf("\n");
 
   if( getNumberOfArguments()>0 ) {
-    if( type!="xyz" ) error("can only print atomic properties when outputting xyz files");
+    if( type!="xyz" ) {
+      error("can only print atomic properties when outputting xyz files");
+    }
 
     std::vector<std::string> argnames;
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-      if( getPntrToArgument(i)->getRank()!=1 || getPntrToArgument(i)->hasDerivatives() ) error("arguments for xyz output should be vectors");
-      if( getPntrToArgument(i)->getNumberOfValues()!=atoms.size() ) error("number of elements in vector " + getPntrToArgument(i)->getName() + " is not equal to number of atoms output");
-      getPntrToArgument(i)->buildDataStore(true); argnames.push_back( getPntrToArgument(i)->getName() );
+      if( getPntrToArgument(i)->getRank()!=1 || getPntrToArgument(i)->hasDerivatives() ) {
+        error("arguments for xyz output should be vectors");
+      }
+      if( getPntrToArgument(i)->getNumberOfValues()!=atoms.size() ) {
+        error("number of elements in vector " + getPntrToArgument(i)->getName() + " is not equal to number of atoms output");
+      }
+      getPntrToArgument(i)->buildDataStore(true);
+      argnames.push_back( getPntrToArgument(i)->getName() );
+    }
+    std::vector<std::string> str_upper, str_lower;
+    std::string errors;
+    parseVector("LESS_THAN_OR_EQUAL",str_upper);
+    parseVector("GREATER_THAN_OR_EQUAL",str_lower);
+    if( !bounds.setBounds( getNumberOfArguments(), str_lower, str_upper, errors ) ) {
+      error( errors );
+    }
+    if( bounds.wereSet() ) {
+      log.printf("  %s \n", bounds.report( argnames ).c_str() );
     }
-    std::vector<std::string> str_upper, str_lower; std::string errors;
-    parseVector("LESS_THAN_OR_EQUAL",str_upper); parseVector("GREATER_THAN_OR_EQUAL",str_lower);
-    if( !bounds.setBounds( getNumberOfArguments(), str_lower, str_upper, errors ) ) error( errors );
-    if( bounds.wereSet() ) log.printf("  %s \n", bounds.report( argnames ).c_str() );
   }
 
   requestAtoms(atoms, false);
@@ -259,11 +290,20 @@ DumpAtoms::DumpAtoms(const ActionOptions&ao):
   if( moldat ) {
     log<<"  MOLINFO DATA found with label " <<moldat->getLabel()<<", using proper atom names\n";
     names.resize(atoms.size());
-    for(unsigned i=0; i<atoms.size(); i++) if(atoms[i].index()<moldat->getPDBsize()) names[i]=moldat->getAtomName(atoms[i]);
+    for(unsigned i=0; i<atoms.size(); i++)
+      if(atoms[i].index()<moldat->getPDBsize()) {
+        names[i]=moldat->getAtomName(atoms[i]);
+      }
     residueNumbers.resize(atoms.size());
-    for(unsigned i=0; i<residueNumbers.size(); ++i) if(atoms[i].index()<moldat->getPDBsize()) residueNumbers[i]=moldat->getResidueNumber(atoms[i]);
+    for(unsigned i=0; i<residueNumbers.size(); ++i)
+      if(atoms[i].index()<moldat->getPDBsize()) {
+        residueNumbers[i]=moldat->getResidueNumber(atoms[i]);
+      }
     residueNames.resize(atoms.size());
-    for(unsigned i=0; i<residueNames.size(); ++i) if(atoms[i].index()<moldat->getPDBsize()) residueNames[i]=moldat->getResidueName(atoms[i]);
+    for(unsigned i=0; i<residueNames.size(); ++i)
+      if(atoms[i].index()<moldat->getPDBsize()) {
+        residueNames[i]=moldat->getResidueName(atoms[i]);
+      }
   }
 }
 
@@ -283,10 +323,15 @@ void DumpAtoms::unlockRequests() {
 
 void DumpAtoms::update() {
   if(type=="xyz") {
-    unsigned nat=0; std::vector<double> args( getNumberOfArguments() );
+    unsigned nat=0;
+    std::vector<double> args( getNumberOfArguments() );
     for(unsigned i=0; i<getNumberOfAtoms(); ++i)  {
-      for(unsigned j=0; j<getNumberOfArguments(); ++j) args[j] = getPntrToArgument(j)->get(i);
-      if( bounds.check( args ) ) nat++;
+      for(unsigned j=0; j<getNumberOfArguments(); ++j) {
+        args[j] = getPntrToArgument(j)->get(i);
+      }
+      if( bounds.check( args ) ) {
+        nat++;
+      }
     }
     of.printf("%d\n",nat);
     const Tensor & t(getPbc().getBox());
@@ -300,13 +345,22 @@ void DumpAtoms::update() {
                );
     }
     for(unsigned i=0; i<getNumberOfAtoms(); ++i) {
-      for(unsigned j=0; j<getNumberOfArguments(); ++j) args[j] = getPntrToArgument(j)->get(i);
-      if( !bounds.check(args) ) continue;
+      for(unsigned j=0; j<getNumberOfArguments(); ++j) {
+        args[j] = getPntrToArgument(j)->get(i);
+      }
+      if( !bounds.check(args) ) {
+        continue;
+      }
       const char* defname="X";
       const char* name=defname;
-      if(names.size()>0) if(names[i].length()>0) name=names[i].c_str();
+      if(names.size()>0)
+        if(names[i].length()>0) {
+          name=names[i].c_str();
+        }
       of.printf(("%s "+fmt_xyz+" "+fmt_xyz+" "+fmt_xyz).c_str(),name,lenunit*getPosition(i)(0),lenunit*getPosition(i)(1),lenunit*getPosition(i)(2));
-      for(unsigned j=0; j<getNumberOfArguments(); ++j) of.printf((" "+fmt_xyz).c_str(), getPntrToArgument(j)->get(i) );
+      for(unsigned j=0; j<getNumberOfArguments(); ++j) {
+        of.printf((" "+fmt_xyz).c_str(), getPntrToArgument(j)->get(i) );
+      }
       of.printf("\n");
     }
   } else if(type=="gro") {
@@ -317,10 +371,17 @@ void DumpAtoms::update() {
       const char* defname="X";
       const char* name=defname;
       unsigned residueNumber=0;
-      if(names.size()>0) if(names[i].length()>0) name=names[i].c_str();
-      if(residueNumbers.size()>0) residueNumber=residueNumbers[i];
+      if(names.size()>0)
+        if(names[i].length()>0) {
+          name=names[i].c_str();
+        }
+      if(residueNumbers.size()>0) {
+        residueNumber=residueNumbers[i];
+      }
       std::string resname="";
-      if(residueNames.size()>0) resname=residueNames[i];
+      if(residueNames.size()>0) {
+        resname=residueNames[i];
+      }
       of.printf(("%5u%-5s%5s%5d"+fmt_gro_pos+fmt_gro_pos+fmt_gro_pos+"\n").c_str(),
                 residueNumber%100000,resname.c_str(),name,getAbsoluteIndex(i).serial()%100000,
                 lenunit*getPosition(i)(0),lenunit*getPosition(i)(1),lenunit*getPosition(i)(2));
@@ -336,17 +397,25 @@ void DumpAtoms::update() {
     int step=getStep();
     float time=getTime()/getUnits().getTime();
     float precision=Tools::fastpow(10.0,iprecision);
-    for(int i=0; i<3; i++) for(int j=0; j<3; j++) box[i][j]=lenunit*t(i,j);
+    for(int i=0; i<3; i++)
+      for(int j=0; j<3; j++) {
+        box[i][j]=lenunit*t(i,j);
+      }
 // here we cannot use a std::vector<rvec> since it does not compile.
 // we thus use a std::unique_ptr<rvec[]>
     auto pos = Tools::make_unique<xdrfile::rvec[]>(natoms);
-    for(int i=0; i<natoms; i++) for(int j=0; j<3; j++) pos[i][j]=lenunit*getPosition(i)(j);
+    for(int i=0; i<natoms; i++)
+      for(int j=0; j<3; j++) {
+        pos[i][j]=lenunit*getPosition(i)(j);
+      }
     if(type=="xtc") {
       write_xtc(xd,natoms,step,time,box,&pos[0],precision);
     } else if(type=="trr") {
       write_trr(xd,natoms,step,time,0.0,box,&pos[0],NULL,NULL);
     }
-  } else plumed_merror("unknown file type "+type);
+  } else {
+    plumed_merror("unknown file type "+type);
+  }
 }
 
 DumpAtoms::~DumpAtoms() {
diff --git a/src/generic/DumpDerivatives.cpp b/src/generic/DumpDerivatives.cpp
index e359bcf057..cb3e48f3c4 100644
--- a/src/generic/DumpDerivatives.cpp
+++ b/src/generic/DumpDerivatives.cpp
@@ -54,8 +54,7 @@ DUMPDERIVATIVES ARG=distance,distanceN STRIDE=1 FILE=deriv
 
 class DumpDerivatives :
   public ActionPilot,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
   std::string file;
   std::string fmt;
   OFile of;
@@ -87,10 +86,11 @@ DumpDerivatives::DumpDerivatives(const ActionOptions&ao):
   Action(ao),
   ActionPilot(ao),
   ActionWithArguments(ao),
-  fmt("%15.10f")
-{
+  fmt("%15.10f") {
   parse("FILE",file);
-  if( file.length()==0 ) error("name of output file was not specified");
+  if( file.length()==0 ) {
+    error("name of output file was not specified");
+  }
   parse("FMT",fmt);
   fmt=" "+fmt;
   of.link(*this);
@@ -98,15 +98,25 @@ DumpDerivatives::DumpDerivatives(const ActionOptions&ao):
   log.printf("  on file %s\n",file.c_str());
   log.printf("  with format %s\n",fmt.c_str());
   unsigned nargs=getNumberOfArguments();
-  if( nargs==0 ) error("no arguments specified");
+  if( nargs==0 ) {
+    error("no arguments specified");
+  }
   (getPntrToArgument(0)->getPntrToAction())->turnOnDerivatives();
-  if( getPntrToArgument(0)->getRank()>0 ) error("cannot dump derivatives of non-scalar objects");
+  if( getPntrToArgument(0)->getRank()>0 ) {
+    error("cannot dump derivatives of non-scalar objects");
+  }
   unsigned npar=getPntrToArgument(0)->getNumberOfDerivatives();
-  if( npar==0 ) error("one or more arguments has no derivatives");
+  if( npar==0 ) {
+    error("one or more arguments has no derivatives");
+  }
   for(unsigned i=1; i<nargs; i++) {
     (getPntrToArgument(i)->getPntrToAction())->turnOnDerivatives();
-    if( getPntrToArgument(i)->getRank()>0 ) error("cannot dump derivatives of non-scalar objects");
-    if( npar!=getPntrToArgument(i)->getNumberOfDerivatives() ) error("the number of derivatives must be the same in all values being dumped");
+    if( getPntrToArgument(i)->getRank()>0 ) {
+      error("cannot dump derivatives of non-scalar objects");
+    }
+    if( npar!=getPntrToArgument(i)->getNumberOfDerivatives() ) {
+      error("the number of derivatives must be the same in all values being dumped");
+    }
   }
   checkRead();
 }
diff --git a/src/generic/DumpForces.cpp b/src/generic/DumpForces.cpp
index 8fc1411f63..b3ba3ab13c 100644
--- a/src/generic/DumpForces.cpp
+++ b/src/generic/DumpForces.cpp
@@ -52,8 +52,7 @@ DUMPFORCES ARG=distance STRIDE=1 FILE=forces
 
 class DumpForces :
   public ActionPilot,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
   std::string file;
   std::string fmt;
   OFile of;
@@ -85,17 +84,20 @@ DumpForces::DumpForces(const ActionOptions&ao):
   Action(ao),
   ActionPilot(ao),
   ActionWithArguments(ao),
-  fmt("%15.10f")
-{
+  fmt("%15.10f") {
   parse("FILE",file);
-  if( file.length()==0 ) error("name of file was not specified");
+  if( file.length()==0 ) {
+    error("name of file was not specified");
+  }
   parse("FMT",fmt);
   fmt=" "+fmt;
   of.link(*this);
   of.open(file);
   log.printf("  on file %s\n",file.c_str());
   log.printf("  with format %s\n",fmt.c_str());
-  if( getNumberOfArguments()==0 ) error("no arguments have been specified");
+  if( getNumberOfArguments()==0 ) {
+    error("no arguments have been specified");
+  }
   checkRead();
 }
 
diff --git a/src/generic/DumpMassCharge.cpp b/src/generic/DumpMassCharge.cpp
index 66107ce17f..5ff4a80632 100644
--- a/src/generic/DumpMassCharge.cpp
+++ b/src/generic/DumpMassCharge.cpp
@@ -25,8 +25,7 @@
 #include "tools/File.h"
 #include "core/PlumedMain.h"
 
-namespace PLMD
-{
+namespace PLMD {
 namespace generic {
 
 //+PLUMEDOC PRINTANALYSIS DUMPMASSCHARGE
@@ -75,8 +74,7 @@ DUMPMASSCHARGE FILE=mcfile ATOMS=solute_ions
 
 class DumpMassCharge:
   public ActionAtomistic,
-  public ActionPilot
-{
+  public ActionPilot {
   std::string file;
   bool first;
   bool second;
@@ -86,7 +84,9 @@ class DumpMassCharge:
   explicit DumpMassCharge(const ActionOptions&);
   ~DumpMassCharge();
   static void registerKeywords( Keywords& keys );
-  bool actionHasForces() override { return false; }
+  bool actionHasForces() override {
+    return false;
+  }
   void prepare() override;
   void calculate() override {}
   void apply() override {}
@@ -113,17 +113,20 @@ DumpMassCharge::DumpMassCharge(const ActionOptions&ao):
   first(true),
   second(true),
   print_masses(true),
-  print_charges(true)
-{
+  print_charges(true) {
   std::vector<AtomNumber> atoms;
   parse("FILE",file);
-  if(file.length()==0) error("name of output file was not specified");
+  if(file.length()==0) {
+    error("name of output file was not specified");
+  }
   log.printf("  output written to file %s\n",file.c_str());
 
   parseAtomList("ATOMS",atoms);
 
   if(atoms.size()==0) {
-    std::vector<std::string> strvec(1); strvec[0]="@mdatoms"; interpretAtomList( strvec,atoms );
+    std::vector<std::string> strvec(1);
+    strvec[0]="@mdatoms";
+    interpretAtomList( strvec,atoms );
   }
 
   bool only_masses = false;
@@ -144,7 +147,9 @@ DumpMassCharge::DumpMassCharge(const ActionOptions&ao):
   checkRead();
 
   log.printf("  printing the following atoms:" );
-  for(unsigned i=0; i<atoms.size(); ++i) log.printf(" %d",atoms[i].serial() );
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf(" %d",atoms[i].serial() );
+  }
   log.printf("\n");
   requestAtoms(atoms);
 
@@ -162,7 +167,9 @@ void DumpMassCharge::prepare() {
 }
 
 void DumpMassCharge::update() {
-  if(!first) return;
+  if(!first) {
+    return;
+  }
   first=false;
 
   OFile of;
@@ -172,8 +179,12 @@ void DumpMassCharge::update() {
   for(unsigned i=0; i<getNumberOfAtoms(); i++) {
     int ii=getAbsoluteIndex(i).index();
     of.printField("index",ii);
-    if(print_masses) {of.printField("mass",getMass(i));}
-    if(print_charges) {of.printField("charge",getCharge(i));}
+    if(print_masses) {
+      of.printField("mass",getMass(i));
+    }
+    if(print_charges) {
+      of.printField("charge",getCharge(i));
+    }
     of.printField();
   }
 }
diff --git a/src/generic/DumpPDB.cpp b/src/generic/DumpPDB.cpp
index 7ab771d0ee..f01dc47361 100644
--- a/src/generic/DumpPDB.cpp
+++ b/src/generic/DumpPDB.cpp
@@ -43,8 +43,7 @@ Output PDB file.
 
 class DumpPDB :
   public ActionWithArguments,
-  public ActionPilot
-{
+  public ActionPilot {
   std::string fmt;
   std::string file;
   std::string description;
@@ -67,7 +66,8 @@ PLUMED_REGISTER_ACTION(DumpPDB,"DUMPPDB")
 void DumpPDB::registerKeywords( Keywords& keys ) {
   Action::registerKeywords( keys );
   ActionPilot::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.use("ARG");
+  ActionWithArguments::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("optional","ATOMS","value containing positions of atoms that should be output");
   keys.add("compulsory","STRIDE","0","the frequency with which the atoms should be output");
   keys.add("compulsory","FILE","the name of the file on which to output these quantities");
@@ -83,60 +83,107 @@ void DumpPDB::registerKeywords( Keywords& keys ) {
 DumpPDB::DumpPDB(const ActionOptions&ao):
   Action(ao),
   ActionWithArguments(ao),
-  ActionPilot(ao)
-{
+  ActionPilot(ao) {
   parse("FILE",file);
-  if(file.length()==0) error("name out output file was not specified");
-  std::vector<std::string> atoms; parseVector("ATOMS",atoms);
+  if(file.length()==0) {
+    error("name out output file was not specified");
+  }
+  std::vector<std::string> atoms;
+  parseVector("ATOMS",atoms);
   if( atoms.size()>0 ) {
-    std::vector<Value*> atom_args; interpretArgumentList( atoms, plumed.getActionSet(), this, atom_args );
-    if( atom_args.size()!=1 ) error("only one action should appear in input to atom args");
-    std::vector<Value*> args( getArguments() ); args.push_back( atom_args[0] ); requestArguments( args );
-    std::vector<std::string> indices; parseVector("ATOM_INDICES",indices); std::vector<Value*> xvals,yvals,zvals,masv,chargev;
+    std::vector<Value*> atom_args;
+    interpretArgumentList( atoms, plumed.getActionSet(), this, atom_args );
+    if( atom_args.size()!=1 ) {
+      error("only one action should appear in input to atom args");
+    }
+    std::vector<Value*> args( getArguments() );
+    args.push_back( atom_args[0] );
+    requestArguments( args );
+    std::vector<std::string> indices;
+    parseVector("ATOM_INDICES",indices);
+    std::vector<Value*> xvals,yvals,zvals,masv,chargev;
     ActionAtomistic::getAtomValuesFromPlumedObject(plumed,xvals,yvals,zvals,masv,chargev);
     ActionAtomistic::interpretAtomList( indices, xvals, this, pdb_atom_indices );
     log.printf("  printing atoms : ");
-    for(unsigned i=0; i<indices.size(); ++i) log.printf("%d ", pdb_atom_indices[i].serial() );
+    for(unsigned i=0; i<indices.size(); ++i) {
+      log.printf("%d ", pdb_atom_indices[i].serial() );
+    }
     log.printf("\n");
-    if( pdb_atom_indices.size()!=atom_args[0]->getShape()[1]/3 ) error("mismatch between size of matrix containing positions and vector of atom indices");
-    beta.resize( atom_args[0]->getShape()[1]/3 ); occupancy.resize( atom_args[0]->getShape()[1]/3 );
-    parseVector("OCCUPANCY", occupancy ); parseVector("BETA", beta );
+    if( pdb_atom_indices.size()!=atom_args[0]->getShape()[1]/3 ) {
+      error("mismatch between size of matrix containing positions and vector of atom indices");
+    }
+    beta.resize( atom_args[0]->getShape()[1]/3 );
+    occupancy.resize( atom_args[0]->getShape()[1]/3 );
+    parseVector("OCCUPANCY", occupancy );
+    parseVector("BETA", beta );
     parseVector("RESIDUE_INDICES",pdb_resid_indices);
     if( pdb_resid_indices.size()==0 ) {
       pdb_resid_indices.resize( pdb_atom_indices.size() );
-      for(unsigned i=0; i<pdb_resid_indices.size(); ++i) pdb_resid_indices[i] = pdb_atom_indices[i].serial();
-    } else if( pdb_resid_indices.size()!=pdb_atom_indices.size() ) error("mismatch between number of atom indices provided and number of residue indices provided");
+      for(unsigned i=0; i<pdb_resid_indices.size(); ++i) {
+        pdb_resid_indices[i] = pdb_atom_indices[i].serial();
+      }
+    } else if( pdb_resid_indices.size()!=pdb_atom_indices.size() ) {
+      error("mismatch between number of atom indices provided and number of residue indices provided");
+    }
   }
   log.printf("  printing configurations to PDB file to file named %s \n", file.c_str() );
-  parseVector("ARG_NAMES",argnames); if( argnames.size()==0 ) buildArgnames();
-  parse("FMT",fmt); fmt=" "+fmt;
-  if( getStride()==0 ) { setStride(0); log.printf("  printing pdb at end of calculation \n"); }
+  parseVector("ARG_NAMES",argnames);
+  if( argnames.size()==0 ) {
+    buildArgnames();
+  }
+  parse("FMT",fmt);
+  fmt=" "+fmt;
+  if( getStride()==0 ) {
+    setStride(0);
+    log.printf("  printing pdb at end of calculation \n");
+  }
 
   parse("DESCRIPTION",description);
-  if( getPntrToArgument(0)->getRank()==0 || getPntrToArgument(0)->hasDerivatives() ) error("argument for printing of PDB should be vector or matrix");
+  if( getPntrToArgument(0)->getRank()==0 || getPntrToArgument(0)->hasDerivatives() ) {
+    error("argument for printing of PDB should be vector or matrix");
+  }
   unsigned nv=getPntrToArgument(0)->getShape()[0];
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->getRank()==0 || getPntrToArgument(i)->hasDerivatives() ) error("argument for printing of PDB should be vector or matrix");
-    if( getPntrToArgument(i)->getShape()[0]!=nv ) error("for printing to pdb files all arguments must have same number of values");
+    if( getPntrToArgument(i)->getRank()==0 || getPntrToArgument(i)->hasDerivatives() ) {
+      error("argument for printing of PDB should be vector or matrix");
+    }
+    if( getPntrToArgument(i)->getShape()[0]!=nv ) {
+      error("for printing to pdb files all arguments must have same number of values");
+    }
   }
 }
 
 void DumpPDB::printAtom( OFile& opdbf, const unsigned& anum, const unsigned& rnum, const Vector& pos, const double& m, const double& q ) const {
-  if( rnum>999 ) plumed_merror("atom number too large to be used as residue number");
-  std::array<char,6> at; const char* msg = h36::hy36encode(5,anum,&at[0]);
-  plumed_assert(msg==nullptr) << msg; at[5]=0; double lunits = plumed.getUnits().getLength()/0.1;
+  if( rnum>999 ) {
+    plumed_merror("atom number too large to be used as residue number");
+  }
+  std::array<char,6> at;
+  const char* msg = h36::hy36encode(5,anum,&at[0]);
+  plumed_assert(msg==nullptr) << msg;
+  at[5]=0;
+  double lunits = plumed.getUnits().getLength()/0.1;
   opdbf.printf("ATOM  %s  X   RES  %4u    %8.3f%8.3f%8.3f%6.2f%6.2f\n",
                &at[0], rnum, lunits*pos[0], lunits*pos[1], lunits*pos[2], m, q );
 }
 
 void DumpPDB::buildArgnames() {
-  unsigned nargs = getNumberOfArguments(); if( pdb_atom_indices.size()>0 ) nargs = nargs - 1;
-  if( nargs<0 ) return;
+  unsigned nargs = getNumberOfArguments();
+  if( pdb_atom_indices.size()>0 ) {
+    nargs = nargs - 1;
+  }
+  if( nargs<0 ) {
+    return;
+  }
 
-  argnames.resize(0); unsigned nvals = getPntrToArgument(0)->getShape()[0];
-  if( getPntrToArgument(0)->getRank()==2 ) nvals = getPntrToArgument(0)->getShape()[0];
+  argnames.resize(0);
+  unsigned nvals = getPntrToArgument(0)->getShape()[0];
+  if( getPntrToArgument(0)->getRank()==2 ) {
+    nvals = getPntrToArgument(0)->getShape()[0];
+  }
   for(unsigned i=0; i<nargs; ++i) {
-    if( getPntrToArgument(i)->getShape()[0]!=nvals ) error("all arguments should have same number of values");
+    if( getPntrToArgument(i)->getShape()[0]!=nvals ) {
+      error("all arguments should have same number of values");
+    }
     if( getPntrToArgument(i)->getRank()==1 ) {
       argnames.push_back( getPntrToArgument(i)->getName() );
     } else if( getPntrToArgument(i)->getRank()==2 ) {
@@ -147,40 +194,62 @@ void DumpPDB::buildArgnames() {
 }
 
 void DumpPDB::update() {
-  OFile opdbf; opdbf.link(*this);
+  OFile opdbf;
+  opdbf.link(*this);
   opdbf.setBackupString("analysis");
   opdbf.open( file );
-  std::size_t psign=fmt.find("%"); plumed_assert( psign!=std::string::npos );
+  std::size_t psign=fmt.find("%");
+  plumed_assert( psign!=std::string::npos );
   std::string descr2="%s=%-" + fmt.substr(psign+1) + " ";
 
-  unsigned totargs = 0; unsigned nvals = getPntrToArgument(0)->getShape()[0];
+  unsigned totargs = 0;
+  unsigned nvals = getPntrToArgument(0)->getShape()[0];
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->getShape()[0]!=nvals ) error("all arguments should have same number of values");
-    if( getPntrToArgument(i)->getRank()==1 ) totargs += 1;
-    else if( getPntrToArgument(i)->getRank()==2 ) totargs += getPntrToArgument(i)->getShape()[1];
+    if( getPntrToArgument(i)->getShape()[0]!=nvals ) {
+      error("all arguments should have same number of values");
+    }
+    if( getPntrToArgument(i)->getRank()==1 ) {
+      totargs += 1;
+    } else if( getPntrToArgument(i)->getRank()==2 ) {
+      totargs += getPntrToArgument(i)->getShape()[1];
+    }
+  }
+  if( totargs!=argnames.size() ) {
+    buildArgnames();
   }
-  if( totargs!=argnames.size() ) buildArgnames();
 
-  if( description.length()>0 ) opdbf.printf("# %s AT STEP %lld TIME %f \n", description.c_str(), getStep(), getTime() );
+  if( description.length()>0 ) {
+    opdbf.printf("# %s AT STEP %lld TIME %f \n", description.c_str(), getStep(), getTime() );
+  }
   unsigned nargs = getNumberOfArguments(), atomarg=0;
   if( pdb_atom_indices.size()>0 ) {
-    if( nargs>1 ) { atomarg = nargs - 1; nargs = nargs-1; }
-    else nargs = 0;
+    if( nargs>1 ) {
+      atomarg = nargs - 1;
+      nargs = nargs-1;
+    } else {
+      nargs = 0;
+    }
   }
   for(unsigned i=0; i<nvals; ++i) {
     unsigned n=0;
     for(unsigned j=0; j<nargs; j++) {
-      Value* thisarg=getPntrToArgument(j); opdbf.printf("REMARK ");
+      Value* thisarg=getPntrToArgument(j);
+      opdbf.printf("REMARK ");
       if( thisarg->getRank()==1 ) {
-        opdbf.printf( descr2.c_str(), argnames[n].c_str(), thisarg->get(i) ); n++;
+        opdbf.printf( descr2.c_str(), argnames[n].c_str(), thisarg->get(i) );
+        n++;
       } else if( thisarg->getRank()==2 ) {
         unsigned ncols = thisarg->getShape()[1];
-        for(unsigned k=0; k<ncols; ++k) { opdbf.printf( descr2.c_str(), argnames[n].c_str(), thisarg->get(i*ncols+k) ); n++; }
+        for(unsigned k=0; k<ncols; ++k) {
+          opdbf.printf( descr2.c_str(), argnames[n].c_str(), thisarg->get(i*ncols+k) );
+          n++;
+        }
       }
       opdbf.printf("\n");
     }
     if( pdb_atom_indices.size()>0 ) {
-      unsigned npos = pdb_atom_indices.size(); Vector pos;
+      unsigned npos = pdb_atom_indices.size();
+      Vector pos;
       for(unsigned k=0; k<npos; ++k) {
         pos[0]=getPntrToArgument(atomarg)->get(npos*(3*i+0) + k);
         pos[1]=getPntrToArgument(atomarg)->get(npos*(3*i+1) + k);
diff --git a/src/generic/DumpProjections.cpp b/src/generic/DumpProjections.cpp
index 87d02d7a18..2e1cf335a7 100644
--- a/src/generic/DumpProjections.cpp
+++ b/src/generic/DumpProjections.cpp
@@ -49,8 +49,7 @@ DUMPPROJECTIONS ARG=d FILE=proj STRIDE=20
 
 class DumpProjections :
   public ActionPilot,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
   std::string file;
   std::string fmt;
   OFile of;
@@ -60,7 +59,9 @@ class DumpProjections :
   static void registerKeywords(Keywords& keys);
   void apply() override {}
   void update() override;
-  bool checkNeedsGradients()const override {return true;}
+  bool checkNeedsGradients()const override {
+    return true;
+  }
   ~DumpProjections();
 };
 
@@ -83,10 +84,11 @@ DumpProjections::DumpProjections(const ActionOptions&ao):
   Action(ao),
   ActionPilot(ao),
   ActionWithArguments(ao),
-  fmt("%15.10f")
-{
+  fmt("%15.10f") {
   parse("FILE",file);
-  if( file.length()==0 ) error("filename not specified");
+  if( file.length()==0 ) {
+    error("filename not specified");
+  }
   parse("FMT",fmt);
   fmt=" "+fmt;
   of.open(file);
diff --git a/src/generic/DumpVector.cpp b/src/generic/DumpVector.cpp
index 51f3b7a963..50a71c718d 100644
--- a/src/generic/DumpVector.cpp
+++ b/src/generic/DumpVector.cpp
@@ -61,7 +61,8 @@ PLUMED_REGISTER_ACTION(DumpVector,"DUMPVECTOR")
 void DumpVector::registerKeywords( Keywords& keys ) {
   Action::registerKeywords( keys );
   ActionPilot::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.use("ARG");
+  ActionWithArguments::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("compulsory","STRIDE","0","the frequency with which the grid should be output to the file.");
   keys.add("compulsory","FILE","density","the file on which to write the vetors");
   keys.add("optional","FMT","the format that should be used to output real numbers");
@@ -72,23 +73,38 @@ DumpVector::DumpVector(const ActionOptions&ao):
   Action(ao),
   ActionWithArguments(ao),
   ActionPilot(ao),
-  fmt("%f")
-{
-  if( getNumberOfArguments()==0 ) error("found no arguments");
-  buildArgnames(); parse("FILE",filename); parseFlag("PRINT_ONE_FILE", onefile);
-  if(filename.length()==0) error("name out output file was not specified");
+  fmt("%f") {
+  if( getNumberOfArguments()==0 ) {
+    error("found no arguments");
+  }
+  buildArgnames();
+  parse("FILE",filename);
+  parseFlag("PRINT_ONE_FILE", onefile);
+  if(filename.length()==0) {
+    error("name out output file was not specified");
+  }
 
   log.printf("  outputting data with label %s to file named %s",getPntrToArgument(0)->getName().c_str(), filename.c_str() );
-  parse("FMT",fmt); log.printf(" with format %s \n", fmt.c_str() ); fmt = " " + fmt;
-  if( onefile ) log.printf("  printing all grids on a single file \n");
-  else log.printf("  printing all grids on separate files \n");
+  parse("FMT",fmt);
+  log.printf(" with format %s \n", fmt.c_str() );
+  fmt = " " + fmt;
+  if( onefile ) {
+    log.printf("  printing all grids on a single file \n");
+  } else {
+    log.printf("  printing all grids on separate files \n");
+  }
 }
 
 void DumpVector::buildArgnames() {
-  argnames.resize(0); unsigned nvals = getPntrToArgument(0)->getShape()[0];
-  if( getPntrToArgument(0)->getRank()==2 ) nvals = getPntrToArgument(0)->getShape()[0];
+  argnames.resize(0);
+  unsigned nvals = getPntrToArgument(0)->getShape()[0];
+  if( getPntrToArgument(0)->getRank()==2 ) {
+    nvals = getPntrToArgument(0)->getShape()[0];
+  }
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->getShape()[0]!=nvals ) error("all arguments should have same number of values");
+    if( getPntrToArgument(i)->getShape()[0]!=nvals ) {
+      error("all arguments should have same number of values");
+    }
     if( getPntrToArgument(i)->getRank()==1 ) {
       argnames.push_back( getPntrToArgument(i)->getName() );
     } else if( getPntrToArgument(i)->getRank()==2 ) {
@@ -99,17 +115,26 @@ void DumpVector::buildArgnames() {
 }
 
 void DumpVector::update() {
-  OFile ofile; ofile.link(*this);
-  if( onefile ) ofile.enforceRestart();
-  else ofile.setBackupString("analysis");
+  OFile ofile;
+  ofile.link(*this);
+  if( onefile ) {
+    ofile.enforceRestart();
+  } else {
+    ofile.setBackupString("analysis");
+  }
   ofile.open( filename );
 
   unsigned totargs = 0;
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->getRank()==1 ) totargs += 1;
-    else if( getPntrToArgument(i)->getRank()==2 ) totargs += getPntrToArgument(i)->getShape()[1];
+    if( getPntrToArgument(i)->getRank()==1 ) {
+      totargs += 1;
+    } else if( getPntrToArgument(i)->getRank()==2 ) {
+      totargs += getPntrToArgument(i)->getShape()[1];
+    }
+  }
+  if( totargs!=argnames.size() ) {
+    buildArgnames();
   }
-  if( totargs!=argnames.size() ) buildArgnames();
 
   unsigned nvals = getPntrToArgument(0)->getShape()[0];
   for(unsigned i=0; i<nvals; ++i) {
@@ -119,10 +144,16 @@ void DumpVector::update() {
     ofile.printField("parameter",int(i));
     for(unsigned j=0; j<getNumberOfArguments(); j++) {
       if( getPntrToArgument(j)->getRank()==1 ) {
-        ofile.fmtField(fmt); ofile.printField(argnames[n],getPntrToArgument(j)->get(i) ); n++;
+        ofile.fmtField(fmt);
+        ofile.printField(argnames[n],getPntrToArgument(j)->get(i) );
+        n++;
       } else if( getPntrToArgument(j)->getRank()==2 ) {
         unsigned ncols = getPntrToArgument(j)->getShape()[1];
-        for(unsigned k=0; k<ncols; ++k) { ofile.fmtField(fmt); ofile.printField(argnames[n],getPntrToArgument(j)->get(i*ncols+k)); n++; }
+        for(unsigned k=0; k<ncols; ++k) {
+          ofile.fmtField(fmt);
+          ofile.printField(argnames[n],getPntrToArgument(j)->get(i*ncols+k));
+          n++;
+        }
       }
     }
     ofile.printField();
diff --git a/src/generic/EffectiveEnergyDrift.cpp b/src/generic/EffectiveEnergyDrift.cpp
index c8e1368645..fe93815ee6 100644
--- a/src/generic/EffectiveEnergyDrift.cpp
+++ b/src/generic/EffectiveEnergyDrift.cpp
@@ -157,15 +157,18 @@ EffectiveEnergyDrift::EffectiveEnergyDrift(const ActionOptions&ao):
   domains(NULL),
   posx(NULL),
   posy(NULL),
-  posz(NULL)
-{
+  posz(NULL) {
   //stride must be == 1
-  if(getStride()!=1) error("EFFECTIVE_ENERGY_DRIFT must have STRIDE=1 to work properly");
+  if(getStride()!=1) {
+    error("EFFECTIVE_ENERGY_DRIFT must have STRIDE=1 to work properly");
+  }
 
   //parse and open FILE
   std::string fileName;
   parse("FILE",fileName);
-  if(fileName.length()==0) error("name out output file was not specified\n");
+  if(fileName.length()==0) {
+    error("name out output file was not specified\n");
+  }
   output.link(*this);
   output.open(fileName);
 
@@ -182,14 +185,19 @@ EffectiveEnergyDrift::EffectiveEnergyDrift(const ActionOptions&ao):
   ensemble=false;
   parseFlag("ENSEMBLE",ensemble);
   if(ensemble&&comm.Get_rank()==0) {
-    if(multi_sim_comm.Get_size()<2) error("You CANNOT run Replica-Averaged simulations without running multiple replicas!\n");
+    if(multi_sim_comm.Get_size()<2) {
+      error("You CANNOT run Replica-Averaged simulations without running multiple replicas!\n");
+    }
   }
 
   log<<"Bibliography "<<cite("Ferrarotti, Bottaro, Perez-Villa, and Bussi, J. Chem. Theory Comput. 11, 139 (2015)")<<"\n";
 
   //construct biases from ActionWithValue with a component named bias
   std::vector<ActionWithValue*> tmpActions=plumed.getActionSet().select<ActionWithValue*>();
-  for(unsigned i=0; i<tmpActions.size(); i++) if(tmpActions[i]->exists(tmpActions[i]->getLabel()+".bias")) biases.push_back(tmpActions[i]);
+  for(unsigned i=0; i<tmpActions.size(); i++)
+    if(tmpActions[i]->exists(tmpActions[i]->getLabel()+".bias")) {
+      biases.push_back(tmpActions[i]);
+    }
 
   //resize counters and displacements useful to communicate with MPI_Allgatherv
   indexCnt.resize(nProc);
@@ -200,13 +208,21 @@ EffectiveEnergyDrift::EffectiveEnergyDrift(const ActionOptions&ao):
   pbc_action=plumed.getActionSet().selectWithLabel<PbcAction*>("Box");
   // Get the domain decomposition object
   std::vector<DomainDecomposition*> ddact=plumed.getActionSet().select<DomainDecomposition*>();
-  if( ddact.size()>1 ) warning("found more than one interface so don't know get gatindex");
+  if( ddact.size()>1 ) {
+    warning("found more than one interface so don't know get gatindex");
+  }
   domains = ddact[0];
   std::vector<ActionToPutData*> inputs=plumed.getActionSet().select<ActionToPutData*>();
   for(const auto & pp : inputs ) {
-    if( pp->getRole()=="x" ) posx = pp;
-    if( pp->getRole()=="y" ) posy = pp;
-    if( pp->getRole()=="z" ) posz = pp;
+    if( pp->getRole()=="x" ) {
+      posx = pp;
+    }
+    if( pp->getRole()=="y" ) {
+      posy = pp;
+    }
+    if( pp->getRole()=="z" ) {
+      posz = pp;
+    }
   }
   plumed_assert( posx && posy && posz );
   //resize the received buffers
@@ -220,15 +236,20 @@ EffectiveEnergyDrift::~EffectiveEnergyDrift() {
 }
 
 void EffectiveEnergyDrift::update() {
-  Pbc & tpbc(pbc_action->getPbc()); bool pbc=tpbc.isSet();
+  Pbc & tpbc(pbc_action->getPbc());
+  bool pbc=tpbc.isSet();
 
   //retrieve data of local atoms
   const std::vector<int>& gatindex = domains->getGatindex();
   nLocalAtoms = gatindex.size();
-  xpositions.resize( gatindex.size() ); posx->getLocalValues( xpositions );
-  ypositions.resize( gatindex.size() ); posy->getLocalValues( ypositions );
-  zpositions.resize( gatindex.size() ); posz->getLocalValues( zpositions );
-  positions.resize( gatindex.size() ); forces.resize( gatindex.size() );
+  xpositions.resize( gatindex.size() );
+  posx->getLocalValues( xpositions );
+  ypositions.resize( gatindex.size() );
+  posy->getLocalValues( ypositions );
+  zpositions.resize( gatindex.size() );
+  posz->getLocalValues( zpositions );
+  positions.resize( gatindex.size() );
+  forces.resize( gatindex.size() );
   for(unsigned i=0; i<gatindex.size(); ++i ) {
     positions[i][0] = xpositions[i];
     positions[i][1] = ypositions[i];
@@ -245,8 +266,13 @@ void EffectiveEnergyDrift::update() {
       positions[i]=matmul(positions[i],IB);
       forces[i]=matmul(B,forces[i]);
     }
-    box=B; Tensor virial; Value* boxValue = pbc_action->copyOutput(0);
-    for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) virial[i][j]=boxValue->getForce(3*i+j);
+    box=B;
+    Tensor virial;
+    Value* boxValue = pbc_action->copyOutput(0);
+    for(unsigned i=0; i<3; ++i)
+      for(unsigned j=0; j<3; ++j) {
+        virial[i][j]=boxValue->getForce(3*i+j);
+      }
     fbox=matmul(transpose(inverse(box)),virial);
   }
 
@@ -286,7 +312,9 @@ void EffectiveEnergyDrift::update() {
     for(int i=0; i<nProc; i++) {
       dataCnt[i] = indexCnt[i]*6;
 
-      if(i+1<nProc) indexDsp[i+1] = indexDsp[i]+indexCnt[i];
+      if(i+1<nProc) {
+        indexDsp[i+1] = indexDsp[i]+indexCnt[i];
+      }
       dataDsp[i] = indexDsp[i]*6;
     }
 
@@ -300,7 +328,9 @@ void EffectiveEnergyDrift::update() {
     pForces.resize(nLocalAtoms);
 
     //compute backmap
-    for(unsigned j=0; j<indexR.size(); j++) backmap[indexR[j]]=j;
+    for(unsigned j=0; j<indexR.size(); j++) {
+      backmap[indexR[j]]=j;
+    }
 
     //fill the vectors pGatindex, pPositions and pForces
     for(int i=0; i<nLocalAtoms; i++) {
@@ -321,15 +351,20 @@ void EffectiveEnergyDrift::update() {
   #pragma omp parallel for reduction(+:eed_tmp)
   for(int i=0; i<nLocalAtoms; i++) {
     Vector dst=delta(pPositions[i],positions[i]);
-    if(pbc) for(unsigned k=0; k<3; k++) dst[k]=Tools::pbc(dst[k]);
+    if(pbc)
+      for(unsigned k=0; k<3; k++) {
+        dst[k]=Tools::pbc(dst[k]);
+      }
     eed_tmp += dotProduct(dst, forces[i]+pForces[i])*0.5;
   }
 
   eed=eed_tmp;
 
   if(plumed.comm.Get_rank()==0) {
-    for(unsigned i=0; i<3; i++) for(unsigned j=0; j<3; j++)
+    for(unsigned i=0; i<3; i++)
+      for(unsigned j=0; j<3; j++) {
         eed-=0.5*(pfbox(i,j)+fbox(i,j))*(box(i,j)-pbox(i,j));
+      }
   }
 
 
@@ -340,15 +375,20 @@ void EffectiveEnergyDrift::update() {
 
     //we cannot just use plumed.getBias() because it will be ==0.0 if PRINT_STRIDE
     //is not a multiple of the bias actions stride
-    for(unsigned i=0; i<biases.size(); i++) bias+=biases[i]->getOutputQuantity("bias");
+    for(unsigned i=0; i<biases.size(); i++) {
+      bias+=biases[i]->getOutputQuantity("bias");
+    }
 
     plumed.comm.Sum(&eedSum,1);
 
     double effective = eedSum+bias-initialBias-plumed.getWork();
     // this is to take into account ensemble averaging
     if(ensemble) {
-      if(plumed.comm.Get_rank()==0) plumed.multi_sim_comm.Sum(&effective,1);
-      else effective=0.;
+      if(plumed.comm.Get_rank()==0) {
+        plumed.multi_sim_comm.Sum(&effective,1);
+      } else {
+        effective=0.;
+      }
       plumed.comm.Sum(&effective,1);
     }
     output.fmtField(" %f");
diff --git a/src/generic/EndPlumed.cpp b/src/generic/EndPlumed.cpp
index 8323d34599..a3d5331bc0 100644
--- a/src/generic/EndPlumed.cpp
+++ b/src/generic/EndPlumed.cpp
@@ -52,8 +52,7 @@ PRINT ARG=d FILE=COLVAR STRIDE=1
 */
 //+ENDPLUMEDOC
 class EndPlumed:
-  public Action
-{
+  public Action {
 public:
   explicit EndPlumed(const ActionOptions&ao);
 /// Register all the relevant keywords for the action
@@ -69,8 +68,7 @@ void EndPlumed::registerKeywords( Keywords& keys ) {
 }
 
 EndPlumed::EndPlumed(const ActionOptions&ao):
-  Action(ao)
-{
+  Action(ao) {
   checkRead();
   plumed.setEndPlumed();
 }
diff --git a/src/generic/FitToTemplate.cpp b/src/generic/FitToTemplate.cpp
index 6fae4e6998..ff8f2f9bc8 100644
--- a/src/generic/FitToTemplate.cpp
+++ b/src/generic/FitToTemplate.cpp
@@ -170,8 +170,7 @@ the ligand.
 class FitToTemplate:
   public ActionPilot,
   public ActionAtomistic,
-  public ActionWithValue
-{
+  public ActionWithValue {
   std::string type;
   bool nopbc;
   std::vector<double> weights;
@@ -194,10 +193,14 @@ class FitToTemplate:
 public:
   explicit FitToTemplate(const ActionOptions&ao);
   static void registerKeywords( Keywords& keys );
-  bool actionHasForces() override { return true; }
+  bool actionHasForces() override {
+    return true;
+  }
   void calculate() override;
   void apply() override;
-  unsigned getNumberOfDerivatives() override {plumed_merror("You should not call this function");};
+  unsigned getNumberOfDerivatives() override {
+    plumed_merror("You should not call this function");
+  };
 };
 
 PLUMED_REGISTER_ACTION(FitToTemplate,"FIT_TO_TEMPLATE")
@@ -216,8 +219,7 @@ FitToTemplate::FitToTemplate(const ActionOptions&ao):
   ActionPilot(ao),
   ActionAtomistic(ao),
   ActionWithValue(ao),
-  nopbc(false)
-{
+  nopbc(false) {
   std::string reference;
   parse("REFERENCE",reference);
   type.assign("SIMPLE");
@@ -231,40 +233,61 @@ FitToTemplate::FitToTemplate(const ActionOptions&ao):
   PDB pdb;
 
   // read everything in ang and transform to nm if we are not in natural units
-  if( !pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength()) )
+  if( !pdb.read(reference,usingNaturalUnits(),0.1/getUnits().getLength()) ) {
     error("missing input file " + reference );
+  }
 
   requestAtoms(pdb.getAtomNumbers());
   log.printf("  found %zu atoms in input \n",pdb.getAtomNumbers().size());
   log.printf("  with indices : ");
   for(unsigned i=0; i<pdb.getAtomNumbers().size(); ++i) {
-    if(i%25==0) log<<"\n";
+    if(i%25==0) {
+      log<<"\n";
+    }
     log.printf("%d ",pdb.getAtomNumbers()[i].serial());
   }
   log.printf("\n");
 
   std::vector<Vector> positions=pdb.getPositions();
   weights=pdb.getOccupancy();
-  std::vector<AtomNumber> aligned=pdb.getAtomNumbers(); p_aligned.resize( aligned.size() );
-  for(unsigned i=0; i<aligned.size(); ++i) p_aligned[i] = getValueIndices( aligned[i] );
+  std::vector<AtomNumber> aligned=pdb.getAtomNumbers();
+  p_aligned.resize( aligned.size() );
+  for(unsigned i=0; i<aligned.size(); ++i) {
+    p_aligned[i] = getValueIndices( aligned[i] );
+  }
 
 
   // normalize weights
-  double n=0.0; for(unsigned i=0; i<weights.size(); ++i) n+=weights[i];
+  double n=0.0;
+  for(unsigned i=0; i<weights.size(); ++i) {
+    n+=weights[i];
+  }
   if(n==0.0) {
     error("PDB file " + reference + " has zero weights. Please check the occupancy column.");
   }
   n=1.0/n;
-  for(unsigned i=0; i<weights.size(); ++i) weights[i]*=n;
+  for(unsigned i=0; i<weights.size(); ++i) {
+    weights[i]*=n;
+  }
 
   // normalize weights for rmsd calculation
   std::vector<double> weights_measure=pdb.getBeta();
-  n=0.0; for(unsigned i=0; i<weights_measure.size(); ++i) n+=weights_measure[i]; n=1.0/n;
-  for(unsigned i=0; i<weights_measure.size(); ++i) weights_measure[i]*=n;
+  n=0.0;
+  for(unsigned i=0; i<weights_measure.size(); ++i) {
+    n+=weights_measure[i];
+  }
+  n=1.0/n;
+  for(unsigned i=0; i<weights_measure.size(); ++i) {
+    weights_measure[i]*=n;
+  }
 
   // subtract the center
-  for(unsigned i=0; i<weights.size(); ++i) center+=positions[i]*weights[i];
-  for(unsigned i=0; i<weights.size(); ++i) positions[i]-=center;
+  for(unsigned i=0; i<weights.size(); ++i) {
+    center+=positions[i]*weights[i];
+  }
+  for(unsigned i=0; i<weights.size(); ++i) {
+    positions[i]-=center;
+  }
 
   if(type=="OPTIMAL" or type=="OPTIMAL-FAST" ) {
     rmsd=Tools::make_unique<RMSD>();
@@ -275,7 +298,8 @@ FitToTemplate::FitToTemplate(const ActionOptions&ao):
     log<<"  Ignoring PBCs when doing alignment, make sure your molecule is whole!<n";
   }
   // register the value of rmsd (might be useful sometimes)
-  addValue(); setNotPeriodic();
+  addValue();
+  setNotPeriodic();
 
   // I remove this optimization now in order to use makeWhole()
   // Notice that for FIT_TO_TEMPLATE TYPE=OPTIMAL a copy was made anyway
@@ -289,14 +313,18 @@ FitToTemplate::FitToTemplate(const ActionOptions&ao):
   // this is required so as to allow modifyGlobalForce() to return correct
   // also for forces that are not owned (and thus not zeored) by all processors.
   pbc_action=plumed.getActionSet().selectWithLabel<PbcAction*>("Box");
-  if( !pbc_action ) error("cannot align box has not been set");
+  if( !pbc_action ) {
+    error("cannot align box has not been set");
+  }
   boxValue=pbc_action->copyOutput(0);
 }
 
 
 void FitToTemplate::calculate() {
 
-  if(!nopbc) makeWhole();
+  if(!nopbc) {
+    makeWhole();
+  }
 
   if (type=="SIMPLE") {
     Vector cc;
@@ -313,11 +341,11 @@ void FitToTemplate::calculate() {
       Vector ato=getGlobalPosition(a);
       setGlobalPosition(a,ato+shift);
     }
-  }
-  else if( type=="OPTIMAL" or type=="OPTIMAL-FAST") {
+  } else if( type=="OPTIMAL" or type=="OPTIMAL-FAST") {
     // specific stuff that provides all that is needed
     double r=rmsd->calc_FitElements( getPositions(), rotation,  drotdpos, centeredpositions, center_positions);
-    setValue(r); unsigned nat = getTotAtoms();
+    setValue(r);
+    unsigned nat = getTotAtoms();
     for(unsigned i=0; i<nat; i++) {
       std::pair<std::size_t,std::size_t> a = getValueIndices( AtomNumber::index(i));
       Vector ato=getGlobalPosition(a);
@@ -338,8 +366,13 @@ void FitToTemplate::apply() {
       totForce+=getForce(a);
     }
     Tensor vv=Tensor(center,totForce);
-    for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) boxValue->addForce( 3*i+j, vv(i,j) );
-    for(unsigned i=0; i<p_aligned.size(); ++i) { addForce( p_aligned[i], -totForce*weights[i]); }
+    for(unsigned i=0; i<3; ++i)
+      for(unsigned j=0; j<3; ++j) {
+        boxValue->addForce( 3*i+j, vv(i,j) );
+      }
+    for(unsigned i=0; i<p_aligned.size(); ++i) {
+      addForce( p_aligned[i], -totForce*weights[i]);
+    }
   } else if ( type=="OPTIMAL" or type=="OPTIMAL-FAST") {
     Vector totForce;
     for(unsigned i=0; i<nat; i++) {
@@ -352,7 +385,10 @@ void FitToTemplate::apply() {
       totForce+=nf;
     }
     Tensor virial;
-    for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) virial[i][j] = boxValue->getForce( 3*i+j );
+    for(unsigned i=0; i<3; ++i)
+      for(unsigned j=0; j<3; ++j) {
+        virial[i][j] = boxValue->getForce( 3*i+j );
+      }
 // notice that an extra Tensor(center,matmul(rotation,totForce)) is required to
 // compute the derivatives of the rotation with respect to center
     Tensor ww=matmul(transpose(rotation),virial+Tensor(center,matmul(rotation,totForce)));
@@ -375,8 +411,12 @@ void FitToTemplate::apply() {
       virial+=extProduct(getPosition(i),g);
     }
 // finally, correction to the virial
-    boxValue->clearInputForce(); virial+=extProduct(matmul(transpose(rotation),center),totForce);
-    for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) boxValue->addForce( 3*i+j, virial(i,j) );
+    boxValue->clearInputForce();
+    virial+=extProduct(matmul(transpose(rotation),center),totForce);
+    for(unsigned i=0; i<3; ++i)
+      for(unsigned j=0; j<3; ++j) {
+        boxValue->addForce( 3*i+j, virial(i,j) );
+      }
   }
 }
 
diff --git a/src/generic/Flush.cpp b/src/generic/Flush.cpp
index 374ba30c8f..eddbd64897 100644
--- a/src/generic/Flush.cpp
+++ b/src/generic/Flush.cpp
@@ -55,13 +55,11 @@ PRINT ARG=d2 STRIDE=10 FILE=colvar2
 //+ENDPLUMEDOC
 
 class Flush:
-  public ActionPilot
-{
+  public ActionPilot {
 public:
   explicit Flush(const ActionOptions&ao):
     Action(ao),
-    ActionPilot(ao)
-  {
+    ActionPilot(ao) {
     checkRead();
   }
   static void registerKeywords( Keywords& keys );
@@ -71,8 +69,9 @@ class Flush:
     plumed.fflush();
     log.flush();
     const ActionSet & actionSet(plumed.getActionSet());
-    for(const auto & p : actionSet)
+    for(const auto & p : actionSet) {
       p->fflush();
+    }
   }
 };
 
diff --git a/src/generic/GatherReplicas.cpp b/src/generic/GatherReplicas.cpp
index eaa0fe7de9..16ac4b0528 100644
--- a/src/generic/GatherReplicas.cpp
+++ b/src/generic/GatherReplicas.cpp
@@ -53,28 +53,44 @@ class GatherReplicas :
 PLUMED_REGISTER_ACTION(GatherReplicas,"GATHER_REPLICAS")
 
 void GatherReplicas::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys ); ActionWithArguments::registerKeywords( keys );
-  keys.remove("ARG"); keys.add("compulsory","ARG","the argument from the various replicas that you would like to gather");
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  keys.remove("ARG");
+  keys.add("compulsory","ARG","the argument from the various replicas that you would like to gather");
   keys.addOutputComponent("rep","default","the input arguments for each of the replicas");
 }
 
 GatherReplicas::GatherReplicas( const ActionOptions& ao ):
   Action(ao),
   ActionWithValue(ao),
-  ActionWithArguments(ao)
-{
-  if( getNumberOfArguments()!=1 ) error("you can only gather one argument at a time with GatherReplicas");
+  ActionWithArguments(ao) {
+  if( getNumberOfArguments()!=1 ) {
+    error("you can only gather one argument at a time with GatherReplicas");
+  }
 
   std::vector<unsigned> shape( getPntrToArgument(0)->getShape() );
-  std::string min, max; nreplicas=multi_sim_comm.Get_size(); bool periodic=false;
-  if( getPntrToArgument(0)->isPeriodic() ) { periodic=true; getPntrToArgument(0)->getDomain( min, max ); }
+  std::string min, max;
+  nreplicas=multi_sim_comm.Get_size();
+  bool periodic=false;
+  if( getPntrToArgument(0)->isPeriodic() ) {
+    periodic=true;
+    getPntrToArgument(0)->getDomain( min, max );
+  }
 
   for(unsigned i=0; i<nreplicas; ++i) {
-    std::string num; Tools::convert( i+1, num);
-    if( getPntrToArgument(0)->hasDerivatives() ) addComponentWithDerivatives( "rep-" + num, shape );
-    else addComponent( "rep-" + num, shape );
-    if( periodic ) componentIsPeriodic( "rep-" + num, min, max );
-    else componentIsNotPeriodic( "rep-" + num );
+    std::string num;
+    Tools::convert( i+1, num);
+    if( getPntrToArgument(0)->hasDerivatives() ) {
+      addComponentWithDerivatives( "rep-" + num, shape );
+    } else {
+      addComponent( "rep-" + num, shape );
+    }
+    if( periodic ) {
+      componentIsPeriodic( "rep-" + num, min, max );
+    } else {
+      componentIsNotPeriodic( "rep-" + num );
+    }
   }
 }
 
@@ -88,25 +104,45 @@ void GatherReplicas::calculate() {
   std::vector<double> dval( nvals*(1+nder) ), datap(nreplicas*nvals*(1+nder) );
   for(unsigned i=0; i<nvals; ++i) {
     dval[i*(1+nder)] = myarg->get(i);
-    if( myarg->getRank()==0 ) { for(unsigned j=0; j<nder; ++j) dval[i*(1+nder)+1+j] = myarg->getDerivative(j); }
-    else if( myarg->hasDerivatives() ) { for(unsigned j=0; j<nder; ++j) dval[i*(1+nder)+1+j] = myarg->getGridDerivative( i, j ); }
+    if( myarg->getRank()==0 ) {
+      for(unsigned j=0; j<nder; ++j) {
+        dval[i*(1+nder)+1+j] = myarg->getDerivative(j);
+      }
+    } else if( myarg->hasDerivatives() ) {
+      for(unsigned j=0; j<nder; ++j) {
+        dval[i*(1+nder)+1+j] = myarg->getGridDerivative( i, j );
+      }
+    }
+  }
+  if(comm.Get_rank()==0) {
+    multi_sim_comm.Allgather(dval,datap);
   }
-  if(comm.Get_rank()==0) multi_sim_comm.Allgather(dval,datap);
 
   for(unsigned k=0; k<nreplicas; k++) {
     Value* myout = getPntrToComponent(k);
-    if( myout->getNumberOfDerivatives()!=myarg->getNumberOfDerivatives() ) myout->resizeDerivatives( myarg->getNumberOfDerivatives() );
+    if( myout->getNumberOfDerivatives()!=myarg->getNumberOfDerivatives() ) {
+      myout->resizeDerivatives( myarg->getNumberOfDerivatives() );
+    }
     unsigned sstart=k*nvals*(1+nder);
     for(unsigned i=0; i<nvals; ++i) {
       myout->set( i, datap[sstart+i*(1+nder)] );
-      if( myarg->getRank()==0 ) { for(unsigned j=0; j<nder; ++j) myout->setDerivative( j, dval[i*(1+nder)+1+j] ); }
-      else if( myarg->hasDerivatives() ) { for(unsigned j=0; j<nder; ++j) myout->addGridDerivatives( i, j, dval[i*(1+nder)+1+j] ); }
+      if( myarg->getRank()==0 ) {
+        for(unsigned j=0; j<nder; ++j) {
+          myout->setDerivative( j, dval[i*(1+nder)+1+j] );
+        }
+      } else if( myarg->hasDerivatives() ) {
+        for(unsigned j=0; j<nder; ++j) {
+          myout->addGridDerivatives( i, j, dval[i*(1+nder)+1+j] );
+        }
+      }
     }
   }
 }
 
 void GatherReplicas::apply() {
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
   error("apply has not been implemented for GatherReplicas");
 }
 
diff --git a/src/generic/Include.cpp b/src/generic/Include.cpp
index f8b44ffddd..26f7d7da91 100644
--- a/src/generic/Include.cpp
+++ b/src/generic/Include.cpp
@@ -148,8 +148,7 @@ RESTRAINT ARG=t AT=1.2 KAPPA=10
 //+ENDPLUMEDOC
 
 class Include :
-  public ActionAnyorder
-{
+  public ActionAnyorder {
 public:
   static void registerKeywords( Keywords& keys );
   explicit Include(const ActionOptions&ao);
@@ -166,8 +165,7 @@ void Include::registerKeywords( Keywords& keys ) {
 
 Include::Include(const ActionOptions&ao):
   Action(ao),
-  ActionAnyorder(ao)
-{
+  ActionAnyorder(ao) {
   std::string f;
   parse("FILE",f);
   checkRead();
diff --git a/src/generic/MassChargeInput.cpp b/src/generic/MassChargeInput.cpp
index 986f7533ed..49755e3cd9 100644
--- a/src/generic/MassChargeInput.cpp
+++ b/src/generic/MassChargeInput.cpp
@@ -60,35 +60,55 @@ void MassChargeInput::registerKeywords(Keywords& keys) {
 
 MassChargeInput::MassChargeInput(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   const ActionSet& actionset(plumed.getActionSet());
   for(const auto & p : actionset) {
     // check that all the preceding actions are ActionSetup
     if( !dynamic_cast<ActionSetup*>(p.get()) && !dynamic_cast<ActionForInterface*>(p.get()) && !dynamic_cast<ActionAnyorder*>(p.get()) ) {
       error("Action " + getLabel() + " is a setup action, and should be only preceded by other setup actions or by actions that can be used in any order.");
-    } else if( (p.get())->getName()=="READMASSCHARGE" ) error("should only be one READMASSCHARGE action in the input file");
+    } else if( (p.get())->getName()=="READMASSCHARGE" ) {
+      error("should only be one READMASSCHARGE action in the input file");
+    }
   }
   // Check for correct number of atoms
-  unsigned natoms=0; std::vector<ActionToPutData*> inputs=plumed.getActionSet().select<ActionToPutData*>();
+  unsigned natoms=0;
+  std::vector<ActionToPutData*> inputs=plumed.getActionSet().select<ActionToPutData*>();
   for(const auto & pp : inputs ) {
-    if( pp->getRole()=="x" ) natoms = (pp->copyOutput(0))->getShape()[0];
+    if( pp->getRole()=="x" ) {
+      natoms = (pp->copyOutput(0))->getShape()[0];
+    }
   }
-  std::string input; parse("FILE",input); std::vector<double> masses( natoms ), charges( natoms );
+  std::string input;
+  parse("FILE",input);
+  std::vector<double> masses( natoms ), charges( natoms );
   if( input.length()>0 ) {
     log.printf("   reading masses and charges from file named %s \n", input.c_str() );
-    IFile ifile; ifile.open( input ); int index; double mass; double charge;
+    IFile ifile;
+    ifile.open( input );
+    int index;
+    double mass;
+    double charge;
     while(ifile.scanField("index",index).scanField("mass",mass).scanField("charge",charge).scanField()) {
-      if( index>=natoms ) error("indices of atoms in input file are too large");
-      masses[index]=mass; charges[index]=charge;
+      if( index>=natoms ) {
+        error("indices of atoms in input file are too large");
+      }
+      masses[index]=mass;
+      charges[index]=charge;
     }
     ifile.close();
   } else {
-    std::string pdbinpt; parse("PDBFILE",pdbinpt); PDB pdb;
+    std::string pdbinpt;
+    parse("PDBFILE",pdbinpt);
+    PDB pdb;
     log.printf("  reading masses and charges from pdb file named %s \n", pdbinpt.c_str() );
-    if( !pdb.read(pdbinpt, false, 1.0 ) ) error("error reading pdb file containing masses and charges");
-    if( natoms!=pdb.size() ) error("mismatch between number of atoms passed from MD code and number of atoms in PDB file");
-    masses = pdb.getOccupancy(); charges = pdb.getBeta();
+    if( !pdb.read(pdbinpt, false, 1.0 ) ) {
+      error("error reading pdb file containing masses and charges");
+    }
+    if( natoms!=pdb.size() ) {
+      error("mismatch between number of atoms passed from MD code and number of atoms in PDB file");
+    }
+    masses = pdb.getOccupancy();
+    charges = pdb.getBeta();
   }
 
   // Now get masses and charges
@@ -96,8 +116,10 @@ MassChargeInput::MassChargeInput(const ActionOptions& ao):
   Tools::convert( masses[0], mstr );
   Tools::convert( charges[0], qstr );
   for(unsigned i=1; i<natoms; ++i) {
-    Tools::convert( masses[i], nnn ); mstr += "," + nnn;
-    Tools::convert( charges[i], nnn ); qstr += "," + nnn;
+    Tools::convert( masses[i], nnn );
+    mstr += "," + nnn;
+    Tools::convert( charges[i], nnn );
+    qstr += "," + nnn;
   }
   // And create constant actions to hold masses and charges
   readInputLine( getShortcutLabel() + "_mass: CONSTANT VALUES=" + mstr );
diff --git a/src/generic/Ones.cpp b/src/generic/Ones.cpp
index c27c3b96ef..bc13bb233e 100644
--- a/src/generic/Ones.cpp
+++ b/src/generic/Ones.cpp
@@ -51,10 +51,16 @@ void Ones::registerKeywords(Keywords& keys) {
 
 Ones::Ones(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  unsigned size; parse("SIZE",size); if( size<1 ) error("size should be greater than 0");
-  std::string ones="1"; for(unsigned i=1; i<size; ++i) ones +=",1";
+  ActionShortcut(ao) {
+  unsigned size;
+  parse("SIZE",size);
+  if( size<1 ) {
+    error("size should be greater than 0");
+  }
+  std::string ones="1";
+  for(unsigned i=1; i<size; ++i) {
+    ones +=",1";
+  }
   readInputLine( getShortcutLabel() + ": CONSTANT NOLOG VALUES=" + ones );
 }
 
diff --git a/src/generic/PDB2Constant.cpp b/src/generic/PDB2Constant.cpp
index 1d80a1014b..ef22ee28d1 100644
--- a/src/generic/PDB2Constant.cpp
+++ b/src/generic/PDB2Constant.cpp
@@ -57,63 +57,117 @@ void PDB2Constant::registerKeywords(Keywords& keys) {
 
 PDB2Constant::PDB2Constant(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string input; parse("REFERENCE",input);
-  unsigned frame; parse("NUMBER",frame); bool noargs=false;
-  std::vector<std::string> argn; parseVector("ARG",argn); std::vector<Value*> theargs;
+  ActionShortcut(ao) {
+  std::string input;
+  parse("REFERENCE",input);
+  unsigned frame;
+  parse("NUMBER",frame);
+  bool noargs=false;
+  std::vector<std::string> argn;
+  parseVector("ARG",argn);
+  std::vector<Value*> theargs;
   if( argn.size()>0 ) {
     parseFlag("NOARGS",noargs);
-    if( !noargs ) ActionWithArguments::interpretArgumentList( argn, plumed.getActionSet(), this, theargs );
-    else if( argn.size()>1 ) error("can only read one argument at a time from input pdb file");
-    else log.printf("  reading argument %s from file \n", argn[0].c_str() );
+    if( !noargs ) {
+      ActionWithArguments::interpretArgumentList( argn, plumed.getActionSet(), this, theargs );
+    } else if( argn.size()>1 ) {
+      error("can only read one argument at a time from input pdb file");
+    } else {
+      log.printf("  reading argument %s from file \n", argn[0].c_str() );
+    }
+  }
+  if( theargs.size()>1 ) {
+    error("can only read one argument at a time from input pdb file");
   }
-  if( theargs.size()>1 ) error("can only read one argument at a time from input pdb file");
 
-  FILE* fp=std::fopen(input.c_str(),"r"); bool do_read=true; std::vector<double> vals;
-  if(!fp) plumed_merror("could not open reference file " + input); unsigned natoms=0, nframes=0;
+  FILE* fp=std::fopen(input.c_str(),"r");
+  bool do_read=true;
+  std::vector<double> vals;
+  if(!fp) {
+    plumed_merror("could not open reference file " + input);
+  }
+  unsigned natoms=0, nframes=0;
 
   while ( do_read ) {
-    PDB mypdb; do_read=mypdb.readFromFilepointer(fp,plumed.usingNaturalUnits(),0.1/plumed.getUnits().getLength());
-    if( !do_read && nframes>0 ) break ;
+    PDB mypdb;
+    do_read=mypdb.readFromFilepointer(fp,plumed.usingNaturalUnits(),0.1/plumed.getUnits().getLength());
+    if( !do_read && nframes>0 ) {
+      break ;
+    }
 
-    if( natoms==0 ) natoms = mypdb.getPositions().size();
-    else if( mypdb.getPositions().size()!=natoms ) plumed_merror("mismatch between sizes of reference configurations");
+    if( natoms==0 ) {
+      natoms = mypdb.getPositions().size();
+    } else if( mypdb.getPositions().size()!=natoms ) {
+      plumed_merror("mismatch between sizes of reference configurations");
+    }
 
     if( nframes+1==frame || frame==0 ) {
       std::vector<double> align( mypdb.getOccupancy() );
-      double asum=0; for(unsigned i=0; i<align.size(); ++i) asum += align[i];
+      double asum=0;
+      for(unsigned i=0; i<align.size(); ++i) {
+        asum += align[i];
+      }
       if( asum>epsilon ) {
-        double iasum = 1 / asum; for(unsigned i=0; i<align.size(); ++i) align[i] *= iasum;
+        double iasum = 1 / asum;
+        for(unsigned i=0; i<align.size(); ++i) {
+          align[i] *= iasum;
+        }
       } else if( mypdb.size()>0 ) {
-        double iasum = 1 / mypdb.size(); for(unsigned i=0; i<align.size(); ++i) align[i] = iasum;
+        double iasum = 1 / mypdb.size();
+        for(unsigned i=0; i<align.size(); ++i) {
+          align[i] = iasum;
+        }
+      }
+      Vector center;
+      center.zero();
+      for(unsigned i=0; i<mypdb.getPositions().size(); ++i) {
+        center += align[i]*mypdb.getPositions()[i];
       }
-      Vector center; center.zero(); for(unsigned i=0; i<mypdb.getPositions().size(); ++i) center += align[i]*mypdb.getPositions()[i];
 
       if( theargs.size()==0 && argn.size()==0 ) {
         for(unsigned j=0; j<3; ++j) {
-          for(unsigned i=0; i<mypdb.getPositions().size(); ++i) vals.push_back( mypdb.getPositions()[i][j] - center[j] );
+          for(unsigned i=0; i<mypdb.getPositions().size(); ++i) {
+            vals.push_back( mypdb.getPositions()[i][j] - center[j] );
+          }
         }
       } else if( noargs ) {
         std::vector<double> argvals( 1 );
-        if( !mypdb.getArgumentValue(argn[0], argvals ) ) error("argument " + argn[0] + " was not set in pdb input");
+        if( !mypdb.getArgumentValue(argn[0], argvals ) ) {
+          error("argument " + argn[0] + " was not set in pdb input");
+        }
         vals.push_back( argvals[0] );
       } else {
         std::vector<double> argvals( theargs[0]->getNumberOfValues() );
-        if( !mypdb.getArgumentValue(theargs[0]->getName(), argvals ) ) error("argument " + theargs[0]->getName() + " was not set in pdb input");
-        for(unsigned i=0; i<argvals.size(); ++i) vals.push_back( argvals[i] );
+        if( !mypdb.getArgumentValue(theargs[0]->getName(), argvals ) ) {
+          error("argument " + theargs[0]->getName() + " was not set in pdb input");
+        }
+        for(unsigned i=0; i<argvals.size(); ++i) {
+          vals.push_back( argvals[i] );
+        }
       }
     }
     nframes++;
   }
-  if( frame>0 ) nframes=1;
-  std::fclose(fp); std::string rnum; plumed_assert( vals.size()>0 );
-  Tools::convert( vals[0], rnum ); std::string valstr = " VALUES=" + rnum;
-  for(unsigned i=1; i<vals.size(); ++i) { Tools::convert( vals[i], rnum ); valstr += "," + rnum; }
+  if( frame>0 ) {
+    nframes=1;
+  }
+  std::fclose(fp);
+  std::string rnum;
+  plumed_assert( vals.size()>0 );
+  Tools::convert( vals[0], rnum );
+  std::string valstr = " VALUES=" + rnum;
+  for(unsigned i=1; i<vals.size(); ++i) {
+    Tools::convert( vals[i], rnum );
+    valstr += "," + rnum;
+  }
   if( vals.size()>nframes ) {
-    std::string nc, nr; Tools::convert( nframes, nr ); Tools::convert( vals.size()/nframes, nc );
+    std::string nc, nr;
+    Tools::convert( nframes, nr );
+    Tools::convert( vals.size()/nframes, nc );
     readInputLine( getShortcutLabel() + ": CONSTANT NROWS=" + nr + " NCOLS=" + nc + valstr );
-  } else readInputLine( getShortcutLabel() + ": CONSTANT" + valstr );
+  } else {
+    readInputLine( getShortcutLabel() + ": CONSTANT" + valstr );
+  }
 }
 
 }
diff --git a/src/generic/Plumed.cpp b/src/generic/Plumed.cpp
index 3972d5b1e6..e449799a1e 100644
--- a/src/generic/Plumed.cpp
+++ b/src/generic/Plumed.cpp
@@ -126,8 +126,7 @@ PLUMED FILE=plumed.dat CHDIR=directory2
 class Plumed:
   public ActionAtomistic,
   public ActionWithValue,
-  public ActionPilot
-{
+  public ActionPilot {
 /// True on root processor
   const bool root;
 /// Separate directory.
@@ -168,7 +167,9 @@ class Plumed:
   unsigned getNumberOfDerivatives() override {
     return 0;
   }
-  bool actionHasForces() override { return true; }
+  bool actionHasForces() override {
+    return true;
+  }
 };
 
 PLUMED_REGISTER_ACTION(Plumed,"PLUMED")
@@ -219,14 +220,15 @@ API([&]() {
   // as a matter of fact, any version <2.5 will not even load due to namespace pollution
   plumed_assert(api>3) << "API>3 is required for the PLUMED action to work correctly\n";
   return api;
-}())
-{
+}()) {
   Tools::DirectoryChanger directoryChanger(directory.c_str());
 
   bool noreplicas;
   parseFlag("NOREPLICAS",noreplicas);
   int nreps;
-  if(root) nreps=multi_sim_comm.Get_size();
+  if(root) {
+    nreps=multi_sim_comm.Get_size();
+  }
   comm.Bcast(nreps,0);
   if(nreps>1) {
     if(noreplicas) {
@@ -256,76 +258,133 @@ API([&]() {
   parse("FILE",file);
   if(file.length()>0) {
     log<<"  with input file "<<file<<"\n";
-  } else plumed_error() << "you must provide an input file\n";
+  } else {
+    plumed_error() << "you must provide an input file\n";
+  }
 
   bool inherited_logfile=false;
   std::string logfile;
   parse("LOG",logfile);
   if(logfile.length()>0) {
     log<<"  with log file "<<logfile<<"\n";
-    if(root) p.cmd("setLogFile",logfile.c_str());
+    if(root) {
+      p.cmd("setLogFile",logfile.c_str());
+    }
   } else if(log.getFILE()) {
     log<<"  with inherited log file\n";
-    if(root) p.cmd("setLog",log.getFILE());
+    if(root) {
+      p.cmd("setLog",log.getFILE());
+    }
     inherited_logfile=true;
   } else {
     log<<"  with log on stdout\n";
-    if(root) p.cmd("setLog",stdout);
+    if(root) {
+      p.cmd("setLog",stdout);
+    }
   }
 
   checkRead();
 
-  if(root) p.cmd("setMDEngine","plumed");
+  if(root) {
+    p.cmd("setMDEngine","plumed");
+  }
 
   double engunits=getUnits().getEnergy();
-  if(root) p.cmd("setMDEnergyUnits",&engunits);
+  if(root) {
+    p.cmd("setMDEnergyUnits",&engunits);
+  }
 
   double lenunits=getUnits().getLength();
-  if(root) p.cmd("setMDLengthUnits",&lenunits);
+  if(root) {
+    p.cmd("setMDLengthUnits",&lenunits);
+  }
 
   double timunits=getUnits().getTime();
-  if(root) p.cmd("setMDTimeUnits",&timunits);
+  if(root) {
+    p.cmd("setMDTimeUnits",&timunits);
+  }
 
   double chaunits=getUnits().getCharge();
-  if(root) p.cmd("setMDChargeUnits",&chaunits);
+  if(root) {
+    p.cmd("setMDChargeUnits",&chaunits);
+  }
   double masunits=getUnits().getMass();
-  if(root) p.cmd("setMDMassUnits",&masunits);
+  if(root) {
+    p.cmd("setMDMassUnits",&masunits);
+  }
 
   double kbt=getkBT();
-  if(root) p.cmd("setKbT",&kbt);
+  if(root) {
+    p.cmd("setKbT",&kbt);
+  }
 
   int res=0;
-  if(getRestart()) res=1;
-  if(root) p.cmd("setRestart",&res);
+  if(getRestart()) {
+    res=1;
+  }
+  if(root) {
+    p.cmd("setRestart",&res);
+  }
 
-  if(root) p.cmd("setNatoms",&natoms);
-  if(root) p.cmd("setTimestep",&dt);
-  if(root) p.cmd("setPlumedDat",file.c_str());
+  if(root) {
+    p.cmd("setNatoms",&natoms);
+  }
+  if(root) {
+    p.cmd("setTimestep",&dt);
+  }
+  if(root) {
+    p.cmd("setPlumedDat",file.c_str());
+  }
 
   addComponentWithDerivatives("bias");
   componentIsNotPeriodic("bias");
 
-  if(inherited_logfile) log<<"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
-  if(root) p.cmd("init");
-  if(inherited_logfile) log<<"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
+  if(inherited_logfile) {
+    log<<"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
+  }
+  if(root) {
+    p.cmd("init");
+  }
+  if(inherited_logfile) {
+    log<<"++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
+  }
 }
 
 void Plumed::prepare() {
   Tools::DirectoryChanger directoryChanger(directory.c_str());
   int step=getStep();
-  if(root) p.cmd("setStep",&step);
-  if(root) p.cmd("prepareDependencies");
+  if(root) {
+    p.cmd("setStep",&step);
+  }
+  if(root) {
+    p.cmd("prepareDependencies");
+  }
   int ene=0;
-  if(root) p.cmd("isEnergyNeeded",&ene);
-  if(ene) plumed_error()<<"It is not currently possible to use ENERGY in a guest PLUMED";
+  if(root) {
+    p.cmd("isEnergyNeeded",&ene);
+  }
+  if(ene) {
+    plumed_error()<<"It is not currently possible to use ENERGY in a guest PLUMED";
+  }
   int n=0;
-  if(root) p.cmd("createFullList",&n);
+  if(root) {
+    p.cmd("createFullList",&n);
+  }
   const int *pointer=nullptr;
-  if(root) p.cmd("getFullList",&pointer);
+  if(root) {
+    p.cmd("getFullList",&pointer);
+  }
   bool redo=(index.size()!=n);
-  if(first) redo=true;
+  if(first) {
+    redo=true;
+  }
   first=false;
-  if(root && !redo) for(int i=0; i<n; i++) if(index[i]!=pointer[i]) { redo=true; break;};
+  if(root && !redo)
+    for(int i=0; i<n; i++)
+      if(index[i]!=pointer[i]) {
+        redo=true;
+        break;
+      };
   if(root && redo) {
     index.resize(n);
     masses.resize(n);
@@ -338,7 +397,9 @@ void Plumed::prepare() {
     p.cmd("setAtomsNlocal",&n);
     p.cmd("setAtomsGatindex",index.data(), {index.size()});
   }
-  if(root) p.cmd("clearFullList");
+  if(root) {
+    p.cmd("clearFullList");
+  }
   int tmp=0;
   if(root && redo) {
     tmp=1;
@@ -347,50 +408,78 @@ void Plumed::prepare() {
   if(tmp) {
     int s=index.size();
     comm.Bcast(s,0);
-    if(!root) index.resize(s);
+    if(!root) {
+      index.resize(s);
+    }
     comm.Bcast(index,0);
     std::vector<AtomNumber> numbers;
     numbers.reserve(index.size());
-    for(auto i : index) numbers.emplace_back(AtomNumber::index(i));
+    for(auto i : index) {
+      numbers.emplace_back(AtomNumber::index(i));
+    }
     requestAtoms(numbers);
   }
 }
 
 void Plumed::calculate() {
   Tools::DirectoryChanger directoryChanger(directory.c_str());
-  if(root) p.cmd("setStopFlag",&stop);
+  if(root) {
+    p.cmd("setStopFlag",&stop);
+  }
   Tensor box=getPbc().getBox();
-  if(root) p.cmd("setBox",&box[0][0], {3,3});
+  if(root)
+    p.cmd("setBox",&box[0][0], {3,3});
 
   virial.zero();
-  for(int i=0; i<forces.size(); i++) forces[i]=0.0;
-  for(int i=0; i<masses.size(); i++) masses[i]=getMass(i);
-  for(int i=0; i<charges.size(); i++) charges[i]=getCharge(i);
+  for(int i=0; i<forces.size(); i++) {
+    forces[i]=0.0;
+  }
+  for(int i=0; i<masses.size(); i++) {
+    masses[i]=getMass(i);
+  }
+  for(int i=0; i<charges.size(); i++) {
+    charges[i]=getCharge(i);
+  }
 
-  if(root) p.cmd("setMasses",masses.data(), {masses.size()});
-  if(root) p.cmd("setCharges",charges.data(), {charges.size()});
-  if(root) p.cmd("setPositions",positions.data(), {masses.size(),3});
-  if(root) p.cmd("setForces",forces.data(),forces.size());
-  if(root) p.cmd("setVirial",&virial[0][0], {3,3});
+  if(root)
+    p.cmd("setMasses",masses.data(), {masses.size()});
+  if(root)
+    p.cmd("setCharges",charges.data(), {charges.size()});
+  if(root)
+    p.cmd("setPositions",positions.data(), {masses.size(),3});
+  if(root) {
+    p.cmd("setForces",forces.data(),forces.size());
+  }
+  if(root)
+    p.cmd("setVirial",&virial[0][0], {3,3});
 
 
-  if(root) for(unsigned i=0; i<getNumberOfAtoms(); i++) {
+  if(root)
+    for(unsigned i=0; i<getNumberOfAtoms(); i++) {
       positions[3*i+0]=getPosition(i)[0];
       positions[3*i+1]=getPosition(i)[1];
       positions[3*i+2]=getPosition(i)[2];
     }
 
-  if(root) p.cmd("shareData");
-  if(root) p.cmd("performCalcNoUpdate");
+  if(root) {
+    p.cmd("shareData");
+  }
+  if(root) {
+    p.cmd("performCalcNoUpdate");
+  }
 
   int s=forces.size();
   comm.Bcast(s,0);
-  if(!root) forces.resize(s);
+  if(!root) {
+    forces.resize(s);
+  }
   comm.Bcast(forces,0);
   comm.Bcast(virial,0);
 
   double bias=0.0;
-  if(root) p.cmd("getBias",&bias);
+  if(root) {
+    p.cmd("getBias",&bias);
+  }
   comm.Bcast(bias,0);
   getPntrToComponent("bias")->set(bias);
 }
@@ -398,14 +487,22 @@ void Plumed::calculate() {
 void Plumed::apply() {
   Tools::DirectoryChanger directoryChanger(directory.c_str());
   std::vector<double> fforces( forces.size() + 9, 0 );
-  for(unsigned i=0; i<forces.size(); i++) fforces[i] += forces[i];
-  for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) fforces[forces.size()+3*i+j] = virial[i][j];
-  unsigned ind=0; setForcesOnAtoms( fforces, ind );
+  for(unsigned i=0; i<forces.size(); i++) {
+    fforces[i] += forces[i];
+  }
+  for(unsigned i=0; i<3; ++i)
+    for(unsigned j=0; j<3; ++j) {
+      fforces[forces.size()+3*i+j] = virial[i][j];
+    }
+  unsigned ind=0;
+  setForcesOnAtoms( fforces, ind );
 }
 
 void Plumed::update() {
   Tools::DirectoryChanger directoryChanger(directory.c_str());
-  if(root) p.cmd("update");
+  if(root) {
+    p.cmd("update");
+  }
   comm.Bcast(stop,0);
   if(stop) {
     log<<"  Action " << getLabel()<<" asked to stop\n";
diff --git a/src/generic/Print.cpp b/src/generic/Print.cpp
index 4f3ca3bfdf..4324bfa59d 100644
--- a/src/generic/Print.cpp
+++ b/src/generic/Print.cpp
@@ -67,8 +67,7 @@ only when required.
 
 class Print :
   public ActionPilot,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
   std::string file;
   OFile ofile;
   std::string fmt;
@@ -114,8 +113,7 @@ Print::Print(const ActionOptions&ao):
   ActionPilot(ao),
   ActionWithArguments(ao),
   fmt("%f"),
-  rotate(0)
-{
+  rotate(0) {
   ofile.link(*this);
   parse("FILE",file);
   if(file.length()>0) {
@@ -139,7 +137,9 @@ Print::Print(const ActionOptions&ao):
   parse("_ROTATE",rotate);
   if(rotate>0) {
     rotateCountdown=rotate;
-    for(unsigned i=0; i<getNumberOfArguments(); ++i) rotateArguments.push_back( getPntrToArgument(i) );
+    for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+      rotateArguments.push_back( getPntrToArgument(i) );
+    }
     std::vector<Value*> a(1,rotateArguments[0]);
     requestArguments(std::vector<Value*>(1,rotateArguments[0]));
     rotateLast=0;
@@ -173,7 +173,8 @@ void Print::update() {
   ofile.fmtField(" %f");
   ofile.printField("time",getTime());
   for(unsigned i=0; i<getNumberOfArguments(); i++) {
-    ofile.fmtField(fmt); getPntrToArgument(i)->print( ofile );
+    ofile.fmtField(fmt);
+    getPntrToArgument(i)->print( ofile );
   }
   ofile.printField();
 }
diff --git a/src/generic/PrintNDX.cpp b/src/generic/PrintNDX.cpp
index afe4a25116..78a9d77088 100644
--- a/src/generic/PrintNDX.cpp
+++ b/src/generic/PrintNDX.cpp
@@ -40,8 +40,7 @@ namespace generic {
 class PrintNDX :
   public ActionPilot,
   public ActionAtomistic,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
   std::string file;
   OFile ofile;
   CheckInRange bounds;
@@ -50,8 +49,12 @@ class PrintNDX :
   std::string writeInGraph() const override;
   explicit PrintNDX(const ActionOptions&);
   static void registerKeywords(Keywords& keys);
-  bool actionHasForces() override { return false; }
-  void calculateNumericalDerivatives( ActionWithValue* a=NULL ) override { plumed_error(); }
+  bool actionHasForces() override {
+    return false;
+  }
+  void calculateNumericalDerivatives( ActionWithValue* a=NULL ) override {
+    plumed_error();
+  }
   void lockRequests() override;
   void unlockRequests() override;
   void apply() override {}
@@ -81,8 +84,7 @@ PrintNDX::PrintNDX(const ActionOptions&ao):
   Action(ao),
   ActionPilot(ao),
   ActionAtomistic(ao),
-  ActionWithArguments(ao)
-{
+  ActionWithArguments(ao) {
   ofile.link(*this);
   parse("FILE",file);
   if(file.length()>0) {
@@ -92,23 +94,39 @@ PrintNDX::PrintNDX(const ActionOptions&ao):
     log.printf("  on plumed log file\n");
     ofile.link(log);
   }
-  std::vector<AtomNumber> all_atoms; parseAtomList("ATOMS",all_atoms); std::vector<std::string> argnames( getNumberOfArguments() );
+  std::vector<AtomNumber> all_atoms;
+  parseAtomList("ATOMS",all_atoms);
+  std::vector<std::string> argnames( getNumberOfArguments() );
   requestAtoms( all_atoms, false );
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->getRank()!=1 || getPntrToArgument(i)->hasDerivatives() ) error("arguments for print ndx should be vector");
-    if( getPntrToArgument(i)->getShape()[0]!=all_atoms.size() ) error("mismatch between number of arguments and number of input atoms");
-    getPntrToArgument(i)->buildDataStore(true); argnames[i] = getPntrToArgument(i)->getName();
+    if( getPntrToArgument(i)->getRank()!=1 || getPntrToArgument(i)->hasDerivatives() ) {
+      error("arguments for print ndx should be vector");
+    }
+    if( getPntrToArgument(i)->getShape()[0]!=all_atoms.size() ) {
+      error("mismatch between number of arguments and number of input atoms");
+    }
+    getPntrToArgument(i)->buildDataStore(true);
+    argnames[i] = getPntrToArgument(i)->getName();
   }
   log.printf("  printing ndx file containing indices of atoms that have arguments in ranges prescribed below \n");
   log.printf("  full set of atom indices investigated are : ");
   for(unsigned int i=0; i<all_atoms.size(); ++i) {
-    if ( (i+1) % 25 == 0 ) log.printf("  \n");
+    if ( (i+1) % 25 == 0 ) {
+      log.printf("  \n");
+    }
     log.printf("  %d", all_atoms[i].serial());
   }
-  log.printf("\n"); std::vector<std::string> str_upper, str_lower; std::string errors;
-  parseVector("LESS_THAN_OR_EQUAL",str_upper); parseVector("GREATER_THAN_OR_EQUAL",str_lower);
-  if( !bounds.setBounds( getNumberOfArguments(), str_lower, str_upper, errors ) ) error( errors );
-  if( bounds.wereSet() ) log.printf("  %s \n", bounds.report( argnames ).c_str() );
+  log.printf("\n");
+  std::vector<std::string> str_upper, str_lower;
+  std::string errors;
+  parseVector("LESS_THAN_OR_EQUAL",str_upper);
+  parseVector("GREATER_THAN_OR_EQUAL",str_lower);
+  if( !bounds.setBounds( getNumberOfArguments(), str_lower, str_upper, errors ) ) {
+    error( errors );
+  }
+  if( bounds.wereSet() ) {
+    log.printf("  %s \n", bounds.report( argnames ).c_str() );
+  }
   checkRead();
 }
 
@@ -127,13 +145,19 @@ void PrintNDX::unlockRequests() {
 }
 
 void PrintNDX::update() {
-  unsigned n=0; std::vector<double> argvals( getNumberOfArguments() );
+  unsigned n=0;
+  std::vector<double> argvals( getNumberOfArguments() );
   ofile.printf("[ %s step %d ] \n", getLabel().c_str(), getStep() );
   for(unsigned i=0; i<getNumberOfAtoms(); ++i) {
-    for(unsigned j=0; j<getNumberOfArguments(); ++j) argvals[j] = getPntrToArgument(j)->get(i);
+    for(unsigned j=0; j<getNumberOfArguments(); ++j) {
+      argvals[j] = getPntrToArgument(j)->get(i);
+    }
     if( bounds.check( argvals ) ) {
-      ofile.printf("%6d", getAbsoluteIndexes()[i].serial() ); n++;
-      if( n%15==0 ) ofile.printf("\n");
+      ofile.printf("%6d", getAbsoluteIndexes()[i].serial() );
+      n++;
+      if( n%15==0 ) {
+        ofile.printf("\n");
+      }
     }
   }
   ofile.printf("\n");
diff --git a/src/generic/RandomExchanges.cpp b/src/generic/RandomExchanges.cpp
index 027e8e0a88..3d0a571ab5 100644
--- a/src/generic/RandomExchanges.cpp
+++ b/src/generic/RandomExchanges.cpp
@@ -71,8 +71,7 @@ should be the same in all input files.
 //+ENDPLUMEDOC
 
 class RandomExchanges:
-  public Action
-{
+  public Action {
 public:
   static void registerKeywords( Keywords& keys );
   explicit RandomExchanges(const ActionOptions&ao);
@@ -88,13 +87,14 @@ void RandomExchanges::registerKeywords( Keywords& keys ) {
 }
 
 RandomExchanges::RandomExchanges(const ActionOptions&ao):
-  Action(ao)
-{
+  Action(ao) {
   plumed.getExchangePatterns().setFlag(ExchangePatterns::RANDOM);
 // I convert the seed to -seed because I think it is more general to use a positive seed in input
   int seed=-1;
   parse("SEED",seed);
-  if(seed>=0) plumed.getExchangePatterns().setSeed(-seed);
+  if(seed>=0) {
+    plumed.getExchangePatterns().setSeed(-seed);
+  }
 }
 
 }
diff --git a/src/generic/Read.cpp b/src/generic/Read.cpp
index bb28bd9148..2b5e7e80ae 100644
--- a/src/generic/Read.cpp
+++ b/src/generic/Read.cpp
@@ -76,8 +76,7 @@ The file input_colvar.data is just a normal colvar file as shown below
 
 class Read :
   public ActionPilot,
-  public ActionWithValue
-{
+  public ActionWithValue {
 private:
   bool ignore_time;
   bool ignore_forces;
@@ -131,8 +130,7 @@ Read::Read(const ActionOptions&ao):
   ActionWithValue(ao),
   ignore_time(false),
   ignore_forces(false),
-  nlinesPerStep(1)
-{
+  nlinesPerStep(1) {
   // Read the file name from the input line
   parse("FILE",filename);
   // Check if time is to be ignored
@@ -151,50 +149,80 @@ Read::Read(const ActionOptions&ao):
   if( !cloned_file ) {
     ifile_ptr=Tools::make_unique<IFile>();
     ifile=ifile_ptr.get();
-    if( !ifile->FileExist(filename) ) error("could not find file named " + filename);
+    if( !ifile->FileExist(filename) ) {
+      error("could not find file named " + filename);
+    }
     ifile->link(*this);
     ifile->open(filename);
     ifile->allowIgnoredFields();
   }
   parse("EVERY",nlinesPerStep);
-  if(nlinesPerStep>1) log.printf("  only reading every %uth line of file %s\n",nlinesPerStep,filename.c_str() );
-  else log.printf("  reading data from file %s\n",filename.c_str() );
+  if(nlinesPerStep>1) {
+    log.printf("  only reading every %uth line of file %s\n",nlinesPerStep,filename.c_str() );
+  } else {
+    log.printf("  reading data from file %s\n",filename.c_str() );
+  }
   // Find out what we are reading
-  std::vector<std::string> valread; parseVector("VALUES",valread);
+  std::vector<std::string> valread;
+  parseVector("VALUES",valread);
 
-  if(nlinesPerStep>1 && cloned_file) error("Opening a file multiple times and using EVERY is not allowed");
+  if(nlinesPerStep>1 && cloned_file) {
+    error("Opening a file multiple times and using EVERY is not allowed");
+  }
 
   std::size_t dot=valread[0].find_first_of('.');
   if( valread[0].find(".")!=std::string::npos ) {
     std::string label=valread[0].substr(0,dot);
     std::string name=valread[0].substr(dot+1);
     if( name=="*" ) {
-      if( valread.size()>1 ) error("all values must be from the same Action when using READ");
+      if( valread.size()>1 ) {
+        error("all values must be from the same Action when using READ");
+      }
       std::vector<std::string> fieldnames;
       ifile->scanFieldList( fieldnames );
       for(unsigned i=0; i<fieldnames.size(); ++i) {
         if( fieldnames[i].substr(0,dot)==label ) {
-          readvals.emplace_back(Tools::make_unique<Value>(this, fieldnames[i], false) ); addComponentWithDerivatives( fieldnames[i].substr(dot+1) );
-          if( ifile->FieldExist("min_" + fieldnames[i]) ) componentIsPeriodic( fieldnames[i].substr(dot+1), "-pi","pi" );
-          else componentIsNotPeriodic( fieldnames[i].substr(dot+1) );
+          readvals.emplace_back(Tools::make_unique<Value>(this, fieldnames[i], false) );
+          addComponentWithDerivatives( fieldnames[i].substr(dot+1) );
+          if( ifile->FieldExist("min_" + fieldnames[i]) ) {
+            componentIsPeriodic( fieldnames[i].substr(dot+1), "-pi","pi" );
+          } else {
+            componentIsNotPeriodic( fieldnames[i].substr(dot+1) );
+          }
         }
       }
     } else {
-      readvals.emplace_back(Tools::make_unique<Value>(this, valread[0], false) ); addComponentWithDerivatives( name );
-      if( ifile->FieldExist("min_" + valread[0]) ) componentIsPeriodic( valread[0].substr(dot+1), "-pi", "pi" );
-      else componentIsNotPeriodic( valread[0].substr(dot+1) );
+      readvals.emplace_back(Tools::make_unique<Value>(this, valread[0], false) );
+      addComponentWithDerivatives( name );
+      if( ifile->FieldExist("min_" + valread[0]) ) {
+        componentIsPeriodic( valread[0].substr(dot+1), "-pi", "pi" );
+      } else {
+        componentIsNotPeriodic( valread[0].substr(dot+1) );
+      }
       for(unsigned i=1; i<valread.size(); ++i) {
-        if( valread[i].substr(0,dot)!=label ) error("all values must be from the same Action when using READ");;
-        readvals.emplace_back(Tools::make_unique<Value>(this, valread[i], false) ); addComponentWithDerivatives( valread[i].substr(dot+1) );
-        if( ifile->FieldExist("min_" + valread[i]) ) componentIsPeriodic( valread[i].substr(dot+1), "-pi", "pi" );
-        else componentIsNotPeriodic( valread[i].substr(dot+1) );
+        if( valread[i].substr(0,dot)!=label ) {
+          error("all values must be from the same Action when using READ");
+        };
+        readvals.emplace_back(Tools::make_unique<Value>(this, valread[i], false) );
+        addComponentWithDerivatives( valread[i].substr(dot+1) );
+        if( ifile->FieldExist("min_" + valread[i]) ) {
+          componentIsPeriodic( valread[i].substr(dot+1), "-pi", "pi" );
+        } else {
+          componentIsNotPeriodic( valread[i].substr(dot+1) );
+        }
       }
     }
   } else {
-    if( valread.size()!=1 ) error("all values must be from the same Action when using READ");
-    readvals.emplace_back(Tools::make_unique<Value>(this, valread[0], false) ); addValueWithDerivatives();
-    if( ifile->FieldExist("min_" + valread[0]) ) setPeriodic( "-pi", "pi" );
-    else setNotPeriodic();
+    if( valread.size()!=1 ) {
+      error("all values must be from the same Action when using READ");
+    }
+    readvals.emplace_back(Tools::make_unique<Value>(this, valread[0], false) );
+    addValueWithDerivatives();
+    if( ifile->FieldExist("min_" + valread[0]) ) {
+      setPeriodic( "-pi", "pi" );
+    } else {
+      setNotPeriodic();
+    }
     log.printf("  reading value %s and storing as %s\n",valread[0].c_str(),getLabel().c_str() );
   }
   checkRead();
@@ -203,9 +231,12 @@ Read::Read(const ActionOptions&ao):
 std::string Read::getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const {
   plumed_assert( !exists( getLabel() ) );
   for(unsigned i=0; i<readvals.size(); ++i) {
-    if( readvals[i]->getName().find( cname )!=std::string::npos ) return "values from the column labelled " + readvals[i]->getName() + " in the file named " + filename;
+    if( readvals[i]->getName().find( cname )!=std::string::npos ) {
+      return "values from the column labelled " + readvals[i]->getName() + " in the file named " + filename;
+    }
   }
-  plumed_error(); return "";
+  plumed_error();
+  return "";
 }
 
 std::string Read::getFilename() const {
@@ -221,8 +252,9 @@ unsigned Read::getNumberOfDerivatives() {
 }
 
 void Read::turnOnDerivatives() {
-  if( !ignore_forces ) error("cannot calculate derivatives for colvars that are read in from a file.  If you are postprocessing and "
-                               "these forces do not matter add the flag IGNORE_FORCES to all READ actions");
+  if( !ignore_forces )
+    error("cannot calculate derivatives for colvars that are read in from a file.  If you are postprocessing and "
+          "these forces do not matter add the flag IGNORE_FORCES to all READ actions");
 }
 
 void Read::prepare() {
@@ -231,7 +263,9 @@ void Read::prepare() {
     if( !ifile->scanField("time",du_time) ) {
       error("Reached end of file " + filename + " before end of trajectory");
     } else if( std::abs( du_time-getTime() )>getTimeStep() && !ignore_time ) {
-      std::string str_dutime,str_ptime; Tools::convert(du_time,str_dutime); Tools::convert(getTime(),str_ptime);
+      std::string str_dutime,str_ptime;
+      Tools::convert(du_time,str_dutime);
+      Tools::convert(getTime(),str_ptime);
       error("mismatched times in colvar files : colvar time=" + str_dutime + " plumed time=" + str_ptime + ". Add IGNORE_TIME to ignore error.");
     }
   }
@@ -254,8 +288,11 @@ void Read::calculate() {
 void Read::update() {
   if( !cloned_file ) {
     for(unsigned i=0; i<nlinesPerStep; ++i) {
-      ifile->scanField(); double du_time;
-      if( !ifile->scanField("time",du_time) && !plumed.inputsAreActive() ) plumed.stop();
+      ifile->scanField();
+      double du_time;
+      if( !ifile->scanField("time",du_time) && !plumed.inputsAreActive() ) {
+        plumed.stop();
+      }
     }
   }
 }
diff --git a/src/generic/ResetCell.cpp b/src/generic/ResetCell.cpp
index 0882258e56..7aa82d9788 100644
--- a/src/generic/ResetCell.cpp
+++ b/src/generic/ResetCell.cpp
@@ -93,8 +93,7 @@ END
 
 class ResetCell:
   public ActionPilot,
-  public ActionAtomistic
-{
+  public ActionAtomistic {
   std::string type;
   Tensor rotation,newbox;
   Value* boxValue;
@@ -118,16 +117,19 @@ void ResetCell::registerKeywords( Keywords& keys ) {
 ResetCell::ResetCell(const ActionOptions&ao):
   Action(ao),
   ActionPilot(ao),
-  ActionAtomistic(ao)
-{
+  ActionAtomistic(ao) {
   type.assign("TRIANGULAR");
   parse("TYPE",type);
 
   log<<"  type: "<<type<<"\n";
-  if(type!="TRIANGULAR") error("undefined type "+type);
+  if(type!="TRIANGULAR") {
+    error("undefined type "+type);
+  }
 
   pbc_action=plumed.getActionSet().selectWithLabel<PbcAction*>("Box");
-  if( !pbc_action ) error("cannot reset cell if box has not been set");
+  if( !pbc_action ) {
+    error("cannot reset cell if box has not been set");
+  }
   boxValue=pbc_action->copyOutput(0);
 }
 
@@ -153,7 +155,9 @@ void ResetCell::calculate() {
   newbox[2][1]=c*(bc-ac*ab)/std::sqrt(1-ab*ab);
   newbox[2][2]=std::sqrt(c*c-newbox[2][0]*newbox[2][0]-newbox[2][1]*newbox[2][1]);
 
-  if(determinant(newbox)*determinant(box)<0) newbox[2][2]=-newbox[2][2];
+  if(determinant(newbox)*determinant(box)<0) {
+    newbox[2][2]=-newbox[2][2];
+  }
 
 // rotation matrix from old to new coordinates
   rotation=transpose(matmul(inverse(box),newbox));
@@ -192,13 +196,20 @@ void ResetCell::apply() {
 // of the virial matrix equal to their symmetric ones.
 // GB
   Tensor virial;
-  for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) virial[i][j]=boxValue->getForce( 3*i+j );
+  for(unsigned i=0; i<3; ++i)
+    for(unsigned j=0; j<3; ++j) {
+      virial[i][j]=boxValue->getForce( 3*i+j );
+    }
   virial[0][1]=virial[1][0];
   virial[0][2]=virial[2][0];
   virial[1][2]=virial[2][1];
 // rotate back virial
-  virial=matmul(transpose(rotation),matmul(virial,rotation)); boxValue->clearInputForce();
-  for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) boxValue->addForce( 3*i+j, virial(i,j) );
+  virial=matmul(transpose(rotation),matmul(virial,rotation));
+  boxValue->clearInputForce();
+  for(unsigned i=0; i<3; ++i)
+    for(unsigned j=0; j<3; ++j) {
+      boxValue->addForce( 3*i+j, virial(i,j) );
+    }
 
 
 }
diff --git a/src/generic/Time.cpp b/src/generic/Time.cpp
index 804074e93c..bee55aa878 100644
--- a/src/generic/Time.cpp
+++ b/src/generic/Time.cpp
@@ -48,7 +48,9 @@ class Time : public ActionWithValue {
 // active methods:
   void calculate() override;
   void apply() override {}
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
 };
 
 PLUMED_REGISTER_ACTION(Time,"TIME")
@@ -60,9 +62,9 @@ void Time::registerKeywords( Keywords& keys ) {
 }
 
 Time::Time(const ActionOptions&ao):
-  Action(ao),ActionWithValue(ao)
-{
-  addValueWithDerivatives(); setNotPeriodic();
+  Action(ao),ActionWithValue(ao) {
+  addValueWithDerivatives();
+  setNotPeriodic();
   // resize derivative by hand to a nonzero value
   getPntrToValue()->resizeDerivatives(1);
 }
diff --git a/src/generic/UpdateIf.cpp b/src/generic/UpdateIf.cpp
index a7abb36d04..b3854282b1 100644
--- a/src/generic/UpdateIf.cpp
+++ b/src/generic/UpdateIf.cpp
@@ -78,8 +78,7 @@ UPDATE_IF ARG=coord END
 
 class UpdateIf:
   public ActionPilot,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
   std::vector<double> lower;
   std::vector<double> upper;
   bool on;
@@ -112,17 +111,28 @@ UpdateIf::UpdateIf(const ActionOptions&ao):
   ActionPilot(ao),
   ActionWithArguments(ao),
   on(false),
-  end(false)
-{
+  end(false) {
   parseFlag("END",end);
   parseVector("LESS_THAN",upper);
   parseVector("MORE_THAN",lower);
-  if(end && upper.size()!=0) error("END and LESS_THAN are not compatible");
-  if(end && lower.size()!=0) error("END and MORE_THAN are not compatible");
-  if(upper.size()==0) upper.assign(getNumberOfArguments(),+std::numeric_limits<double>::max());
-  if(lower.size()==0) lower.assign(getNumberOfArguments(),-std::numeric_limits<double>::max());
-  if(upper.size()!=getNumberOfArguments()) error("LESS_THAN should have the same size as ARG");
-  if(lower.size()!=getNumberOfArguments()) error("MORE_THAN should have the same size as ARG");
+  if(end && upper.size()!=0) {
+    error("END and LESS_THAN are not compatible");
+  }
+  if(end && lower.size()!=0) {
+    error("END and MORE_THAN are not compatible");
+  }
+  if(upper.size()==0) {
+    upper.assign(getNumberOfArguments(),+std::numeric_limits<double>::max());
+  }
+  if(lower.size()==0) {
+    lower.assign(getNumberOfArguments(),-std::numeric_limits<double>::max());
+  }
+  if(upper.size()!=getNumberOfArguments()) {
+    error("LESS_THAN should have the same size as ARG");
+  }
+  if(lower.size()!=getNumberOfArguments()) {
+    error("MORE_THAN should have the same size as ARG");
+  }
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
     log<<"  boundaries for argument "<<i<<"    "<<lower[i]<<" "<<upper[i]<<"\n";
   }
@@ -136,15 +146,21 @@ void UpdateIf::prepare() {
 void UpdateIf::calculate() {
   on=true;
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if(getArgument(i)>=upper[i] || getArgument(i)<=lower[i]) on=false;
+    if(getArgument(i)>=upper[i] || getArgument(i)<=lower[i]) {
+      on=false;
+    }
   }
 }
 
 void UpdateIf::beforeUpdate() {
-  if(end) plumed.updateFlagsPop();
-  else {
-    if(on) plumed.updateFlagsPush(plumed.updateFlagsTop());
-    else   plumed.updateFlagsPush(false);
+  if(end) {
+    plumed.updateFlagsPop();
+  } else {
+    if(on) {
+      plumed.updateFlagsPush(plumed.updateFlagsTop());
+    } else {
+      plumed.updateFlagsPush(false);
+    }
   }
 }
 
diff --git a/src/generic/WholeMolecules.cpp b/src/generic/WholeMolecules.cpp
index e04ebfca4a..38a7c743f1 100644
--- a/src/generic/WholeMolecules.cpp
+++ b/src/generic/WholeMolecules.cpp
@@ -101,8 +101,7 @@ WHOLEMOLECULES RESIDUES=all MOLTYPE=protein
 
 class WholeMolecules:
   public ActionPilot,
-  public ActionAtomistic
-{
+  public ActionAtomistic {
   std::vector<std::vector<std::pair<std::size_t,std::size_t> > > p_groups;
   std::vector<std::vector<std::pair<std::size_t,std::size_t> > > p_roots;
   std::vector<Vector> refs;
@@ -110,7 +109,9 @@ class WholeMolecules:
 public:
   explicit WholeMolecules(const ActionOptions&ao);
   static void registerKeywords( Keywords& keys );
-  bool actionHasForces() override { return false; }
+  bool actionHasForces() override {
+    return false;
+  }
   void calculate() override;
   void apply() override {}
 };
@@ -137,8 +138,7 @@ WholeMolecules::WholeMolecules(const ActionOptions&ao):
   Action(ao),
   ActionPilot(ao),
   ActionAtomistic(ao),
-  doemst(false), addref(false)
-{
+  doemst(false), addref(false) {
   std::vector<std::vector<AtomNumber> > groups;
   std::vector<std::vector<AtomNumber> > roots;
   // parse optional flags
@@ -149,20 +149,30 @@ WholeMolecules::WholeMolecules(const ActionOptions&ao):
   for(int i=0;; i++) {
     std::vector<AtomNumber> group;
     parseAtomList("ENTITY",i,group);
-    if( group.empty() ) break;
+    if( group.empty() ) {
+      break;
+    }
     groups.push_back(group);
   }
 
   // Read residues to align from MOLINFO
-  std::vector<std::string> resstrings; parseVector("RESIDUES",resstrings);
+  std::vector<std::string> resstrings;
+  parseVector("RESIDUES",resstrings);
   if( resstrings.size()>0 ) {
     if( resstrings.size()==1 ) {
-      if( resstrings[0]=="all" ) resstrings[0]="all-ter";   // Include terminal groups in alignment
+      if( resstrings[0]=="all" ) {
+        resstrings[0]="all-ter";  // Include terminal groups in alignment
+      }
+    }
+    std::string moltype;
+    parse("MOLTYPE",moltype);
+    if(moltype.length()==0) {
+      error("Found RESIDUES keyword without specification of the molecule - use MOLTYPE");
     }
-    std::string moltype; parse("MOLTYPE",moltype);
-    if(moltype.length()==0) error("Found RESIDUES keyword without specification of the molecule - use MOLTYPE");
     auto* moldat=plumed.getActionSet().selectLatest<GenericMolInfo*>(this);
-    if( !moldat ) error("MOLINFO is required to use RESIDUES");
+    if( !moldat ) {
+      error("MOLINFO is required to use RESIDUES");
+    }
     std::vector< std::vector<AtomNumber> > backatoms;
     moldat->getBackbone( resstrings, moltype, backatoms );
     for(unsigned i=0; i<backatoms.size(); ++i) {
@@ -171,12 +181,16 @@ WholeMolecules::WholeMolecules(const ActionOptions&ao):
   }
 
   // check number of groups
-  if(groups.size()==0) error("no atoms found for WHOLEMOLECULES!");
+  if(groups.size()==0) {
+    error("no atoms found for WHOLEMOLECULES!");
+  }
 
   // if using PDBs reorder atoms in groups based on proximity in PDB file
   if(doemst) {
     auto* moldat=plumed.getActionSet().selectLatest<GenericMolInfo*>(this);
-    if( !moldat ) error("MOLINFO is required to use EMST");
+    if( !moldat ) {
+      error("MOLINFO is required to use EMST");
+    }
     // initialize tree
     Tree tree = Tree(moldat);
     // cycle on groups and reorder atoms
@@ -189,7 +203,9 @@ WholeMolecules::WholeMolecules(const ActionOptions&ao):
     // fill root vector with previous atom in groups
     for(unsigned i=0; i<groups.size(); ++i) {
       std::vector<AtomNumber> root;
-      for(unsigned j=0; j<groups[i].size()-1; ++j) root.push_back(groups[i][j]);
+      for(unsigned j=0; j<groups[i].size()-1; ++j) {
+        root.push_back(groups[i][j]);
+      }
       // store root atoms
       roots.push_back(root);
     }
@@ -198,7 +214,9 @@ WholeMolecules::WholeMolecules(const ActionOptions&ao):
   // adding reference if needed
   if(addref) {
     auto* moldat=plumed.getActionSet().selectLatest<GenericMolInfo*>(this);
-    if( !moldat ) error("MOLINFO is required to use ADDREFERENCE");
+    if( !moldat ) {
+      error("MOLINFO is required to use ADDREFERENCE");
+    }
     for(unsigned i=0; i<groups.size(); ++i) {
       // add reference position of first atom in entity
       refs.push_back(moldat->getPosition(groups[i][0]));
@@ -208,9 +226,13 @@ WholeMolecules::WholeMolecules(const ActionOptions&ao):
   // print out info
   for(unsigned i=0; i<groups.size(); ++i) {
     log.printf("  atoms in entity %d : ",i);
-    for(unsigned j=0; j<groups[i].size(); ++j) log.printf("%d ",groups[i][j].serial() );
+    for(unsigned j=0; j<groups[i].size(); ++j) {
+      log.printf("%d ",groups[i][j].serial() );
+    }
     log.printf("\n");
-    if(addref) log.printf("     with reference position : %lf %lf %lf\n",refs[i][0],refs[i][1],refs[i][2]);
+    if(addref) {
+      log.printf("     with reference position : %lf %lf %lf\n",refs[i][0],refs[i][1],refs[i][2]);
+    }
   }
 
   // collect all atoms
@@ -223,13 +245,17 @@ WholeMolecules::WholeMolecules(const ActionOptions&ao):
   p_groups.resize( groups.size() );
   for(unsigned i=0; i<groups.size(); ++i) {
     p_groups[i].resize( groups[i].size() );
-    for(unsigned j=0; j<groups[i].size(); ++j) p_groups[i][j] = getValueIndices( groups[i][j] );
+    for(unsigned j=0; j<groups[i].size(); ++j) {
+      p_groups[i][j] = getValueIndices( groups[i][j] );
+    }
   }
   // Convert roots to p_roots
   p_roots.resize( roots.size() );
   for(unsigned i=0; i<roots.size(); ++i) {
     p_roots[i].resize( roots[i].size() );
-    for(unsigned j=0; j<roots[i].size(); ++j) p_roots[i][j] = getValueIndices( roots[i][j] );
+    for(unsigned j=0; j<roots[i].size(); ++j) {
+      p_roots[i][j] = getValueIndices( roots[i][j] );
+    }
   }
 
 
diff --git a/src/generic/WrapAround.cpp b/src/generic/WrapAround.cpp
index e4ed858559..26bb3cfd53 100644
--- a/src/generic/WrapAround.cpp
+++ b/src/generic/WrapAround.cpp
@@ -145,8 +145,7 @@ DUMPATOMS FILE=dump.xyz ATOMS=solute,water
 
 class WrapAround:
   public ActionPilot,
-  public ActionAtomistic
-{
+  public ActionAtomistic {
   // cppcheck-suppress duplInheritedMember
   std::vector<Vector> refatoms;
   std::vector<std::pair<std::size_t,std::size_t> > p_atoms;
@@ -156,7 +155,9 @@ class WrapAround:
 public:
   explicit WrapAround(const ActionOptions&ao);
   static void registerKeywords( Keywords& keys );
-  bool actionHasForces() override { return false; }
+  bool actionHasForces() override {
+    return false;
+  }
   void calculate() override;
   void apply() override {}
 };
@@ -179,39 +180,60 @@ WrapAround::WrapAround(const ActionOptions&ao):
   ActionPilot(ao),
   ActionAtomistic(ao),
   groupby(1),
-  pair_(false)
-{
-  std::vector<AtomNumber> atoms; parseAtomList("ATOMS",atoms);
-  std::vector<AtomNumber> reference; parseAtomList("AROUND",reference);
+  pair_(false) {
+  std::vector<AtomNumber> atoms;
+  parseAtomList("ATOMS",atoms);
+  std::vector<AtomNumber> reference;
+  parseAtomList("AROUND",reference);
   parse("GROUPBY",groupby);
   parseFlag("PAIR", pair_);
 
   log.printf("  atoms in reference :");
-  for(unsigned j=0; j<reference.size(); ++j) log.printf(" %d",reference[j].serial() );
+  for(unsigned j=0; j<reference.size(); ++j) {
+    log.printf(" %d",reference[j].serial() );
+  }
   log.printf("\n");
   log.printf("  atoms to be wrapped :");
-  for(unsigned j=0; j<atoms.size(); ++j) log.printf(" %d",atoms[j].serial() );
+  for(unsigned j=0; j<atoms.size(); ++j) {
+    log.printf(" %d",atoms[j].serial() );
+  }
   log.printf("\n");
-  if(groupby>1) log<<"  atoms will be grouped by "<<groupby<<"\n";
-  if(pair_) log.printf("  pairing atoms and references\n");
+  if(groupby>1) {
+    log<<"  atoms will be grouped by "<<groupby<<"\n";
+  }
+  if(pair_) {
+    log.printf("  pairing atoms and references\n");
+  }
 
-  if(atoms.size()%groupby!=0) error("number of atoms should be a multiple of groupby option");
+  if(atoms.size()%groupby!=0) {
+    error("number of atoms should be a multiple of groupby option");
+  }
   // additional checks with PAIR
-  if(pair_ && atoms.size()!=reference.size()*groupby) error("with PAIR you must have: #ATOMS = #AROUND * #GROUPBY");
+  if(pair_ && atoms.size()!=reference.size()*groupby) {
+    error("with PAIR you must have: #ATOMS = #AROUND * #GROUPBY");
+  }
 
   checkRead();
 
   // do not remove duplicates with pair
   if(!pair_) {
-    if(groupby<=1) Tools::removeDuplicates(atoms);
+    if(groupby<=1) {
+      Tools::removeDuplicates(atoms);
+    }
     Tools::removeDuplicates(reference);
   }
 
   std::vector<AtomNumber> merged(atoms.size()+reference.size());
   merge(atoms.begin(),atoms.end(),reference.begin(),reference.end(),merged.begin());
-  p_atoms.resize( atoms.size() ); for(unsigned i=0; i<atoms.size(); ++i) p_atoms[i] = getValueIndices( atoms[i] );
-  refatoms.resize( reference.size() ); p_reference.resize( reference.size() );
-  for(unsigned i=0; i<reference.size(); ++i) p_reference[i] = getValueIndices( reference[i] );
+  p_atoms.resize( atoms.size() );
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    p_atoms[i] = getValueIndices( atoms[i] );
+  }
+  refatoms.resize( reference.size() );
+  p_reference.resize( reference.size() );
+  for(unsigned i=0; i<reference.size(); ++i) {
+    p_reference[i] = getValueIndices( reference[i] );
+  }
   Tools::removeDuplicates(merged);
   requestAtoms(merged);
   doNotRetrieve();
@@ -219,7 +241,9 @@ WrapAround::WrapAround(const ActionOptions&ao):
 }
 
 void WrapAround::calculate() {
-  for(unsigned j=0; j<p_reference.size(); ++j) refatoms[j] = getGlobalPosition(p_reference[j]);
+  for(unsigned j=0; j<p_reference.size(); ++j) {
+    refatoms[j] = getGlobalPosition(p_reference[j]);
+  }
 
   for(unsigned i=0; i<p_atoms.size(); i+=groupby) {
     Vector second, first=getGlobalPosition(p_atoms[i]);
@@ -241,7 +265,8 @@ void WrapAround::calculate() {
     }
     second=refatoms[closest];
 // place first atom of the group
-    first=second+pbcDistance(second,first); setGlobalPosition(p_atoms[i],first);
+    first=second+pbcDistance(second,first);
+    setGlobalPosition(p_atoms[i],first);
 // then place other atoms close to the first of the group
     for(unsigned j=1; j<groupby; j++) {
       second=getGlobalPosition(p_atoms[i+j]);
diff --git a/src/gridtools/ActionWithGrid.cpp b/src/gridtools/ActionWithGrid.cpp
index 658e28c9c4..b1a8db9828 100644
--- a/src/gridtools/ActionWithGrid.cpp
+++ b/src/gridtools/ActionWithGrid.cpp
@@ -28,9 +28,11 @@ ActionWithGrid* ActionWithGrid::getInputActionWithGrid( Action* action ) {
   ActionWithGrid* ag = dynamic_cast<ActionWithGrid*>( action );
   if( !ag && action->getName()=="ACCUMULATE" ) {
     ActionWithArguments* aa=dynamic_cast<ActionWithArguments*>( action );
-    plumed_assert( aa ); ag = dynamic_cast<ActionWithGrid*>( (aa->getPntrToArgument(0))->getPntrToAction() );
+    plumed_assert( aa );
+    ag = dynamic_cast<ActionWithGrid*>( (aa->getPntrToArgument(0))->getPntrToAction() );
   }
-  plumed_assert( ag ); return ag;
+  plumed_assert( ag );
+  return ag;
 }
 
 void ActionWithGrid::registerKeywords( Keywords& keys ) {
@@ -40,13 +42,15 @@ void ActionWithGrid::registerKeywords( Keywords& keys ) {
 ActionWithGrid::ActionWithGrid(const ActionOptions&ao):
   Action(ao),
   ActionWithVector(ao),
-  firststep(true)
-{
+  firststep(true) {
 }
 
 void ActionWithGrid::calculate() {
   plumed_assert( !actionInChain() );
-  if( firststep ) { setupOnFirstStep( true ); firststep=false; }
+  if( firststep ) {
+    setupOnFirstStep( true );
+    firststep=false;
+  }
 
   runAllTasks();
 }
diff --git a/src/gridtools/ConvertToFES.cpp b/src/gridtools/ConvertToFES.cpp
index f2b18bdabd..fadfabf944 100644
--- a/src/gridtools/ConvertToFES.cpp
+++ b/src/gridtools/ConvertToFES.cpp
@@ -73,21 +73,35 @@ void ConvertToFES::registerKeywords( Keywords& keys ) {
   keys.add("optional","TEMP","the temperature at which you are operating");
   keys.addFlag("MINTOZERO",false,"set the minimum in the free energy to be equal to zero");
   keys.setValueDescription("the free energy surface");
-  keys.needsAction("FIND_GRID_MINIMUM"); keys.needsAction("CUSTOM");
+  keys.needsAction("FIND_GRID_MINIMUM");
+  keys.needsAction("CUSTOM");
 }
 
 ConvertToFES::ConvertToFES(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  bool minzero=false; parseFlag("MINTOZERO",minzero);
-  double simtemp=getkBT(); if( simtemp==0 ) error("TEMP not set - use keyword TEMP");
+  ActionShortcut(ao) {
+  bool minzero=false;
+  parseFlag("MINTOZERO",minzero);
+  double simtemp=getkBT();
+  if( simtemp==0 ) {
+    error("TEMP not set - use keyword TEMP");
+  }
 
-  std::vector<std::string> argv; parseVector("GRID",argv);
-  if( argv.size()==0 ) parseVector("ARG",argv);
-  if( argv.size()!=1 ) error("should only have one argument");
+  std::vector<std::string> argv;
+  parseVector("GRID",argv);
+  if( argv.size()==0 ) {
+    parseVector("ARG",argv);
+  }
+  if( argv.size()!=1 ) {
+    error("should only have one argument");
+  }
 
-  std::string str_temp; Tools::convert( simtemp, str_temp ); std::string flab=""; if( minzero ) flab="_unz";
+  std::string str_temp;
+  Tools::convert( simtemp, str_temp );
+  std::string flab="";
+  if( minzero ) {
+    flab="_unz";
+  }
   readInputLine( getShortcutLabel() + flab + ": CUSTOM ARG=" + argv[0] + " FUNC=-" + str_temp + "*log(x) PERIODIC=NO");
   if( minzero ) {
     readInputLine( getShortcutLabel() + "_min: FIND_GRID_MINIMUM ARG=" + getShortcutLabel() + "_unz" );
diff --git a/src/gridtools/DumpGrid.cpp b/src/gridtools/DumpGrid.cpp
index d6eedd3277..6eabb02f72 100644
--- a/src/gridtools/DumpGrid.cpp
+++ b/src/gridtools/DumpGrid.cpp
@@ -198,7 +198,8 @@ PLUMED_REGISTER_ACTION(DumpGrid,"DUMPGRID")
 void DumpGrid::registerKeywords( Keywords& keys ) {
   Action::registerKeywords( keys );
   ActionPilot::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.use("ARG");
+  ActionWithArguments::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("optional","GRID","the grid you would like to print (can also use ARG for specifying what is being printed)");
   keys.add("compulsory","STRIDE","0","the frequency with which the grid should be output to the file.  Default of zero means dump at end of calculation");
   keys.add("compulsory","FILE","density","the file on which to write the grid.");
@@ -211,34 +212,59 @@ DumpGrid::DumpGrid(const ActionOptions&ao):
   Action(ao),
   ActionWithArguments(ao),
   ActionPilot(ao),
-  fmt("%f")
-{
+  fmt("%f") {
   if( getNumberOfArguments()==0 ) {
-    std::vector<Value*> grids; parseArgumentList("GRID",grids); requestArguments(grids);
+    std::vector<Value*> grids;
+    parseArgumentList("GRID",grids);
+    requestArguments(grids);
+  }
+  if( getNumberOfArguments()!=1 ) {
+    error("should only be one argument");
+  }
+  if( getPntrToArgument(0)->getRank()==0 || !getPntrToArgument(0)->hasDerivatives() ) {
+    error("input should be a grid");
+  }
+  if( getName()=="DUMPCUBE" && getPntrToArgument(0)->getRank()!=3 ) {
+    error("input should be a three dimensional grid");
   }
-  if( getNumberOfArguments()!=1 ) error("should only be one argument");
-  if( getPntrToArgument(0)->getRank()==0 || !getPntrToArgument(0)->hasDerivatives() ) error("input should be a grid");
-  if( getName()=="DUMPCUBE" && getPntrToArgument(0)->getRank()!=3 ) error("input should be a three dimensional grid");
   parse("FILE",filename);
-  if(filename.length()==0) error("name out output file was not specified");
+  if(filename.length()==0) {
+    error("name out output file was not specified");
+  }
   ActionWithGrid* ag = ActionWithGrid::getInputActionWithGrid( getPntrToArgument(0)->getPntrToAction() );
-  if( !ag ) error( getPntrToArgument(0)->getName() + " is not grid");
+  if( !ag ) {
+    error( getPntrToArgument(0)->getName() + " is not grid");
+  }
 
   log.printf("  outputting grid with label %s to file named %s",getPntrToArgument(0)->getName().c_str(), filename.c_str() );
-  parse("FMT",fmt); log.printf(" with format %s \n", fmt.c_str() );
-  if( getName()=="DUMPGRID" ) fmt = " " + fmt; else if( getName()=="DUMPCUBE" ) fmt = fmt + " ";
-  parseFlag("PRINT_ONE_FILE", onefile); parseFlag("PRINT_XYZ",xyzfile);
+  parse("FMT",fmt);
+  log.printf(" with format %s \n", fmt.c_str() );
+  if( getName()=="DUMPGRID" ) {
+    fmt = " " + fmt;
+  } else if( getName()=="DUMPCUBE" ) {
+    fmt = fmt + " ";
+  }
+  parseFlag("PRINT_ONE_FILE", onefile);
+  parseFlag("PRINT_XYZ",xyzfile);
   if( xyzfile ) {
-    if( getName()=="DUMPCUBE" ) error("PRINT_XYZ flag not compatible with DUMPCUBE");
-    if( ag->getGridCoordinatesObject().getGridType()=="flat" ) error("can only use PRINT_XYZ option for fibonacci grids");
+    if( getName()=="DUMPCUBE" ) {
+      error("PRINT_XYZ flag not compatible with DUMPCUBE");
+    }
+    if( ag->getGridCoordinatesObject().getGridType()=="flat" ) {
+      error("can only use PRINT_XYZ option for fibonacci grids");
+    }
     log.printf("  outputting grid to xyzfile\n");
   }
-  if( onefile ) log.printf("  printing all grids on a single file \n");
-  else log.printf("  printing all grids on separate files \n");
+  if( onefile ) {
+    log.printf("  printing all grids on a single file \n");
+  } else {
+    log.printf("  printing all grids on separate files \n");
+  }
 }
 
 void DumpGrid::update() {
-  OFile ofile; ofile.link(*this);
+  OFile ofile;
+  ofile.link(*this);
   if( onefile ) {
     ofile.enforceRestart();
     ofile.open( filename );
@@ -248,44 +274,66 @@ void DumpGrid::update() {
   }
 
   ActionWithGrid* ag = ActionWithGrid::getInputActionWithGrid( getPntrToArgument(0)->getPntrToAction() );
-  plumed_assert( ag ); const GridCoordinatesObject & mygrid = ag->getGridCoordinatesObject();
+  plumed_assert( ag );
+  const GridCoordinatesObject & mygrid = ag->getGridCoordinatesObject();
 
   if( getName()=="DUMPCUBE" ) {
-    double lunit=1.0; std::vector<std::string> argnames( ag->getGridCoordinateNames() );
+    double lunit=1.0;
+    std::vector<std::string> argnames( ag->getGridCoordinateNames() );
 
     ofile.printf("PLUMED CUBE FILE\n");
     ofile.printf("OUTER LOOP: X, MIDDLE LOOP: Y, INNER LOOP: Z\n");
     // Number of atoms followed by position of origin (origin set so that center of grid is in center of cell)
-    bool isdists=true; std::vector<double> extent(3); std::vector<std::string> min( mygrid.getMin() ), max( mygrid.getMax() );
+    bool isdists=true;
+    std::vector<double> extent(3);
+    std::vector<std::string> min( mygrid.getMin() ), max( mygrid.getMax() );
     for(unsigned j=0; j<3; ++j) {
       if( argnames[j].find(".")!=std::string::npos ) {
         std::size_t dot = argnames[j].find(".");
         std::string name = argnames[j].substr(dot+1);
-        if( name!="x" && name!="y" && name!="z" ) isdists=false;
-      } else isdists=false;
+        if( name!="x" && name!="y" && name!="z" ) {
+          isdists=false;
+        }
+      } else {
+        isdists=false;
+      }
 
-      double mind, maxd; Tools::convert( min[j], mind ); Tools::convert( max[j], maxd );
-      if( mygrid.isPeriodic(j) ) extent[j]=maxd-mind;
-      else { extent[j]=maxd-mind+mygrid.getGridSpacing()[j]; }
+      double mind, maxd;
+      Tools::convert( min[j], mind );
+      Tools::convert( max[j], maxd );
+      if( mygrid.isPeriodic(j) ) {
+        extent[j]=maxd-mind;
+      } else {
+        extent[j]=maxd-mind+mygrid.getGridSpacing()[j];
+      }
     }
     if( isdists ) {
-      if( plumed.usingNaturalUnits() ) lunit = 1.0/0.5292;
-      else lunit = plumed.getUnits().getLength()/.05929;
+      if( plumed.usingNaturalUnits() ) {
+        lunit = 1.0/0.5292;
+      } else {
+        lunit = plumed.getUnits().getLength()/.05929;
+      }
     }
-    std::string ostr = "%d " + fmt + fmt + fmt + "\n"; Value* gval=getPntrToArgument(0);
+    std::string ostr = "%d " + fmt + fmt + fmt + "\n";
+    Value* gval=getPntrToArgument(0);
     ofile.printf(ostr.c_str(),1,-0.5*lunit*extent[0],-0.5*lunit*extent[1],-0.5*lunit*extent[2]);
     ofile.printf(ostr.c_str(),mygrid.getNbin(true)[0],lunit*mygrid.getGridSpacing()[0],0.0,0.0);  // Number of bins in each direction followed by
     ofile.printf(ostr.c_str(),mygrid.getNbin(true)[1],0.0,lunit*mygrid.getGridSpacing()[1],0.0);  // shape of voxel
     ofile.printf(ostr.c_str(),mygrid.getNbin(true)[2],0.0,0.0,lunit*mygrid.getGridSpacing()[2]);
     ofile.printf(ostr.c_str(),1,0.0,0.0,0.0); // Fake atom otherwise VMD doesn't work
-    std::vector<unsigned> pp(3); std::vector<unsigned> nbin( mygrid.getNbin(true) );
+    std::vector<unsigned> pp(3);
+    std::vector<unsigned> nbin( mygrid.getNbin(true) );
     for(pp[0]=0; pp[0]<nbin[0]; ++pp[0]) {
       for(pp[1]=0; pp[1]<nbin[1]; ++pp[1]) {
         for(pp[2]=0; pp[2]<nbin[2]; ++pp[2]) {
           unsigned ival=pp[pp.size()-1];
-          for(unsigned i=pp.size()-1; i>0; --i) ival=ival*nbin[i-1]+pp[i-1];
+          for(unsigned i=pp.size()-1; i>0; --i) {
+            ival=ival*nbin[i-1]+pp[i-1];
+          }
           ofile.printf(fmt.c_str(), gval->get(ival) );
-          if(pp[2]%6==5) ofile.printf("\n");
+          if(pp[2]%6==5) {
+            ofile.printf("\n");
+          }
         }
         ofile.printf("\n");
       }
@@ -293,11 +341,15 @@ void DumpGrid::update() {
   } else if( xyzfile ) {
     std::vector<double> coords(3);
     Value* myarg = getPntrToArgument(0);
-    unsigned nvals = myarg->getNumberOfValues(); ofile.printf("%d\n\n", nvals);
+    unsigned nvals = myarg->getNumberOfValues();
+    ofile.printf("%d\n\n", nvals);
     for(unsigned i=0; i<nvals; ++i) {
-      double val = myarg->get(i); mygrid.getGridPointCoordinates( i, coords );
+      double val = myarg->get(i);
+      mygrid.getGridPointCoordinates( i, coords );
       ofile.printf("X");
-      for(unsigned j=0; j<3; ++j) ofile.printf((" " + fmt).c_str(), val*coords[j] );
+      for(unsigned j=0; j<3; ++j) {
+        ofile.printf((" " + fmt).c_str(), val*coords[j] );
+      }
       ofile.printf("\n");
     }
   } else {
@@ -320,7 +372,9 @@ void DumpGrid::update() {
     for(unsigned i=0; i<gval->getNumberOfValues(); ++i) {
       // Retrieve and print the grid coordinates
       mygrid.getGridPointCoordinates( i, ind, xx );
-      if(i>0 && gval->getRank()==2 && ind[gval->getRank()-2]==0) ofile.printf("\n");
+      if(i>0 && gval->getRank()==2 && ind[gval->getRank()-2]==0) {
+        ofile.printf("\n");
+      }
       ofile.fmtField(fmt);
       if( mygrid.getGridType()=="fibonacci" ) {
         ofile.printField("nbins", static_cast<int>(gval->getNumberOfValues()) );
@@ -329,16 +383,26 @@ void DumpGrid::update() {
           ofile.printField("min_" + argn[j], mygrid.getMin()[j] );
           ofile.printField("max_" + argn[j], mygrid.getMax()[j] );
           ofile.printField("nbins_" + argn[j], static_cast<int>(mygrid.getNbin(false)[j]) );
-          if( mygrid.isPeriodic(j) ) ofile.printField("periodic_" + argn[j], "true" );
-          else         ofile.printField("periodic_" + argn[j], "false" );
+          if( mygrid.isPeriodic(j) ) {
+            ofile.printField("periodic_" + argn[j], "true" );
+          } else {
+            ofile.printField("periodic_" + argn[j], "false" );
+          }
         }
       }
       // Print the grid coordinates
-      for(unsigned j=0; j<gval->getRank(); ++j) { ofile.fmtField(fmt); ofile.printField(argn[j],xx[j]); }
+      for(unsigned j=0; j<gval->getRank(); ++j) {
+        ofile.fmtField(fmt);
+        ofile.printField(argn[j],xx[j]);
+      }
       // Print value
-      ofile.fmtField(fmt); ofile.printField( gval->getName(), gval->get(i) );
+      ofile.fmtField(fmt);
+      ofile.printField( gval->getName(), gval->get(i) );
       // Print the derivatives
-      for(unsigned j=0; j<gval->getRank(); ++j) { ofile.fmtField(fmt); ofile.printField( "d" + gval->getName() + "_" + argn[j], gval->getGridDerivative(i,j) ); }
+      for(unsigned j=0; j<gval->getRank(); ++j) {
+        ofile.fmtField(fmt);
+        ofile.printField( "d" + gval->getName() + "_" + argn[j], gval->getGridDerivative(i,j) );
+      }
       ofile.printField();
     }
   }
diff --git a/src/gridtools/EvaluateFunctionOnGrid.cpp b/src/gridtools/EvaluateFunctionOnGrid.cpp
index 9add313e8f..8576f92e82 100644
--- a/src/gridtools/EvaluateFunctionOnGrid.cpp
+++ b/src/gridtools/EvaluateFunctionOnGrid.cpp
@@ -74,33 +74,52 @@ void EvaluateFunctionOnGrid::registerKeywords(Keywords& keys ) {
   keys.add("compulsory","GRID","the name of the grid that we are using to evaluate the function");
   keys.add("optional","ARG","the arguments that you would like to use when evaluating the function.  If not specified these are determined from the names of the grid dimensions");
   keys.reserve("compulsory","PERIODIC","if the output of your function is periodic then you should specify the periodicity of the function.  If the output is not periodic you must state this using PERIODIC=NO");
-  EvaluateGridFunction ii; ii.registerKeywords( keys );
-  keys.addActionNameSuffix("_SCALAR"); keys.addActionNameSuffix("_VECTOR");
+  EvaluateGridFunction ii;
+  ii.registerKeywords( keys );
+  keys.addActionNameSuffix("_SCALAR");
+  keys.addActionNameSuffix("_VECTOR");
 }
 
 EvaluateFunctionOnGrid::EvaluateFunctionOnGrid(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Get the grid that we are evaluating here
-  std::vector<std::string> gridn(1); parse("GRID",gridn[0]);
-  std::vector<Value*> gridv; ActionWithArguments::interpretArgumentList( gridn, plumed.getActionSet(), this, gridv );
+  std::vector<std::string> gridn(1);
+  parse("GRID",gridn[0]);
+  std::vector<Value*> gridv;
+  ActionWithArguments::interpretArgumentList( gridn, plumed.getActionSet(), this, gridv );
   // Read the input arguments from the input file
-  std::vector<std::string> argn; parseVector("ARG",argn);
+  std::vector<std::string> argn;
+  parseVector("ARG",argn);
   // Now get the arguments
   ActionWithGrid* ag = dynamic_cast<ActionWithGrid*>( gridv[0]->getPntrToAction() );
-  if( !ag ) error("argument to GRID argument is not a grid");
+  if( !ag ) {
+    error("argument to GRID argument is not a grid");
+  }
   if( argn.size()==0 ) {
     std::vector<std::string> argn2( ag->getGridCoordinateNames() );
-    argn.resize( argn2.size() ); for(unsigned i=0; i<argn2.size(); ++i) argn[i]=argn2[i];
+    argn.resize( argn2.size() );
+    for(unsigned i=0; i<argn2.size(); ++i) {
+      argn[i]=argn2[i];
+    }
+  }
+  if( argn.size()!=gridv[0]->getRank() ) {
+    error("found wrong number of arguments in Evaluate function on grid");
   }
-  if( argn.size()!=gridv[0]->getRank() ) error("found wrong number of arguments in Evaluate function on grid");
   // Now use this information to create a gridobject
-  if( ag->getGridCoordinatesObject().getGridType()=="fibonacci" ) error("cannot interpolate on fibonacci sphere");
+  if( ag->getGridCoordinatesObject().getGridType()=="fibonacci" ) {
+    error("cannot interpolate on fibonacci sphere");
+  }
   // Now get the actual values we are using
-  std::vector<Value*> vals; ActionWithArguments::interpretArgumentList( argn, plumed.getActionSet(), this, vals );
-  if( vals.size()==0 ) error("found no input arguments to function");
-  std::string allargs = gridn[0]; for(unsigned i=0; i<argn.size(); ++i) allargs += "," + argn[i];
+  std::vector<Value*> vals;
+  ActionWithArguments::interpretArgumentList( argn, plumed.getActionSet(), this, vals );
+  if( vals.size()==0 ) {
+    error("found no input arguments to function");
+  }
+  std::string allargs = gridn[0];
+  for(unsigned i=0; i<argn.size(); ++i) {
+    allargs += "," + argn[i];
+  }
   function::FunctionShortcut<int>::createAction( this, vals, allargs );
 }
 
diff --git a/src/gridtools/EvaluateGridFunction.cpp b/src/gridtools/EvaluateGridFunction.cpp
index 47d0490bb4..b00ffa66a6 100644
--- a/src/gridtools/EvaluateGridFunction.cpp
+++ b/src/gridtools/EvaluateGridFunction.cpp
@@ -35,24 +35,35 @@ void EvaluateGridFunction::registerKeywords( Keywords& keys ) {
 
 std::vector<bool> EvaluateGridFunction::getPbc() const {
   std::vector<bool> ipbc( gridobject.getDimension() );
-  for(unsigned i=0; i<ipbc.size(); ++i) ipbc[i] = gridobject.isPeriodic(i);
+  for(unsigned i=0; i<ipbc.size(); ++i) {
+    ipbc[i] = gridobject.isPeriodic(i);
+  }
   return ipbc;
 }
 
 void EvaluateGridFunction::read( ActionWithArguments* action ) {
-  if( action->getPntrToArgument(0)->getRank()==0 || !action->getPntrToArgument(0)->hasDerivatives() ) action->error("should have one grid as input to this action");
+  if( action->getPntrToArgument(0)->getRank()==0 || !action->getPntrToArgument(0)->hasDerivatives() ) {
+    action->error("should have one grid as input to this action");
+  }
   // Get the input grid
   ActionWithGrid* ag = ActionWithGrid::getInputActionWithGrid( (action->getPntrToArgument(0))->getPntrToAction() );
-  if( ag->getGridCoordinatesObject().getGridType()!="flat" ) action->error("cannot interpolate on fibonacci sphere");
+  if( ag->getGridCoordinatesObject().getGridType()!="flat" ) {
+    action->error("cannot interpolate on fibonacci sphere");
+  }
   std::vector<bool> ipbc( ag->getGridCoordinatesObject().getDimension() );
-  for(unsigned i=0; i<ipbc.size(); ++i) ipbc[i] = ag->getGridCoordinatesObject().isPeriodic(i);
+  for(unsigned i=0; i<ipbc.size(); ++i) {
+    ipbc[i] = ag->getGridCoordinatesObject().isPeriodic(i);
+  }
   gridobject.setup( "flat", ipbc, 0, 0.0 );
   // Now use this information to create a gridobject
   std::vector<std::string> argn;
   parseFlag(action,"ZERO_OUTSIDE_GRID_RANGE",set_zero_outside_range);
-  if( set_zero_outside_range ) action->log.printf("  function is zero outside grid range \n");
+  if( set_zero_outside_range ) {
+    action->log.printf("  function is zero outside grid range \n");
+  }
   // Get the type of interpolation that we are doing
-  std::string itype; parse(action,"INTERPOLATION_TYPE",itype);
+  std::string itype;
+  parse(action,"INTERPOLATION_TYPE",itype);
   if( itype=="spline" ) {
     interpolation_type=spline;
     spline_interpolator=Tools::make_unique<Interpolator>( action->getPntrToArgument(0), gridobject );
@@ -62,7 +73,9 @@ void EvaluateGridFunction::read( ActionWithArguments* action ) {
     interpolation_type=floor;
   } else if( itype=="ceiling" ) {
     interpolation_type=ceiling;
-  } else action->error("type " + itype + " of interpolation is not defined");
+  } else {
+    action->error("type " + itype + " of interpolation is not defined");
+  }
   action->log.printf("  generating off grid points using %s interpolation \n", itype.c_str() );
 }
 
@@ -70,49 +83,80 @@ void EvaluateGridFunction::setup( ActionWithValue* action ) {
   FunctionTemplateBase::setup( action );
   ActionWithArguments* aarg = dynamic_cast<ActionWithArguments*>( action );
   ActionWithGrid* ag = ActionWithGrid::getInputActionWithGrid( (aarg->getPntrToArgument(0))->getPntrToAction() );
-  const GridCoordinatesObject & ingrid = ag->getGridCoordinatesObject(); std::vector<double> sp( ingrid.getGridSpacing() );
+  const GridCoordinatesObject & ingrid = ag->getGridCoordinatesObject();
+  std::vector<double> sp( ingrid.getGridSpacing() );
   gridobject.setBounds( ingrid.getMin(), ingrid.getMax(), ingrid.getNbin(false), sp );
 }
 
 void EvaluateGridFunction::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
-  if( set_zero_outside_range && !gridobject.inbounds( args ) ) { vals[0]=0.0; return; }
-  unsigned dimension = gridobject.getDimension(); plumed_dbg_assert( args.size()==dimension && vals.size()==1 );
+  if( set_zero_outside_range && !gridobject.inbounds( args ) ) {
+    vals[0]=0.0;
+    return;
+  }
+  unsigned dimension = gridobject.getDimension();
+  plumed_dbg_assert( args.size()==dimension && vals.size()==1 );
   if( interpolation_type==spline ) {
     std::vector<double> der( dimension );
     vals[0] =  spline_interpolator->splineInterpolation( args, der );
-    for(unsigned j=0; j<dimension; ++j) derivatives(0,j) = der[j];
+    for(unsigned j=0; j<dimension; ++j) {
+      derivatives(0,j) = der[j];
+    }
   } else if( interpolation_type==linear ) {
-    Value* values=action->getPntrToArgument(0); std::vector<double> xfloor(dimension);
+    Value* values=action->getPntrToArgument(0);
+    std::vector<double> xfloor(dimension);
     std::vector<unsigned> indices(dimension), nindices(dimension), ind(dimension);
-    gridobject.getIndices( args, indices ); unsigned nn=gridobject.getIndex(args);
+    gridobject.getIndices( args, indices );
+    unsigned nn=gridobject.getIndex(args);
     gridobject.getGridPointCoordinates( nn, nindices, xfloor );
-    double y1 = values->get(nn); vals[0] = y1;
+    double y1 = values->get(nn);
+    vals[0] = y1;
     for(unsigned i=0; i<args.size(); ++i) {
-      int x0=1; if(nindices[i]==indices[i]) x0=0;
+      int x0=1;
+      if(nindices[i]==indices[i]) {
+        x0=0;
+      }
       double ddx=gridobject.getGridSpacing()[i];
       double X = fabs((args[i]-xfloor[i])/ddx-(double)x0);
-      for(unsigned j=0; j<args.size(); ++j) ind[j] = indices[j];
-      if( gridobject.isPeriodic(i) && (ind[i]+1)==gridobject.getNbin(false)[i] ) ind[i]=0;
-      else ind[i] = ind[i] + 1;
+      for(unsigned j=0; j<args.size(); ++j) {
+        ind[j] = indices[j];
+      }
+      if( gridobject.isPeriodic(i) && (ind[i]+1)==gridobject.getNbin(false)[i] ) {
+        ind[i]=0;
+      } else {
+        ind[i] = ind[i] + 1;
+      }
       vals[0] += ( values->get( gridobject.getIndex(ind) ) - y1 )*X;
       derivatives(0,i) = ( values->get( gridobject.getIndex(ind) ) - y1 ) / ddx;
     }
   } else if( interpolation_type==floor ) {
-    Value* values=action->getPntrToArgument(0); std::vector<unsigned> indices(dimension);
-    gridobject.getIndices( args, indices ); unsigned nn = gridobject.getIndex(indices);
+    Value* values=action->getPntrToArgument(0);
+    std::vector<unsigned> indices(dimension);
+    gridobject.getIndices( args, indices );
+    unsigned nn = gridobject.getIndex(indices);
     plumed_dbg_assert( nn<values->getNumberOfValues() );
     vals[0] = values->get( nn );
-    for(unsigned j=0; j<dimension; ++j) derivatives(0,j) = values->getGridDerivative( nn, j );
+    for(unsigned j=0; j<dimension; ++j) {
+      derivatives(0,j) = values->getGridDerivative( nn, j );
+    }
   } else if( interpolation_type==ceiling ) {
-    Value* values=action->getPntrToArgument(0); std::vector<unsigned> indices(dimension);
+    Value* values=action->getPntrToArgument(0);
+    std::vector<unsigned> indices(dimension);
     gridobject.getIndices( args, indices );
     for(unsigned i=0; i<indices.size(); ++i) {
-      if( gridobject.isPeriodic(i) && (indices[i]+1)==gridobject.getNbin(false)[i] ) indices[i]=0;
-      else indices[i] = indices[i] + 1;
+      if( gridobject.isPeriodic(i) && (indices[i]+1)==gridobject.getNbin(false)[i] ) {
+        indices[i]=0;
+      } else {
+        indices[i] = indices[i] + 1;
+      }
     }
-    unsigned nn = gridobject.getIndex(indices); vals[0] = values->get( nn );
-    for(unsigned j=0; j<dimension; ++j) derivatives(0,j) = values->getGridDerivative( nn, j );
-  } else plumed_error();
+    unsigned nn = gridobject.getIndex(indices);
+    vals[0] = values->get( nn );
+    for(unsigned j=0; j<dimension; ++j) {
+      derivatives(0,j) = values->getGridDerivative( nn, j );
+    }
+  } else {
+    plumed_error();
+  }
 }
 
 void EvaluateGridFunction::applyForce( const ActionWithArguments* action, const std::vector<double>& args, const double& force, std::vector<double>& forcesToApply ) const {
@@ -120,32 +164,52 @@ void EvaluateGridFunction::applyForce( const ActionWithArguments* action, const
   if( interpolation_type==spline ) {
     action->error("can't apply forces on values interpolated using splines");
   } else if( interpolation_type==linear ) {
-    Value* values=action->getPntrToArgument(0); std::vector<double> xfloor(dimension);
+    Value* values=action->getPntrToArgument(0);
+    std::vector<double> xfloor(dimension);
     std::vector<unsigned> indices(dimension), nindices(dimension), ind(dimension);
-    gridobject.getIndices( args, indices ); unsigned nn=gridobject.getIndex(args);
+    gridobject.getIndices( args, indices );
+    unsigned nn=gridobject.getIndex(args);
     gridobject.getGridPointCoordinates( nn, nindices, xfloor );
     for(unsigned i=0; i<args.size(); ++i) {
-      int x0=1; if(nindices[i]==indices[i]) x0=0;
+      int x0=1;
+      if(nindices[i]==indices[i]) {
+        x0=0;
+      }
       double ddx=gridobject.getGridSpacing()[i];
       double X = fabs((args[i]-xfloor[i])/ddx-(double)x0);
-      for(unsigned j=0; j<args.size(); ++j) ind[j] = indices[j];
-      if( gridobject.isPeriodic(i) && (ind[i]+1)==gridobject.getNbin(false)[i] ) ind[i]=0;
-      else ind[i] = ind[i] + 1;
-      forcesToApply[nn] += force*(1-X); forcesToApply[gridobject.getIndex(ind)] += X*force;
+      for(unsigned j=0; j<args.size(); ++j) {
+        ind[j] = indices[j];
+      }
+      if( gridobject.isPeriodic(i) && (ind[i]+1)==gridobject.getNbin(false)[i] ) {
+        ind[i]=0;
+      } else {
+        ind[i] = ind[i] + 1;
+      }
+      forcesToApply[nn] += force*(1-X);
+      forcesToApply[gridobject.getIndex(ind)] += X*force;
     }
   } else if( interpolation_type==floor ) {
-    Value* values=action->getPntrToArgument(0); std::vector<unsigned> indices(dimension);
-    gridobject.getIndices( args, indices ); unsigned nn = gridobject.getIndex(indices);
+    Value* values=action->getPntrToArgument(0);
+    std::vector<unsigned> indices(dimension);
+    gridobject.getIndices( args, indices );
+    unsigned nn = gridobject.getIndex(indices);
     forcesToApply[nn] += force;
   } else if( interpolation_type==ceiling ) {
-    Value* values=action->getPntrToArgument(0); std::vector<unsigned> indices(dimension);
+    Value* values=action->getPntrToArgument(0);
+    std::vector<unsigned> indices(dimension);
     gridobject.getIndices( args, indices );
     for(unsigned i=0; i<indices.size(); ++i) {
-      if( gridobject.isPeriodic(i) && (indices[i]+1)==gridobject.getNbin(false)[i] ) indices[i]=0;
-      else indices[i] = indices[i] + 1;
+      if( gridobject.isPeriodic(i) && (indices[i]+1)==gridobject.getNbin(false)[i] ) {
+        indices[i]=0;
+      } else {
+        indices[i] = indices[i] + 1;
+      }
     }
-    unsigned nn = gridobject.getIndex(indices); forcesToApply[nn] += force;
-  } else plumed_error();
+    unsigned nn = gridobject.getIndex(indices);
+    forcesToApply[nn] += force;
+  } else {
+    plumed_error();
+  }
 }
 
 }
diff --git a/src/gridtools/EvaluateGridFunction.h b/src/gridtools/EvaluateGridFunction.h
index 19be97ac9a..4acadb28b9 100644
--- a/src/gridtools/EvaluateGridFunction.h
+++ b/src/gridtools/EvaluateGridFunction.h
@@ -42,7 +42,9 @@ class EvaluateGridFunction : public function::FunctionTemplateBase {
 /// This is used to setup the input gridobject's bounds with the grid data from values
   void registerKeywords( Keywords& keys ) override ;
   void read( ActionWithArguments* action ) override ;
-  unsigned getArgStart() const override { return 1; }
+  unsigned getArgStart() const override {
+    return 1;
+  }
   void setup( ActionWithValue* action ) override;
   void calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const override ;
 /// Get the vector containing the minimum value of the grid in each dimension
diff --git a/src/gridtools/FindGridOptimum.cpp b/src/gridtools/FindGridOptimum.cpp
index 516822e4d3..db00f6fbbd 100644
--- a/src/gridtools/FindGridOptimum.cpp
+++ b/src/gridtools/FindGridOptimum.cpp
@@ -54,20 +54,25 @@ class FindGridOptimum : public ActionWithGrid {
 public:
   static void registerKeywords( Keywords& keys );
   explicit FindGridOptimum(const ActionOptions&ao);
-  void setupOnFirstStep( const bool incalc ) override { plumed_error(); }
+  void setupOnFirstStep( const bool incalc ) override {
+    plumed_error();
+  }
   unsigned getNumberOfDerivatives() override ;
   void calculate() override ;
   std::vector<std::string> getGridCoordinateNames() const override ;
   const GridCoordinatesObject& getGridCoordinatesObject() const override ;
   double calculateValueAndDerivatives( const std::vector<double>& pp, std::vector<double>& der );
-  void performTask( const unsigned& current, MultiValue& myvals ) const override { plumed_error(); }
+  void performTask( const unsigned& current, MultiValue& myvals ) const override {
+    plumed_error();
+  }
 };
 
 PLUMED_REGISTER_ACTION(FindGridOptimum,"FIND_GRID_MAXIMUM")
 PLUMED_REGISTER_ACTION(FindGridOptimum,"FIND_GRID_MINIMUM")
 
 void FindGridOptimum::registerKeywords( Keywords& keys ) {
-  ActionWithGrid::registerKeywords( keys ); keys.use("ARG");
+  ActionWithGrid::registerKeywords( keys );
+  keys.use("ARG");
   keys.addFlag("NOINTERPOL",false,"do not interpolate the function when finding the optimum");
   keys.add("compulsory","CGTOL","1E-4","the tolerance for the conjugate gradient optimization");
   keys.addOutputComponent("optval","default","the value of the function at the optimum");
@@ -78,17 +83,28 @@ void FindGridOptimum::registerKeywords( Keywords& keys ) {
 FindGridOptimum::FindGridOptimum(const ActionOptions&ao):
   Action(ao),
   ActionWithGrid(ao),
-  cgtol(0)
-{
-  if( getName()=="FIND_GRID_MAXIMUM" ) domin=false;
-  else if( getName()=="FIND_GRID_MINIMUM" ) domin=true;
-  else plumed_error();
+  cgtol(0) {
+  if( getName()=="FIND_GRID_MAXIMUM" ) {
+    domin=false;
+  } else if( getName()=="FIND_GRID_MINIMUM" ) {
+    domin=true;
+  } else {
+    plumed_error();
+  }
   // Create value for this function
   std::vector<std::string> argn( getGridCoordinateNames() );
-  std::vector<unsigned> shape(0); for(unsigned i=0; i<argn.size(); ++i) addComponent( argn[i] + "_opt", shape );
-  addComponent( "optval", shape ); componentIsNotPeriodic( "optval" );
-  bool nointerpol=false; parseFlag("NOINTERPOL",nointerpol);
-  if( !nointerpol ) { parse("CGTOL",cgtol); function=Tools::make_unique<Interpolator>( getPntrToArgument(0), getGridCoordinatesObject() ); }
+  std::vector<unsigned> shape(0);
+  for(unsigned i=0; i<argn.size(); ++i) {
+    addComponent( argn[i] + "_opt", shape );
+  }
+  addComponent( "optval", shape );
+  componentIsNotPeriodic( "optval" );
+  bool nointerpol=false;
+  parseFlag("NOINTERPOL",nointerpol);
+  if( !nointerpol ) {
+    parse("CGTOL",cgtol);
+    function=Tools::make_unique<Interpolator>( getPntrToArgument(0), getGridCoordinatesObject() );
+  }
 }
 
 unsigned FindGridOptimum::getNumberOfDerivatives() {
@@ -97,12 +113,14 @@ unsigned FindGridOptimum::getNumberOfDerivatives() {
 
 const GridCoordinatesObject& FindGridOptimum::getGridCoordinatesObject() const {
   ActionWithGrid* ag=ActionWithGrid::getInputActionWithGrid( getPntrToArgument(0)->getPntrToAction() );
-  plumed_assert( ag ); return ag->getGridCoordinatesObject();
+  plumed_assert( ag );
+  return ag->getGridCoordinatesObject();
 }
 
 std::vector<std::string> FindGridOptimum::getGridCoordinateNames() const {
   ActionWithGrid* ag=ActionWithGrid::getInputActionWithGrid( getPntrToArgument(0)->getPntrToAction() );
-  plumed_assert( ag ); return ag->getGridCoordinateNames();
+  plumed_assert( ag );
+  return ag->getGridCoordinateNames();
 }
 
 double FindGridOptimum::calculateValueAndDerivatives( const std::vector<double>& pp, std::vector<double>& der ) {
@@ -110,39 +128,70 @@ double FindGridOptimum::calculateValueAndDerivatives( const std::vector<double>&
   // We normalise the derivatives here and set them so that the linesearch is done over the cell that we know
   // in the grid that we know the minimum is inside
   std::vector<double> spacing( getGridCoordinatesObject().getGridSpacing() );
-  double norm = 0; for(unsigned i=0; i<der.size(); ++i) norm += der[i]*der[i];
-  norm = sqrt(norm); for(unsigned i=0; i<der.size(); ++i) der[i] = spacing[i]*der[i] / norm;
-  if( domin ) return val;
+  double norm = 0;
+  for(unsigned i=0; i<der.size(); ++i) {
+    norm += der[i]*der[i];
+  }
+  norm = sqrt(norm);
+  for(unsigned i=0; i<der.size(); ++i) {
+    der[i] = spacing[i]*der[i] / norm;
+  }
+  if( domin ) {
+    return val;
+  }
   // If we are looking for a maximum
-  for(unsigned i=0; i<der.size(); ++i) der[i] = -der[i];
+  for(unsigned i=0; i<der.size(); ++i) {
+    der[i] = -der[i];
+  }
   return -val;
 }
 
 void FindGridOptimum::calculate() {
-  const GridCoordinatesObject& ingrid = getGridCoordinatesObject(); Value* gval = getPntrToArgument(0);
-  std::vector<double> optargs( gval->getRank() ); std::vector<unsigned> gridind( gval->getRank() );
-  double optval=gval->get( 0 ); ingrid.getGridPointCoordinates( 0, gridind, optargs );
-  unsigned nval = gval->getNumberOfValues(); bool constant=true;
+  const GridCoordinatesObject& ingrid = getGridCoordinatesObject();
+  Value* gval = getPntrToArgument(0);
+  std::vector<double> optargs( gval->getRank() );
+  std::vector<unsigned> gridind( gval->getRank() );
+  double optval=gval->get( 0 );
+  ingrid.getGridPointCoordinates( 0, gridind, optargs );
+  unsigned nval = gval->getNumberOfValues();
+  bool constant=true;
   for(unsigned i=0; i<nval; ++i) {
     double tval = gval->get( i );
-    if( domin && (tval<optval || std::isnan(optval)) ) { constant=false; optval=tval; ingrid.getGridPointCoordinates( i, gridind, optargs ); }
-    if( !domin && (tval>optval || std::isnan(optval)) ) { constant=false; optval=tval; ingrid.getGridPointCoordinates( i, gridind, optargs ); }
+    if( domin && (tval<optval || std::isnan(optval)) ) {
+      constant=false;
+      optval=tval;
+      ingrid.getGridPointCoordinates( i, gridind, optargs );
+    }
+    if( !domin && (tval>optval || std::isnan(optval)) ) {
+      constant=false;
+      optval=tval;
+      ingrid.getGridPointCoordinates( i, gridind, optargs );
+    }
   }
   // This basically ensures we deal with cases where all points on the grid are infinity as isinf doesn't work on intel compiler
   if( constant ) {
-    if( domin && gval->get(0)>=gval->get(1) ) return;
-    else if( gval->get(0)<=gval->get(1) ) return;
+    if( domin && gval->get(0)>=gval->get(1) ) {
+      return;
+    } else if( gval->get(0)<=gval->get(1) ) {
+      return;
+    }
+  }
+  if( std::isinf(optval) ) {
+    return;
   }
-  if( std::isinf(optval) ) { return; }
 
-  if( std::isnan(optval) ) error("all values on grid are nans");
+  if( std::isnan(optval) ) {
+    error("all values on grid are nans");
+  }
   // And do conjugate gradient optimisation (because we can!!)
   if( cgtol>0 ) {
     ConjugateGradient<FindGridOptimum> myminimiser( this );
     myminimiser.minimise( cgtol, optargs, &FindGridOptimum::calculateValueAndDerivatives );
   }
   // And set the final value
-  for(unsigned j=0; j<optargs.size(); ++j) getPntrToComponent(j)->set( optargs[j] );
+  for(unsigned j=0; j<optargs.size(); ++j) {
+    getPntrToComponent(j)->set( optargs[j] );
+  }
   std::vector<double> optder( gval->getRank() );
   getPntrToComponent(optargs.size())->set( function->splineInterpolation( optargs, optder ) );
 }
diff --git a/src/gridtools/FunctionOfGrid.h b/src/gridtools/FunctionOfGrid.h
index aec8cae75d..89cfe8bb7c 100644
--- a/src/gridtools/FunctionOfGrid.h
+++ b/src/gridtools/FunctionOfGrid.h
@@ -42,7 +42,9 @@ class FunctionOfGrid : public ActionWithGrid {
 /// Get the number of derivatives for this action
   unsigned getNumberOfDerivatives() override ;
 /// Get the label to write in the graph
-  std::string writeInGraph() const override { return myfunc.getGraphInfo( getName() ); }
+  std::string writeInGraph() const override {
+    return myfunc.getGraphInfo( getName() );
+  }
 /// Get the underlying names
   std::vector<std::string> getGridCoordinateNames() const override ;
 /// Get the underlying grid coordinates object
@@ -58,10 +60,17 @@ class FunctionOfGrid : public ActionWithGrid {
 
 template <class T>
 void FunctionOfGrid<T>::registerKeywords(Keywords& keys ) {
-  ActionWithGrid::registerKeywords(keys); keys.use("ARG"); std::string name = keys.getDisplayName();
-  std::size_t und=name.find("_GRID"); keys.setDisplayName( name.substr(0,und) );
+  ActionWithGrid::registerKeywords(keys);
+  keys.use("ARG");
+  std::string name = keys.getDisplayName();
+  std::size_t und=name.find("_GRID");
+  keys.setDisplayName( name.substr(0,und) );
   keys.reserve("compulsory","PERIODIC","if the output of your function is periodic then you should specify the periodicity of the function.  If the output is not periodic you must state this using PERIODIC=NO");
-  T tfunc; tfunc.registerKeywords( keys ); if( typeid(tfunc)==typeid(function::Custom()) ) keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
+  T tfunc;
+  tfunc.registerKeywords( keys );
+  if( typeid(tfunc)==typeid(function::Custom()) ) {
+    keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
+  }
   if( keys.getDisplayName()=="INTEGRATE") {
     keys.setValueDescription("the numerical integral of the input function over its whole domain");
   } else if( keys.outputComponentExists(".#!value") ) {
@@ -72,34 +81,49 @@ void FunctionOfGrid<T>::registerKeywords(Keywords& keys ) {
 template <class T>
 FunctionOfGrid<T>::FunctionOfGrid(const ActionOptions&ao):
   Action(ao),
-  ActionWithGrid(ao)
-{
-  if( getNumberOfArguments()==0 ) error("found no arguments");
+  ActionWithGrid(ao) {
+  if( getNumberOfArguments()==0 ) {
+    error("found no arguments");
+  }
   // This will require a fix
-  if( getPntrToArgument(0)->getRank()==0 || !getPntrToArgument(0)->hasDerivatives() ) error("first input to this action must be a grid");
+  if( getPntrToArgument(0)->getRank()==0 || !getPntrToArgument(0)->hasDerivatives() ) {
+    error("first input to this action must be a grid");
+  }
   // Get the shape of the input grid
   std::vector<unsigned> shape( getPntrToArgument(0)->getShape() );
   for(unsigned i=1; i<getNumberOfArguments(); ++i ) {
-    if( getPntrToArgument(i)->getRank()==0 ) continue;
+    if( getPntrToArgument(i)->getRank()==0 ) {
+      continue;
+    }
     std::vector<unsigned> s( getPntrToArgument(i)->getShape() );
-    if( s.size()!=shape.size() ) error("mismatch between dimensionalities of input grids");
+    if( s.size()!=shape.size() ) {
+      error("mismatch between dimensionalities of input grids");
+    }
   }
   // Read the input and do some checks
   myfunc.read( this );
   // Check we are not calculating an integral
-  if( myfunc.zeroRank() ) { shape.resize(0); }
+  if( myfunc.zeroRank() ) {
+    shape.resize(0);
+  }
   // Check that derivatives are available
-  if( !myfunc.derivativesImplemented() ) error("derivatives have not been implemended for " + getName() );
+  if( !myfunc.derivativesImplemented() ) {
+    error("derivatives have not been implemended for " + getName() );
+  }
   // Get the names of the components
   std::vector<std::string> components( keywords.getOutputComponents() );
   // Create the values to hold the output
-  if( components.size()!=1 || components[0]!=".#!value" ) error("functions of grid should only output one grid");
+  if( components.size()!=1 || components[0]!=".#!value" ) {
+    error("functions of grid should only output one grid");
+  }
   addValueWithDerivatives( shape );
   // Set the periodicities of the output components
   myfunc.setPeriodicityForOutputs( this );
   // Check if we can turn off the derivatives when they are zero
   if( myfunc.getDerivativeZeroIfValueIsZero() )  {
-    for(int i=0; i<getNumberOfComponents(); ++i) getPntrToComponent(i)->setDerivativeIsZeroWhenValueIsZero();
+    for(int i=0; i<getNumberOfComponents(); ++i) {
+      getPntrToComponent(i)->setDerivativeIsZeroWhenValueIsZero();
+    }
   }
   setupOnFirstStep( false );
 }
@@ -112,56 +136,82 @@ void FunctionOfGrid<T>::setupOnFirstStep( const bool incalc ) {
   if( mygrid.getGridType()=="flat" ) {
     std::vector<unsigned> shape( getGridCoordinatesObject().getNbin(true) );
     for(unsigned i=1; i<getNumberOfArguments(); ++i ) {
-      if( getPntrToArgument(i)->getRank()==0 ) continue;
+      if( getPntrToArgument(i)->getRank()==0 ) {
+        continue;
+      }
       std::vector<unsigned> s( getPntrToArgument(i)->getShape() );
       for(unsigned j=0; j<shape.size(); ++j) {
-        if( shape[j]!=s[j] ) error("mismatch between sizes of input grids");
+        if( shape[j]!=s[j] ) {
+          error("mismatch between sizes of input grids");
+        }
       }
     }
     for(int i=0; i<getNumberOfComponents(); ++i) {
-      if( getPntrToComponent(i)->getRank()>0 ) getPntrToComponent(i)->setShape(shape);
+      if( getPntrToComponent(i)->getRank()>0 ) {
+        getPntrToComponent(i)->setShape(shape);
+      }
     }
     std::vector<double> vv( getGridCoordinatesObject().getGridSpacing() );
-    volume=vv[0]; for(unsigned i=1; i<vv.size(); ++i) volume *=vv[i];
-  } else volume=4*pi / static_cast<double>( npoints );
+    volume=vv[0];
+    for(unsigned i=1; i<vv.size(); ++i) {
+      volume *=vv[i];
+    }
+  } else {
+    volume=4*pi / static_cast<double>( npoints );
+  }
   // This resizes the scalars
   for(int i=0; i<getNumberOfComponents(); ++i) {
-    if( getPntrToComponent(i)->getRank()==0 ) getPntrToComponent(i)->resizeDerivatives( npoints );
+    if( getPntrToComponent(i)->getRank()==0 ) {
+      getPntrToComponent(i)->resizeDerivatives( npoints );
+    }
+  }
+  if( getName()=="SUM_GRID" ) {
+    volume = 1.0;
   }
-  if( getName()=="SUM_GRID" ) volume = 1.0;
   // This sets the prefactor to the volume which converts integrals to sums
-  myfunc.setup( this ); myfunc.setPrefactor( this, volume );
+  myfunc.setup( this );
+  myfunc.setPrefactor( this, volume );
 }
 
 template <class T>
 const GridCoordinatesObject& FunctionOfGrid<T>::getGridCoordinatesObject() const {
   ActionWithGrid* ag=ActionWithGrid::getInputActionWithGrid( getPntrToArgument(0)->getPntrToAction() );
-  plumed_assert( ag ); return ag->getGridCoordinatesObject();
+  plumed_assert( ag );
+  return ag->getGridCoordinatesObject();
 }
 
 template <class T>
 std::vector<std::string> FunctionOfGrid<T>::getGridCoordinateNames() const {
   ActionWithGrid* ag=ActionWithGrid::getInputActionWithGrid( getPntrToArgument(0)->getPntrToAction() );
-  plumed_assert( ag ); return ag->getGridCoordinateNames();
+  plumed_assert( ag );
+  return ag->getGridCoordinateNames();
 }
 
 template <class T>
 unsigned FunctionOfGrid<T>::getNumberOfDerivatives() {
-  if( myfunc.zeroRank() ) return getPntrToArgument(0)->getNumberOfValues();
+  if( myfunc.zeroRank() ) {
+    return getPntrToArgument(0)->getNumberOfValues();
+  }
   unsigned nder = getGridCoordinatesObject().getDimension();
   return getGridCoordinatesObject().getDimension() + getNumberOfArguments() - myfunc.getArgStart();
 }
 
 template <class T>
 void FunctionOfGrid<T>::performTask( const unsigned& current, MultiValue& myvals ) const {
-  unsigned argstart=myfunc.getArgStart(); std::vector<double> args( getNumberOfArguments() - argstart );
+  unsigned argstart=myfunc.getArgStart();
+  std::vector<double> args( getNumberOfArguments() - argstart );
   for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->getRank()==0 ) args[i-argstart]=getPntrToArgument(i)->get();
-    else args[i-argstart] = getPntrToArgument(i)->get(current);
+    if( getPntrToArgument(i)->getRank()==0 ) {
+      args[i-argstart]=getPntrToArgument(i)->get();
+    } else {
+      args[i-argstart] = getPntrToArgument(i)->get(current);
+    }
   }
   // Calculate the function and its derivatives
-  std::vector<double> vals(1); Matrix<double> derivatives( 1, getNumberOfArguments()-argstart );
-  myfunc.calc( this, args, vals, derivatives ); unsigned np = myvals.getTaskIndex();
+  std::vector<double> vals(1);
+  Matrix<double> derivatives( 1, getNumberOfArguments()-argstart );
+  myfunc.calc( this, args, vals, derivatives );
+  unsigned np = myvals.getTaskIndex();
   // And set the values and derivatives
   unsigned ostrn = getConstPntrToComponent(0)->getPositionInStream();
   myvals.addValue( ostrn, vals[0] );
@@ -172,14 +222,19 @@ void FunctionOfGrid<T>::performTask( const unsigned& current, MultiValue& myvals
       myvals.addDerivative( ostrn, getConstPntrToComponent(0)->getRank()+j-argstart, derivatives(0,j-argstart) );
       // And now we calculate the derivatives of the value that is stored on the grid correctly so that we can interpolate functions
       if( getPntrToArgument(j)->getRank()!=0 ) {
-        for(unsigned k=0; k<getPntrToArgument(j)->getRank(); ++k) myvals.addDerivative( ostrn, k, derivatives(0,j-argstart)*getPntrToArgument(j)->getGridDerivative( np, k ) );
+        for(unsigned k=0; k<getPntrToArgument(j)->getRank(); ++k) {
+          myvals.addDerivative( ostrn, k, derivatives(0,j-argstart)*getPntrToArgument(j)->getGridDerivative( np, k ) );
+        }
       }
     }
     unsigned nderivatives = getConstPntrToComponent(0)->getNumberOfGridDerivatives();
-    for(unsigned j=0; j<nderivatives; ++j) myvals.updateIndex( ostrn, j );
+    for(unsigned j=0; j<nderivatives; ++j) {
+      myvals.updateIndex( ostrn, j );
+    }
   } else if( !doNotCalculateDerivatives() ) {
     // These are the derivatives of the integral
-    myvals.addDerivative( ostrn, current, derivatives(0,0) ); myvals.updateIndex( ostrn, current );
+    myvals.addDerivative( ostrn, current, derivatives(0,0) );
+    myvals.updateIndex( ostrn, current );
   }
 }
 
@@ -190,31 +245,45 @@ void FunctionOfGrid<T>::gatherStoredValue( const unsigned& valindex, const unsig
     plumed_dbg_assert( getNumberOfComponents()==1 && valindex==0 );
     unsigned nder = getConstPntrToComponent(0)->getNumberOfGridDerivatives();
     unsigned ostr = getConstPntrToComponent(0)->getPositionInStream();
-    unsigned kp = bufstart + code*(1+nder); buffer[kp] += myvals.get( ostr );
-    for(unsigned i=0; i<nder; ++i) buffer[kp + 1 + i] += myvals.getDerivative( ostr, i );
-  } else ActionWithVector::gatherStoredValue( valindex, code, myvals, bufstart, buffer );
+    unsigned kp = bufstart + code*(1+nder);
+    buffer[kp] += myvals.get( ostr );
+    for(unsigned i=0; i<nder; ++i) {
+      buffer[kp + 1 + i] += myvals.getDerivative( ostr, i );
+    }
+  } else {
+    ActionWithVector::gatherStoredValue( valindex, code, myvals, bufstart, buffer );
+  }
 }
 
 template <class T>
 void FunctionOfGrid<T>::apply() {
-  if( doNotCalculateDerivatives() || !getPntrToComponent(0)->forcesWereAdded() ) return;
+  if( doNotCalculateDerivatives() || !getPntrToComponent(0)->forcesWereAdded() ) {
+    return;
+  }
 
   // This applies forces for the integral
-  if( myfunc.zeroRank() ) { ActionWithVector::apply(); return; }
+  if( myfunc.zeroRank() ) {
+    ActionWithVector::apply();
+    return;
+  }
 
   // Work out how to deal with arguments
   unsigned nscalars=0, argstart=myfunc.getArgStart();
   for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->getRank()==0 ) { nscalars++; }
+    if( getPntrToArgument(i)->getRank()==0 ) {
+      nscalars++;
+    }
   }
 
-  std::vector<double> totv(nscalars,0); Value* outval=getPntrToComponent(0);
+  std::vector<double> totv(nscalars,0);
+  Value* outval=getPntrToComponent(0);
   for(unsigned i=0; i<outval->getNumberOfValues(); ++i) {
     nscalars=0;
     for(unsigned j=argstart; j<getNumberOfArguments(); ++j) {
       double fforce = outval->getForce(i);
       if( getPntrToArgument(j)->getRank()==0 ) {
-        totv[nscalars] += fforce*outval->getGridDerivative( i, outval->getRank()+j ); nscalars++;
+        totv[nscalars] += fforce*outval->getGridDerivative( i, outval->getRank()+j );
+        nscalars++;
       } else {
         double vval = outval->getGridDerivative( i, outval->getRank()+j  );
         getPntrToArgument(j)->addForce( i, fforce*vval );
@@ -223,7 +292,10 @@ void FunctionOfGrid<T>::apply() {
   }
   nscalars=0;
   for(unsigned i=argstart; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->getRank()==0 ) { getPntrToArgument(i)->addForce( 0, totv[nscalars] ); nscalars++; }
+    if( getPntrToArgument(i)->getRank()==0 ) {
+      getPntrToArgument(i)->addForce( 0, totv[nscalars] );
+      nscalars++;
+    }
   }
 
 }
diff --git a/src/gridtools/Gradient.cpp b/src/gridtools/Gradient.cpp
index 051a3bb1b8..edeaaebb18 100644
--- a/src/gridtools/Gradient.cpp
+++ b/src/gridtools/Gradient.cpp
@@ -51,40 +51,58 @@ void Gradient::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","KERNEL","gaussian-bin","the type of kernel function to be used in the grids");
   keys.add("compulsory","ATOMS","calculate the gradient of these atoms");
   keys.setValueDescription("the desired gradient");
-  keys.needsAction("DISTANCES"); keys.needsAction("KDE"); keys.needsAction("INTERPOLATE_GRID");
-  keys.needsAction("CUSTOM"); keys.needsAction("SUM_GRID"); keys.needsAction("COMBINE");
+  keys.needsAction("DISTANCES");
+  keys.needsAction("KDE");
+  keys.needsAction("INTERPOLATE_GRID");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("SUM_GRID");
+  keys.needsAction("COMBINE");
 }
 
 Gradient::Gradient(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string atom_str; parse("ATOMS",atom_str);
-  std::string dir; parse("DIR",dir);
-  std::string origin_str; parse("ORIGIN",origin_str);
-  std::string nbin_str; parse("NBINS",nbin_str);
-  std::string band_str; parse("SIGMA",band_str);
-  std::string kernel_str; parse("KERNEL",kernel_str);
+  ActionShortcut(ao) {
+  std::string atom_str;
+  parse("ATOMS",atom_str);
+  std::string dir;
+  parse("DIR",dir);
+  std::string origin_str;
+  parse("ORIGIN",origin_str);
+  std::string nbin_str;
+  parse("NBINS",nbin_str);
+  std::string band_str;
+  parse("SIGMA",band_str);
+  std::string kernel_str;
+  parse("KERNEL",kernel_str);
   // First get positions of all atoms relative to origin
   readInputLine( getShortcutLabel() + "_dist: DISTANCES ORIGIN=" + origin_str + " ATOMS=" + atom_str + " COMPONENTS");
   // Now constrcut the histograms
   if( dir=="x" || dir=="xy" || dir=="xz" || dir=="xyz" ) {
     readInputLine( getShortcutLabel() + "_xhisto: KDE ARG=" + getShortcutLabel() + "_dist.x GRID_BIN=" + nbin_str + " KERNEL=" + kernel_str + " BANDWIDTH=" + band_str );
-    std::string thislab = getShortcutLabel() + "_xgrad"; if( dir=="x" ) thislab = getShortcutLabel();
+    std::string thislab = getShortcutLabel() + "_xgrad";
+    if( dir=="x" ) {
+      thislab = getShortcutLabel();
+    }
     readInputLine( thislab + "_shift: INTERPOLATE_GRID ARG=" + getShortcutLabel() + "_xhisto INTERPOLATION_TYPE=ceiling MIDPOINTS");
     readInputLine( thislab + "_x2: CUSTOM ARG=" + getShortcutLabel() + "_xhisto," + thislab + "_shift FUNC=(x-y)*(x-y) PERIODIC=NO");
     readInputLine( thislab + ": SUM_GRID ARG=" + thislab + "_x2 PERIODIC=NO");
   }
   if( dir=="y" || dir=="xy" || dir=="yz" || dir=="xyz" ) {
     readInputLine( getShortcutLabel() + "_yhisto: KDE ARG=" + getShortcutLabel() + "_dist.y GRID_BIN=" + nbin_str + " KERNEL=" + kernel_str + " BANDWIDTH=" + band_str );
-    std::string thislab = getShortcutLabel() + "_ygrad"; if( dir=="y" ) thislab = getShortcutLabel();
+    std::string thislab = getShortcutLabel() + "_ygrad";
+    if( dir=="y" ) {
+      thislab = getShortcutLabel();
+    }
     readInputLine( thislab + "_shift: INTERPOLATE_GRID ARG=" + getShortcutLabel() + "_yhisto INTERPOLATION_TYPE=ceiling MIDPOINTS");
     readInputLine( thislab + "_x2: CUSTOM ARG=" + getShortcutLabel() + "_yhisto," + thislab + "_shift FUNC=(x-y)*(x-y) PERIODIC=NO");
     readInputLine( thislab + ": SUM_GRID ARG=" + thislab + "_x2 PERIODIC=NO");
   }
   if( dir=="z" || dir=="yz" || dir=="xz" || dir=="xyz" ) {
     readInputLine( getShortcutLabel() + "_zhisto: KDE ARG=" + getShortcutLabel() + "_dist.z GRID_BIN=" + nbin_str + " KERNEL=" + kernel_str + " BANDWIDTH=" + band_str );
-    std::string thislab = getShortcutLabel() + "_zgrad"; if( dir=="z" ) thislab = getShortcutLabel();
+    std::string thislab = getShortcutLabel() + "_zgrad";
+    if( dir=="z" ) {
+      thislab = getShortcutLabel();
+    }
     readInputLine( thislab + "_shift: INTERPOLATE_GRID ARG=" + getShortcutLabel() + "_zhisto INTERPOLATION_TYPE=ceiling MIDPOINTS");
     readInputLine( thislab + "_x2: CUSTOM ARG=" + getShortcutLabel() + "_zhisto," + thislab + "_shift FUNC=(x-y)*(x-y) PERIODIC=NO");
     readInputLine( thislab + ": SUM_GRID ARG=" + thislab + "_x2 PERIODIC=NO");
diff --git a/src/gridtools/GridCoordinatesObject.cpp b/src/gridtools/GridCoordinatesObject.cpp
index ef4705e511..5656cb0431 100644
--- a/src/gridtools/GridCoordinatesObject.cpp
+++ b/src/gridtools/GridCoordinatesObject.cpp
@@ -28,93 +28,156 @@ namespace gridtools {
 
 void GridCoordinatesObject::setup( const std::string& geom, const std::vector<bool>& ipbc,
                                    const unsigned& np, const double& fib_cutoff ) {
-  if( geom=="flat" ) { gtype=flat; dimension = ipbc.size(); }
-  else if( geom=="fibonacci" ) { gtype=fibonacci; dimension = 3; }
-  else plumed_merror( geom + " is invalid geometry type");
+  if( geom=="flat" ) {
+    gtype=flat;
+    dimension = ipbc.size();
+  } else if( geom=="fibonacci" ) {
+    gtype=fibonacci;
+    dimension = 3;
+  } else {
+    plumed_merror( geom + " is invalid geometry type");
+  }
 
   if( gtype==flat ) {
-    bounds_set=false; npoints=0; pbc.resize( ipbc.size() ); for(unsigned i=0; i<ipbc.size(); ++i) pbc[i]=ipbc[i];
+    bounds_set=false;
+    npoints=0;
+    pbc.resize( ipbc.size() );
+    for(unsigned i=0; i<ipbc.size(); ++i) {
+      pbc[i]=ipbc[i];
+    }
   } else if( gtype==fibonacci ) {
-    bounds_set=true; root5 = sqrt(5);
-    npoints = np; golden = ( 1 + sqrt(5) ) / 2.0; igolden = golden - 1;
-    fib_increment = 2*pi*igolden; log_golden2 = std::log( golden*golden );
+    bounds_set=true;
+    root5 = sqrt(5);
+    npoints = np;
+    golden = ( 1 + sqrt(5) ) / 2.0;
+    igolden = golden - 1;
+    fib_increment = 2*pi*igolden;
+    log_golden2 = std::log( golden*golden );
     fib_offset = 2 / static_cast<double>( npoints );
     fib_shift = fib_offset/2 - 1;
 
     std::vector<double> icoord( dimension ), jcoord( dimension );
     // Find minimum distance between each pair of points
-    std::vector<unsigned> tindices( dimension ); std::vector<double> mindists( npoints );
+    std::vector<unsigned> tindices( dimension );
+    std::vector<double> mindists( npoints );
     for(unsigned i=0; i<npoints; ++i) {
-      getFibonacciCoordinates( i, icoord ); mindists[i] = 0;
+      getFibonacciCoordinates( i, icoord );
+      mindists[i] = 0;
       for(unsigned j=0; j<npoints; ++j) {
-        if( i==j ) continue ; // Points are not neighbors to themselves
+        if( i==j ) {
+          continue ;  // Points are not neighbors to themselves
+        }
         getFibonacciCoordinates( j, jcoord );
         // Calculate the dot product
-        double dot=0; for(unsigned k=0; k<dimension; ++k) dot += icoord[k]*jcoord[k];
-        if( dot>mindists[i] ) mindists[i]=dot;
+        double dot=0;
+        for(unsigned k=0; k<dimension; ++k) {
+          dot += icoord[k]*jcoord[k];
+        }
+        if( dot>mindists[i] ) {
+          mindists[i]=dot;
+        }
       }
     }
     // And now take minimum of dot products
     double min=mindists[0];
     for(unsigned i=1; i<npoints; ++i) {
-      if( mindists[i]<min ) min=mindists[i];
+      if( mindists[i]<min ) {
+        min=mindists[i];
+      }
     }
     double final_cutoff;
-    if( fib_cutoff<-1 ) final_cutoff=-1;
-    else final_cutoff = cos( acos( fib_cutoff ) + acos( min ) );
+    if( fib_cutoff<-1 ) {
+      final_cutoff=-1;
+    } else {
+      final_cutoff = cos( acos( fib_cutoff ) + acos( min ) );
+    }
 
     // And now construct the neighbor list
     fib_nlist.resize( npoints );
     for(unsigned i=0; i<npoints; ++i) {
       getFibonacciCoordinates( i, icoord );
       for(unsigned j=0; j<npoints; ++j) {
-        if( i==j ) continue ; // Points are not neighbors to themselves
+        if( i==j ) {
+          continue ;  // Points are not neighbors to themselves
+        }
         getFibonacciCoordinates( j, jcoord );
         // Calculate the dot product
-        double dot=0; for(unsigned k=0; k<dimension; ++k) dot += icoord[k]*jcoord[k];
-        if( dot>final_cutoff ) { fib_nlist[i].push_back(j); }
+        double dot=0;
+        for(unsigned k=0; k<dimension; ++k) {
+          dot += icoord[k]*jcoord[k];
+        }
+        if( dot>final_cutoff ) {
+          fib_nlist[i].push_back(j);
+        }
       }
     }
-  } else plumed_error();
+  } else {
+    plumed_error();
+  }
 }
 
 void GridCoordinatesObject::setBounds( const std::vector<std::string>& smin, const std::vector<std::string>& smax,
                                        const std::vector<unsigned>& binsin, std::vector<double>& spacing ) {
   plumed_dbg_assert( smin.size()==dimension && smax.size()==dimension );
   plumed_assert( gtype==flat && (spacing.size()==dimension || binsin.size()==dimension) );
-  str_min.resize( dimension ); str_max.resize( dimension ); nbin.resize( dimension );
-  min.resize( dimension ); max.resize( dimension ); dx.resize( dimension ); stride.resize( dimension );
-
-  npoints=1; bounds_set=(smin[0]!="auto" && smax[0]!="auto");
+  str_min.resize( dimension );
+  str_max.resize( dimension );
+  nbin.resize( dimension );
+  min.resize( dimension );
+  max.resize( dimension );
+  dx.resize( dimension );
+  stride.resize( dimension );
+
+  npoints=1;
+  bounds_set=(smin[0]!="auto" && smax[0]!="auto");
   if( bounds_set ) {
     for(unsigned i=1; i<dimension; ++i) {
-      if( smin[i]=="auto" || smax[i]=="auto" ) { bounds_set=false; break; }
+      if( smin[i]=="auto" || smax[i]=="auto" ) {
+        bounds_set=false;
+        break;
+      }
     }
   }
   for(unsigned i=0; i<dimension; ++i) {
-    str_min[i]=smin[i]; str_max[i]=smax[i];
+    str_min[i]=smin[i];
+    str_max[i]=smax[i];
     if( bounds_set ) {
       Tools::convert( str_min[i], min[i] );
       Tools::convert( str_max[i], max[i] );
     }
     if( spacing.size()==dimension && binsin.size()==dimension ) {
-      if( spacing[i]==0 ) nbin[i] = binsin[i];
-      else if( bounds_set ) {
-        double range = max[i] - min[i]; nbin[i] = std::round( range / spacing[i]); dx[i]=spacing[i];
+      if( spacing[i]==0 ) {
+        nbin[i] = binsin[i];
+      } else if( bounds_set ) {
+        double range = max[i] - min[i];
+        nbin[i] = std::round( range / spacing[i]);
+        dx[i]=spacing[i];
         // This check ensures that nbins is set correctly if spacing is set the same as the number of bins
-        if( nbin[i]!=binsin[i] ) plumed_merror("mismatch between input spacing and input number of bins");
+        if( nbin[i]!=binsin[i] ) {
+          plumed_merror("mismatch between input spacing and input number of bins");
+        }
       }
     } else if( binsin.size()==dimension ) {
-      nbin[i]=binsin[i]; dx[i] = ( max[i] - min[i] ) / static_cast<double>( nbin[i] );
+      nbin[i]=binsin[i];
+      dx[i] = ( max[i] - min[i] ) / static_cast<double>( nbin[i] );
     } else if( spacing.size()==dimension && bounds_set ) {
-      nbin[i] = std::floor(( max[i] - min[i] ) / spacing[i]) + 1; dx[i]=spacing[i];
-    } else if( bounds_set ) plumed_error();
-    if( !pbc[i] ) { max[i] +=dx[i]; nbin[i]+=1; }
+      nbin[i] = std::floor(( max[i] - min[i] ) / spacing[i]) + 1;
+      dx[i]=spacing[i];
+    } else if( bounds_set ) {
+      plumed_error();
+    }
+    if( !pbc[i] ) {
+      max[i] +=dx[i];
+      nbin[i]+=1;
+    }
     stride[i]=npoints;
     npoints*=nbin[i];
   }
   if( spacing.size()!=dimension && bounds_set ) {
-    spacing.resize(dimension); for(unsigned i=0; i<dimension; ++i) spacing[i]=dx[i];
+    spacing.resize(dimension);
+    for(unsigned i=0; i<dimension; ++i) {
+      spacing[i]=dx[i];
+    }
   }
 }
 
@@ -129,11 +192,17 @@ unsigned GridCoordinatesObject::getIndex( const std::vector<unsigned>& indices )
 }
 
 bool GridCoordinatesObject::inbounds( const std::vector<double>& point ) const {
-  if( gtype==fibonacci ) return true;
+  if( gtype==fibonacci ) {
+    return true;
+  }
   plumed_dbg_assert( bounds_set && point.size()==dimension );
   for(unsigned i=0; i<dimension; ++i) {
-    if( pbc[i] ) continue;
-    if( point[i]<min[i] || point[i]>(max[i]-dx[i]) ) return false;
+    if( pbc[i] ) {
+      continue;
+    }
+    if( point[i]<min[i] || point[i]>(max[i]-dx[i]) ) {
+      return false;
+    }
   }
   return true;
 }
@@ -142,15 +211,19 @@ void GridCoordinatesObject::getIndices( const std::vector<double>& point, std::v
   plumed_dbg_assert( gtype==flat && bounds_set && point.size()==dimension && indices.size()==dimension );
   for(unsigned i=0; i<dimension; ++i) {
     indices[i]=std::floor( (point[i] - min[i])/dx[i] );
-    if( pbc[i] ) indices[i]=indices[i]%nbin[i];
-    else if( indices[i]>nbin[i] ) plumed_merror("point is outside grid range");
+    if( pbc[i] ) {
+      indices[i]=indices[i]%nbin[i];
+    } else if( indices[i]>nbin[i] ) {
+      plumed_merror("point is outside grid range");
+    }
   }
 }
 
 unsigned GridCoordinatesObject::getIndex( const std::vector<double>& point ) const {
   plumed_dbg_assert( bounds_set && point.size()==dimension );
   if( gtype==flat ) {
-    std::vector<unsigned> indices(dimension); getIndices( point, indices );
+    std::vector<unsigned> indices(dimension);
+    getIndices( point, indices );
     return getIndex( indices );
   } else if( gtype==fibonacci ) {
     return getFibonacciIndex( point );
@@ -162,34 +235,63 @@ unsigned GridCoordinatesObject::getIndex( const std::vector<double>& point ) con
 unsigned GridCoordinatesObject::getFibonacciIndex( const std::vector<double>& p ) const {
   plumed_dbg_assert( gtype==fibonacci );
   // Convert input point to coordinates on cylinder
-  int k=2; double phi = atan2( p[2], p[0] ), sinthet2 = 1 - p[1]*p[1];
+  int k=2;
+  double phi = atan2( p[2], p[0] ), sinthet2 = 1 - p[1]*p[1];
   // Calculate power to raise golden ratio
-  if( sinthet2<epsilon ) { k = 2; }
-  else {
+  if( sinthet2<epsilon ) {
+    k = 2;
+  } else {
     k = std::floor( std::log( npoints*pi*root5*sinthet2 ) / log_golden2 );
-    if( k<2 ) k = 2;
+    if( k<2 ) {
+      k = 2;
+    }
   }
   double Fk = pow( golden, k ) / root5, F0 = std::round(Fk), F1 = std::round(Fk*golden);
-  Matrix<double> B(2,2), invB(2,2); std::vector<double> thisp(3);
+  Matrix<double> B(2,2), invB(2,2);
+  std::vector<double> thisp(3);
   B(0,0) = 2*pi*((F0+1)*igolden - std::floor((F0+1)*igolden)) - fib_increment;
   B(0,1) = 2*pi*((F1+1)*igolden - std::floor((F1+1)*igolden)) - fib_increment;
-  B(1,0) = -2*F0/npoints; B(1,1) = -2*F1/npoints; Invert( B, invB );
-  std::vector<double> vv(2), rc(2); vv[0]=-phi; vv[1] = p[1] - fib_shift;
-  mult( invB, vv, rc ); std::vector<int> c(2); c[0]=std::floor(rc[0]); c[1]=std::floor(rc[1]);
-  unsigned outind=0; double mindist = 10000000.;
+  B(1,0) = -2*F0/npoints;
+  B(1,1) = -2*F1/npoints;
+  Invert( B, invB );
+  std::vector<double> vv(2), rc(2);
+  vv[0]=-phi;
+  vv[1] = p[1] - fib_shift;
+  mult( invB, vv, rc );
+  std::vector<int> c(2);
+  c[0]=std::floor(rc[0]);
+  c[1]=std::floor(rc[1]);
+  unsigned outind=0;
+  double mindist = 10000000.;
   for(int s=0; s<4; ++s) {
     double ttt, costheta = B(1,0)*( c[0] + s%2 ) + B(1,1)*( c[1] + s/2 ) + fib_shift;
-    if( costheta>1 ) ttt=1; else if( costheta<-1 ) ttt=-1; else ttt=costheta;
+    if( costheta>1 ) {
+      ttt=1;
+    } else if( costheta<-1 ) {
+      ttt=-1;
+    } else {
+      ttt=costheta;
+    }
     costheta = 2*ttt - costheta;
-    unsigned i = std::floor( 0.5*npoints*(1+costheta) ); getFibonacciCoordinates( i, thisp );
-    double dist=0; for(unsigned j=0; j<3; ++j) { double tmp=thisp[j]-p[j]; dist += tmp*tmp; }
-    if( dist<mindist ) { outind = i; mindist = dist; }
+    unsigned i = std::floor( 0.5*npoints*(1+costheta) );
+    getFibonacciCoordinates( i, thisp );
+    double dist=0;
+    for(unsigned j=0; j<3; ++j) {
+      double tmp=thisp[j]-p[j];
+      dist += tmp*tmp;
+    }
+    if( dist<mindist ) {
+      outind = i;
+      mindist = dist;
+    }
   }
   return outind;
 }
 
 void GridCoordinatesObject::convertIndexToIndices( const unsigned& index, const std::vector<unsigned>& nnbin, std::vector<unsigned>& indices ) const {
-  plumed_dbg_assert( gtype==flat ); unsigned kk=index; indices[0]=index%nnbin[0];
+  plumed_dbg_assert( gtype==flat );
+  unsigned kk=index;
+  indices[0]=index%nnbin[0];
   for(unsigned i=1; i<dimension-1; ++i) {
     kk=(kk-indices[i-1])/nnbin[i-1];
     indices[i]=kk%nnbin[i];
@@ -200,11 +302,13 @@ void GridCoordinatesObject::convertIndexToIndices( const unsigned& index, const
 }
 
 void GridCoordinatesObject::getIndices( const unsigned& index, std::vector<unsigned>& indices ) const {
-  plumed_dbg_assert( gtype==flat ); convertIndexToIndices( index, nbin, indices );
+  plumed_dbg_assert( gtype==flat );
+  convertIndexToIndices( index, nbin, indices );
 }
 
 void GridCoordinatesObject::getGridPointCoordinates( const unsigned& ipoint, std::vector<double>& x ) const {
-  std::vector<unsigned> tindices( dimension ); getGridPointCoordinates( ipoint, tindices, x );
+  std::vector<unsigned> tindices( dimension );
+  getGridPointCoordinates( ipoint, tindices, x );
 }
 
 void GridCoordinatesObject::getGridPointCoordinates( const unsigned& ipoint, std::vector<unsigned>& tindices, std::vector<double>& x ) const {
@@ -219,64 +323,101 @@ void GridCoordinatesObject::getGridPointCoordinates( const unsigned& ipoint, std
 }
 
 void GridCoordinatesObject::putCoordinateAtValue( const unsigned& ind, const double& val, std::vector<double>& coords ) const {
-  std::vector<double> point( dimension ); getGridPointCoordinates( ind, point );
+  std::vector<double> point( dimension );
+  getGridPointCoordinates( ind, point );
   if( gtype==flat ) {
-    if( coords.size()!=(dimension+1) ) coords.resize( (dimension+1) );
-    for(unsigned i=0; i<dimension; ++i) coords[i]=point[i]; coords[point.size()]=val;
+    if( coords.size()!=(dimension+1) ) {
+      coords.resize( (dimension+1) );
+    }
+    for(unsigned i=0; i<dimension; ++i) {
+      coords[i]=point[i];
+    }
+    coords[point.size()]=val;
   } else if( gtype==fibonacci ) {
-    if( coords.size()!=3 ) coords.resize(3);
-    for(unsigned i=0; i<3; ++i) coords[i] = val*point[i];
+    if( coords.size()!=3 ) {
+      coords.resize(3);
+    }
+    for(unsigned i=0; i<3; ++i) {
+      coords[i] = val*point[i];
+    }
   } else {
     plumed_error();
   }
 }
 
 void GridCoordinatesObject::getFlatGridCoordinates( const unsigned& ipoint, std::vector<unsigned>& tindices, std::vector<double>& x ) const {
-  plumed_dbg_assert( gtype==flat ); getIndices( ipoint, tindices );
-  for(unsigned i=0; i<dimension; ++i) x[i] = min[i] + dx[i]*tindices[i];
+  plumed_dbg_assert( gtype==flat );
+  getIndices( ipoint, tindices );
+  for(unsigned i=0; i<dimension; ++i) {
+    x[i] = min[i] + dx[i]*tindices[i];
+  }
 }
 
 void GridCoordinatesObject::getFibonacciCoordinates( const unsigned& ipoint, std::vector<double>& x ) const {
   plumed_dbg_assert( gtype==fibonacci );
-  x[1] = (ipoint*fib_offset) + fib_shift; double r = sqrt( 1 - x[1]*x[1] );
-  double phi = ipoint*fib_increment; x[0] = r*cos(phi); x[2] = r*sin(phi);
-  double norm=0; for(unsigned j=0; j<3; ++j) norm+=x[j]*x[j];
-  norm = sqrt(norm); for(unsigned j=0; j<3; ++j) x[j] = x[j] / norm;
+  x[1] = (ipoint*fib_offset) + fib_shift;
+  double r = sqrt( 1 - x[1]*x[1] );
+  double phi = ipoint*fib_increment;
+  x[0] = r*cos(phi);
+  x[2] = r*sin(phi);
+  double norm=0;
+  for(unsigned j=0; j<3; ++j) {
+    norm+=x[j]*x[j];
+  }
+  norm = sqrt(norm);
+  for(unsigned j=0; j<3; ++j) {
+    x[j] = x[j] / norm;
+  }
 }
 
 void GridCoordinatesObject::getSplineNeighbors( const unsigned& mybox, unsigned& nneighbors, std::vector<unsigned>& mysneigh ) const {
-  plumed_dbg_assert( gtype==flat ); mysneigh.resize( static_cast<unsigned>(pow(2.,dimension)) );
+  plumed_dbg_assert( gtype==flat );
+  mysneigh.resize( static_cast<unsigned>(pow(2.,dimension)) );
 
-  unsigned inind; nneighbors = 0;
+  unsigned inind;
+  nneighbors = 0;
   std::vector<unsigned> tmp_indices( dimension );
   std::vector<unsigned> my_indices( dimension );
   getIndices( mybox, my_indices );
   for(unsigned i=0; i<mysneigh.size(); ++i) {
-    unsigned tmp=i; inind=0;
+    unsigned tmp=i;
+    inind=0;
     for(unsigned j=0; j<dimension; ++j) {
-      unsigned i0=tmp%2+my_indices[j]; tmp/=2;
-      if(!pbc[j] && i0==nbin[j]) continue;
-      if( pbc[j] && i0==nbin[j]) i0=0;
+      unsigned i0=tmp%2+my_indices[j];
+      tmp/=2;
+      if(!pbc[j] && i0==nbin[j]) {
+        continue;
+      }
+      if( pbc[j] && i0==nbin[j]) {
+        i0=0;
+      }
       tmp_indices[inind++]=i0;
     }
-    if( inind==dimension ) mysneigh[nneighbors++]=getIndex( tmp_indices );
+    if( inind==dimension ) {
+      mysneigh[nneighbors++]=getIndex( tmp_indices );
+    }
   }
 }
 
 std::vector<std::string> GridCoordinatesObject::getMin() const {
-  plumed_dbg_assert( gtype==flat ); return str_min;
+  plumed_dbg_assert( gtype==flat );
+  return str_min;
 }
 
 std::vector<std::string> GridCoordinatesObject::getMax() const {
-  plumed_dbg_assert( gtype==flat ); return str_max;
+  plumed_dbg_assert( gtype==flat );
+  return str_max;
 }
 
 std::vector<unsigned> GridCoordinatesObject::getNbin( const bool& shape ) const {
   plumed_dbg_assert( gtype==flat && nbin.size()==dimension );
   std::vector<unsigned> ngrid( dimension );
   for(unsigned i=0; i<dimension; ++i) {
-    if( !pbc[i] && !shape ) ngrid[i]=nbin[i] - 1;
-    else ngrid[i]=nbin[i];
+    if( !pbc[i] && !shape ) {
+      ngrid[i]=nbin[i] - 1;
+    } else {
+      ngrid[i]=nbin[i];
+    }
   }
   return ngrid;
 }
@@ -288,13 +429,20 @@ void GridCoordinatesObject::getNeighbors( const std::vector<double>& pp, const s
   if( gtype == flat ) {
     plumed_dbg_assert( nneigh.size()==dimension );
     std::vector<unsigned> indices( dimension );
-    for(unsigned i=0; i<dimension; ++i) indices[i] = std::floor( (pp[i]-min[i])/dx[i] );
+    for(unsigned i=0; i<dimension; ++i) {
+      indices[i] = std::floor( (pp[i]-min[i])/dx[i] );
+    }
     getNeighbors( indices, nneigh, num_neighbors, neighbors );
   } else if( gtype == fibonacci ) {
     unsigned find = getFibonacciIndex( pp );
     num_neighbors = 1 + fib_nlist[find].size();
-    if( neighbors.size()<num_neighbors ) neighbors.resize( num_neighbors );
-    neighbors[0]=find; for(unsigned i=0; i<fib_nlist[find].size(); ++i) neighbors[1+i] = fib_nlist[find][i];
+    if( neighbors.size()<num_neighbors ) {
+      neighbors.resize( num_neighbors );
+    }
+    neighbors[0]=find;
+    for(unsigned i=0; i<fib_nlist[find].size(); ++i) {
+      neighbors[1+i] = fib_nlist[find][i];
+    }
   } else {
     plumed_error();
   }
@@ -304,13 +452,18 @@ void GridCoordinatesObject::getNeighbors( const std::vector<unsigned>& indices,
     unsigned& num_neighbors, std::vector<unsigned>& neighbors ) const {
   plumed_dbg_assert( gtype==flat && bounds_set && nneigh.size()==dimension );
 
-  unsigned num_neigh=1; std::vector<unsigned> small_bin( dimension );
+  unsigned num_neigh=1;
+  std::vector<unsigned> small_bin( dimension );
   for(unsigned i=0; i<dimension; ++i) {
     small_bin[i]=(2*nneigh[i]+1);
-    if( pbc[i] && small_bin[i]>nbin[i] ) small_bin[i]=nbin[i];
+    if( pbc[i] && small_bin[i]>nbin[i] ) {
+      small_bin[i]=nbin[i];
+    }
     num_neigh *=small_bin[i];
   }
-  if( neighbors.size()!=num_neigh ) neighbors.resize( num_neigh );
+  if( neighbors.size()!=num_neigh ) {
+    neighbors.resize( num_neigh );
+  }
 
   num_neighbors=0;
   std::vector<unsigned> s_indices(dimension), t_indices(dimension);
@@ -319,10 +472,18 @@ void GridCoordinatesObject::getNeighbors( const std::vector<unsigned>& indices,
     convertIndexToIndices( index, small_bin, s_indices );
     for(unsigned i=0; i<dimension; ++i) {
       int i0=s_indices[i]-nneigh[i]+indices[i];
-      if(!pbc[i] && i0<0)        found=false;
-      if(!pbc[i] && i0>=nbin[i]) found=false;
-      if( pbc[i] && i0<0)        i0=nbin[i]-(-i0)%nbin[i];
-      if( pbc[i] && i0>=nbin[i]) i0%=nbin[i];
+      if(!pbc[i] && i0<0) {
+        found=false;
+      }
+      if(!pbc[i] && i0>=nbin[i]) {
+        found=false;
+      }
+      if( pbc[i] && i0<0) {
+        i0=nbin[i]-(-i0)%nbin[i];
+      }
+      if( pbc[i] && i0>=nbin[i]) {
+        i0%=nbin[i];
+      }
       t_indices[i]=static_cast<unsigned>(i0);
     }
     if( found ) {
diff --git a/src/gridtools/GridCoordinatesObject.h b/src/gridtools/GridCoordinatesObject.h
index b8d3662df8..e7da5f03f2 100644
--- a/src/gridtools/GridCoordinatesObject.h
+++ b/src/gridtools/GridCoordinatesObject.h
@@ -123,7 +123,9 @@ unsigned GridCoordinatesObject::getNumberOfPoints() const {
 
 inline
 const std::vector<double>& GridCoordinatesObject::getGridSpacing() const {
-  if( gtype==flat ) return dx;
+  if( gtype==flat ) {
+    return dx;
+  }
   plumed_merror("dont understand what spacing means for spherical grids");
   return dx;
 }
@@ -131,7 +133,10 @@ const std::vector<double>& GridCoordinatesObject::getGridSpacing() const {
 inline
 double GridCoordinatesObject::getCellVolume() const {
   if( gtype==flat ) {
-    double myvol=1.0; for(unsigned i=0; i<dimension; ++i) myvol *= dx[i];
+    double myvol=1.0;
+    for(unsigned i=0; i<dimension; ++i) {
+      myvol *= dx[i];
+    }
     return myvol;
   } else {
     return 4*pi / static_cast<double>( getNumberOfPoints() );
@@ -157,8 +162,11 @@ const std::vector<unsigned>& GridCoordinatesObject::getStride() const {
 
 inline
 std::string GridCoordinatesObject::getGridType() const {
-  if( gtype==flat ) return "flat";
-  else if( gtype==fibonacci ) return "fibonacci";
+  if( gtype==flat ) {
+    return "flat";
+  } else if( gtype==fibonacci ) {
+    return "fibonacci";
+  }
   return "";
 }
 
diff --git a/src/gridtools/GridSearch.h b/src/gridtools/GridSearch.h
index 1225c2519a..b1beec455e 100644
--- a/src/gridtools/GridSearch.h
+++ b/src/gridtools/GridSearch.h
@@ -47,18 +47,23 @@ class GridSearch {
 public:
   GridSearch( const std::vector<double>& mmin, const std::vector<double>& mmax, const std::vector<unsigned>& ng, const std::vector<unsigned>& nfg, FCLASS* funcc ) :
     myclass_func( funcc ),
-    using_fgrid(false)
-  {
+    using_fgrid(false) {
     // Setup the min and max values for the grid
     std::vector<std::string> gmin( nfg.size() ), gmax( nfg.size() );
-    std::vector<bool> pbc( nfg.size(), false ); std::vector<double> dummy_spacing;
-    for(unsigned i=0; i<nfg.size(); ++i) { Tools::convert(mmin[i],gmin[i]); Tools::convert(mmax[i],gmax[i]); }
+    std::vector<bool> pbc( nfg.size(), false );
+    std::vector<double> dummy_spacing;
+    for(unsigned i=0; i<nfg.size(); ++i) {
+      Tools::convert(mmin[i],gmin[i]);
+      Tools::convert(mmax[i],gmax[i]);
+    }
     // Create the coarse grid grid objects
     mygrid.setup( "flat", pbc, 0, 0.0 );
     mygrid.setBounds( gmin, gmax, ng, dummy_spacing );
     // Setup the fine grid object
     if( nfg[0]>0 ) {
-      using_fgrid=true; myfgrid.setup("flat", pbc, 0, 0.0 ); dummy_spacing.resize(0);
+      using_fgrid=true;
+      myfgrid.setup("flat", pbc, 0, 0.0 );
+      dummy_spacing.resize(0);
       myfgrid.setBounds( gmin, gmax, nfg, dummy_spacing );
     }
     value.reset( new Value( NULL, "gval", true, mygrid.getNbin(true)) );
@@ -70,29 +75,42 @@ class GridSearch {
 
 template <class FCLASS>
 void GridSearch<FCLASS>::setGridElement( const unsigned& ind, const double& emin, const std::vector<double>& der ) {
-  value->set( ind, emin ); for(unsigned j=0; j<der.size(); ++j) value->setGridDerivatives( ind, j, der[j] );
+  value->set( ind, emin );
+  for(unsigned j=0; j<der.size(); ++j) {
+    value->setGridDerivatives( ind, j, der[j] );
+  }
 }
 
 template <class FCLASS>
 bool GridSearch<FCLASS>::minimise( std::vector<double>& p, engf_pointer myfunc ) {
-  std::vector<double> der( p.size() ); std::vector<double> coords( p.size() );
+  std::vector<double> der( p.size() );
+  std::vector<double> coords( p.size() );
   double initial_eng = (myclass_func->*myfunc)( p, der );
-  mygrid.getGridPointCoordinates( 0, coords ); unsigned pmin=0;
-  double emin=(myclass_func->*myfunc)( coords, der ); setGridElement( 0, emin, der );
+  mygrid.getGridPointCoordinates( 0, coords );
+  unsigned pmin=0;
+  double emin=(myclass_func->*myfunc)( coords, der );
+  setGridElement( 0, emin, der );
   for(unsigned i=1; i<mygrid.getNumberOfPoints(); ++i) {
     mygrid.getGridPointCoordinates( i, coords );
     double eng = (myclass_func->*myfunc)( coords, der );
     setGridElement( i, eng, der );
-    if( eng<emin ) { emin=eng; pmin=i; }
+    if( eng<emin ) {
+      emin=eng;
+      pmin=i;
+    }
   }
 
   if( using_fgrid ) {
-    myfgrid.getGridPointCoordinates( 0, coords ); pmin=0;
+    myfgrid.getGridPointCoordinates( 0, coords );
+    pmin=0;
     double emin = myinterp->splineInterpolation( coords, der );
     for(unsigned i=1; i<myfgrid.getNumberOfPoints(); ++i) {
       myfgrid.getGridPointCoordinates( i, coords );
       double eng = myinterp->splineInterpolation( coords, der );
-      if( eng<emin ) { emin=eng; pmin=i; }
+      if( eng<emin ) {
+        emin=eng;
+        pmin=i;
+      }
     }
     myfgrid.getGridPointCoordinates( pmin, coords );
     double checkEng = (myclass_func->*myfunc)( coords, der );
diff --git a/src/gridtools/Histogram.cpp b/src/gridtools/Histogram.cpp
index e7db8defab..f3e2e24bbd 100644
--- a/src/gridtools/Histogram.cpp
+++ b/src/gridtools/Histogram.cpp
@@ -202,7 +202,9 @@ class Histogram : public ActionShortcut {
 PLUMED_REGISTER_ACTION(Histogram,"HISTOGRAM")
 
 void Histogram::registerKeywords( Keywords& keys ) {
-  ActionShortcut::registerKeywords( keys ); keys.use("UPDATE_FROM"); keys.use("UPDATE_UNTIL");
+  ActionShortcut::registerKeywords( keys );
+  keys.use("UPDATE_FROM");
+  keys.use("UPDATE_UNTIL");
   keys.add("compulsory","NORMALIZATION","ndata","This controls how the data is normalized it can be set equal to true, false or ndata.  See above for an explanation");
   keys.add("optional","ARG","the quantity that is being averaged");
   keys.add("optional","DATA","an alternative to the ARG keyword");
@@ -217,27 +219,47 @@ void Histogram::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","STRIDE","1","the frequency with which to store data for averaging");
   keys.add("compulsory","CLEAR","0","the frequency with whihc to clear the data that is being averaged");
   keys.setValueDescription("the estimate of the histogram as a function of the argument that was obtained");
-  keys.needsAction("COMBINE"); keys.needsAction("CUSTOM"); keys.needsAction("ONES");
-  keys.needsAction("KDE"); keys.needsAction("ACCUMULATE");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("ONES");
+  keys.needsAction("KDE");
+  keys.needsAction("ACCUMULATE");
 }
 
 Histogram::Histogram( const ActionOptions& ao ):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string normflag; parse("NORMALIZATION",normflag);
-  std::string lw; parse("LOGWEIGHTS",lw); std::string stride, clearstride; parse("STRIDE",stride); parse("CLEAR",clearstride);
+  ActionShortcut(ao) {
+  std::string normflag;
+  parse("NORMALIZATION",normflag);
+  std::string lw;
+  parse("LOGWEIGHTS",lw);
+  std::string stride, clearstride;
+  parse("STRIDE",stride);
+  parse("CLEAR",clearstride);
   if( lw.length()>0 && normflag!="ndata" ) {
     readInputLine( getShortcutLabel() + "_wsum: COMBINE ARG=" + lw + " PERIODIC=NO");
     readInputLine( getShortcutLabel() + "_weight: CUSTOM ARG=" + getShortcutLabel() + "_wsum FUNC=exp(x) PERIODIC=NO");
-  } else readInputLine( getShortcutLabel() + "_weight: ONES SIZE=1" );
-
-  std::vector<std::string> arglist; parseVector("ARG",arglist); if( arglist.size()==0 ) parseVector("DATA",arglist);
-  if( arglist.size()==0 ) error("arguments have not been specified use ARG");
-  std::vector<Value*> theargs; ActionWithArguments::interpretArgumentList( arglist, plumed.getActionSet(), this, theargs );
-  plumed_assert( theargs.size()>0 ); std::string argstr=theargs[0]->getName();
-  for(unsigned i=1; i<theargs.size(); ++i) argstr += "," + theargs[i]->getName();
-  std::string strnum; Tools::convert( theargs[0]->getNumberOfValues(), strnum );
+  } else {
+    readInputLine( getShortcutLabel() + "_weight: ONES SIZE=1" );
+  }
+
+  std::vector<std::string> arglist;
+  parseVector("ARG",arglist);
+  if( arglist.size()==0 ) {
+    parseVector("DATA",arglist);
+  }
+  if( arglist.size()==0 ) {
+    error("arguments have not been specified use ARG");
+  }
+  std::vector<Value*> theargs;
+  ActionWithArguments::interpretArgumentList( arglist, plumed.getActionSet(), this, theargs );
+  plumed_assert( theargs.size()>0 );
+  std::string argstr=theargs[0]->getName();
+  for(unsigned i=1; i<theargs.size(); ++i) {
+    argstr += "," + theargs[i]->getName();
+  }
+  std::string strnum;
+  Tools::convert( theargs[0]->getNumberOfValues(), strnum );
   if( theargs[0]->getNumberOfValues()==1 ) {
     // Create the KDE object
     readInputLine( getShortcutLabel() + "_kde: KDE ARG=" + argstr + " " + convertInputLineToString() );
diff --git a/src/gridtools/InterpolateGrid.cpp b/src/gridtools/InterpolateGrid.cpp
index e667494c62..64479aefd8 100644
--- a/src/gridtools/InterpolateGrid.cpp
+++ b/src/gridtools/InterpolateGrid.cpp
@@ -75,30 +75,44 @@ PLUMED_REGISTER_ACTION(InterpolateGrid,"INTERPOLATE_GRID")
 
 void InterpolateGrid::registerKeywords( Keywords& keys ) {
   ActionWithGrid::registerKeywords( keys );
-  keys.add("optional","GRID_BIN","the number of bins for the grid"); keys.use("ARG");
+  keys.add("optional","GRID_BIN","the number of bins for the grid");
+  keys.use("ARG");
   keys.add("optional","GRID_SPACING","the approximate grid spacing (to be used as an alternative or together with GRID_BIN)");
   keys.addFlag("MIDPOINTS",false,"interpolate the values of the function at the midpoints of the grid coordinates of the input grid");
-  EvaluateGridFunction ii; ii.registerKeywords( keys );
+  EvaluateGridFunction ii;
+  ii.registerKeywords( keys );
 }
 
 InterpolateGrid::InterpolateGrid(const ActionOptions&ao):
   Action(ao),
-  ActionWithGrid(ao)
-{
-  if( getNumberOfArguments()!=1 ) error("should only be one argument to this action");
-  if( getPntrToArgument(0)->getRank()==0 || !getPntrToArgument(0)->hasDerivatives() ) error("input to this action should be a grid");
+  ActionWithGrid(ao) {
+  if( getNumberOfArguments()!=1 ) {
+    error("should only be one argument to this action");
+  }
+  if( getPntrToArgument(0)->getRank()==0 || !getPntrToArgument(0)->hasDerivatives() ) {
+    error("input to this action should be a grid");
+  }
 
-  parseFlag("MIDPOINTS",midpoints); parseVector("GRID_BIN",nbin); parseVector("GRID_SPACING",gspacing); unsigned dimension = getPntrToArgument(0)->getRank();
-  if( !midpoints && nbin.size()!=dimension && gspacing.size()!=dimension ) error("MIDPOINTS, GRID_BIN or GRID_SPACING must be set");
+  parseFlag("MIDPOINTS",midpoints);
+  parseVector("GRID_BIN",nbin);
+  parseVector("GRID_SPACING",gspacing);
+  unsigned dimension = getPntrToArgument(0)->getRank();
+  if( !midpoints && nbin.size()!=dimension && gspacing.size()!=dimension ) {
+    error("MIDPOINTS, GRID_BIN or GRID_SPACING must be set");
+  }
   if( midpoints ) {
     log.printf("  evaluating function at midpoints of cells in input grid\n");
   } else if( nbin.size()==dimension ) {
     log.printf("  number of bins in grid %d", nbin[0]);
-    for(unsigned i=1; i<nbin.size(); ++i) log.printf(", %d", nbin[i]);
+    for(unsigned i=1; i<nbin.size(); ++i) {
+      log.printf(", %d", nbin[i]);
+    }
     log.printf("\n");
   } else if( gspacing.size()==dimension ) {
     log.printf("  spacing for bins in grid %f", gspacing[0]);
-    for(unsigned i=1; i<gspacing.size(); ++i) log.printf(", %d", gspacing[i]);
+    for(unsigned i=1; i<gspacing.size(); ++i) {
+      log.printf(", %d", gspacing[i]);
+    }
     log.printf("\n");
   }
   // Create the input grid
@@ -111,38 +125,54 @@ InterpolateGrid::InterpolateGrid(const ActionOptions&ao):
   addValueWithDerivatives( shape );
 
   if( getPntrToArgument(0)->isPeriodic() ) {
-    std::string min, max; getPntrToArgument(0)->getDomain( min, max ); setPeriodic( min, max );
-  } else setNotPeriodic();
+    std::string min, max;
+    getPntrToArgument(0)->getDomain( min, max );
+    setPeriodic( min, max );
+  } else {
+    setNotPeriodic();
+  }
   setupOnFirstStep( false );
 }
 
 void InterpolateGrid::setupOnFirstStep( const bool incalc ) {
   input_grid.setup( this );
   ActionWithGrid* ag=ActionWithGrid::getInputActionWithGrid( getPntrToArgument(0)->getPntrToAction() );
-  plumed_assert( ag ); const GridCoordinatesObject& mygrid = ag->getGridCoordinatesObject();
+  plumed_assert( ag );
+  const GridCoordinatesObject& mygrid = ag->getGridCoordinatesObject();
   if( midpoints ) {
-    double min, max; nbin.resize( getPntrToComponent(0)->getRank() );
+    double min, max;
+    nbin.resize( getPntrToComponent(0)->getRank() );
     std::vector<std::string> str_min( input_grid.getMin() ), str_max(input_grid.getMax() );
     for(unsigned i=0; i<nbin.size(); ++i) {
       if( incalc ) {
-        Tools::convert( str_min[i], min ); Tools::convert( str_max[i], max );
+        Tools::convert( str_min[i], min );
+        Tools::convert( str_max[i], max );
         min += 0.5*input_grid.getGridSpacing()[i];
       }
       if( input_grid.getPbc()[i] ) {
         nbin[i] = input_grid.getNbin()[i];
-        if( incalc ) max += 0.5*input_grid.getGridSpacing()[i];
+        if( incalc ) {
+          max += 0.5*input_grid.getGridSpacing()[i];
+        }
       } else {
         nbin[i] = input_grid.getNbin()[i] - 1;
-        if( incalc ) max -= 0.5*input_grid.getGridSpacing()[i];
+        if( incalc ) {
+          max -= 0.5*input_grid.getGridSpacing()[i];
+        }
       }
       if( incalc ) {
-        Tools::convert( min, str_min[i] ); Tools::convert( max, str_max[i] );
+        Tools::convert( min, str_min[i] );
+        Tools::convert( max, str_max[i] );
       }
     }
     output_grid.setBounds( str_min, str_max, nbin,  gspacing );
-  } else output_grid.setBounds( mygrid.getMin(), mygrid.getMax(), nbin, gspacing );
+  } else {
+    output_grid.setBounds( mygrid.getMin(), mygrid.getMax(), nbin, gspacing );
+  }
   getPntrToComponent(0)->setShape( output_grid.getNbin(true) );
-  if( !incalc ) gspacing.resize(0);
+  if( !incalc ) {
+    gspacing.resize(0);
+  }
 }
 
 unsigned InterpolateGrid::getNumberOfDerivatives() {
@@ -155,26 +185,40 @@ const GridCoordinatesObject& InterpolateGrid::getGridCoordinatesObject() const {
 
 std::vector<std::string> InterpolateGrid::getGridCoordinateNames() const {
   ActionWithGrid* ag = ActionWithGrid::getInputActionWithGrid( getPntrToArgument(0)->getPntrToAction() );
-  plumed_assert( ag ); return ag->getGridCoordinateNames();
+  plumed_assert( ag );
+  return ag->getGridCoordinateNames();
 }
 
 void InterpolateGrid::performTask( const unsigned& current, MultiValue& myvals ) const {
-  std::vector<double> pos( output_grid.getDimension() ); output_grid.getGridPointCoordinates( current, pos );
-  std::vector<double> val(1); Matrix<double> der( 1, output_grid.getDimension() ); input_grid.calc( this, pos, val, der );
-  unsigned ostrn = getConstPntrToComponent(0)->getPositionInStream(); myvals.setValue( ostrn, val[0] );
-  for(unsigned i=0; i<output_grid.getDimension(); ++i) { myvals.addDerivative( ostrn, i, der(0,i) ); myvals.updateIndex( ostrn, i ); }
+  std::vector<double> pos( output_grid.getDimension() );
+  output_grid.getGridPointCoordinates( current, pos );
+  std::vector<double> val(1);
+  Matrix<double> der( 1, output_grid.getDimension() );
+  input_grid.calc( this, pos, val, der );
+  unsigned ostrn = getConstPntrToComponent(0)->getPositionInStream();
+  myvals.setValue( ostrn, val[0] );
+  for(unsigned i=0; i<output_grid.getDimension(); ++i) {
+    myvals.addDerivative( ostrn, i, der(0,i) );
+    myvals.updateIndex( ostrn, i );
+  }
 }
 
 void InterpolateGrid::gatherStoredValue( const unsigned& valindex, const unsigned& code, const MultiValue& myvals,
     const unsigned& bufstart, std::vector<double>& buffer ) const {
-  plumed_dbg_assert( valindex==0 ); unsigned ostrn = getConstPntrToComponent(0)->getPositionInStream();
-  unsigned istart = bufstart + (1+output_grid.getDimension())*code; buffer[istart] += myvals.get( ostrn );
-  for(unsigned i=0; i<output_grid.getDimension(); ++i) buffer[istart+1+i] += myvals.getDerivative( ostrn, i );
+  plumed_dbg_assert( valindex==0 );
+  unsigned ostrn = getConstPntrToComponent(0)->getPositionInStream();
+  unsigned istart = bufstart + (1+output_grid.getDimension())*code;
+  buffer[istart] += myvals.get( ostrn );
+  for(unsigned i=0; i<output_grid.getDimension(); ++i) {
+    buffer[istart+1+i] += myvals.getDerivative( ostrn, i );
+  }
 }
 
 void InterpolateGrid::gatherForcesOnStoredValue( const Value* myval, const unsigned& itask, const MultiValue& myvals, std::vector<double>& forces ) const {
-  std::vector<double> pos(output_grid.getDimension()); double ff = myval->getForce(itask);
-  output_grid.getGridPointCoordinates( itask, pos ); input_grid.applyForce( this, pos, ff, forces );
+  std::vector<double> pos(output_grid.getDimension());
+  double ff = myval->getForce(itask);
+  output_grid.getGridPointCoordinates( itask, pos );
+  input_grid.applyForce( this, pos, ff, forces );
 }
 
 
diff --git a/src/gridtools/Interpolator.cpp b/src/gridtools/Interpolator.cpp
index 43cdb865a3..b5f2f65f30 100644
--- a/src/gridtools/Interpolator.cpp
+++ b/src/gridtools/Interpolator.cpp
@@ -25,37 +25,49 @@ namespace PLMD {
 namespace gridtools {
 
 double Interpolator::splineInterpolation( const std::vector<double>& x, std::vector<double>& der ) const {
-  plumed_dbg_assert( gridobject.getGridType()=="flat" ); unsigned dimension = gridobject.getDimension();
+  plumed_dbg_assert( gridobject.getGridType()=="flat" );
+  unsigned dimension = gridobject.getDimension();
 
-  double X,X2,X3,value=0; der.assign(der.size(),0.0);
+  double X,X2,X3,value=0;
+  der.assign(der.size(),0.0);
   std::vector<double> fd(dimension);
   std::vector<double> C(dimension);
   std::vector<double> D(dimension);
   std::vector<double> dder(dimension);
 
   std::vector<unsigned> nindices(dimension);
-  std::vector<unsigned> indices(dimension); gridobject.getIndices( x, indices );
-  std::vector<double> xfloor(dimension); gridobject.getGridPointCoordinates( gridobject.getIndex(x), nindices, xfloor );
+  std::vector<unsigned> indices(dimension);
+  gridobject.getIndices( x, indices );
+  std::vector<double> xfloor(dimension);
+  gridobject.getGridPointCoordinates( gridobject.getIndex(x), nindices, xfloor );
 
   // loop over neighbors
-  std::vector<unsigned> neigh; unsigned n_neigh;
+  std::vector<unsigned> neigh;
+  unsigned n_neigh;
   gridobject.getSplineNeighbors( gridobject.getIndex(indices), n_neigh, neigh );
   for(unsigned int ipoint=0; ipoint<n_neigh; ++ipoint) {
     double grid=values->get( neigh[ipoint] );
-    for(unsigned j=0; j<dimension; ++j) dder[j] = values->getGridDerivative( neigh[ipoint], j );
+    for(unsigned j=0; j<dimension; ++j) {
+      dder[j] = values->getGridDerivative( neigh[ipoint], j );
+    }
 
     gridobject.getIndices( neigh[ipoint], nindices );
     double ff=1.0;
     for(unsigned j=0; j<dimension; ++j) {
       int x0=1;
-      if(nindices[j]==indices[j]) x0=0;
+      if(nindices[j]==indices[j]) {
+        x0=0;
+      }
       double ddx=gridobject.getGridSpacing()[j];
       X=fabs((x[j]-xfloor[j])/ddx-(double)x0);
       X2=X*X;
       X3=X2*X;
       double yy;
-      if(fabs(grid)<0.0000001) yy=0.0;
-      else yy=-dder[j]/grid;
+      if(fabs(grid)<0.0000001) {
+        yy=0.0;
+      } else {
+        yy=-dder[j]/grid;
+      }
       C[j]=(1.0-3.0*X2+2.0*X3) - (x0?-1.0:1.0)*yy*(X-2.0*X2+X3)*ddx;
       D[j]=( -6.0*X +6.0*X2) - (x0?-1.0:1.0)*yy*(1.0-4.0*X +3.0*X2)*ddx;
       D[j]*=(x0?-1.0:1.0)/ddx;
@@ -63,10 +75,15 @@ double Interpolator::splineInterpolation( const std::vector<double>& x, std::vec
     }
     for(unsigned j=0; j<dimension; ++j) {
       fd[j]=D[j];
-      for(unsigned i=0; i<dimension; ++i) if(i!=j) fd[j]*=C[i];
+      for(unsigned i=0; i<dimension; ++i)
+        if(i!=j) {
+          fd[j]*=C[i];
+        }
     }
     value+=grid*ff;
-    for(unsigned j=0; j<dimension; ++j) der[j]+=grid*fd[j];
+    for(unsigned j=0; j<dimension; ++j) {
+      der[j]+=grid*fd[j];
+    }
   }
   return value;
 }
diff --git a/src/gridtools/KDE.cpp b/src/gridtools/KDE.cpp
index 5303d4f2f5..11ae374693 100644
--- a/src/gridtools/KDE.cpp
+++ b/src/gridtools/KDE.cpp
@@ -94,7 +94,8 @@ PLUMED_REGISTER_ACTION(KDE,"KDE")
 PLUMED_REGISTER_ACTION(KDE,"SPHERICAL_KDE")
 
 void KDE::registerKeywords( Keywords& keys ) {
-  ActionWithGrid::registerKeywords( keys ); keys.use("ARG");
+  ActionWithGrid::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("optional","HEIGHTS","this keyword takes the label of an action that calculates a vector of values.  The elements of this vector "
            "are used as weights for the Gaussians.");
   keys.add("optional","VOLUMES","this keyword take the label of an action that calculates a vector of values.  The elements of this vector "
@@ -119,30 +120,42 @@ KDE::KDE(const ActionOptions&ao):
   Action(ao),
   ActionWithGrid(ao),
   hasheight(false),
-  fixed_width(false)
-{
-  std::vector<unsigned> shape( getNumberOfArguments() ); center.resize( getNumberOfArguments() );
+  fixed_width(false) {
+  std::vector<unsigned> shape( getNumberOfArguments() );
+  center.resize( getNumberOfArguments() );
   numberOfKernels=getPntrToArgument(0)->getNumberOfValues();
   for(unsigned i=1; i<shape.size(); ++i) {
-    if( numberOfKernels!=getPntrToArgument(i)->getNumberOfValues() ) error("mismatch between numbers of values in input arguments");
+    if( numberOfKernels!=getPntrToArgument(i)->getNumberOfValues() ) {
+      error("mismatch between numbers of values in input arguments");
+    }
   }
 
-  bool weights_are_volumes=true; std::vector<std::string> weight_str; parseVector("VOLUMES",weight_str);
+  bool weights_are_volumes=true;
+  std::vector<std::string> weight_str;
+  parseVector("VOLUMES",weight_str);
   if( weight_str.size()==0 ) {
     parseVector("HEIGHTS",weight_str);
-    if( weight_str.size()>0 ) weights_are_volumes=false;
+    if( weight_str.size()>0 ) {
+      weights_are_volumes=false;
+    }
   }
   hasheight=(weight_str.size()==1);
-  if( weight_str.size()>1 ) error("only one scalar/vector/matrix should be input to HEIGHTS");
+  if( weight_str.size()>1 ) {
+    error("only one scalar/vector/matrix should be input to HEIGHTS");
+  }
 
   if( getName()=="KDE" ) {
     parse("KERNEL",kerneltype);
     if( kerneltype!="DISCRETE" ) {
-      std::string bandwidth; std::vector<std::string> bwidths; parseVector("BANDWIDTH",bwidths);
+      std::string bandwidth;
+      std::vector<std::string> bwidths;
+      parseVector("BANDWIDTH",bwidths);
       if( bwidths.size()>0 ) {
         std::string band="VALUES=" + bwidths[0];
         for(unsigned i=0; i<bwidths.size(); ++i) {
-          if( i>0 ) band += "," + bwidths[i];
+          if( i>0 ) {
+            band += "," + bwidths[i];
+          }
         }
         plumed.readInputLine( getLabel() + "_sigma: CONSTANT " + band );
         plumed.readInputLine( getLabel() + "_cov: CUSTOM ARG=" + getLabel() + "_sigma FUNC=x*x PERIODIC=NO" );
@@ -150,51 +163,84 @@ KDE::KDE(const ActionOptions&ao):
         bandwidth = getLabel() + "_icov";
 
         if( (kerneltype=="gaussian" || kerneltype=="GAUSSIAN") && weights_are_volumes ) {
-          std::string pstr; Tools::convert( sqrt(pow(2*pi,bwidths.size())), pstr );
+          std::string pstr;
+          Tools::convert( sqrt(pow(2*pi,bwidths.size())), pstr );
           plumed.readInputLine( getLabel() + "_bwprod: PRODUCT ARG=" + getLabel() + "_cov");
           plumed.readInputLine( getLabel() + "_vol: CUSTOM ARG=" + getLabel() + "_bwprod FUNC=(sqrt(x)*" + pstr + ") PERIODIC=NO");
-          if( hasheight ) plumed.readInputLine( getLabel() + "_height: CUSTOM ARG=" + weight_str[0] + "," + getLabel() + "_vol FUNC=x/y PERIODIC=NO");
-          else plumed.readInputLine( getLabel() + "_height: CUSTOM ARG=" + getLabel() + "_vol FUNC=1/x PERIODIC=NO");
-          hasheight=true; weight_str.resize(1); weight_str[0] = getLabel() + "_height";
+          if( hasheight ) {
+            plumed.readInputLine( getLabel() + "_height: CUSTOM ARG=" + weight_str[0] + "," + getLabel() + "_vol FUNC=x/y PERIODIC=NO");
+          } else {
+            plumed.readInputLine( getLabel() + "_height: CUSTOM ARG=" + getLabel() + "_vol FUNC=1/x PERIODIC=NO");
+          }
+          hasheight=true;
+          weight_str.resize(1);
+          weight_str[0] = getLabel() + "_height";
         }
-      } else parse("METRIC",bandwidth);
+      } else {
+        parse("METRIC",bandwidth);
+      }
       weight_str.push_back( bandwidth );
     }
   }
   if( weight_str.size()>0 ) {
-    std::vector<Value*> weight_args; ActionWithArguments::interpretArgumentList( weight_str, plumed.getActionSet(), this, weight_args );
-    std::vector<Value*> args( getArguments() ); args.push_back( weight_args[0] );
-    if( hasheight && weight_args[0]->getNumberOfValues()>1 && numberOfKernels!=weight_args[0]->getNumberOfValues() ) error("mismatch between numbers of values in input arguments and HEIGHTS");
+    std::vector<Value*> weight_args;
+    ActionWithArguments::interpretArgumentList( weight_str, plumed.getActionSet(), this, weight_args );
+    std::vector<Value*> args( getArguments() );
+    args.push_back( weight_args[0] );
+    if( hasheight && weight_args[0]->getNumberOfValues()>1 && numberOfKernels!=weight_args[0]->getNumberOfValues() ) {
+      error("mismatch between numbers of values in input arguments and HEIGHTS");
+    }
 
     if( weight_str.size()==2 ) {
       log.printf("  quantities used for weights are : %s \n", weight_str[0].c_str() );
       args.push_back( weight_args[1] );
-      if( weight_args[1]->getRank()==1 && weight_args[1]->getNumberOfValues()!=shape.size() ) error("size of bandwidth vector is incorrect");
-      if( weight_args[1]->getRank()>2 ) error("bandwidths cannot have rank greater than 2");
-      bwargno=args.size()-1; log.printf("  bandwidths are taken from : %s \n", weight_str[1].c_str() );
+      if( weight_args[1]->getRank()==1 && weight_args[1]->getNumberOfValues()!=shape.size() ) {
+        error("size of bandwidth vector is incorrect");
+      }
+      if( weight_args[1]->getRank()>2 ) {
+        error("bandwidths cannot have rank greater than 2");
+      }
+      bwargno=args.size()-1;
+      log.printf("  bandwidths are taken from : %s \n", weight_str[1].c_str() );
     } else if( !hasheight ) {
-      if( weight_args[0]->getRank()==1 && weight_args[0]->getNumberOfValues()!=shape.size() ) error("size of bandwidth vector is incorrect");
-      if( weight_args[0]->getRank()>2 ) error("bandwidths cannot have rank greater than 2");
-      bwargno=args.size()-1; log.printf("  bandwidths are taken from : %s \n", weight_str[0].c_str() );
+      if( weight_args[0]->getRank()==1 && weight_args[0]->getNumberOfValues()!=shape.size() ) {
+        error("size of bandwidth vector is incorrect");
+      }
+      if( weight_args[0]->getRank()>2 ) {
+        error("bandwidths cannot have rank greater than 2");
+      }
+      bwargno=args.size()-1;
+      log.printf("  bandwidths are taken from : %s \n", weight_str[0].c_str() );
     } else if ( weight_str.size()==1 ) {
       log.printf("  quantities used for weights are : %s \n", weight_str[0].c_str() );
-    } else error("only one scalar/vector/matrix should be input to HEIGHTS");
+    } else {
+      error("only one scalar/vector/matrix should be input to HEIGHTS");
+    }
     requestArguments( args );
   }
 
   if( getName()=="KDE" ) {
-    bool hasauto=false; gmin.resize( shape.size() ); gmax.resize( shape.size() );
-    parseVector("GRID_MIN",gmin); parseVector("GRID_MAX",gmax);
+    bool hasauto=false;
+    gmin.resize( shape.size() );
+    gmax.resize( shape.size() );
+    parseVector("GRID_MIN",gmin);
+    parseVector("GRID_MAX",gmax);
     for(unsigned i=0; i<gmin.size(); ++i) {
       if( gmin[i]=="auto" ) {
         log.printf("  for %dth coordinate min and max are set from cell directions \n", (i+1) );
         hasauto=true;  // We need to do a preparation step to set the grid from the box size
-        if( gmax[i]!="auto" ) error("if gmin is set from box vectors gmax must also be set in the same way");
+        if( gmax[i]!="auto" ) {
+          error("if gmin is set from box vectors gmax must also be set in the same way");
+        }
         if( getPntrToArgument(i)->isPeriodic() ) {
-          if( gmin[i]=="auto" ) getPntrToArgument(i)->getDomain( gmin[i], gmax[i] );
-          else {
-            std::string str_min, str_max; getPntrToArgument(i)->getDomain( str_min, str_max );
-            if( str_min!=gmin[i] || str_max!=gmax[i] ) error("all periodic arguments should have the same domain");
+          if( gmin[i]=="auto" ) {
+            getPntrToArgument(i)->getDomain( gmin[i], gmax[i] );
+          } else {
+            std::string str_min, str_max;
+            getPntrToArgument(i)->getDomain( str_min, str_max );
+            if( str_min!=gmin[i] || str_max!=gmax[i] ) {
+              error("all periodic arguments should have the same domain");
+            }
           }
         } else if( getPntrToArgument(i)->getName().find(".")!=std::string::npos ) {
           std::size_t dot = getPntrToArgument(i)->getName().find_first_of(".");
@@ -209,94 +255,145 @@ KDE::KDE(const ActionOptions&ao):
         log.printf("  for %dth coordinate min is set to %s and max is set to %s \n", (i+1), gmin[i].c_str(), gmax[i].c_str() );
       }
     }
-    if( hasauto && gmin.size()>3 ) error("can only set GRID_MIN and GRID_MAX automatically if components of distance are used in input");
+    if( hasauto && gmin.size()>3 ) {
+      error("can only set GRID_MIN and GRID_MAX automatically if components of distance are used in input");
+    }
 
-    parseVector("GRID_BIN",nbin); parseVector("GRID_SPACING",gspacing); parse("CUTOFF",dp2cutoff);
+    parseVector("GRID_BIN",nbin);
+    parseVector("GRID_SPACING",gspacing);
+    parse("CUTOFF",dp2cutoff);
     if( kerneltype.find("bin")==std::string::npos && kerneltype!="DISCRETE" ) {
-      std::string errors; switchingFunction.set( kerneltype + " R_0=1.0 NOSTRETCH", errors );
-      if( errors.length()!=0 ) error("problem reading switching function description " + errors);
+      std::string errors;
+      switchingFunction.set( kerneltype + " R_0=1.0 NOSTRETCH", errors );
+      if( errors.length()!=0 ) {
+        error("problem reading switching function description " + errors);
+      }
     }
 
-    if( nbin.size()!=shape.size() && gspacing.size()!=shape.size() ) error("GRID_BIN or GRID_SPACING must be set");
+    if( nbin.size()!=shape.size() && gspacing.size()!=shape.size() ) {
+      error("GRID_BIN or GRID_SPACING must be set");
+    }
     // Create a value
     std::vector<bool> ipbc( shape.size() );
     for(unsigned i=0; i<shape.size(); ++i) {
-      if( getPntrToArgument( i )->isPeriodic() || gmin[i]=="auto" ) ipbc[i]=true;
-      else ipbc[i]=false;
+      if( getPntrToArgument( i )->isPeriodic() || gmin[i]=="auto" ) {
+        ipbc[i]=true;
+      } else {
+        ipbc[i]=false;
+      }
     }
     gridobject.setup( "flat", ipbc, 0, 0.0 );
   } else {
-    if( shape.size()!=3 ) error("should have three coordinates in input to this action");
+    if( shape.size()!=3 ) {
+      error("should have three coordinates in input to this action");
+    }
 
-    parse("GRID_BIN",nbins); log.printf("  setting number of bins to %d \n", nbins );
-    parse("CONCENTRATION",von_misses_concentration); fixed_width=true;
+    parse("GRID_BIN",nbins);
+    log.printf("  setting number of bins to %d \n", nbins );
+    parse("CONCENTRATION",von_misses_concentration);
+    fixed_width=true;
     von_misses_norm = von_misses_concentration / ( 4*pi*sinh( von_misses_concentration ) );
     log.printf("  setting concentration parameter to %f \n", von_misses_concentration );
 
     // Create a value
     std::vector<bool> ipbc( shape.size(), false );
     double fib_cutoff = std::log( epsilon / von_misses_norm ) / von_misses_concentration;
-    gridobject.setup( "fibonacci", ipbc, nbins, fib_cutoff ); checkRead();
+    gridobject.setup( "fibonacci", ipbc, nbins, fib_cutoff );
+    checkRead();
 
     // Setup the grid
-    shape[0]=nbins; shape[1]=shape[2]=1;
+    shape[0]=nbins;
+    shape[1]=shape[2]=1;
   }
   parseFlag("IGNORE_IF_OUT_OF_RANGE",ignore_out_of_bounds);
-  if( ignore_out_of_bounds ) log.printf("  ignoring kernels that are outside of grid \n");
-  addValueWithDerivatives( shape ); setNotPeriodic();
+  if( ignore_out_of_bounds ) {
+    log.printf("  ignoring kernels that are outside of grid \n");
+  }
+  addValueWithDerivatives( shape );
+  setNotPeriodic();
   getPntrToComponent(0)->setDerivativeIsZeroWhenValueIsZero();
   // Make sure we store all the arguments
-  for(unsigned i=0; i<getNumberOfArguments(); ++i) getPntrToArgument(i)->buildDataStore();
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    getPntrToArgument(i)->buildDataStore();
+  }
   // Check for task reduction
-  updateTaskListReductionStatus(); setupOnFirstStep( false );
+  updateTaskListReductionStatus();
+  setupOnFirstStep( false );
 }
 
 void KDE::setupOnFirstStep( const bool incalc ) {
-  if( getName()=="SPHERICAL_KDE" ) return ;
+  if( getName()=="SPHERICAL_KDE" ) {
+    return ;
+  }
 
   for(unsigned i=0; i<getNumberOfDerivatives(); ++i) {
     if( gmin[i]=="auto" && incalc ) {
       double lcoord, ucoord;
-      PbcAction* bv = plumed.getActionSet().selectWithLabel<PbcAction*>("Box"); Tensor box( bv->getPbc().getBox() );
+      PbcAction* bv = plumed.getActionSet().selectWithLabel<PbcAction*>("Box");
+      Tensor box( bv->getPbc().getBox() );
       std::size_t dot = getPntrToArgument(i)->getName().find_first_of(".");
       std::string name = getPntrToArgument(i)->getName().substr(dot+1);
-      if( name=="x" ) { lcoord=-0.5*box(0,0); ucoord=0.5*box(0,0); }
-      else if( name=="y" ) { lcoord=-0.5*box(1,1); ucoord=0.5*box(1,1); }
-      else if( name=="z" ) { lcoord=-0.5*box(2,2); ucoord=0.5*box(2,2); }
-      else plumed_error();
+      if( name=="x" ) {
+        lcoord=-0.5*box(0,0);
+        ucoord=0.5*box(0,0);
+      } else if( name=="y" ) {
+        lcoord=-0.5*box(1,1);
+        ucoord=0.5*box(1,1);
+      } else if( name=="z" ) {
+        lcoord=-0.5*box(2,2);
+        ucoord=0.5*box(2,2);
+      } else {
+        plumed_error();
+      }
       // And convert to strings for bin and bmax
-      Tools::convert( lcoord, gmin[i] ); Tools::convert( ucoord, gmax[i] );
+      Tools::convert( lcoord, gmin[i] );
+      Tools::convert( ucoord, gmax[i] );
     }
     if( incalc ) {
       grid_diff_value.push_back( Value() );
-      if( gridobject.isPeriodic(i) ) grid_diff_value[i].setDomain( gmin[i], gmax[i] );
-      else grid_diff_value[i].setNotPeriodic();
+      if( gridobject.isPeriodic(i) ) {
+        grid_diff_value[i].setDomain( gmin[i], gmax[i] );
+      } else {
+        grid_diff_value[i].setNotPeriodic();
+      }
     }
   }
   // And setup the grid object
   gridobject.setBounds( gmin, gmax, nbin, gspacing );
   std::vector<unsigned> shape( gridobject.getNbin(true) );
   getPntrToComponent(0)->setShape( shape );
-  bool hasauto=false; for(unsigned i=0; i<gmin.size(); ++i) { if(gmin[i]=="auto" || gmax[i]=="auto" ) { hasauto=true; break; } }
+  bool hasauto=false;
+  for(unsigned i=0; i<gmin.size(); ++i) {
+    if(gmin[i]=="auto" || gmax[i]=="auto" ) {
+      hasauto=true;
+      break;
+    }
+  }
   // And setup the neighbors
   if( !hasauto && kerneltype!="DISCRETE" && getPntrToArgument(bwargno)->isConstant() ) {
-    fixed_width=true; setupNeighborsVector();
+    fixed_width=true;
+    setupNeighborsVector();
   }
 }
 
 void KDE::setupNeighborsVector() {
   if( kerneltype!="DISCRETE" ) {
-    std::vector<double> support(gmin.size(),0); nneigh.resize( gmin.size() );
+    std::vector<double> support(gmin.size(),0);
+    nneigh.resize( gmin.size() );
     if( kerneltype.find("bin")!=std::string::npos ) {
       std::size_t dd = kerneltype.find("-bin");
-      HistogramBead bead; bead.setKernelType( kerneltype.substr(0,dd) );
+      HistogramBead bead;
+      bead.setKernelType( kerneltype.substr(0,dd) );
       Value* bw_arg=getPntrToArgument(bwargno);
       if( bw_arg->getRank()<2 ) {
         for(unsigned i=0; i<support.size(); ++i) {
           bead.set( 0, gridobject.getGridSpacing()[i], 1./sqrt(bw_arg->get(i)) );
-          support[i] = bead.getCutoff(); nneigh[i] = static_cast<unsigned>( ceil( support[i]/gridobject.getGridSpacing()[i] ));
+          support[i] = bead.getCutoff();
+          nneigh[i] = static_cast<unsigned>( ceil( support[i]/gridobject.getGridSpacing()[i] ));
         }
-      } else plumed_error();
+      } else {
+        plumed_error();
+      }
     } else {
       Value* bw_arg=getPntrToArgument(bwargno);
       if( bw_arg->getRank()<2 ) {
@@ -305,24 +402,41 @@ void KDE::setupNeighborsVector() {
           nneigh[i] = static_cast<unsigned>( ceil( support[i] / gridobject.getGridSpacing()[i] ) );
         }
       } else if( bw_arg->getRank()==2 ) {
-        Matrix<double> metric(support.size(),support.size()); unsigned k=0;
+        Matrix<double> metric(support.size(),support.size());
+        unsigned k=0;
         for(unsigned i=0; i<support.size(); ++i) {
-          for(unsigned j=0; j<support.size(); ++j) { metric(i,j)=bw_arg->get(k); k++; }
+          for(unsigned j=0; j<support.size(); ++j) {
+            metric(i,j)=bw_arg->get(k);
+            k++;
+          }
         }
-        Matrix<double> myautovec(support.size(),support.size()); std::vector<double> myautoval(support.size());
-        diagMat(metric,myautoval,myautovec); double maxautoval=1/myautoval[0]; unsigned ind_maxautoval=0;
+        Matrix<double> myautovec(support.size(),support.size());
+        std::vector<double> myautoval(support.size());
+        diagMat(metric,myautoval,myautovec);
+        double maxautoval=1/myautoval[0];
+        unsigned ind_maxautoval=0;
         for(unsigned i=1; i<support.size(); i++) {
-          double neweig=1/myautoval[i]; if(neweig>maxautoval) { maxautoval=neweig; ind_maxautoval=i; }
+          double neweig=1/myautoval[i];
+          if(neweig>maxautoval) {
+            maxautoval=neweig;
+            ind_maxautoval=i;
+          }
         }
         for(unsigned i=0; i<support.size(); i++) {
           support[i] = sqrt(2.0*dp2cutoff)*fabs(sqrt(maxautoval)*myautovec(i,ind_maxautoval));
           nneigh[i] = static_cast<unsigned>( ceil( support[i] / gridobject.getGridSpacing()[i] ) );
         }
-      } else plumed_error();
+      } else {
+        plumed_error();
+      }
     }
     for(unsigned i=0; i<gridobject.getDimension(); ++i) {
-      double fmax, fmin; Tools::convert( gridobject.getMin()[i], fmin ); Tools::convert( gridobject.getMax()[i], fmax );
-      if( gridobject.isPeriodic(i) && 2*support[i]>(fmax-fmin) ) error("bandwidth is too large for periodic grid");
+      double fmax, fmin;
+      Tools::convert( gridobject.getMin()[i], fmin );
+      Tools::convert( gridobject.getMax()[i], fmax );
+      if( gridobject.isPeriodic(i) && 2*support[i]>(fmax-fmin) ) {
+        error("bandwidth is too large for periodic grid");
+      }
     }
   }
 }
@@ -333,7 +447,9 @@ unsigned KDE::getNumberOfDerivatives() {
 
 std::vector<std::string> KDE::getGridCoordinateNames() const {
   std::vector<std::string> names( gridobject.getDimension() );
-  for(unsigned i=0; i<names.size(); ++i) names[i] = getPntrToArgument(i)->getName();
+  for(unsigned i=0; i<names.size(); ++i) {
+    names[i] = getPntrToArgument(i)->getName();
+  }
   return names;
 }
 
@@ -342,25 +458,41 @@ const GridCoordinatesObject& KDE::getGridCoordinatesObject() const {
 }
 
 void KDE::areAllTasksRequired( std::vector<ActionWithVector*>& task_reducing_actions ) {
-  if( numberOfKernels==1 || (hasheight && getPntrToArgument(gridobject.getDimension())->getRank()>0) ) task_reducing_actions.push_back(this);
+  if( numberOfKernels==1 || (hasheight && getPntrToArgument(gridobject.getDimension())->getRank()>0) ) {
+    task_reducing_actions.push_back(this);
+  }
 }
 
 void KDE::getNumberOfTasks( unsigned& ntasks ) {
-  if( !fixed_width ) setupNeighborsVector();
+  if( !fixed_width ) {
+    setupNeighborsVector();
+  }
   ntasks = numberOfKernels = getPntrToArgument(0)->getNumberOfValues();
-  if( numberOfKernels>1 ) return;
+  if( numberOfKernels>1 ) {
+    return;
+  }
 
-  hh = 1.0; if( hasheight ) hh = getPntrToArgument(gridobject.getDimension())->get();
-  for(unsigned i=0; i<center.size(); ++i) center[i]=getPntrToArgument(i)->get();
+  hh = 1.0;
+  if( hasheight ) {
+    hh = getPntrToArgument(gridobject.getDimension())->get();
+  }
+  for(unsigned i=0; i<center.size(); ++i) {
+    center[i]=getPntrToArgument(i)->get();
+  }
   if( !ignore_out_of_bounds && !gridobject.inbounds( center ) ) {
     //if( fabs(height)>epsilon ) warning("bounds are possibly set too small as hills with substantial heights are being ignored");
     return;
   }
   if( kerneltype=="DISCRETE" ) {
-    num_neigh=1; neighbors.resize(1);
-    for(unsigned i=0; i<center.size(); ++i) center[i] += 0.5*gridobject.getGridSpacing()[i];
+    num_neigh=1;
+    neighbors.resize(1);
+    for(unsigned i=0; i<center.size(); ++i) {
+      center[i] += 0.5*gridobject.getGridSpacing()[i];
+    }
     neighbors[0]=gridobject.getIndex( center );
-  } else gridobject.getNeighbors( center, nneigh, num_neigh, neighbors );
+  } else {
+    gridobject.getNeighbors( center, nneigh, num_neigh, neighbors );
+  }
   ntasks = getPntrToComponent(0)->getNumberOfValues();
   return;
 }
@@ -368,75 +500,121 @@ void KDE::getNumberOfTasks( unsigned& ntasks ) {
 int KDE::checkTaskStatus( const unsigned& taskno, int& flag ) const {
   if( numberOfKernels>1 ) {
     if( hasheight && getPntrToArgument(gridobject.getDimension())->getRank()>0
-        && fabs(getPntrToArgument(gridobject.getDimension())->get(taskno))<epsilon ) return 0;
+        && fabs(getPntrToArgument(gridobject.getDimension())->get(taskno))<epsilon ) {
+      return 0;
+    }
     return 1;
   }
   for(unsigned i=0; i<num_neigh; ++i) {
-    if( taskno==neighbors[i] ) return 1;
+    if( taskno==neighbors[i] ) {
+      return 1;
+    }
   }
   return 0;
 }
 
 void KDE::performTask( const unsigned& current, MultiValue& myvals ) const {
   if( numberOfKernels==1 ) {
-    double newval; std::vector<double> args( gridobject.getDimension() ), der( gridobject.getDimension() );
+    double newval;
+    std::vector<double> args( gridobject.getDimension() ), der( gridobject.getDimension() );
     unsigned valout = getConstPntrToComponent(0)->getPositionInStream();
     gridobject.getGridPointCoordinates( current, args );
     if( getName()=="KDE" ) {
       if( kerneltype=="DISCRETE" ) {
         newval = 1.0;
       } else if( kerneltype.find("bin")!=std::string::npos ) {
-        double val=hh; std::size_t dd = kerneltype.find("-bin");
-        HistogramBead bead; bead.setKernelType( kerneltype.substr(0,dd) ); Value* bw_arg=getPntrToArgument(bwargno);
+        double val=hh;
+        std::size_t dd = kerneltype.find("-bin");
+        HistogramBead bead;
+        bead.setKernelType( kerneltype.substr(0,dd) );
+        Value* bw_arg=getPntrToArgument(bwargno);
         for(unsigned j=0; j<args.size(); ++j) {
           if( gridobject.isPeriodic(j) ) {
-            double lcoord,  ucoord; Tools::convert( gmin[j], lcoord );
-            Tools::convert( gmax[j], ucoord ); bead.isPeriodic( lcoord, ucoord );
-          } else bead.isNotPeriodic();
-          if( bw_arg->getRank()<2 ) bead.set( args[j], args[j]+gridobject.getGridSpacing()[j], 1/sqrt(bw_arg->get(j)) );
-          else if( bw_arg->getRank()==2 ) plumed_error();
+            double lcoord,  ucoord;
+            Tools::convert( gmin[j], lcoord );
+            Tools::convert( gmax[j], ucoord );
+            bead.isPeriodic( lcoord, ucoord );
+          } else {
+            bead.isNotPeriodic();
+          }
+          if( bw_arg->getRank()<2 ) {
+            bead.set( args[j], args[j]+gridobject.getGridSpacing()[j], 1/sqrt(bw_arg->get(j)) );
+          } else if( bw_arg->getRank()==2 ) {
+            plumed_error();
+          }
           double contr = bead.calculateWithCutoff( args[j], der[j] );
-          val = val*contr; der[j] = der[j] / contr;
+          val = val*contr;
+          der[j] = der[j] / contr;
         }
-        for(unsigned j=0; j<args.size(); ++j) der[j] *= val; newval=val;
+        for(unsigned j=0; j<args.size(); ++j) {
+          der[j] *= val;
+        }
+        newval=val;
       } else {
         newval = evaluateKernel( args, center, hh, der );
       }
     } else {
-      double dot=0; for(unsigned i=0; i<der.size(); ++i) { dot += args[i]*center[i]; }
+      double dot=0;
+      for(unsigned i=0; i<der.size(); ++i) {
+        dot += args[i]*center[i];
+      }
       newval = hh*von_misses_norm*exp( von_misses_concentration*dot );
-      for(unsigned i=0; i<der.size(); ++i) der[i] = von_misses_concentration*newval*args[i];
+      for(unsigned i=0; i<der.size(); ++i) {
+        der[i] = von_misses_concentration*newval*args[i];
+      }
     }
     myvals.setValue( valout, newval );
-    for(unsigned i=0; i<der.size(); ++i) { myvals.addDerivative( valout, i, der[i] ); myvals.updateIndex( valout, i ); }
+    for(unsigned i=0; i<der.size(); ++i) {
+      myvals.addDerivative( valout, i, der[i] );
+      myvals.updateIndex( valout, i );
+    }
   }
 }
 
 void KDE::retrieveArgumentsAndHeight( const MultiValue& myvals, std::vector<double>& args, double& height ) const {
-  height=1.0; for(unsigned i=0; i<args.size(); ++i) args[i]=getPntrToArgument(i)->get( myvals.getTaskIndex() );
-  if( hasheight && getPntrToArgument(args.size())->getRank()==0 ) height = getPntrToArgument( args.size() )->get();
-  else if( hasheight ) height = getPntrToArgument( args.size() )->get( myvals.getTaskIndex() );
+  height=1.0;
+  for(unsigned i=0; i<args.size(); ++i) {
+    args[i]=getPntrToArgument(i)->get( myvals.getTaskIndex() );
+  }
+  if( hasheight && getPntrToArgument(args.size())->getRank()==0 ) {
+    height = getPntrToArgument( args.size() )->get();
+  } else if( hasheight ) {
+    height = getPntrToArgument( args.size() )->get( myvals.getTaskIndex() );
+  }
 }
 
 double KDE::evaluateKernel( const std::vector<double>& gpoint, const std::vector<double>& args, const double& height, std::vector<double>& der ) const {
-  double r2=0, hval = height; Value* bw_arg=getPntrToArgument(bwargno);
+  double r2=0, hval = height;
+  Value* bw_arg=getPntrToArgument(bwargno);
   if( bw_arg->getRank()<2 ) {
     for(unsigned j=0; j<der.size(); ++j) {
       double tmp = -grid_diff_value[j].difference( gpoint[j], args[j] );
-      der[j] = tmp*bw_arg->get(j); r2 += tmp*der[j];
+      der[j] = tmp*bw_arg->get(j);
+      r2 += tmp*der[j];
     }
   } else if( bw_arg->getRank()==2 ) {
     for(unsigned j=0; j<der.size(); ++j) {
-      der[j]=0; double dp_j, dp_k; dp_j = -grid_diff_value[j].difference( gpoint[j], args[j] );
+      der[j]=0;
+      double dp_j, dp_k;
+      dp_j = -grid_diff_value[j].difference( gpoint[j], args[j] );
       for(unsigned k=0; k<der.size(); ++k ) {
-        if(j==k) dp_k = dp_j;
-        else dp_k = -grid_diff_value[k].difference( gpoint[k], args[k] );
-        der[j] += bw_arg->get(j*der.size()+k)*dp_k; r2 += dp_j*dp_k*bw_arg->get(j*der.size()+k);
+        if(j==k) {
+          dp_k = dp_j;
+        } else {
+          dp_k = -grid_diff_value[k].difference( gpoint[k], args[k] );
+        }
+        der[j] += bw_arg->get(j*der.size()+k)*dp_k;
+        r2 += dp_j*dp_k*bw_arg->get(j*der.size()+k);
       }
     }
-  } else plumed_error();
+  } else {
+    plumed_error();
+  }
   double dval, val=hval*switchingFunction.calculateSqr( r2, dval );
-  dval *= hval; for(unsigned j=0; j<der.size(); ++j) der[j] *= dval;
+  dval *= hval;
+  for(unsigned j=0; j<der.size(); ++j) {
+    der[j] *= dval;
+  }
   return val;
 }
 
@@ -446,24 +624,34 @@ void KDE::setupHistogramBeads( std::vector<HistogramBead>& bead ) const {
   for(unsigned j=0; j<bead.size(); ++j) {
     bead[j].setKernelType( ktype );
     if( gridobject.isPeriodic(j) ) {
-      double lcoord,  ucoord; Tools::convert( gmin[j], lcoord );
-      Tools::convert( gmax[j], ucoord ); bead[j].isPeriodic( lcoord, ucoord );
-    } else bead[j].isNotPeriodic();
+      double lcoord,  ucoord;
+      Tools::convert( gmin[j], lcoord );
+      Tools::convert( gmax[j], ucoord );
+      bead[j].isPeriodic( lcoord, ucoord );
+    } else {
+      bead[j].isNotPeriodic();
+    }
   }
 }
 
 double KDE::evaluateBeadValue( std::vector<HistogramBead>& bead, const std::vector<double>& gpoint, const std::vector<double>& args,
                                const double& height, std::vector<double>& der ) const {
-  double val=height; std::vector<double> contr( args.size() ); Value* bw_arg=getPntrToArgument(bwargno);
+  double val=height;
+  std::vector<double> contr( args.size() );
+  Value* bw_arg=getPntrToArgument(bwargno);
   if( bw_arg->getRank()<2 ) {
     for(unsigned j=0; j<args.size(); ++j) {
       bead[j].set( gpoint[j], gpoint[j]+gridobject.getGridSpacing()[j], 1/sqrt(bw_arg->get(j)) );
       contr[j] = bead[j].calculateWithCutoff( args[j], der[j] );
       val = val*contr[j];
     }
-  } else plumed_error();
+  } else {
+    plumed_error();
+  }
   for(unsigned j=0; j<args.size(); ++j) {
-    if( fabs(contr[j])>epsilon ) der[j] *= val / contr[j];
+    if( fabs(contr[j])>epsilon ) {
+      der[j] *= val / contr[j];
+    }
   }
   return val;
 }
@@ -473,60 +661,86 @@ void KDE::gatherStoredValue( const unsigned& valindex, const unsigned& code, con
   plumed_dbg_assert( valindex==0 );
   if( numberOfKernels==1 ) {
     unsigned istart = bufstart + (1+gridobject.getDimension())*code;
-    unsigned valout = getConstPntrToComponent(0)->getPositionInStream(); buffer[istart] += myvals.get( valout );
-    for(unsigned i=0; i<gridobject.getDimension(); ++i) buffer[istart+1+i] += myvals.getDerivative( valout, i );
+    unsigned valout = getConstPntrToComponent(0)->getPositionInStream();
+    buffer[istart] += myvals.get( valout );
+    for(unsigned i=0; i<gridobject.getDimension(); ++i) {
+      buffer[istart+1+i] += myvals.getDerivative( valout, i );
+    }
     return;
   }
-  std::vector<double> args( gridobject.getDimension() ); double height; retrieveArgumentsAndHeight( myvals, args, height );
+  std::vector<double> args( gridobject.getDimension() );
+  double height;
+  retrieveArgumentsAndHeight( myvals, args, height );
   if( !ignore_out_of_bounds && !gridobject.inbounds( args ) ) {
     // if( fabs(height)>epsilon ) warning("bounds are possibly set too small as hills with substantial heights are being ignored");
     return ;
   }
   // Add the kernel to the grid
-  unsigned num_neigh; std::vector<unsigned> neighbors;
-  if( kerneltype!="DISCRETE" ) gridobject.getNeighbors( args, nneigh, num_neigh, neighbors );
+  unsigned num_neigh;
+  std::vector<unsigned> neighbors;
+  if( kerneltype!="DISCRETE" ) {
+    gridobject.getNeighbors( args, nneigh, num_neigh, neighbors );
+  }
   std::vector<double> der( args.size() ), gpoint( args.size() );
   if( fabs(height)>epsilon ) {
     if( getName()=="KDE" ) {
       if( kerneltype=="DISCRETE" ) {
         std::vector<double> newargs( args.size() );
-        for(unsigned i=0; i<args.size(); ++i) newargs[i] = args[i] + 0.5*gridobject.getGridSpacing()[i];
+        for(unsigned i=0; i<args.size(); ++i) {
+          newargs[i] = args[i] + 0.5*gridobject.getGridSpacing()[i];
+        }
         plumed_assert( bufstart + gridobject.getIndex( newargs )*(1+args.size())<buffer.size() );
         buffer[ bufstart + gridobject.getIndex( newargs )*(1+args.size()) ] += height;
       } else if( kerneltype.find("bin")!=std::string::npos ) {
-        std::vector<HistogramBead> bead( args.size() ); setupHistogramBeads( bead );
+        std::vector<HistogramBead> bead( args.size() );
+        setupHistogramBeads( bead );
         for(unsigned i=0; i<num_neigh; ++i) {
           gridobject.getGridPointCoordinates( neighbors[i], gpoint );
           double val = evaluateBeadValue( bead, gpoint, args, height, der );
           buffer[ bufstart + neighbors[i]*(1+der.size()) ] += val;
-          for(unsigned j=0; j<der.size(); ++j) buffer[ bufstart + neighbors[i]*(1+der.size()) + 1 + j ] += val*der[j];
+          for(unsigned j=0; j<der.size(); ++j) {
+            buffer[ bufstart + neighbors[i]*(1+der.size()) + 1 + j ] += val*der[j];
+          }
         }
       } else {
         for(unsigned i=0; i<num_neigh; ++i) {
           gridobject.getGridPointCoordinates( neighbors[i], gpoint );
           buffer[ bufstart + neighbors[i]*(1+der.size()) ] += evaluateKernel( gpoint, args, height, der );
-          for(unsigned j=0; j<der.size(); ++j) buffer[ bufstart + neighbors[i]*(1+der.size()) + 1 + j ] += der[j];
+          for(unsigned j=0; j<der.size(); ++j) {
+            buffer[ bufstart + neighbors[i]*(1+der.size()) + 1 + j ] += der[j];
+          }
         }
       }
     } else {
       for(unsigned i=0; i<num_neigh; ++i) {
         gridobject.getGridPointCoordinates( neighbors[i], gpoint );
-        double dot=0; for(unsigned j=0; j<gpoint.size(); ++j) dot += args[j]*gpoint[j];
+        double dot=0;
+        for(unsigned j=0; j<gpoint.size(); ++j) {
+          dot += args[j]*gpoint[j];
+        }
         double newval = height*von_misses_norm*exp( von_misses_concentration*dot );
         buffer[ bufstart + neighbors[i]*(1+gpoint.size()) ] += newval;
-        for(unsigned j=0; j<gpoint.size(); ++j) buffer[ bufstart + neighbors[i]*(1+gpoint.size()) + 1 + j ] += von_misses_concentration*newval*gpoint[j];
+        for(unsigned j=0; j<gpoint.size(); ++j) {
+          buffer[ bufstart + neighbors[i]*(1+gpoint.size()) + 1 + j ] += von_misses_concentration*newval*gpoint[j];
+        }
       }
     }
   }
 }
 
 void KDE::updateForceTasksFromValue( const Value* myval, std::vector<unsigned>& force_tasks ) const {
-  if( !myval->forcesWereAdded() ) return ;
-  if( numberOfKernels==1 ) plumed_error();
+  if( !myval->forcesWereAdded() ) {
+    return ;
+  }
+  if( numberOfKernels==1 ) {
+    plumed_error();
+  }
 
   int flag=1;
   for(unsigned i=0; i<numberOfKernels; ++i) {
-    if( checkTaskStatus( i, flag ) ) force_tasks.push_back(i);
+    if( checkTaskStatus( i, flag ) ) {
+      force_tasks.push_back(i);
+    }
   }
 }
 
@@ -535,40 +749,72 @@ void KDE::gatherForcesOnStoredValue( const Value* myval, const unsigned& itask,
     plumed_error();
     return;
   }
-  double height; std::vector<double> args( gridobject.getDimension() );
+  double height;
+  std::vector<double> args( gridobject.getDimension() );
   retrieveArgumentsAndHeight( myvals, args, height );
-  unsigned num_neigh; std::vector<unsigned> neighbors;
+  unsigned num_neigh;
+  std::vector<unsigned> neighbors;
   gridobject.getNeighbors( args, nneigh, num_neigh, neighbors );
   std::vector<double> der( args.size() ), gpoint( args.size() );
-  unsigned hforce_start = 0; for(unsigned j=0; j<der.size(); ++j) hforce_start += getPntrToArgument(j)->getNumberOfStoredValues();
+  unsigned hforce_start = 0;
+  for(unsigned j=0; j<der.size(); ++j) {
+    hforce_start += getPntrToArgument(j)->getNumberOfStoredValues();
+  }
   if( fabs(height)>epsilon ) {
     if( getName()=="KDE" ) {
       if( kerneltype.find("bin")!=std::string::npos ) {
-        std::vector<HistogramBead> bead( args.size() ); setupHistogramBeads( bead );
+        std::vector<HistogramBead> bead( args.size() );
+        setupHistogramBeads( bead );
         for(unsigned i=0; i<num_neigh; ++i) {
           gridobject.getGridPointCoordinates( neighbors[i], gpoint );
-          double val = evaluateBeadValue( bead, gpoint, args, height, der ); double fforce = getConstPntrToComponent(0)->getForce( neighbors[i] );
-          if( hasheight && getPntrToArgument(args.size())->getRank()==0 ) forces[ hforce_start ] += val*fforce / height;
-          else if( hasheight ) forces[ hforce_start + getPntrToArgument(args.size())->getIndexInStore(itask) ] += val*fforce / height;
-          unsigned n=0; for(unsigned j=0; j<der.size(); ++j) { forces[n + getPntrToArgument(j)->getIndexInStore(itask)] += der[j]*fforce; n += getPntrToArgument(j)->getNumberOfStoredValues(); }
+          double val = evaluateBeadValue( bead, gpoint, args, height, der );
+          double fforce = getConstPntrToComponent(0)->getForce( neighbors[i] );
+          if( hasheight && getPntrToArgument(args.size())->getRank()==0 ) {
+            forces[ hforce_start ] += val*fforce / height;
+          } else if( hasheight ) {
+            forces[ hforce_start + getPntrToArgument(args.size())->getIndexInStore(itask) ] += val*fforce / height;
+          }
+          unsigned n=0;
+          for(unsigned j=0; j<der.size(); ++j) {
+            forces[n + getPntrToArgument(j)->getIndexInStore(itask)] += der[j]*fforce;
+            n += getPntrToArgument(j)->getNumberOfStoredValues();
+          }
         }
       } else {
         for(unsigned i=0; i<num_neigh; ++i) {
           gridobject.getGridPointCoordinates( neighbors[i], gpoint );
           double val = evaluateKernel( gpoint, args, height, der ), fforce = getConstPntrToComponent(0)->getForce( neighbors[i] );
-          if( hasheight && getPntrToArgument(args.size())->getRank()==0 ) forces[ hforce_start ] += val*fforce / height;
-          else if( hasheight ) forces[ hforce_start + getPntrToArgument(args.size())->getIndexInStore(itask) ] += val*fforce / height;
-          unsigned n=0; for(unsigned j=0; j<der.size(); ++j) { forces[n + getPntrToArgument(j)->getIndexInStore(itask)] += -der[j]*fforce; n += getPntrToArgument(j)->getNumberOfStoredValues(); }
+          if( hasheight && getPntrToArgument(args.size())->getRank()==0 ) {
+            forces[ hforce_start ] += val*fforce / height;
+          } else if( hasheight ) {
+            forces[ hforce_start + getPntrToArgument(args.size())->getIndexInStore(itask) ] += val*fforce / height;
+          }
+          unsigned n=0;
+          for(unsigned j=0; j<der.size(); ++j) {
+            forces[n + getPntrToArgument(j)->getIndexInStore(itask)] += -der[j]*fforce;
+            n += getPntrToArgument(j)->getNumberOfStoredValues();
+          }
         }
       }
     } else {
       for(unsigned i=0; i<num_neigh; ++i) {
         gridobject.getGridPointCoordinates( neighbors[i], gpoint );
-        double dot=0; for(unsigned j=0; j<gpoint.size(); ++j) dot += args[j]*gpoint[j];
-        double fforce = myval->getForce( neighbors[i] ); double newval = height*von_misses_norm*exp( von_misses_concentration*dot );
-        if( hasheight && getPntrToArgument(args.size())->getRank()==0 ) forces[ hforce_start ] += newval*fforce / height;
-        else if( hasheight ) forces[ hforce_start + getPntrToArgument(args.size())->getIndexInStore(itask) ] += newval*fforce / height;
-        unsigned n=0; for(unsigned j=0; j<gpoint.size(); ++j) { forces[n + getPntrToArgument(j)->getIndexInStore(itask)] += von_misses_concentration*newval*gpoint[j]*fforce; n += getPntrToArgument(j)->getNumberOfStoredValues(); }
+        double dot=0;
+        for(unsigned j=0; j<gpoint.size(); ++j) {
+          dot += args[j]*gpoint[j];
+        }
+        double fforce = myval->getForce( neighbors[i] );
+        double newval = height*von_misses_norm*exp( von_misses_concentration*dot );
+        if( hasheight && getPntrToArgument(args.size())->getRank()==0 ) {
+          forces[ hforce_start ] += newval*fforce / height;
+        } else if( hasheight ) {
+          forces[ hforce_start + getPntrToArgument(args.size())->getIndexInStore(itask) ] += newval*fforce / height;
+        }
+        unsigned n=0;
+        for(unsigned j=0; j<gpoint.size(); ++j) {
+          forces[n + getPntrToArgument(j)->getIndexInStore(itask)] += von_misses_concentration*newval*gpoint[j]*fforce;
+          n += getPntrToArgument(j)->getNumberOfStoredValues();
+        }
       }
     }
   }
diff --git a/src/gridtools/KLEntropy.cpp b/src/gridtools/KLEntropy.cpp
index e41845373d..9c0896b9dc 100644
--- a/src/gridtools/KLEntropy.cpp
+++ b/src/gridtools/KLEntropy.cpp
@@ -49,18 +49,24 @@ void KLEntropy::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","REFERENCE","a file containing the reference density in grid format");
   keys.add("compulsory","VALUE","the name of the value that should be read from the grid");
   keys.setValueDescription("the value of the KL-Entropy");
-  keys.needsAction("REFERENCE_GRID"); keys.needsAction("CUSTOM"); keys.needsAction("INTEGRATE_GRID");
+  keys.needsAction("REFERENCE_GRID");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("INTEGRATE_GRID");
 }
 
 KLEntropy::KLEntropy( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Reference grid object
-  std::string ref_str, val_str, input_g; parse("VALUE",val_str); parse("REFERENCE",ref_str); parse("ARG",input_g);
+  std::string ref_str, val_str, input_g;
+  parse("VALUE",val_str);
+  parse("REFERENCE",ref_str);
+  parse("ARG",input_g);
   readInputLine( getShortcutLabel() + "_ref: REFERENCE_GRID VALUE=" + val_str + " FILE=" + ref_str );
   // Compute KL divergence
-  if( input_g=="") plumed_merror("could not find ARG keyword in input to KL_ENTROPY");
+  if( input_g=="") {
+    plumed_merror("could not find ARG keyword in input to KL_ENTROPY");
+  }
   readInputLine( getShortcutLabel()  + "_kl: CUSTOM ARG=" + input_g + "," + getShortcutLabel() + "_ref FUNC=y*log(y/(0.5*(x+y))) PERIODIC=NO");
   // Compute integral
   readInputLine( getShortcutLabel() + ": INTEGRATE_GRID ARG=" + getShortcutLabel() + "_kl PERIODIC=NO");
diff --git a/src/gridtools/MultiColvarDensity.cpp b/src/gridtools/MultiColvarDensity.cpp
index a51b83f557..f76404bbe0 100644
--- a/src/gridtools/MultiColvarDensity.cpp
+++ b/src/gridtools/MultiColvarDensity.cpp
@@ -99,37 +99,76 @@ void MultiColvarDensity::registerKeywords( Keywords& keys ) {
   keys.addFlag("UNORMALIZED",false,"do not divide by the density");
   keys.add("optional","NORMALIZATION","set true/false to determine how to the data is normalised");
   keys.setValueDescription("the average value of the order parameters at each point on the grid");
-  keys.needsAction("DISTANCES"); keys.needsAction("KDE"); keys.needsAction("ACCUMULATE");
-  keys.needsAction("CUSTOM"); keys.needsAction("ONES"); keys.needsAction("CUSTOM");
+  keys.needsAction("DISTANCES");
+  keys.needsAction("KDE");
+  keys.needsAction("ACCUMULATE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("ONES");
+  keys.needsAction("CUSTOM");
 }
 
 MultiColvarDensity::MultiColvarDensity(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in the position of the origin
-  std::string origin_str; parse("ORIGIN",origin_str);
+  std::string origin_str;
+  parse("ORIGIN",origin_str);
   // Read in the quantity we are calculating the density for
-  std::string atoms_str, data_str; parse("ATOMS",atoms_str); parse("DATA",data_str);
-  if( atoms_str.length()==0 && data_str.length()==0 ) error("quantity to calculate the density for was not specified used DATA/ATOMS");
+  std::string atoms_str, data_str;
+  parse("ATOMS",atoms_str);
+  parse("DATA",data_str);
+  if( atoms_str.length()==0 && data_str.length()==0 ) {
+    error("quantity to calculate the density for was not specified used DATA/ATOMS");
+  }
   // Get the information on the direction for the density
-  std::string dir, direction_string; parse("DIR",dir); std::string nbins=""; parse("NBINS",nbins); if(nbins.length()>0) nbins=" GRID_BIN=" + nbins;
-  if( dir=="x" ) direction_string = "ARG=" + getShortcutLabel() + "_dist.x " + nbins;
-  else if( dir=="y" ) direction_string = "ARG=" + getShortcutLabel() + "_dist.y " + nbins;
-  else if( dir=="z" ) direction_string = "ARG=" + getShortcutLabel() + "_dist.z " + nbins;
-  else if( dir=="xy" ) direction_string = "ARG=" + getShortcutLabel() + "_dist.x," + getShortcutLabel() + "_dist.y " + nbins;
-  else if( dir=="xz" ) direction_string = "ARG=" + getShortcutLabel() + "_dist.x," + getShortcutLabel() + "_dist.z " + nbins;
-  else if( dir=="yz" ) direction_string = "ARG=" + getShortcutLabel() + "_dist.y," + getShortcutLabel() + "_dist.z " + nbins;
-  else if( dir=="xyz" ) direction_string = "ARG=" + getShortcutLabel() + "_dist.x," + getShortcutLabel() + "_dist.y," + getShortcutLabel() + "_dist.z " + nbins;
-  else error( dir + " is invalid dir specification use x/y/z/xy/xz/yz/xyz");
+  std::string dir, direction_string;
+  parse("DIR",dir);
+  std::string nbins="";
+  parse("NBINS",nbins);
+  if(nbins.length()>0) {
+    nbins=" GRID_BIN=" + nbins;
+  }
+  if( dir=="x" ) {
+    direction_string = "ARG=" + getShortcutLabel() + "_dist.x " + nbins;
+  } else if( dir=="y" ) {
+    direction_string = "ARG=" + getShortcutLabel() + "_dist.y " + nbins;
+  } else if( dir=="z" ) {
+    direction_string = "ARG=" + getShortcutLabel() + "_dist.z " + nbins;
+  } else if( dir=="xy" ) {
+    direction_string = "ARG=" + getShortcutLabel() + "_dist.x," + getShortcutLabel() + "_dist.y " + nbins;
+  } else if( dir=="xz" ) {
+    direction_string = "ARG=" + getShortcutLabel() + "_dist.x," + getShortcutLabel() + "_dist.z " + nbins;
+  } else if( dir=="yz" ) {
+    direction_string = "ARG=" + getShortcutLabel() + "_dist.y," + getShortcutLabel() + "_dist.z " + nbins;
+  } else if( dir=="xyz" ) {
+    direction_string = "ARG=" + getShortcutLabel() + "_dist.x," + getShortcutLabel() + "_dist.y," + getShortcutLabel() + "_dist.z " + nbins;
+  } else {
+    error( dir + " is invalid dir specification use x/y/z/xy/xz/yz/xyz");
+  }
 
   // Parse the keymap for this averaging stuff
-  std::string stride, clear; parse("STRIDE",stride); parse("CLEAR",clear); bool unorm; parseFlag("UNORMALIZED",unorm);
-  if( !unorm ) { std::string normstr; parse("NORMALIZATION",normstr); if( normstr=="false" ) unorm=true; }
+  std::string stride, clear;
+  parse("STRIDE",stride);
+  parse("CLEAR",clear);
+  bool unorm;
+  parseFlag("UNORMALIZED",unorm);
+  if( !unorm ) {
+    std::string normstr;
+    parse("NORMALIZATION",normstr);
+    if( normstr=="false" ) {
+      unorm=true;
+    }
+  }
   // Create distance action
-  bool hasheights; std::string dist_words = getShortcutLabel() + "_dist: DISTANCES COMPONENTS ORIGIN=" + origin_str;
-  if( atoms_str.length()>0 ) { hasheights=false; dist_words += " ATOMS=" + atoms_str; }
-  else { hasheights=true; dist_words += " ATOMS=" + data_str; }
+  bool hasheights;
+  std::string dist_words = getShortcutLabel() + "_dist: DISTANCES COMPONENTS ORIGIN=" + origin_str;
+  if( atoms_str.length()>0 ) {
+    hasheights=false;
+    dist_words += " ATOMS=" + atoms_str;
+  } else {
+    hasheights=true;
+    dist_words += " ATOMS=" + data_str;
+  }
   // plumed_massert( keys.count("ORIGIN"), "you must specify the position of the origin" );
   readInputLine( dist_words );
 
@@ -137,8 +176,12 @@ MultiColvarDensity::MultiColvarDensity(const ActionOptions&ao):
   // Make the kde object for the numerator if needed
   if( hasheights ) {
     readInputLine( getShortcutLabel() + "_inumer: KDE VOLUMES=" + data_str + " " + direction_string + " " + inputLine );
-    if( unorm ) { readInputLine( getShortcutLabel() + ": ACCUMULATE ARG=" + getShortcutLabel() + "_inumer STRIDE=" + stride + " CLEAR=" + clear ); return; }
-    else readInputLine( getShortcutLabel() + "_numer: ACCUMULATE ARG=" + getShortcutLabel() + "_inumer STRIDE=" + stride + " CLEAR=" + clear );
+    if( unorm ) {
+      readInputLine( getShortcutLabel() + ": ACCUMULATE ARG=" + getShortcutLabel() + "_inumer STRIDE=" + stride + " CLEAR=" + clear );
+      return;
+    } else {
+      readInputLine( getShortcutLabel() + "_numer: ACCUMULATE ARG=" + getShortcutLabel() + "_inumer STRIDE=" + stride + " CLEAR=" + clear );
+    }
   }
   // Make the kde object
   readInputLine( getShortcutLabel() + "_kde: KDE " + inputLine  + " " + direction_string );
diff --git a/src/gridtools/PairEntropies.cpp b/src/gridtools/PairEntropies.cpp
index 59db395548..5ef52e9cd6 100644
--- a/src/gridtools/PairEntropies.cpp
+++ b/src/gridtools/PairEntropies.cpp
@@ -44,39 +44,59 @@ class PairEntropies : public ActionShortcut {
 PLUMED_REGISTER_ACTION(PairEntropies,"PAIRENTROPIES")
 
 void PairEntropies::registerKeywords( Keywords& keys ) {
-  RDF::registerKeywords( keys ); keys.remove("GROUP"); keys.remove("GROUPA"); keys.remove("GROUPB");
+  RDF::registerKeywords( keys );
+  keys.remove("GROUP");
+  keys.remove("GROUPA");
+  keys.remove("GROUPB");
   keys.add("atoms","ATOMS","the atoms that you would like to compute the entropies for");
   keys.setValueDescription("the a vector containing the KL-entropy that is computed from the radial distribution function around each of the atoms in the input");
-  keys.needsAction("PAIRENTROPY"); keys.needsAction("INTERPOLATE_GRID");
-  keys.needsAction("INTEGRATE_GRID"); keys.needsAction("CUSTOM");
+  keys.needsAction("PAIRENTROPY");
+  keys.needsAction("INTERPOLATE_GRID");
+  keys.needsAction("INTEGRATE_GRID");
+  keys.needsAction("CUSTOM");
   keys.needsAction("CONCATENATE");
 }
 
 PairEntropies::PairEntropies(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in the atoms involved
-  std::string atoms_str; parse("ATOMS",atoms_str);
+  std::string atoms_str;
+  parse("ATOMS",atoms_str);
   // Create the x2 value
-  std::string maxr, nbins, dens; parse("MAXR",maxr); parse("GRID_BIN",nbins); parse("DENSITY",dens);
+  std::string maxr, nbins, dens;
+  parse("MAXR",maxr);
+  parse("GRID_BIN",nbins);
+  parse("DENSITY",dens);
   std::string grid_setup = "GRID_MIN=0 GRID_MAX=" + maxr + " GRID_BIN=" + nbins;
   RDF::createX2ReferenceObject( getShortcutLabel(), grid_setup, dens.length()==0, this );
   // Create the number of input atoms
   std::string pair_str = "GRID_BIN=" + nbins + " MAXR=" + maxr + " " + convertInputLineToString();
-  std::vector<std::string> awords=Tools::getWords(atoms_str,"\t\n ,"); Tools::interpretRanges( awords );
+  std::vector<std::string> awords=Tools::getWords(atoms_str,"\t\n ,");
+  Tools::interpretRanges( awords );
   // Now create all the pairentropy objects
   for(unsigned i=0; i<awords.size(); ++i) {
-    std::string ilab, jlab, atoms_str2; Tools::convert( awords[i], ilab );
+    std::string ilab, jlab, atoms_str2;
+    Tools::convert( awords[i], ilab );
     for(unsigned j=0; j<awords.size(); ++j) {
-      if( awords[i]==awords[j] ) continue; Tools::convert( awords[j], jlab );
-      if( atoms_str2.length()==0 ) atoms_str2 = jlab; else atoms_str2 += "," + jlab;
+      if( awords[i]==awords[j] ) {
+        continue;
+      }
+      Tools::convert( awords[j], jlab );
+      if( atoms_str2.length()==0 ) {
+        atoms_str2 = jlab;
+      } else {
+        atoms_str2 += "," + jlab;
+      }
     }
     readInputLine( getShortcutLabel() + ilab + ": PAIRENTROPY GROUPA=" + ilab + " GROUPB=" + atoms_str2 + " " + pair_str + " REFERENCE=" + getShortcutLabel() );
   }
   // And compose a vector containing the values of all the pair entropies
   std::string num, argstr = "ARG=" + getShortcutLabel() + "1";
-  for(unsigned i=1; i<awords.size(); ++i) { Tools::convert( i+1, num ); argstr += "," + getShortcutLabel() + num; }
+  for(unsigned i=1; i<awords.size(); ++i) {
+    Tools::convert( i+1, num );
+    argstr += "," + getShortcutLabel() + num;
+  }
   readInputLine( getShortcutLabel() + ": CONCATENATE " + argstr );
 }
 
diff --git a/src/gridtools/PairEntropy.cpp b/src/gridtools/PairEntropy.cpp
index 26ad720034..d1e1989582 100644
--- a/src/gridtools/PairEntropy.cpp
+++ b/src/gridtools/PairEntropy.cpp
@@ -44,33 +44,51 @@ class PairEntropy : public ActionShortcut {
 PLUMED_REGISTER_ACTION(PairEntropy,"PAIRENTROPY")
 
 void PairEntropy::registerKeywords( Keywords& keys ) {
-  RDF::registerKeywords( keys ); keys.needsAction("RDF");
+  RDF::registerKeywords( keys );
+  keys.needsAction("RDF");
   keys.setValueDescription("the KL-entropy that is computed from the radial distribution function");
-  keys.needsAction("INTERPOLATE_GRID"); keys.needsAction("INTEGRATE_GRID");
+  keys.needsAction("INTERPOLATE_GRID");
+  keys.needsAction("INTEGRATE_GRID");
 }
 
 PairEntropy::PairEntropy(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string ref_str, ref_name; parse("REFERENCE",ref_name);
-  if( ref_name.length()>0 ) ref_str = "REFERENCE=" + ref_name; else ref_name = getShortcutLabel() + "_rdf";
+  ActionShortcut(ao) {
+  std::string ref_str, ref_name;
+  parse("REFERENCE",ref_name);
+  if( ref_name.length()>0 ) {
+    ref_str = "REFERENCE=" + ref_name;
+  } else {
+    ref_name = getShortcutLabel() + "_rdf";
+  }
   // Read in the atoms and get the number of atoms that we are using
-  std::string atom_str, group_str, natoms; parse("GROUP",group_str);
+  std::string atom_str, group_str, natoms;
+  parse("GROUP",group_str);
   if( group_str.length()>0 ) {
     atom_str="GROUP=" + group_str;
     std::vector<std::string> awords=Tools::getWords(group_str,"\t\n ,");
-    Tools::interpretRanges( awords ); Tools::convert( awords.size(), natoms );
+    Tools::interpretRanges( awords );
+    Tools::convert( awords.size(), natoms );
   } else {
     std::string groupa_str, groupb_str;
-    parse("GROUPA",groupa_str); parse("GROUPB",groupb_str);
+    parse("GROUPA",groupa_str);
+    parse("GROUPB",groupb_str);
     atom_str="GROUPA=" + groupa_str + " GROUPB=" + groupb_str;
     std::vector<std::string> awords=Tools::getWords(groupb_str,"\t\n ,");
-    Tools::interpretRanges( awords ); Tools::convert( awords.size()+1, natoms );
+    Tools::interpretRanges( awords );
+    Tools::convert( awords.size()+1, natoms );
   }
   // Read in all other keywords and create the RDF object
-  std::string maxr, nbins, dens, bw, cutoff; parse("MAXR",maxr); parse("GRID_BIN",nbins); parse("DENSITY",dens); parse("BANDWIDTH",bw); parse("CUTOFF",cutoff);
-  std::string dens_str; if( dens.length()>0 ) dens_str = " DENSITY=" + dens;
+  std::string maxr, nbins, dens, bw, cutoff;
+  parse("MAXR",maxr);
+  parse("GRID_BIN",nbins);
+  parse("DENSITY",dens);
+  parse("BANDWIDTH",bw);
+  parse("CUTOFF",cutoff);
+  std::string dens_str;
+  if( dens.length()>0 ) {
+    dens_str = " DENSITY=" + dens;
+  }
   readInputLine( getShortcutLabel() + "_rdf: RDF " + atom_str + " CUTOFF=" + cutoff + " GRID_BIN=" + nbins + " MAXR=" + maxr + dens_str + " BANDWIDTH=" + bw + " " + ref_str);
   // And compute the two functions we are integrating (we use two matheval objects here and sum them in order to avoid nans from taking logarithms of zero)
   readInputLine( getShortcutLabel() + "_conv_t1: CUSTOM ARG=" + getShortcutLabel() + "_rdf," + ref_name + "_x2 FUNC=x*y*log(x) PERIODIC=NO");
@@ -81,8 +99,11 @@ PairEntropy::PairEntropy(const ActionOptions&ao):
   readInputLine( getShortcutLabel() + "_int: INTEGRATE_GRID ARG=" + getShortcutLabel() + "_midp PERIODIC=NO"); // And then integrate
   // And multiply by final normalizing constant
   std::string norm_str;
-  if( dens.length()>0 ) norm_str = " FUNC=-2*pi*x*" + dens;
-  else norm_str = "," + ref_name + "_vol FUNC=-(2*pi*x/y)*" + natoms;
+  if( dens.length()>0 ) {
+    norm_str = " FUNC=-2*pi*x*" + dens;
+  } else {
+    norm_str = "," + ref_name + "_vol FUNC=-(2*pi*x/y)*" + natoms;
+  }
   readInputLine( getShortcutLabel() + ": CUSTOM PERIODIC=NO ARG=" + getShortcutLabel() + "_int" + norm_str );
 }
 
diff --git a/src/gridtools/RDF.cpp b/src/gridtools/RDF.cpp
index 1716d5cd14..c4b99128ec 100644
--- a/src/gridtools/RDF.cpp
+++ b/src/gridtools/RDF.cpp
@@ -40,7 +40,9 @@ void RDF::createX2ReferenceObject( const std::string& lab, const std::string& gr
   // Create grid with normalizing function
   action->readInputLine( lab  + "_x2: REFERENCE_GRID PERIODIC=NO FUNC=x*x " + grid_setup );
   // Compute density if required
-  if( calc_dens ) action->readInputLine( lab + "_vol: VOLUME" );
+  if( calc_dens ) {
+    action->readInputLine( lab + "_vol: VOLUME" );
+  }
 }
 
 void RDF::registerKeywords( Keywords& keys ) {
@@ -58,44 +60,68 @@ void RDF::registerKeywords( Keywords& keys ) {
   keys.add("optional","DENSITY","the reference density to use when normalizing the RDF");
   keys.add("hidden","REFERENCE","this is the label of the reference objects");
   keys.setValueDescription("the radial distribution function");
-  keys.needsAction("REFERENCE_GRID"); keys.needsAction("VOLUME"); keys.needsAction("DISTANCE_MATRIX");
-  keys.needsAction("CUSTOM"); keys.needsAction("KDE"); keys.needsAction("ACCUMULATE");
+  keys.needsAction("REFERENCE_GRID");
+  keys.needsAction("VOLUME");
+  keys.needsAction("DISTANCE_MATRIX");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("KDE");
+  keys.needsAction("ACCUMULATE");
   keys.needsAction("CONSTANT");
 }
 
 RDF::RDF(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in grid extent and number of bins
-  std::string maxr, nbins, dens; parse("MAXR",maxr); parse("GRID_BIN",nbins); parse("DENSITY",dens);
+  std::string maxr, nbins, dens;
+  parse("MAXR",maxr);
+  parse("GRID_BIN",nbins);
+  parse("DENSITY",dens);
   std::string grid_setup = "GRID_MIN=0 GRID_MAX=" + maxr + " GRID_BIN=" + nbins;
   // Create grid with normalizing function on it
-  std::string refstr; parse("REFERENCE",refstr);
+  std::string refstr;
+  parse("REFERENCE",refstr);
   if( refstr.length()==0 ) {
-    createX2ReferenceObject( getShortcutLabel(), grid_setup, dens.length()==0, this ); refstr = getShortcutLabel();
+    createX2ReferenceObject( getShortcutLabel(), grid_setup, dens.length()==0, this );
+    refstr = getShortcutLabel();
   }
   // Read input to histogram
-  std::string cutoff, kernel, bandwidth, kernel_data; parse("KERNEL",kernel);
+  std::string cutoff, kernel, bandwidth, kernel_data;
+  parse("KERNEL",kernel);
   if( kernel=="DISCRETE" ) {
-    cutoff = maxr; kernel_data="KERNEL=DISCRETE";
+    cutoff = maxr;
+    kernel_data="KERNEL=DISCRETE";
     warning("rdf is normalised by dividing by the surface area at the grid value and not by the volume of the bin as it should be with discrete kernels");
   } else {
-    parse("BANDWIDTH",bandwidth); double rcut; parse("CUTOFF",rcut); kernel_data="KERNEL=" + kernel + " IGNORE_IF_OUT_OF_RANGE BANDWIDTH=" + bandwidth;
-    double bw; Tools::convert( bandwidth, bw ); double fcut; Tools::convert( maxr, fcut ); Tools::convert( fcut + sqrt(2.0*rcut)*bw, cutoff );
+    parse("BANDWIDTH",bandwidth);
+    double rcut;
+    parse("CUTOFF",rcut);
+    kernel_data="KERNEL=" + kernel + " IGNORE_IF_OUT_OF_RANGE BANDWIDTH=" + bandwidth;
+    double bw;
+    Tools::convert( bandwidth, bw );
+    double fcut;
+    Tools::convert( maxr, fcut );
+    Tools::convert( fcut + sqrt(2.0*rcut)*bw, cutoff );
   }
 
   // Create contact matrix
-  std::string natoms, str_norm_atoms, atom_str, group_str, groupa_str, groupb_str; parse("GROUP",group_str);
+  std::string natoms, str_norm_atoms, atom_str, group_str, groupa_str, groupb_str;
+  parse("GROUP",group_str);
   if( group_str.length()>0 ) {
-    atom_str="GROUP=" + group_str; std::vector<std::string> awords=Tools::getWords(group_str,"\t\n ,");
-    Tools::interpretRanges( awords ); Tools::convert( awords.size(), natoms ); str_norm_atoms = natoms;
+    atom_str="GROUP=" + group_str;
+    std::vector<std::string> awords=Tools::getWords(group_str,"\t\n ,");
+    Tools::interpretRanges( awords );
+    Tools::convert( awords.size(), natoms );
+    str_norm_atoms = natoms;
   } else {
-    parse("GROUPA",groupa_str); parse("GROUPB",groupb_str);
+    parse("GROUPA",groupa_str);
+    parse("GROUPB",groupb_str);
     std::vector<std::string> awords=Tools::getWords(groupb_str,"\t\n ,");
-    Tools::interpretRanges( awords ); Tools::convert( awords.size(), natoms );
+    Tools::interpretRanges( awords );
+    Tools::convert( awords.size(), natoms );
     atom_str="GROUPA=" + groupa_str + " GROUPB=" + groupb_str;
-    std::vector<std::string> bwords=Tools::getWords(groupa_str,"\t\n ,"); Tools::interpretRanges( bwords );
+    std::vector<std::string> bwords=Tools::getWords(groupa_str,"\t\n ,");
+    Tools::interpretRanges( bwords );
     Tools::convert( bwords.size()+1, str_norm_atoms );
   }
   // Retrieve the number of atoms
@@ -104,11 +130,15 @@ RDF::RDF(const ActionOptions&ao):
   // Calculate weights of distances
   readInputLine( getShortcutLabel() + "_wmat: CUSTOM ARG=" + getShortcutLabel() + "_mat FUNC=step(" + cutoff + "-x) PERIODIC=NO");
   // Now create a histogram from the contact matrix
-  unsigned clear, stride; parse("CLEAR",clear); parse("STRIDE",stride);
+  unsigned clear, stride;
+  parse("CLEAR",clear);
+  parse("STRIDE",stride);
   if( clear==1 ) {
     readInputLine( getShortcutLabel() + "_kde: KDE ARG=" + getShortcutLabel() + "_mat VOLUMES=" + getShortcutLabel() + "_wmat " + grid_setup + " " + kernel_data);
   } else {
-    std::string stridestr, clearstr; Tools::convert( stride, stridestr ); Tools::convert( clear, clearstr );
+    std::string stridestr, clearstr;
+    Tools::convert( stride, stridestr );
+    Tools::convert( clear, clearstr );
     readInputLine( getShortcutLabel() + "_okde: KDE ARG=" + getShortcutLabel() + "_mat HEIGHTS=" + getShortcutLabel() + "_wmat " + grid_setup + " " + kernel_data);
     readInputLine( getShortcutLabel() + "_kde: ACCUMULATE ARG=" + getShortcutLabel() + "_okde STRIDE=" + stridestr + " CLEAR=" + clearstr );
     readInputLine( getShortcutLabel() + "_one: CONSTANT VALUE=1");
@@ -119,11 +149,17 @@ RDF::RDF(const ActionOptions&ao):
   // And normalize by density and number of atoms (separated from above to avoid nans)
   std::string func_str = "PERIODIC=NO ARG=" + getShortcutLabel() + "_vrdf";
   if( dens.length()>0 ) {
-    if( clear==1 ) func_str += " FUNC=x/(" + dens + "*" + str_norm_atoms + ")";
-    else func_str += "," + getShortcutLabel() + "_norm FUNC=x/(y*" + dens + "*" + str_norm_atoms + ")";
+    if( clear==1 ) {
+      func_str += " FUNC=x/(" + dens + "*" + str_norm_atoms + ")";
+    } else {
+      func_str += "," + getShortcutLabel() + "_norm FUNC=x/(y*" + dens + "*" + str_norm_atoms + ")";
+    }
   } else {
-    if( clear==1 ) func_str += "," + refstr + "_vol FUNC=x*y/(" + natoms + "*" + str_norm_atoms + ")";
-    else func_str += "," + refstr + "_vol," + getShortcutLabel() + "_norm FUNC=x*y/(z*" + natoms + "*" + str_norm_atoms + ")";
+    if( clear==1 ) {
+      func_str += "," + refstr + "_vol FUNC=x*y/(" + natoms + "*" + str_norm_atoms + ")";
+    } else {
+      func_str += "," + refstr + "_vol," + getShortcutLabel() + "_norm FUNC=x*y/(z*" + natoms + "*" + str_norm_atoms + ")";
+    }
   }
   readInputLine( getShortcutLabel() + ": CUSTOM " + func_str);
 }
diff --git a/src/gridtools/ReadGridInSetup.cpp b/src/gridtools/ReadGridInSetup.cpp
index 2ac2b91952..132872819b 100644
--- a/src/gridtools/ReadGridInSetup.cpp
+++ b/src/gridtools/ReadGridInSetup.cpp
@@ -63,8 +63,12 @@ class ReadGridInSetup : public ActionWithGrid {
   static void registerKeywords( Keywords& keys );
   explicit ReadGridInSetup(const ActionOptions&ao);
   unsigned getNumberOfDerivatives() override ;
-  void setupOnFirstStep( const bool incalc ) override { plumed_merror("should not be in ReadGridInSetup setupOnFirstStep" ); }
-  void performTask( const unsigned& current, MultiValue& myvals ) const override { plumed_merror("should not be in readGridInSetup performTask"); }
+  void setupOnFirstStep( const bool incalc ) override {
+    plumed_merror("should not be in ReadGridInSetup setupOnFirstStep" );
+  }
+  void performTask( const unsigned& current, MultiValue& myvals ) const override {
+    plumed_merror("should not be in readGridInSetup performTask");
+  }
   std::vector<std::string> getGridCoordinateNames() const override ;
   const GridCoordinatesObject& getGridCoordinatesObject() const override ;
 };
@@ -72,7 +76,8 @@ class ReadGridInSetup : public ActionWithGrid {
 PLUMED_REGISTER_ACTION(ReadGridInSetup,"REFERENCE_GRID")
 
 void ReadGridInSetup::registerKeywords( Keywords& keys ) {
-  ActionWithGrid::registerKeywords(keys); keys.remove("SERIAL");
+  ActionWithGrid::registerKeywords(keys);
+  keys.remove("SERIAL");
   keys.add("optional","FUNC","the function to compute on the grid");
   keys.add("compulsory","GRID_MIN","auto","the lower bounds for the grid");
   keys.add("compulsory","GRID_MAX","auto","the upper bounds for the grid");
@@ -87,33 +92,50 @@ void ReadGridInSetup::registerKeywords( Keywords& keys ) {
 
 ReadGridInSetup::ReadGridInSetup(const ActionOptions&ao):
   Action(ao),
-  ActionWithGrid(ao)
-{
-  std::string func; parse("FUNC",func);
+  ActionWithGrid(ao) {
+  std::string func;
+  parse("FUNC",func);
   if( func.length()>0 ) {
     // Read in stuff for grid
-    std::vector<std::string> gmin; parseVector("GRID_MIN",gmin);
-    std::vector<std::string> gmax(gmin.size()); parseVector("GRID_MAX",gmax);
-    std::vector<unsigned> gbin(gmin.size()); parseVector("GRID_BIN",gbin);
-    std::vector<std::string> pbc(gmin.size()); parseVector("PERIODIC",pbc);
+    std::vector<std::string> gmin;
+    parseVector("GRID_MIN",gmin);
+    std::vector<std::string> gmax(gmin.size());
+    parseVector("GRID_MAX",gmax);
+    std::vector<unsigned> gbin(gmin.size());
+    parseVector("GRID_BIN",gbin);
+    std::vector<std::string> pbc(gmin.size());
+    parseVector("PERIODIC",pbc);
     std::vector<bool> ipbc( pbc.size() );
     for(unsigned i=0; i<ipbc.size(); ++i) {
-      if( pbc[i]=="YES" ) ipbc[i]=true;
-      else if( pbc[i]=="NO" ) ipbc[i]=false;
-      else error( pbc[i] + " is not a valid instruction to the PERIODIC keyword");
+      if( pbc[i]=="YES" ) {
+        ipbc[i]=true;
+      } else if( pbc[i]=="NO" ) {
+        ipbc[i]=false;
+      } else {
+        error( pbc[i] + " is not a valid instruction to the PERIODIC keyword");
+      }
     }
 
     // Read in the variables
     parseVector("VAR",dernames);
     if(dernames.size()==0) {
       dernames.resize(gmin.size());
-      if(gmin.size()>3)
+      if(gmin.size()>3) {
         error("Using more than 3 arguments you should explicitly write their names with VAR");
-      if(dernames.size()>0) dernames[0]="x";
-      if(dernames.size()>1) dernames[1]="y";
-      if(dernames.size()>2) dernames[2]="z";
+      }
+      if(dernames.size()>0) {
+        dernames[0]="x";
+      }
+      if(dernames.size()>1) {
+        dernames[1]="y";
+      }
+      if(dernames.size()>2) {
+        dernames[2]="z";
+      }
+    }
+    if(dernames.size()!=gmin.size()) {
+      error("Size of VAR array should be the same as number of grid dimensions");
     }
-    if(dernames.size()!=gmin.size()) error("Size of VAR array should be the same as number of grid dimensions");
 
     // Create the grid and the value of the grid
     createGridAndValue( "flat", ipbc, 0, gmin, gmax, gbin );
@@ -121,14 +143,22 @@ ReadGridInSetup::ReadGridInSetup(const ActionOptions&ao):
     // Read in stuff for function
     log.printf("  evaluating function : %s\n",func.c_str());
     log.printf("  with variables :");
-    for(unsigned i=0; i<dernames.size(); i++) log.printf(" %s",dernames[i].c_str());
+    for(unsigned i=0; i<dernames.size(); i++) {
+      log.printf(" %s",dernames[i].c_str());
+    }
     log.printf("\n");
     log.printf("  on %d", gbin[0]);
-    for(unsigned i=1; i<gbin.size(); ++i) log.printf(" by %d \n", gbin[i]);
+    for(unsigned i=1; i<gbin.size(); ++i) {
+      log.printf(" by %d \n", gbin[i]);
+    }
     log.printf(" grid of points between (%s", gmin[0].c_str() );
-    for(unsigned i=1; i<gmin.size(); ++i) log.printf(", %s", gmin[i].c_str() );
+    for(unsigned i=1; i<gmin.size(); ++i) {
+      log.printf(", %s", gmin[i].c_str() );
+    }
     log.printf(") and (%s", gmax[0].c_str() );
-    for(unsigned i=1; i<gmax.size(); ++i) log.printf(", %s", gmax[i].c_str() );
+    for(unsigned i=1; i<gmax.size(); ++i) {
+      log.printf(", %s", gmax[i].c_str() );
+    }
     log.printf(")\n");
 
     lepton::ParsedExpression pe=lepton::Parser::parse(func).optimize(leptonConstants);
@@ -147,7 +177,8 @@ ReadGridInSetup::ReadGridInSetup(const ActionOptions&ao):
       expression_deriv[i]=pe.createCompiledExpression();
     }
     // And finally calculate all the grid points
-    std::vector<double> dder( dernames.size() ), xx( dernames.size() ); Value* valout=getPntrToComponent(0);
+    std::vector<double> dder( dernames.size() ), xx( dernames.size() );
+    Value* valout=getPntrToComponent(0);
     for(unsigned index=0; index<valout->getNumberOfValues(); ++index) {
       gridobject.getGridPointCoordinates( index, xx );
       for(unsigned j=0; j<xx.size(); ++j) {
@@ -172,48 +203,73 @@ ReadGridInSetup::ReadGridInSetup(const ActionOptions&ao):
       }
     }
   } else {
-    std::string valuestr; parse("VALUE",valuestr);
-    std::string tstyle, filen; parse("FILE",filen);
+    std::string valuestr;
+    parse("VALUE",valuestr);
+    std::string tstyle, filen;
+    parse("FILE",filen);
     if( filen.length()>0 ) {
       std::size_t dot=filen.find_first_of(".");
-      if( dot!=std::string::npos ) tstyle=filen.substr(dot+1);
-      if( tstyle!="grid" ) error("can only read in grids using read value in setup");
+      if( dot!=std::string::npos ) {
+        tstyle=filen.substr(dot+1);
+      }
+      if( tstyle!="grid" ) {
+        error("can only read in grids using read value in setup");
+      }
       log.printf("  reading function %s on grid from file %s \n", valuestr.c_str(), filen.c_str() );
     }
-    IFile ifile; ifile.open(filen);
-    if( !ifile.FieldExist( valuestr ) ) error("could not find grid value in input file");
-    std::vector<std::string> fieldnames; ifile.scanFieldList( fieldnames );
+    IFile ifile;
+    ifile.open(filen);
+    if( !ifile.FieldExist( valuestr ) ) {
+      error("could not find grid value in input file");
+    }
+    std::vector<std::string> fieldnames;
+    ifile.scanFieldList( fieldnames );
 
     // Retrieve the names of the variables the grid is computed over
     bool flatgrid=false;
     for(unsigned i=0; i<fieldnames.size(); ++i) {
-      if( fieldnames[i].find("min_")!=std::string::npos ) flatgrid=true;
+      if( fieldnames[i].find("min_")!=std::string::npos ) {
+        flatgrid=true;
+      }
       std::size_t dot = fieldnames[i].find_first_of("d" + valuestr + "_" );
-      if( fieldnames[i].find("d" + valuestr + "_")!=std::string::npos ) dernames.push_back( fieldnames[i].substr(dot+2+valuestr.length()) );
+      if( fieldnames[i].find("d" + valuestr + "_")!=std::string::npos ) {
+        dernames.push_back( fieldnames[i].substr(dot+2+valuestr.length()) );
+      }
+    }
+    if( flatgrid && dernames.size()==0 ) {
+      error("could not find any derivatives for value " + valuestr + " in input file.  Header should contain at least columns with a name starting d" + valuestr + "_");
     }
-    if( flatgrid && dernames.size()==0 ) error("could not find any derivatives for value " + valuestr + " in input file.  Header should contain at least columns with a name starting d" + valuestr + "_");
     // Now get all the header data for the grid
-    std::vector<std::string> gmin( dernames.size() ), gmax( dernames.size() ); std::string pstring;
-    int gbin1; std::vector<unsigned> gbin( dernames.size() ); std::vector<bool> ipbc( dernames.size() );
+    std::vector<std::string> gmin( dernames.size() ), gmax( dernames.size() );
+    std::string pstring;
+    int gbin1;
+    std::vector<unsigned> gbin( dernames.size() );
+    std::vector<bool> ipbc( dernames.size() );
     if( !flatgrid ) {
-      ifile.scanField( "nbins", gbin1); gbin[0]=gbin1;
+      ifile.scanField( "nbins", gbin1);
+      gbin[0]=gbin1;
       createGridAndValue( "fibonacci", ipbc, gbin[0], gmin, gmax, gbin );
     } else {
       for(unsigned i=0; i<dernames.size(); ++i) {
         ifile.scanField( "min_" + dernames[i], gmin[i]);
         ifile.scanField( "max_" + dernames[i], gmax[i]);
         ifile.scanField( "periodic_" + dernames[i], pstring );
-        ifile.scanField( "nbins_" + dernames[i], gbin1); gbin[i]=gbin1;
+        ifile.scanField( "nbins_" + dernames[i], gbin1);
+        gbin[i]=gbin1;
         if( pstring=="true" ) {
           log.printf("   for periodic coordinate %s minimum is %s maximum is %s and number of bins is %d \n",dernames[i].c_str(),gmin[i].c_str(),gmax[i].c_str(),gbin[i]);
           ipbc[i]=true;
         } else if( pstring=="false" ) {
           log.printf("   for coordinate %s minimum is %s maximum is %s and number of bins is %d \n",dernames[i].c_str(),gmin[i].c_str(),gmax[i].c_str(),gbin[i]);
           ipbc[i]=false;
-        } else error("do not understand periodidicy of " + dernames[i] );
+        } else {
+          error("do not understand periodidicy of " + dernames[i] );
+        }
 
         bool hasder=ifile.FieldExist( "d" + valuestr + "_" + dernames[i] );
-        if( !hasder ) plumed_merror("missing derivatives from grid file");
+        if( !hasder ) {
+          plumed_merror("missing derivatives from grid file");
+        }
       }
       createGridAndValue( "flat", ipbc, 0, gmin, gmax, gbin );
     }
@@ -221,7 +277,8 @@ ReadGridInSetup::ReadGridInSetup(const ActionOptions&ao):
     Value* valout=getPntrToComponent(0);
     std::vector<double> dder( dernames.size() ), xx( dernames.size() );
     for(unsigned i=0; i<valout->getNumberOfValues(); ++i) {
-      double x, val; ifile.scanField( valuestr, val );
+      double x, val;
+      ifile.scanField( valuestr, val );
       for(unsigned j=0; j<dernames.size(); ++j) {
         ifile.scanField(dernames[j],x);
         if( !flatgrid ) {
@@ -234,11 +291,18 @@ ReadGridInSetup::ReadGridInSetup(const ActionOptions&ao):
           ifile.scanField( "periodic_" + dernames[j], pstring );
         }
       }
-      for(unsigned j=0; j<dernames.size(); ++j) ifile.scanField( "d" + valuestr + "_" + dernames[j], dder[j] );
+      for(unsigned j=0; j<dernames.size(); ++j) {
+        ifile.scanField( "d" + valuestr + "_" + dernames[j], dder[j] );
+      }
 
-      unsigned index=gridobject.getIndex(xx); if( !flatgrid ) index=i;
+      unsigned index=gridobject.getIndex(xx);
+      if( !flatgrid ) {
+        index=i;
+      }
       valout->set( index, val );
-      for(unsigned j=0; j<dernames.size(); ++j) valout->addGridDerivatives( index, j, dder[j] );
+      for(unsigned j=0; j<dernames.size(); ++j) {
+        valout->addGridDerivatives( index, j, dder[j] );
+      }
       ifile.scanField();
     }
     ifile.close();
@@ -248,15 +312,20 @@ ReadGridInSetup::ReadGridInSetup(const ActionOptions&ao):
 void ReadGridInSetup::createGridAndValue( const std::string& gtype, const std::vector<bool>& ipbc, const unsigned& nfermi,
     const std::vector<std::string>& gmin, const std::vector<std::string>& gmax,
     const std::vector<unsigned>& gbin ) {
-  gridobject.setup( gtype, ipbc, nfermi, 0.0 ); std::vector<double> gspacing;
+  gridobject.setup( gtype, ipbc, nfermi, 0.0 );
+  std::vector<double> gspacing;
   if( gtype=="flat" ) {
     gridobject.setBounds( gmin, gmax, gbin, gspacing );
     // Now create the value
     std::vector<unsigned> shape( gridobject.getNbin(true) );
-    ActionWithValue::addValueWithDerivatives( shape ); setNotPeriodic();
+    ActionWithValue::addValueWithDerivatives( shape );
+    setNotPeriodic();
   } else {
-    std::vector<unsigned> shape( 3 ); shape[0]=gbin[0]; shape[1]=shape[2]=1;
-    ActionWithValue::addValueWithDerivatives( shape ); setNotPeriodic();
+    std::vector<unsigned> shape( 3 );
+    shape[0]=gbin[0];
+    shape[1]=shape[2]=1;
+    ActionWithValue::addValueWithDerivatives( shape );
+    setNotPeriodic();
   }
   for(unsigned i=0; i<getNumberOfComponents(); ++i) {
     getPntrToComponent(i)->setConstant();
diff --git a/src/isdb/CS2Backbone.cpp b/src/isdb/CS2Backbone.cpp
index e91cfa1321..a4234f5035 100644
--- a/src/isdb/CS2Backbone.cpp
+++ b/src/isdb/CS2Backbone.cpp
@@ -176,160 +176,193 @@ class CS2BackboneDB {
 public:
 
   inline unsigned kind(const std::string &s) {
-    if(s=="GLY") return GLY;
-    else if(s=="PRO") return PRO;
+    if(s=="GLY") {
+      return GLY;
+    } else if(s=="PRO") {
+      return PRO;
+    }
     return STD;
   }
 
   inline unsigned atom_kind(const std::string &s) {
-    if(s=="HA")return HA_ATOM;
-    else if(s=="H") return H_ATOM;
-    else if(s=="N") return N_ATOM;
-    else if(s=="CA")return CA_ATOM;
-    else if(s=="CB")return CB_ATOM;
-    else if(s=="C") return C_ATOM;
+    if(s=="HA") {
+      return HA_ATOM;
+    } else if(s=="H") {
+      return H_ATOM;
+    } else if(s=="N") {
+      return N_ATOM;
+    } else if(s=="CA") {
+      return CA_ATOM;
+    } else if(s=="CB") {
+      return CB_ATOM;
+    } else if(s=="C") {
+      return C_ATOM;
+    }
     return -1;
   }
 
-  unsigned get_numXtraDists() {return numXtraDists;}
+  unsigned get_numXtraDists() {
+    return numXtraDists;
+  }
 
   //PARAMETERS
-  inline double * CONSTAACURR(const unsigned a_kind, const unsigned at_kind) {return c_aa[a_kind][at_kind];}
-  inline double * CONSTAANEXT(const unsigned a_kind, const unsigned at_kind) {return c_aa_succ[a_kind][at_kind];}
-  inline double * CONSTAAPREV(const unsigned a_kind, const unsigned at_kind) {return c_aa_prev[a_kind][at_kind];}
-  inline double * CONST_BB2(const unsigned a_kind, const unsigned at_kind) {return co_bb[a_kind][at_kind];}
-  inline double * CONST_SC2(const unsigned a_kind, const unsigned at_kind, unsigned res_type) { return co_sc_[a_kind][at_kind][res_type];}
-  inline double * CONST_XD(const unsigned a_kind, const unsigned at_kind) { return co_xd[a_kind][at_kind];}
-  inline double * CO_SPHERE(const unsigned a_kind, const unsigned at_kind, unsigned exp_type) { return co_sphere[a_kind][at_kind][exp_type];}
-  inline double * CO_RING(const unsigned a_kind, const unsigned at_kind) { return co_ring[a_kind][at_kind];}
-  inline double * CO_DA(const unsigned a_kind, const unsigned at_kind) { return co_da[a_kind][at_kind];}
-  inline double * PARS_DA(const unsigned a_kind, const unsigned at_kind, const unsigned ang_kind) { return pars_da[a_kind][at_kind][ang_kind];}
+  inline double * CONSTAACURR(const unsigned a_kind, const unsigned at_kind) {
+    return c_aa[a_kind][at_kind];
+  }
+  inline double * CONSTAANEXT(const unsigned a_kind, const unsigned at_kind) {
+    return c_aa_succ[a_kind][at_kind];
+  }
+  inline double * CONSTAAPREV(const unsigned a_kind, const unsigned at_kind) {
+    return c_aa_prev[a_kind][at_kind];
+  }
+  inline double * CONST_BB2(const unsigned a_kind, const unsigned at_kind) {
+    return co_bb[a_kind][at_kind];
+  }
+  inline double * CONST_SC2(const unsigned a_kind, const unsigned at_kind, unsigned res_type) {
+    return co_sc_[a_kind][at_kind][res_type];
+  }
+  inline double * CONST_XD(const unsigned a_kind, const unsigned at_kind) {
+    return co_xd[a_kind][at_kind];
+  }
+  inline double * CO_SPHERE(const unsigned a_kind, const unsigned at_kind, unsigned exp_type) {
+    return co_sphere[a_kind][at_kind][exp_type];
+  }
+  inline double * CO_RING(const unsigned a_kind, const unsigned at_kind) {
+    return co_ring[a_kind][at_kind];
+  }
+  inline double * CO_DA(const unsigned a_kind, const unsigned at_kind) {
+    return co_da[a_kind][at_kind];
+  }
+  inline double * PARS_DA(const unsigned a_kind, const unsigned at_kind, const unsigned ang_kind) {
+    return pars_da[a_kind][at_kind][ang_kind];
+  }
 
   void parse(const std::string &file, const double dscale) {
     std::ifstream in;
     in.open(file.c_str());
-    if(!in) plumed_merror("Unable to open DB file: " + file);
+    if(!in) {
+      plumed_merror("Unable to open DB file: " + file);
+    }
 
     unsigned c_kind = 0;
     unsigned c_atom = 0;
     unsigned nline = 0;
 
-    for(unsigned i=0; i<3; i++) for(unsigned j=0; j<6; j++) {
+    for(unsigned i=0; i<3; i++)
+      for(unsigned j=0; j<6; j++) {
         for(unsigned k=0; k<20; k++) {
           c_aa[i][j][k]=0.;
           c_aa_prev[i][j][k]=0.;
           c_aa_succ[i][j][k]=0.;
-          for(unsigned m=0; m<20; m++) co_sc_[i][j][k][m]=0.;
+          for(unsigned m=0; m<20; m++) {
+            co_sc_[i][j][k][m]=0.;
+          }
+        }
+        for(unsigned k=0; k<16; k++) {
+          co_bb[i][j][k]=0.;
+        }
+        for(unsigned k=0; k<8; k++) {
+          co_sphere[i][j][0][k]=0.;
+          co_sphere[i][j][1][k]=0.;
         }
-        for(unsigned k=0; k<16; k++) {co_bb[i][j][k]=0.; }
-        for(unsigned k=0; k<8; k++) { co_sphere[i][j][0][k]=0.; co_sphere[i][j][1][k]=0.; }
         for(unsigned k=0; k<3; k++) {
           co_da[i][j][k]=0.;
-          for(unsigned l=0; l<5; l++) pars_da[i][j][k][l]=0.;
+          for(unsigned l=0; l<5; l++) {
+            pars_da[i][j][k][l]=0.;
+          }
+        }
+        for(unsigned k=0; k<5; k++) {
+          co_ring[i][j][k]=0.;
+        }
+        for(unsigned k=0; k<numXtraDists; k++) {
+          co_xd[i][j][k]=0.;
         }
-        for(unsigned k=0; k<5; k++) co_ring[i][j][k]=0.;
-        for(unsigned k=0; k<numXtraDists; k++) co_xd[i][j][k]=0.;
       }
 
     while(!in.eof()) {
       std::string line;
       getline(in,line);
       ++nline;
-      if(line.compare(0,1,"#")==0) continue;
+      if(line.compare(0,1,"#")==0) {
+        continue;
+      }
       std::vector<std::string> tok;
       std::vector<std::string> tmp;
       tok = split(line,' ');
       for(unsigned q=0; q<tok.size(); q++)
-        if(tok[q].size()) tmp.push_back(tok[q]);
+        if(tok[q].size()) {
+          tmp.push_back(tok[q]);
+        }
       tok = tmp;
-      if(tok.size()==0) continue;
+      if(tok.size()==0) {
+        continue;
+      }
       if(tok[0]=="PAR") {
         c_kind = kind(tok[2]);
         c_atom = atom_kind(tok[1]);
         continue;
-      }
-      else if(tok[0]=="WEIGHT") {
+      } else if(tok[0]=="WEIGHT") {
         continue;
-      }
-      else if(tok[0]=="FLATBTM") {
+      } else if(tok[0]=="FLATBTM") {
         continue;
-      }
-      else if (tok[0] == "SCALEHARM") {
+      } else if (tok[0] == "SCALEHARM") {
         continue;
-      }
-      else if (tok[0] == "TANHAMPLI") {
+      } else if (tok[0] == "TANHAMPLI") {
         continue;
-      }
-      else if (tok[0] == "ENDHARMON") {
+      } else if (tok[0] == "ENDHARMON") {
         continue;
-      }
-      else if (tok[0] == "MAXRCDEVI") {
+      } else if (tok[0] == "MAXRCDEVI") {
         continue;
-      }
-      else if (tok[0] == "RANDCOIL") {
+      } else if (tok[0] == "RANDCOIL") {
         continue;
-      }
-      else if (tok[0] == "CONST") {
+      } else if (tok[0] == "CONST") {
         continue;
-      }
-      else if (tok[0] == "CONSTAA") {
+      } else if (tok[0] == "CONSTAA") {
         assign(c_aa[c_kind][c_atom],tok,1);
         continue;
-      }
-      else if (tok[0] == "CONSTAA-1") {
+      } else if (tok[0] == "CONSTAA-1") {
         assign(c_aa_prev[c_kind][c_atom],tok,1);
         continue;
-      }
-      else if (tok[0] == "CONSTAA+1") {
+      } else if (tok[0] == "CONSTAA+1") {
         assign(c_aa_succ[c_kind][c_atom],tok,1);
         continue;
-      }
-      else if (tok[0] == "COBB1") {
+      } else if (tok[0] == "COBB1") {
         continue;
-      }
-      else if (tok[0] == "COBB2") {
+      } else if (tok[0] == "COBB2") {
         //angstrom to nm
         assign(co_bb[c_kind][c_atom],tok,dscale);
         continue;
-      }
-      else if (tok[0] == "SPHERE1") {
+      } else if (tok[0] == "SPHERE1") {
         // angstrom^-3 to nm^-3
         assign(co_sphere[c_kind][c_atom][0],tok,1./(dscale*dscale*dscale));
         continue;
-      }
-      else if (tok[0] == "SPHERE2") {
+      } else if (tok[0] == "SPHERE2") {
         //angstrom to nm
         assign(co_sphere[c_kind][c_atom][1],tok,dscale);
         continue;
-      }
-      else if (tok[0] == "DIHEDRALS") {
+      } else if (tok[0] == "DIHEDRALS") {
         assign(co_da[c_kind][c_atom],tok,1);
         continue;
-      }
-      else if (tok[0] == "RINGS") {
+      } else if (tok[0] == "RINGS") {
         // angstrom^-3 to nm^-3
         assign(co_ring[c_kind][c_atom],tok,1./(dscale*dscale*dscale));
-        for(unsigned i=1; i<tok.size(); i++)
+        for(unsigned i=1; i<tok.size(); i++) {
           co_ring[c_kind][c_atom][i-1] *= 1000;
+        }
         continue;
-      }
-      else if (tok[0] == "HBONDS") {
+      } else if (tok[0] == "HBONDS") {
         continue;
-      }
-      else if (tok[0] == "XTRADISTS") {
+      } else if (tok[0] == "XTRADISTS") {
         //angstrom to nm
         assign(co_xd[c_kind][c_atom],tok,dscale);
         continue;
-      }
-      else if(tok[0]=="DIHEDPHI") {
+      } else if(tok[0]=="DIHEDPHI") {
         assign(pars_da[c_kind][c_atom][0],tok,1);
         continue;
-      }
-      else if(tok[0]=="DIHEDPSI") {
+      } else if(tok[0]=="DIHEDPSI") {
         assign(pars_da[c_kind][c_atom][1],tok,1);
         continue;
-      }
-      else if(tok[0]=="DIHEDCHI1") {
+      } else if(tok[0]=="DIHEDCHI1") {
         assign(pars_da[c_kind][c_atom][2],tok,1);
         continue;
       }
@@ -346,7 +379,9 @@ class CS2BackboneDB {
           break;
         }
       }
-      if(ok) continue;
+      if(ok) {
+        continue;
+      }
 
       const std::string scIdent2 [] = {"COSCALA2", "COSCARG2", "COSCASN2", "COSCASP2", "COSCCYS2", "COSCGLN2", "COSCGLU2",
                                        "COSCGLY2", "COSCHIS2", "COSCILE2", "COSCLEU2", "COSCLYS2", "COSCMET2", "COSCPHE2",
@@ -357,10 +392,13 @@ class CS2BackboneDB {
         if(tok[0]==scIdent2[scC]) {
           //angstrom to nm
           assign(co_sc_[c_kind][c_atom][scC],tok,dscale);
-          ok = true; break;
+          ok = true;
+          break;
         }
       }
-      if(ok) continue;
+      if(ok) {
+        continue;
+      }
 
       if(tok.size()) {
         std::string str_err = "DB WARNING: unrecognized token: " + tok[0];
@@ -390,7 +428,9 @@ class CS2BackboneDB {
   void assign(double * f, const std::vector<std::string> & v, const double scale) {
     for(unsigned i=1; i<v.size(); i++) {
       f[i-1] = scale*(atof(v[i].c_str()));
-      if(std::abs(f[i-1])<0.000001) f[i-1]=0.;
+      if(std::abs(f[i-1])<0.000001) {
+        f[i-1]=0.;
+      }
     }
   }
 };
@@ -433,8 +473,7 @@ class CS2Backbone : public MetainferenceBase {
       totcsatoms(0),
       res_num(0),
       chain(0),
-      ipos(0)
-    {
+      ipos(0) {
       xd1.reserve(26);
       xd2.reserve(26);
       box_nb.reserve(150);
@@ -455,9 +494,10 @@ class CS2Backbone : public MetainferenceBase {
       rtype(0),
       numAtoms(0),
       lengthN2(NAN),
-      lengthNV(NAN)
-    {
-      for(unsigned i=0; i<6; i++) atom[i]=0;
+      lengthNV(NAN) {
+      for(unsigned i=0; i<6; i++) {
+        atom[i]=0;
+      }
     }
   };
 
@@ -528,13 +568,14 @@ CS2Backbone::CS2Backbone(const ActionOptions&ao):
   max_cs_atoms(0),
   camshift(false),
   pbc(true),
-  serial(false)
-{
+  serial(false) {
   std::vector<AtomNumber> used_atoms;
   parseAtomList("ATOMS",used_atoms);
 
   parseFlag("CAMSHIFT",camshift);
-  if(camshift&&getDoScore()) plumed_merror("It is not possible to use CAMSHIFT and DOSCORE at the same time");
+  if(camshift&&getDoScore()) {
+    plumed_merror("It is not possible to use CAMSHIFT and DOSCORE at the same time");
+  }
 
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
@@ -568,10 +609,13 @@ CS2Backbone::CS2Backbone(const ActionOptions&ao):
   db.parse(stringadb,scale);
 
   PDB pdb;
-  if( !pdb.read(stringapdb,usingNaturalUnits(),1./scale) ) plumed_merror("missing input file " + stringapdb);
+  if( !pdb.read(stringapdb,usingNaturalUnits(),1./scale) ) {
+    plumed_merror("missing input file " + stringapdb);
+  }
 
   // first of all we build the list of chemical shifts we want to predict
-  log.printf("  Reading experimental data ...\n"); log.flush();
+  log.printf("  Reading experimental data ...\n");
+  log.flush();
   stringadb = stringa_data + std::string("/CAshifts.dat");
   log.printf("  Initializing CA shifts %s\n", stringadb.c_str());
   init_cs(stringadb, "CA", pdb);
@@ -591,15 +635,20 @@ CS2Backbone::CS2Backbone(const ActionOptions&ao):
   log.printf("  Initializing N shifts %s\n", stringadb.c_str());
   init_cs(stringadb, "N", pdb);
 
-  if(chemicalshifts.size()==0) plumed_merror("There are no chemical shifts to calculate, there must be at least a not empty file (CA|CB|C|HA|H|N|shifts.dat)");
+  if(chemicalshifts.size()==0) {
+    plumed_merror("There are no chemical shifts to calculate, there must be at least a not empty file (CA|CB|C|HA|H|N|shifts.dat)");
+  }
 
   init_types(pdb);
   init_rings(pdb);
 
   log<<"  Bibliography "
      <<plumed.cite("Kohlhoff K, Robustelli P, Cavalli A, Salvatella A, Vendruscolo M, J. Am. Chem. Soc. 131, 13894 (2009)");
-  if(camshift) log<<plumed.cite("Granata D, Camilloni C, Vendruscolo M, Laio A, Proc. Natl. Acad. Sci. USA 110, 6817 (2013)");
-  else log<<plumed.cite("Camilloni C, Robustelli P, De Simone A, Cavalli A, Vendruscolo M, J. Am. Chem. Soc. 134, 3968 (2012)");
+  if(camshift) {
+    log<<plumed.cite("Granata D, Camilloni C, Vendruscolo M, Laio A, Proc. Natl. Acad. Sci. USA 110, 6817 (2013)");
+  } else {
+    log<<plumed.cite("Camilloni C, Robustelli P, De Simone A, Cavalli A, Vendruscolo M, J. Am. Chem. Soc. 134, 3968 (2012)");
+  }
   log<<plumed.cite("Bonomi M, Camilloni C, Bioinformatics, 33, 3999 (2017)");
   log<<"\n";
 
@@ -609,8 +658,10 @@ CS2Backbone::CS2Backbone(const ActionOptions&ao):
     setNotPeriodic();
   } else {
     for(unsigned cs=0; cs<chemicalshifts.size(); cs++) {
-      std::string num; Tools::convert(chemicalshifts[cs].res_num,num);
-      std::string chain_num; Tools::convert(chemicalshifts[cs].chain,chain_num);
+      std::string num;
+      Tools::convert(chemicalshifts[cs].res_num,num);
+      std::string chain_num;
+      Tools::convert(chemicalshifts[cs].chain,chain_num);
       if(getDoScore()) {
         addComponent(chemicalshifts[cs].nucleus+chain_num+"-"+num);
         componentIsNotPeriodic(chemicalshifts[cs].nucleus+chain_num+"-"+num);
@@ -622,13 +673,17 @@ CS2Backbone::CS2Backbone(const ActionOptions&ao):
         chemicalshifts[cs].comp = getPntrToComponent(chemicalshifts[cs].nucleus+chain_num+"-"+num);
       }
     }
-    if(getDoScore()) Initialise(chemicalshifts.size());
+    if(getDoScore()) {
+      Initialise(chemicalshifts.size());
+    }
   }
 
   if(!noexp) {
     for(unsigned cs=0; cs<chemicalshifts.size(); cs++) {
-      std::string num; Tools::convert(chemicalshifts[cs].res_num,num);
-      std::string chain_num; Tools::convert(chemicalshifts[cs].chain,chain_num);
+      std::string num;
+      Tools::convert(chemicalshifts[cs].res_num,num);
+      std::string chain_num;
+      Tools::convert(chemicalshifts[cs].chain,chain_num);
       addComponent("exp"+chemicalshifts[cs].nucleus+chain_num+"-"+num);
       componentIsNotPeriodic("exp"+chemicalshifts[cs].nucleus+chain_num+"-"+num);
       Value* comp=getPntrToComponent("exp"+chemicalshifts[cs].nucleus+chain_num+"-"+num);
@@ -649,7 +704,9 @@ void CS2Backbone::init_cs(const std::string &file, const std::string &nucl, cons
 
   std::ifstream in;
   in.open(file.c_str());
-  if(!in) return;
+  if(!in) {
+    return;
+  }
   std::istream_iterator<std::string> iter(in), end;
   unsigned begin=0;
 
@@ -661,42 +718,73 @@ void CS2Backbone::init_cs(const std::string &file, const std::string &nucl, cons
       if(begin==1) {
         begin=0;
         ichain++;
-      } else begin=1;
+      } else {
+        begin=1;
+      }
       continue;
     }
     int ro = atoi(tok.c_str());
-    if(ro<0) plumed_merror("Residue numbers should be positive\n");
+    if(ro<0) {
+      plumed_merror("Residue numbers should be positive\n");
+    }
     unsigned resnum = static_cast<unsigned> (ro);
     tok = *iter;
     ++iter;
     double cs = atof(tok.c_str());
-    if(cs==0) continue;
+    if(cs==0) {
+      continue;
+    }
 
     unsigned fres, lres;
     std::string errmsg;
     pdb.getResidueRange(chains[ichain], fres, lres, errmsg);
-    if(resnum==fres||resnum==lres) plumed_merror("First and Last residue of each chain should be annotated as # in " + file + " Remember that residue numbers should match");
+    if(resnum==fres||resnum==lres) {
+      plumed_merror("First and Last residue of each chain should be annotated as # in " + file + " Remember that residue numbers should match");
+    }
 
     // check in the PDB for the chain/residue/atom and enable the chemical shift
     std::string RES = pdb.getResidueName(resnum, chains[ichain]);
-    if(RES=="HIE"||RES=="HIP"||RES=="HIS"||RES=="HSP"||RES=="HSE"||RES=="CYS"||RES=="GLH"||RES=="ASH"||RES=="UNK") continue;
-    if(RES=="GLN"&&nucl=="CB") continue;
-    if(RES=="ILE"&&nucl=="CB") continue;
-    if(RES=="PRO"&&nucl=="N") continue;
-    if(RES=="PRO"&&nucl=="H") continue;
-    if(RES=="PRO"&&nucl=="CB") continue;
-    if(RES=="GLY"&&nucl=="HA") continue;
-    if(RES=="GLY"&&nucl=="CB") continue;
+    if(RES=="HIE"||RES=="HIP"||RES=="HIS"||RES=="HSP"||RES=="HSE"||RES=="CYS"||RES=="GLH"||RES=="ASH"||RES=="UNK") {
+      continue;
+    }
+    if(RES=="GLN"&&nucl=="CB") {
+      continue;
+    }
+    if(RES=="ILE"&&nucl=="CB") {
+      continue;
+    }
+    if(RES=="PRO"&&nucl=="N") {
+      continue;
+    }
+    if(RES=="PRO"&&nucl=="H") {
+      continue;
+    }
+    if(RES=="PRO"&&nucl=="CB") {
+      continue;
+    }
+    if(RES=="GLY"&&nucl=="HA") {
+      continue;
+    }
+    if(RES=="GLY"&&nucl=="CB") {
+      continue;
+    }
 
     ChemicalShift tmp_cs;
 
     tmp_cs.exp_cs = cs;
-    if(nucl=="CA")      tmp_cs.nucleus = "ca-";
-    else if(nucl=="CB") tmp_cs.nucleus = "cb-";
-    else if(nucl=="C")  tmp_cs.nucleus = "co-";
-    else if(nucl=="HA") tmp_cs.nucleus = "ha-";
-    else if(nucl=="H")  tmp_cs.nucleus = "hn-";
-    else if(nucl=="N")  tmp_cs.nucleus = "nh-";
+    if(nucl=="CA") {
+      tmp_cs.nucleus = "ca-";
+    } else if(nucl=="CB") {
+      tmp_cs.nucleus = "cb-";
+    } else if(nucl=="C") {
+      tmp_cs.nucleus = "co-";
+    } else if(nucl=="HA") {
+      tmp_cs.nucleus = "ha-";
+    } else if(nucl=="H") {
+      tmp_cs.nucleus = "hn-";
+    } else if(nucl=="N") {
+      tmp_cs.nucleus = "nh-";
+    }
     tmp_cs.chain = ichain;
     tmp_cs.res_num = resnum;
     tmp_cs.res_type_curr = frag2enum(RES);
@@ -705,44 +793,73 @@ void CS2Backbone::init_cs(const std::string &file, const std::string &nucl, cons
     tmp_cs.res_name = RES;
     tmp_cs.res_kind = db.kind(RES);
     tmp_cs.atm_kind = db.atom_kind(nucl);
-    if(RES!="ALA"&&RES!="GLY") {tmp_cs.bb.resize(18); tmp_cs.has_chi1=true;}
-    else {tmp_cs.bb.resize(16); tmp_cs.has_chi1=false;}
+    if(RES!="ALA"&&RES!="GLY") {
+      tmp_cs.bb.resize(18);
+      tmp_cs.has_chi1=true;
+    } else {
+      tmp_cs.bb.resize(16);
+      tmp_cs.has_chi1=false;
+    }
 
     std::vector<AtomNumber> res_atoms = pdb.getAtomsInResidue(resnum, chains[ichain]);
     // find the position of the nucleus and of the other backbone atoms as well as for phi/psi/chi
     for(unsigned a=0; a<res_atoms.size(); a++) {
       std::string AN = pdb.getAtomName(res_atoms[a]);
-      if(nucl=="HA"&&(AN=="HA"||AN=="HA1"||AN=="HA3")) tmp_cs.ipos = res_atoms[a].index();
-      else if(nucl=="H"&&(AN=="H"||AN=="HN"))          tmp_cs.ipos = res_atoms[a].index();
-      else if(nucl=="N"&&AN=="N")                      tmp_cs.ipos = res_atoms[a].index();
-      else if(nucl=="CA"&&AN=="CA")                    tmp_cs.ipos = res_atoms[a].index();
-      else if(nucl=="CB"&&AN=="CB")                    tmp_cs.ipos = res_atoms[a].index();
-      else if(nucl=="C"&&AN=="C" )                     tmp_cs.ipos = res_atoms[a].index();
+      if(nucl=="HA"&&(AN=="HA"||AN=="HA1"||AN=="HA3")) {
+        tmp_cs.ipos = res_atoms[a].index();
+      } else if(nucl=="H"&&(AN=="H"||AN=="HN")) {
+        tmp_cs.ipos = res_atoms[a].index();
+      } else if(nucl=="N"&&AN=="N") {
+        tmp_cs.ipos = res_atoms[a].index();
+      } else if(nucl=="CA"&&AN=="CA") {
+        tmp_cs.ipos = res_atoms[a].index();
+      } else if(nucl=="CB"&&AN=="CB") {
+        tmp_cs.ipos = res_atoms[a].index();
+      } else if(nucl=="C"&&AN=="C" ) {
+        tmp_cs.ipos = res_atoms[a].index();
+      }
     }
 
     std::vector<AtomNumber> prev_res_atoms = pdb.getAtomsInResidue(resnum-1, chains[ichain]);
     // find the position of the previous residues backbone atoms
     for(unsigned a=0; a<prev_res_atoms.size(); a++) {
       std::string AN = pdb.getAtomName(prev_res_atoms[a]);
-      if(AN=="N")                             { tmp_cs.bb[Np]  = prev_res_atoms[a].index(); }
-      else if(AN=="CA")                       { tmp_cs.bb[CAp] = prev_res_atoms[a].index(); }
-      else if(AN=="HA"||AN=="HA1"||AN=="HA3") { tmp_cs.bb[HAp] = prev_res_atoms[a].index(); }
-      else if(AN=="C" )                       { tmp_cs.bb[Cp]  = prev_res_atoms[a].index(); }
-      else if(AN=="O" )                       { tmp_cs.bb[Op]  = prev_res_atoms[a].index(); }
+      if(AN=="N")                             {
+        tmp_cs.bb[Np]  = prev_res_atoms[a].index();
+      } else if(AN=="CA")                       {
+        tmp_cs.bb[CAp] = prev_res_atoms[a].index();
+      } else if(AN=="HA"||AN=="HA1"||AN=="HA3") {
+        tmp_cs.bb[HAp] = prev_res_atoms[a].index();
+      } else if(AN=="C" )                       {
+        tmp_cs.bb[Cp]  = prev_res_atoms[a].index();
+      } else if(AN=="O" )                       {
+        tmp_cs.bb[Op]  = prev_res_atoms[a].index();
+      }
     }
 
     for(unsigned a=0; a<res_atoms.size(); a++) {
       std::string AN = pdb.getAtomName(res_atoms[a]);
-      if(AN=="N")                                         { tmp_cs.bb[Nc]  = res_atoms[a].index(); }
-      else if(AN=="H" ||AN=="HN"||(AN=="CD"&&RES=="PRO")) { tmp_cs.bb[Hc]  = res_atoms[a].index(); }
-      else if(AN=="CA")                                   { tmp_cs.bb[CAc] = res_atoms[a].index(); }
-      else if(AN=="HA"||AN=="HA1"||AN=="HA3")             { tmp_cs.bb[HAc] = res_atoms[a].index(); }
-      else if(AN=="C" )                                   { tmp_cs.bb[Cc]  = res_atoms[a].index(); }
-      else if(AN=="O" )                                   { tmp_cs.bb[Oc]  = res_atoms[a].index(); }
+      if(AN=="N")                                         {
+        tmp_cs.bb[Nc]  = res_atoms[a].index();
+      } else if(AN=="H" ||AN=="HN"||(AN=="CD"&&RES=="PRO")) {
+        tmp_cs.bb[Hc]  = res_atoms[a].index();
+      } else if(AN=="CA")                                   {
+        tmp_cs.bb[CAc] = res_atoms[a].index();
+      } else if(AN=="HA"||AN=="HA1"||AN=="HA3")             {
+        tmp_cs.bb[HAc] = res_atoms[a].index();
+      } else if(AN=="C" )                                   {
+        tmp_cs.bb[Cc]  = res_atoms[a].index();
+      } else if(AN=="O" )                                   {
+        tmp_cs.bb[Oc]  = res_atoms[a].index();
+      }
 
       if(RES!="ALA"&&RES!="GLY") {
-        if(AN=="CB") tmp_cs.bb[CBc] = res_atoms[a].index();
-        if(is_chi1_cx(RES,AN)) tmp_cs.bb[CGc] = res_atoms[a].index();
+        if(AN=="CB") {
+          tmp_cs.bb[CBc] = res_atoms[a].index();
+        }
+        if(is_chi1_cx(RES,AN)) {
+          tmp_cs.bb[CGc] = res_atoms[a].index();
+        }
       }
     }
 
@@ -751,11 +868,17 @@ void CS2Backbone::init_cs(const std::string &file, const std::string &nucl, cons
     // find the position of the previous residues backbone atoms
     for(unsigned a=0; a<next_res_atoms.size(); a++) {
       std::string AN = pdb.getAtomName(next_res_atoms[a]);
-      if(AN=="N")                                          { tmp_cs.bb[Nn]  = next_res_atoms[a].index(); }
-      else if(AN=="H" ||AN=="HN"||(AN=="CD"&&NRES=="PRO")) { tmp_cs.bb[Hn]  = next_res_atoms[a].index(); }
-      else if(AN=="CA")                                    { tmp_cs.bb[CAn] = next_res_atoms[a].index(); }
-      else if(AN=="HA"||AN=="HA1"||AN=="HA3")              { tmp_cs.bb[HAn] = next_res_atoms[a].index(); }
-      else if(AN=="C" )                                    { tmp_cs.bb[Cn]  = next_res_atoms[a].index(); }
+      if(AN=="N")                                          {
+        tmp_cs.bb[Nn]  = next_res_atoms[a].index();
+      } else if(AN=="H" ||AN=="HN"||(AN=="CD"&&NRES=="PRO")) {
+        tmp_cs.bb[Hn]  = next_res_atoms[a].index();
+      } else if(AN=="CA")                                    {
+        tmp_cs.bb[CAn] = next_res_atoms[a].index();
+      } else if(AN=="HA"||AN=="HA1"||AN=="HA3")              {
+        tmp_cs.bb[HAn] = next_res_atoms[a].index();
+      } else if(AN=="C" )                                    {
+        tmp_cs.bb[Cn]  = next_res_atoms[a].index();
+      }
     }
 
     // set sidechain atoms
@@ -778,14 +901,26 @@ void CS2Backbone::init_cs(const std::string &file, const std::string &nucl, cons
 
     for(unsigned q=0; q<db.get_numXtraDists()-1; q++) {
       std::vector<AtomNumber> at1;
-      if(resOffsetP1[q]== 0) at1 = res_atoms;
-      if(resOffsetP1[q]==-1) at1 = prev_res_atoms;
-      if(resOffsetP1[q]==+1) at1 = next_res_atoms;
+      if(resOffsetP1[q]== 0) {
+        at1 = res_atoms;
+      }
+      if(resOffsetP1[q]==-1) {
+        at1 = prev_res_atoms;
+      }
+      if(resOffsetP1[q]==+1) {
+        at1 = next_res_atoms;
+      }
 
       std::vector<AtomNumber> at2;
-      if(resOffsetP2[q]== 0) at2 = res_atoms;
-      if(resOffsetP2[q]==-1) at2 = prev_res_atoms;
-      if(resOffsetP2[q]==+1) at2 = next_res_atoms;
+      if(resOffsetP2[q]== 0) {
+        at2 = res_atoms;
+      }
+      if(resOffsetP2[q]==-1) {
+        at2 = prev_res_atoms;
+      }
+      if(resOffsetP2[q]==+1) {
+        at2 = next_res_atoms;
+      }
 
       int tmp1 = -1;
       for(unsigned a=0; a<at1.size(); a++) {
@@ -815,7 +950,9 @@ void CS2Backbone::init_cs(const std::string &file, const std::string &nucl, cons
 
     // ready to add a new chemical shifts
     tmp_cs.csatoms = 1 + 16 + tmp_cs.side_chain.size() + 2*tmp_cs.xd1.size();
-    if(tmp_cs.res_name!="ALA"&&tmp_cs.res_name!="GLY") tmp_cs.csatoms += 2;
+    if(tmp_cs.res_name!="ALA"&&tmp_cs.res_name!="GLY") {
+      tmp_cs.csatoms += 2;
+    }
     chemicalshifts.push_back(tmp_cs);
   }
 
@@ -831,28 +968,41 @@ void CS2Backbone::init_types(const PDB &pdb) {
     std::string fragName = pdb.getResidueName(aa[i]);
     std::string atom_name = pdb.getAtomName(aa[i]);
     char atom_type = atom_name[0];
-    if(isdigit(atom_name[0])) atom_type = atom_name[1];
+    if(isdigit(atom_name[0])) {
+      atom_type = atom_name[1];
+    }
     res_num.push_back(frag);
     unsigned t = 0;
     if (!isSP2(fragName, atom_name)) {
-      if (atom_type == 'C') t = D_C;
-      else if (atom_type == 'O') t = D_O;
-      else if (atom_type == 'H') t = D_H;
-      else if (atom_type == 'N') t = D_N;
-      else if (atom_type == 'S') t = D_S;
-      else plumed_merror("Unknown atom type: " + atom_name);
+      if (atom_type == 'C') {
+        t = D_C;
+      } else if (atom_type == 'O') {
+        t = D_O;
+      } else if (atom_type == 'H') {
+        t = D_H;
+      } else if (atom_type == 'N') {
+        t = D_N;
+      } else if (atom_type == 'S') {
+        t = D_S;
+      } else {
+        plumed_merror("Unknown atom type: " + atom_name);
+      }
     } else {
-      if (atom_type == 'C') t = D_C2;
-      else if (atom_type == 'O') t = D_O2;
-      else if (atom_type == 'N') t = D_N2;
-      else plumed_merror("Unknown atom type: " + atom_name);
+      if (atom_type == 'C') {
+        t = D_C2;
+      } else if (atom_type == 'O') {
+        t = D_O2;
+      } else if (atom_type == 'N') {
+        t = D_N2;
+      } else {
+        plumed_merror("Unknown atom type: " + atom_name);
+      }
     }
     type.push_back(t);
   }
 }
 
-void CS2Backbone::init_rings(const PDB &pdb)
-{
+void CS2Backbone::init_rings(const PDB &pdb) {
   const std::string pheTyr_n[] = {"CG","CD1","CE1","CZ","CE2","CD2"};
   const std::string trp1_n[]   = {"CD2","CE2","CZ2","CH2","CZ3","CE3"};
   const std::string trp2_n[]   = {"CG","CD1","NE1","CE2","CD2"};
@@ -874,7 +1024,9 @@ void CS2Backbone::init_rings(const PDB &pdb)
       if(!((frg=="PHE")||(frg=="TYR")||(frg=="TRP")||
            (frg=="HIS")||(frg=="HIP")||(frg=="HID")||
            (frg=="HIE")||(frg=="HSD")||(frg=="HSE")||
-           (frg=="HSP"))) continue;
+           (frg=="HSP"))) {
+        continue;
+      }
 
       std::vector<AtomNumber> frg_atoms = pdb.getAtomsInResidue(res,chains[i]);
 
@@ -891,8 +1043,12 @@ void CS2Backbone::init_rings(const PDB &pdb)
         }
         ri.numAtoms = 6;
         total_rings_atoms += 6;
-        if(frg=="PHE") ri.rtype = RingInfo::R_PHE;
-        if(frg=="TYR") ri.rtype = RingInfo::R_TYR;
+        if(frg=="PHE") {
+          ri.rtype = RingInfo::R_PHE;
+        }
+        if(frg=="TYR") {
+          ri.rtype = RingInfo::R_TYR;
+        }
         ringInfo.push_back(ri);
 
       } else if(frg=="TRP") {
@@ -950,14 +1106,21 @@ void CS2Backbone::init_rings(const PDB &pdb)
     }
   }
 
-  for(unsigned cs=0; cs<chemicalshifts.size(); cs++) chemicalshifts[cs].csatoms += total_rings_atoms;
+  for(unsigned cs=0; cs<chemicalshifts.size(); cs++) {
+    chemicalshifts[cs].csatoms += total_rings_atoms;
+  }
 }
 
-void CS2Backbone::calculate()
-{
-  if(pbc) makeWhole();
-  if(getExchangeStep()) box_count=0;
-  if(box_count==0) update_neighb();
+void CS2Backbone::calculate() {
+  if(pbc) {
+    makeWhole();
+  }
+  if(getExchangeStep()) {
+    box_count=0;
+  }
+  if(box_count==0) {
+    update_neighb();
+  }
   compute_ring_parameters();
 
   std::vector<double> camshift_sigma2(6);
@@ -976,7 +1139,9 @@ void CS2Backbone::calculate()
   cs_derivs.resize(chemicalshifts.size()*max_cs_atoms,Vector(0,0,0));
   cs_atoms.resize(chemicalshifts.size()*max_cs_atoms,0);
   all_shifts.resize(chemicalshifts.size(),0);
-  if(camshift||getDoScore()) aa_derivs.resize(getNumberOfAtoms(),Vector(0,0,0));
+  if(camshift||getDoScore()) {
+    aa_derivs.resize(getNumberOfAtoms(),Vector(0,0,0));
+  }
 
   unsigned stride = comm.Get_size();
   unsigned rank   = comm.Get_rank();
@@ -986,7 +1151,9 @@ void CS2Backbone::calculate()
   }
 
   unsigned nt=OpenMP::getNumThreads();
-  if(nt*stride*2>chemicalshifts.size()) nt=1;
+  if(nt*stride*2>chemicalshifts.size()) {
+    nt=1;
+  }
 
   // a single loop over all chemical shifts
   #pragma omp parallel num_threads(nt)
@@ -1011,9 +1178,13 @@ void CS2Backbone::calculate()
       const unsigned bbsize = 16;
       for(unsigned q=0; q<bbsize; q++) {
         const double cb2q = CONST_BB2[q];
-        if(cb2q==0.) continue;
+        if(cb2q==0.) {
+          continue;
+        }
         const unsigned jpos = myfrag->bb[q];
-        if(ipos==jpos) continue;
+        if(ipos==jpos) {
+          continue;
+        }
         const Vector distance = delta(getPosition(jpos),getPosition(ipos));
         const double d = distance.modulo();
         const double fact = cb2q/d;
@@ -1110,9 +1281,13 @@ void CS2Backbone::calculate()
       const unsigned sidsize = myfrag->side_chain.size();
       for(unsigned q=0; q<sidsize; q++) {
         const double cs2q = CONST_SC2[q];
-        if(cs2q==0.) continue;
+        if(cs2q==0.) {
+          continue;
+        }
         const unsigned jpos = myfrag->side_chain[q];
-        if(ipos==jpos) continue;
+        if(ipos==jpos) {
+          continue;
+        }
         const Vector distance = delta(getPosition(jpos),getPosition(ipos));
         const double d = distance.modulo();
         const double fact = cs2q/d;
@@ -1131,8 +1306,12 @@ void CS2Backbone::calculate()
       const unsigned xdsize=myfrag->xd1.size();
       for(unsigned q=0; q<xdsize; q++) {
         const double cxdq = CONST_XD[q];
-        if(cxdq==0.) continue;
-        if(myfrag->xd1[q]==-1||myfrag->xd2[q]==-1) continue;
+        if(cxdq==0.) {
+          continue;
+        }
+        if(myfrag->xd1[q]==-1||myfrag->xd2[q]==-1) {
+          continue;
+        }
         const Vector distance = delta(getPosition(myfrag->xd1[q]),getPosition(myfrag->xd2[q]));
         const double d = distance.modulo();
         const double fact = cxdq/d;
@@ -1184,7 +1363,9 @@ void CS2Backbone::calculate()
 
         const double fU       = fUU/nL;
         double OneOverN = 1./6.;
-        if(ringInfo[q].numAtoms==5) OneOverN=1./3.;
+        if(ringInfo[q].numAtoms==5) {
+          OneOverN=1./3.;
+        }
         const Vector factor2  = OneOverN*n;
         const Vector factor4  = (OneOverN/dL_nL)*d;
 
@@ -1274,7 +1455,9 @@ void CS2Backbone::calculate()
   }
 
   ++box_count;
-  if(box_count == box_nupdate) box_count = 0;
+  if(box_count == box_nupdate) {
+    box_count = 0;
+  }
 
   if(!camshift) {
     if(!serial) {
@@ -1287,8 +1470,9 @@ void CS2Backbone::calculate()
     for(unsigned cs=0; cs<chemicalshifts.size(); cs++) {
       Value *comp = chemicalshifts[cs].comp;
       comp->set(all_shifts[cs]);
-      if(getDoScore()) setCalcData(cs, all_shifts[cs]);
-      else {
+      if(getDoScore()) {
+        setCalcData(cs, all_shifts[cs]);
+      } else {
         const unsigned kdx=cs*max_cs_atoms;
         Tensor csvirial;
         for(unsigned i=0; i<chemicalshifts[cs].totcsatoms; i++) {
@@ -1298,7 +1482,9 @@ void CS2Backbone::calculate()
         setBoxDerivatives(comp,csvirial);
       }
     }
-    if(!getDoScore()) return;
+    if(!getDoScore()) {
+      return;
+    }
   }
 
   double score = 0.;
@@ -1329,7 +1515,9 @@ void CS2Backbone::calculate()
 
   if(!serial) {
     comm.Sum(&aa_derivs[0][0], 3*aa_derivs.size());
-    if(camshift) comm.Sum(&score, 1);
+    if(camshift) {
+      comm.Sum(&score, 1);
+    }
   }
 
   Tensor virial;
@@ -1352,7 +1540,9 @@ void CS2Backbone::calculate()
   }
 
   /* at this point we cycle over all atoms */
-  for(unsigned i=0; i<getNumberOfAtoms(); i++) setAtomsDerivatives(val, i,  aa_derivs[i]);
+  for(unsigned i=0; i<getNumberOfAtoms(); i++) {
+    setAtomsDerivatives(val, i,  aa_derivs[i]);
+  }
   setBoxDerivatives(val,-virial);
 }
 
@@ -1367,16 +1557,22 @@ void CS2Backbone::update_neighb() {
     const unsigned res_curr = res_num[chemicalshifts[cs].ipos];
     for(unsigned bat=0; bat<boxsize; bat++) {
       const unsigned res_dist = std::abs(static_cast<int>(res_curr-res_num[bat]));
-      if(res_dist<2) continue;
+      if(res_dist<2) {
+        continue;
+      }
       const Vector distance = delta(getPosition(bat),getPosition(chemicalshifts[cs].ipos));
       const double d2=distance.modulo2();
-      if(d2<cutOffNB2) chemicalshifts[cs].box_nb.push_back(bat);
+      if(d2<cutOffNB2) {
+        chemicalshifts[cs].box_nb.push_back(bat);
+      }
     }
     chemicalshifts[cs].totcsatoms = chemicalshifts[cs].csatoms + chemicalshifts[cs].box_nb.size();
   }
   max_cs_atoms=0;
   for(unsigned cs=0; cs<chemicalshifts.size(); cs++) {
-    if(chemicalshifts[cs].totcsatoms>max_cs_atoms) max_cs_atoms = chemicalshifts[cs].totcsatoms;
+    if(chemicalshifts[cs].totcsatoms>max_cs_atoms) {
+      max_cs_atoms = chemicalshifts[cs].totcsatoms;
+    }
   }
 }
 
@@ -1392,7 +1588,9 @@ void CS2Backbone::compute_ring_parameters() {
       ringInfo[i].g[5] = delta(getPosition(ringInfo[i].atom[3]),getPosition(ringInfo[i].atom[1]));
       // ring center
       Vector midP = getPosition(ringInfo[i].atom[0]);
-      for(unsigned j=1; j<size; j++) midP += getPosition(ringInfo[i].atom[j]);
+      for(unsigned j=1; j<size; j++) {
+        midP += getPosition(ringInfo[i].atom[j]);
+      }
       ringInfo[i].position = midP/6.;
       // compute normal std::vector to plane
       Vector n1 = crossProduct(ringInfo[i].g[2], -ringInfo[i].g[4]);
@@ -1416,37 +1614,69 @@ void CS2Backbone::compute_ring_parameters() {
 
 CS2Backbone::aa_t CS2Backbone::frag2enum(const std::string &aa) {
   aa_t type = ALA;
-  if (aa == "ALA") type = ALA;
-  else if (aa == "ARG") type = ARG;
-  else if (aa == "ASN") type = ASN;
-  else if (aa == "ASP") type = ASP;
-  else if (aa == "ASH") type = ASP;
-  else if (aa == "CYS") type = CYS;
-  else if (aa == "CYM") type = CYS;
-  else if (aa == "GLN") type = GLN;
-  else if (aa == "GLU") type = GLU;
-  else if (aa == "GLH") type = GLU;
-  else if (aa == "GLY") type = GLY;
-  else if (aa == "HIS") type = HIS;
-  else if (aa == "HSE") type = HIS;
-  else if (aa == "HIE") type = HIS;
-  else if (aa == "HSP") type = HIS;
-  else if (aa == "HIP") type = HIS;
-  else if (aa == "HSD") type = HIS;
-  else if (aa == "HID") type = HIS;
-  else if (aa == "ILE") type = ILE;
-  else if (aa == "LEU") type = LEU;
-  else if (aa == "LYS") type = LYS;
-  else if (aa == "MET") type = MET;
-  else if (aa == "PHE") type = PHE;
-  else if (aa == "PRO") type = PRO;
-  else if (aa == "SER") type = SER;
-  else if (aa == "THR") type = THR;
-  else if (aa == "TRP") type = TRP;
-  else if (aa == "TYR") type = TYR;
-  else if (aa == "VAL") type = VAL;
-  else if (aa == "UNK") type = UNK;
-  else plumed_merror("Error converting std::string " + aa + " into amino acid index: not a valid 3-letter code");
+  if (aa == "ALA") {
+    type = ALA;
+  } else if (aa == "ARG") {
+    type = ARG;
+  } else if (aa == "ASN") {
+    type = ASN;
+  } else if (aa == "ASP") {
+    type = ASP;
+  } else if (aa == "ASH") {
+    type = ASP;
+  } else if (aa == "CYS") {
+    type = CYS;
+  } else if (aa == "CYM") {
+    type = CYS;
+  } else if (aa == "GLN") {
+    type = GLN;
+  } else if (aa == "GLU") {
+    type = GLU;
+  } else if (aa == "GLH") {
+    type = GLU;
+  } else if (aa == "GLY") {
+    type = GLY;
+  } else if (aa == "HIS") {
+    type = HIS;
+  } else if (aa == "HSE") {
+    type = HIS;
+  } else if (aa == "HIE") {
+    type = HIS;
+  } else if (aa == "HSP") {
+    type = HIS;
+  } else if (aa == "HIP") {
+    type = HIS;
+  } else if (aa == "HSD") {
+    type = HIS;
+  } else if (aa == "HID") {
+    type = HIS;
+  } else if (aa == "ILE") {
+    type = ILE;
+  } else if (aa == "LEU") {
+    type = LEU;
+  } else if (aa == "LYS") {
+    type = LYS;
+  } else if (aa == "MET") {
+    type = MET;
+  } else if (aa == "PHE") {
+    type = PHE;
+  } else if (aa == "PRO") {
+    type = PRO;
+  } else if (aa == "SER") {
+    type = SER;
+  } else if (aa == "THR") {
+    type = THR;
+  } else if (aa == "TRP") {
+    type = TRP;
+  } else if (aa == "TYR") {
+    type = TYR;
+  } else if (aa == "VAL") {
+    type = VAL;
+  } else if (aa == "UNK") {
+    type = UNK;
+  } else {
+    plumed_merror("Error converting std::string " + aa + " into amino acid index: not a valid 3-letter code");
+  }
   return type;
 }
 
@@ -1759,85 +1989,153 @@ std::vector<std::string> CS2Backbone::side_chain_atoms(const std::string &s) {
     sc.push_back( "2HG2" );
     sc.push_back( "3HG2" );
     return sc;
-  } else plumed_merror("Sidechain atoms unknown: " + s);
+  } else {
+    plumed_merror("Sidechain atoms unknown: " + s);
+  }
 }
 
 bool CS2Backbone::isSP2(const std::string & resType, const std::string & atomName) {
   bool sp2 = false;
-  if (atomName == "C") return true;
-  if (atomName == "O") return true;
+  if (atomName == "C") {
+    return true;
+  }
+  if (atomName == "O") {
+    return true;
+  }
 
   if(resType == "TRP") {
-    if      (atomName == "CG")  sp2 = true;
-    else if (atomName == "CD1") sp2 = true;
-    else if (atomName == "CD2") sp2 = true;
-    else if (atomName == "CE2") sp2 = true;
-    else if (atomName == "CE3") sp2 = true;
-    else if (atomName == "CZ2") sp2 = true;
-    else if (atomName == "CZ3") sp2 = true;
-    else if (atomName == "CH2") sp2 = true;
+    if      (atomName == "CG") {
+      sp2 = true;
+    } else if (atomName == "CD1") {
+      sp2 = true;
+    } else if (atomName == "CD2") {
+      sp2 = true;
+    } else if (atomName == "CE2") {
+      sp2 = true;
+    } else if (atomName == "CE3") {
+      sp2 = true;
+    } else if (atomName == "CZ2") {
+      sp2 = true;
+    } else if (atomName == "CZ3") {
+      sp2 = true;
+    } else if (atomName == "CH2") {
+      sp2 = true;
+    }
   } else if (resType == "ASP") {
-    if      (atomName == "CG")  sp2 = true;
-    else if (atomName == "OD1") sp2 = true;
-    else if (atomName == "OD2") sp2 = true;
+    if      (atomName == "CG") {
+      sp2 = true;
+    } else if (atomName == "OD1") {
+      sp2 = true;
+    } else if (atomName == "OD2") {
+      sp2 = true;
+    }
   } else if (resType == "GLU") {
-    if      (atomName == "CD")  sp2 = true;
-    else if (atomName == "OE1") sp2 = true;
-    else if (atomName == "OE2") sp2 = true;
+    if      (atomName == "CD") {
+      sp2 = true;
+    } else if (atomName == "OE1") {
+      sp2 = true;
+    } else if (atomName == "OE2") {
+      sp2 = true;
+    }
   } else if (resType == "ARG") {
-    if (atomName == "CZ") sp2 = true;
+    if (atomName == "CZ") {
+      sp2 = true;
+    }
   } else if (resType == "HIS") {
-    if      (atomName == "CG")  sp2 = true;
-    else if (atomName == "ND1") sp2 = true;
-    else if (atomName == "CD2") sp2 = true;
-    else if (atomName == "CE1") sp2 = true;
-    else if (atomName == "NE2") sp2 = true;
+    if      (atomName == "CG") {
+      sp2 = true;
+    } else if (atomName == "ND1") {
+      sp2 = true;
+    } else if (atomName == "CD2") {
+      sp2 = true;
+    } else if (atomName == "CE1") {
+      sp2 = true;
+    } else if (atomName == "NE2") {
+      sp2 = true;
+    }
   } else if (resType == "PHE") {
-    if      (atomName == "CG")  sp2 = true;
-    else if (atomName == "CD1") sp2 = true;
-    else if (atomName == "CD2") sp2 = true;
-    else if (atomName == "CE1") sp2 = true;
-    else if (atomName == "CE2") sp2 = true;
-    else if (atomName == "CZ")  sp2 = true;
+    if      (atomName == "CG") {
+      sp2 = true;
+    } else if (atomName == "CD1") {
+      sp2 = true;
+    } else if (atomName == "CD2") {
+      sp2 = true;
+    } else if (atomName == "CE1") {
+      sp2 = true;
+    } else if (atomName == "CE2") {
+      sp2 = true;
+    } else if (atomName == "CZ") {
+      sp2 = true;
+    }
   } else if (resType == "TYR") {
-    if      (atomName == "CG")  sp2 = true;
-    else if (atomName == "CD1") sp2 = true;
-    else if (atomName == "CD2") sp2 = true;
-    else if (atomName == "CE1") sp2 = true;
-    else if (atomName == "CE2") sp2 = true;
-    else if (atomName == "CZ")  sp2 = true;
+    if      (atomName == "CG") {
+      sp2 = true;
+    } else if (atomName == "CD1") {
+      sp2 = true;
+    } else if (atomName == "CD2") {
+      sp2 = true;
+    } else if (atomName == "CE1") {
+      sp2 = true;
+    } else if (atomName == "CE2") {
+      sp2 = true;
+    } else if (atomName == "CZ") {
+      sp2 = true;
+    }
   } else if (resType == "ASN") {
-    if      (atomName == "CG")  sp2 = true;
-    else if (atomName == "OD1") sp2 = true;
+    if      (atomName == "CG") {
+      sp2 = true;
+    } else if (atomName == "OD1") {
+      sp2 = true;
+    }
   } else if (resType == "GLN") {
-    if      (atomName == "CD")  sp2 = true;
-    else if (atomName == "OE1") sp2 = true;
+    if      (atomName == "CD") {
+      sp2 = true;
+    } else if (atomName == "OE1") {
+      sp2 = true;
+    }
   }
 
   return sp2;
 }
 
 bool CS2Backbone::is_chi1_cx(const std::string & frg, const std::string & atm) {
-  if(atm=="CG")                                        return true;
-  if((frg == "CYS")&&(atm =="SG"))                     return true;
-  if(((frg == "ILE")||(frg == "VAL"))&&(atm == "CG1")) return true;
-  if((frg == "SER")&&(atm == "OG"))                    return true;
-  if((frg == "THR")&&(atm == "OG1"))                   return true;
+  if(atm=="CG") {
+    return true;
+  }
+  if((frg == "CYS")&&(atm =="SG")) {
+    return true;
+  }
+  if(((frg == "ILE")||(frg == "VAL"))&&(atm == "CG1")) {
+    return true;
+  }
+  if((frg == "SER")&&(atm == "OG")) {
+    return true;
+  }
+  if((frg == "THR")&&(atm == "OG1")) {
+    return true;
+  }
 
   return false;
 }
 
 void CS2Backbone::xdist_name_map(std::string & name) {
-  if((name == "OT1")||(name == "OC1")) name = "O";
-  else if ((name == "HN") || (name == "HT1") || (name == "H1")) name = "H";
-  else if ((name == "CG1")|| (name == "OG")||
-           (name == "SG") || (name == "OG1")) name = "CG";
-  else if ((name == "HA1")|| (name == "HA3")) name = "HA";
+  if((name == "OT1")||(name == "OC1")) {
+    name = "O";
+  } else if ((name == "HN") || (name == "HT1") || (name == "H1")) {
+    name = "H";
+  } else if ((name == "CG1")|| (name == "OG")||
+             (name == "SG") || (name == "OG1")) {
+    name = "CG";
+  } else if ((name == "HA1")|| (name == "HA3")) {
+    name = "HA";
+  }
 }
 
 void CS2Backbone::update() {
   // write status file
-  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) writeStatus();
+  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) {
+    writeStatus();
+  }
 }
 
 }
diff --git a/src/isdb/Caliber.cpp b/src/isdb/Caliber.cpp
index 338df29e47..9059ebec34 100644
--- a/src/isdb/Caliber.cpp
+++ b/src/isdb/Caliber.cpp
@@ -144,20 +144,27 @@ Caliber::Caliber(const ActionOptions&ao):
   scale_(1),
   doregres_zero_(false),
   nregres_zero_(0),
-  optsigmamean_stride_(0)
-{
+  optsigmamean_stride_(0) {
   parse("KAPPA",mult);
   std::string filename;
   parse("FILE",filename);
-  if( filename.length()==0 ) error("No external variable file was specified");
+  if( filename.length()==0 ) {
+    error("No external variable file was specified");
+  }
   unsigned averaging=0;
   parse("AVERAGING", averaging);
-  if(averaging>0) optsigmamean_stride_ = averaging;
+  if(averaging>0) {
+    optsigmamean_stride_ = averaging;
+  }
   double tscale=1.0;
   parse("TSCALE", tscale);
-  if(tscale<=0.) error("The time scale factor must be greater than 0.");
+  if(tscale<=0.) {
+    error("The time scale factor must be greater than 0.");
+  }
   parse("SCALE", scale_);
-  if(scale_==0.) error("The time scale factor cannot be 0.");
+  if(scale_==0.) {
+    error("The time scale factor cannot be 0.");
+  }
   // regression with zero intercept
   parse("REGRES_ZERO", nregres_zero_);
   if(nregres_zero_>0) {
@@ -177,7 +184,9 @@ Caliber::Caliber(const ActionOptions&ao):
   if(master) {
     nrep_    = multi_sim_comm.Get_size();
     replica_ = multi_sim_comm.Get_rank();
-    if(noensemble) nrep_ = 1;
+    if(noensemble) {
+      nrep_ = 1;
+    }
   } else {
     nrep_    = 0;
     replica_ = 0;
@@ -188,11 +197,15 @@ Caliber::Caliber(const ActionOptions&ao):
   const unsigned narg = getNumberOfArguments();
   sigma_mean2_.resize(narg,1);
   sigma_mean2_last_.resize(narg);
-  for(unsigned j=0; j<narg; j++) sigma_mean2_last_[j].push_back(0.000001);
+  for(unsigned j=0; j<narg; j++) {
+    sigma_mean2_last_[j].push_back(0.000001);
+  }
 
   log.printf("  Time resolved data from file %s\n",filename.c_str());
   std::ifstream varfile(filename.c_str());
-  if(varfile.fail()) error("Cannot open "+filename);
+  if(varfile.fail()) {
+    error("Cannot open "+filename);
+  }
   var.resize(narg);
   dvar.resize(narg);
   while (!varfile.eof()) {
@@ -209,17 +222,28 @@ Caliber::Caliber(const ActionOptions&ao):
   const double deltat = time[1] - time[0];
   for(unsigned i=0; i<narg; i++) {
     for(unsigned j=0; j<var[i].size(); j++) {
-      if(j==0) dvar[i].push_back((var[i][j+1] - var[i][j])/(deltat));
-      else if(j==var[i].size()-1) dvar[i].push_back((var[i][j] - var[i][j-1])/(deltat));
-      else dvar[i].push_back((var[i][j+1] - var[i][j-1])/(2.*deltat));
+      if(j==0) {
+        dvar[i].push_back((var[i][j+1] - var[i][j])/(deltat));
+      } else if(j==var[i].size()-1) {
+        dvar[i].push_back((var[i][j] - var[i][j-1])/(deltat));
+      } else {
+        dvar[i].push_back((var[i][j+1] - var[i][j-1])/(2.*deltat));
+      }
     }
   }
 
   for(unsigned i=0; i<narg; i++) {
-    std::string num; Tools::convert(i,num);
-    addComponent("x0-"+num); componentIsNotPeriodic("x0-"+num); x0comp.push_back(getPntrToComponent("x0-"+num));
-    addComponent("kappa-"+num); componentIsNotPeriodic("kappa-"+num); kcomp.push_back(getPntrToComponent("kappa-"+num));
-    addComponent("mean-"+num); componentIsNotPeriodic("mean-"+num); mcomp.push_back(getPntrToComponent("mean-"+num));
+    std::string num;
+    Tools::convert(i,num);
+    addComponent("x0-"+num);
+    componentIsNotPeriodic("x0-"+num);
+    x0comp.push_back(getPntrToComponent("x0-"+num));
+    addComponent("kappa-"+num);
+    componentIsNotPeriodic("kappa-"+num);
+    kcomp.push_back(getPntrToComponent("kappa-"+num));
+    addComponent("mean-"+num);
+    componentIsNotPeriodic("mean-"+num);
+    mcomp.push_back(getPntrToComponent("mean-"+num));
   }
 
   if(doregres_zero_) {
@@ -231,19 +255,23 @@ Caliber::Caliber(const ActionOptions&ao):
   log<<"  Bibliography "<<plumed.cite("Capelli, Tiana, Camilloni, J Chem Phys, 148, 184114");
 }
 
-void Caliber::get_sigma_mean(const double fact, const std::vector<double> &mean)
-{
+void Caliber::get_sigma_mean(const double fact, const std::vector<double> &mean) {
   const unsigned narg = getNumberOfArguments();
   const double dnrep = static_cast<double>(nrep_);
 
-  if(sigma_mean2_last_[0].size()==optsigmamean_stride_) for(unsigned i=0; i<narg; ++i) sigma_mean2_last_[i].erase(sigma_mean2_last_[i].begin());
+  if(sigma_mean2_last_[0].size()==optsigmamean_stride_)
+    for(unsigned i=0; i<narg; ++i) {
+      sigma_mean2_last_[i].erase(sigma_mean2_last_[i].begin());
+    }
   std::vector<double> sigma_mean2_now(narg,0);
   if(master) {
     for(unsigned i=0; i<narg; ++i) {
       double tmp = getArgument(i)-mean[i];
       sigma_mean2_now[i] = fact*tmp*tmp;
     }
-    if(nrep_>1) multi_sim_comm.Sum(&sigma_mean2_now[0], narg);
+    if(nrep_>1) {
+      multi_sim_comm.Sum(&sigma_mean2_now[0], narg);
+    }
   }
   comm.Sum(&sigma_mean2_now[0], narg);
 
@@ -253,35 +281,44 @@ void Caliber::get_sigma_mean(const double fact, const std::vector<double> &mean)
   }
 }
 
-void Caliber::replica_averaging(const double fact, std::vector<double> &mean)
-{
+void Caliber::replica_averaging(const double fact, std::vector<double> &mean) {
   const unsigned narg = getNumberOfArguments();
   if(master) {
-    for(unsigned i=0; i<narg; ++i) mean[i] = fact*getArgument(i);
-    if(nrep_>1) multi_sim_comm.Sum(&mean[0], narg);
+    for(unsigned i=0; i<narg; ++i) {
+      mean[i] = fact*getArgument(i);
+    }
+    if(nrep_>1) {
+      multi_sim_comm.Sum(&mean[0], narg);
+    }
   }
   comm.Sum(&mean[0], narg);
 }
 
-double Caliber::getSpline(const unsigned iarg)
-{
+double Caliber::getSpline(const unsigned iarg) {
   const double deltat = time[1] - time[0];
   const int tindex = static_cast<int>(getTime()/deltat);
 
   unsigned start, end;
   start=tindex;
-  if(tindex+1<var[iarg].size()) end=tindex+2;
-  else end=var[iarg].size();
+  if(tindex+1<var[iarg].size()) {
+    end=tindex+2;
+  } else {
+    end=var[iarg].size();
+  }
 
   double value=0;
   for(unsigned ipoint=start; ipoint<end; ++ipoint) {
     double grid=var[iarg][ipoint];
     double dder=dvar[iarg][ipoint];
     double yy=0.;
-    if(std::abs(grid)>0.0000001) yy=-dder/grid;
+    if(std::abs(grid)>0.0000001) {
+      yy=-dder/grid;
+    }
 
     int x0=1;
-    if(ipoint==tindex) x0=0;
+    if(ipoint==tindex) {
+      x0=0;
+    }
 
     double X=std::abs((getTime()-time[tindex])/deltat-(double)x0);
     double X2=X*X;
@@ -293,8 +330,7 @@ double Caliber::getSpline(const unsigned iarg)
   return value;
 }
 
-void Caliber::do_regression_zero(const std::vector<double> &mean)
-{
+void Caliber::do_regression_zero(const std::vector<double> &mean) {
 // parameters[i] = scale_ * mean[i]: find scale_ with linear regression
   double num = 0.0;
   double den = 0.0;
@@ -309,8 +345,7 @@ void Caliber::do_regression_zero(const std::vector<double> &mean)
   }
 }
 
-void Caliber::calculate()
-{
+void Caliber::calculate() {
   const unsigned narg = getNumberOfArguments();
   const double dnrep = static_cast<double>(nrep_);
   const double fact = 1.0/dnrep;
@@ -318,10 +353,14 @@ void Caliber::calculate()
   std::vector<double> mean(narg,0);
   std::vector<double> dmean_x(narg,fact);
   replica_averaging(fact, mean);
-  if(optsigmamean_stride_>0) get_sigma_mean(fact, mean);
+  if(optsigmamean_stride_>0) {
+    get_sigma_mean(fact, mean);
+  }
 
   // in case of regression with zero intercept, calculate scale
-  if(doregres_zero_ && getStep()%nregres_zero_==0) do_regression_zero(mean);
+  if(doregres_zero_ && getStep()%nregres_zero_==0) {
+    do_regression_zero(mean);
+  }
 
   double ene=0;
   for(unsigned i=0; i<narg; ++i) {
@@ -336,7 +375,9 @@ void Caliber::calculate()
     mcomp[i]->set(mean[i]);
   }
 
-  if(doregres_zero_) valueScale->set(scale_);
+  if(doregres_zero_) {
+    valueScale->set(scale_);
+  }
 
   setBias(ene);
 }
diff --git a/src/isdb/EMMI.cpp b/src/isdb/EMMI.cpp
index e79b63c4c7..f9eaf05ed5 100644
--- a/src/isdb/EMMI.cpp
+++ b/src/isdb/EMMI.cpp
@@ -110,8 +110,7 @@ PRINT ARG=emr.* FILE=COLVAR STRIDE=500 FMT=%20.10f
 class EMMI :
   public ActionAtomistic,
   public ActionWithArguments,
-  public ActionWithValue
-{
+  public ActionWithValue {
 private:
 
 // temperature in kbt
@@ -293,8 +292,11 @@ void EMMI::setDerivatives() {
   }
 
   // Resize all derivative arrays
-  forces.resize( nder ); forcesToApply.resize( nder );
-  for(int i=0; i<getNumberOfComponents(); ++i) getPntrToComponent(i)->resizeDerivatives(nder);
+  forces.resize( nder );
+  forcesToApply.resize( nder );
+  for(int i=0; i<getNumberOfComponents(); ++i) {
+    getPntrToComponent(i)->resizeDerivatives(nder);
+  }
 }
 
 inline
@@ -330,27 +332,39 @@ void EMMI::calculateNumericalDerivatives( ActionWithValue* a=NULL ) {
   if( getNumberOfAtoms()>0 ) {
     Matrix<double> save_derivatives( getNumberOfComponents(), getNumberOfArguments() );
     for(int j=0; j<getNumberOfComponents(); ++j) {
-      for(unsigned i=0; i<getNumberOfArguments(); ++i) if(getPntrToComponent(j)->hasDerivatives()) save_derivatives(j,i)=getPntrToComponent(j)->getDerivative(i);
+      for(unsigned i=0; i<getNumberOfArguments(); ++i)
+        if(getPntrToComponent(j)->hasDerivatives()) {
+          save_derivatives(j,i)=getPntrToComponent(j)->getDerivative(i);
+        }
     }
     calculateAtomicNumericalDerivatives( a, getNumberOfArguments() );
     for(int j=0; j<getNumberOfComponents(); ++j) {
-      for(unsigned i=0; i<getNumberOfArguments(); ++i) if(getPntrToComponent(j)->hasDerivatives()) getPntrToComponent(j)->addDerivative( i, save_derivatives(j,i) );
+      for(unsigned i=0; i<getNumberOfArguments(); ++i)
+        if(getPntrToComponent(j)->hasDerivatives()) {
+          getPntrToComponent(j)->addDerivative( i, save_derivatives(j,i) );
+        }
     }
   }
 }
 
 inline
 void EMMI::apply() {
-  bool wasforced=false; forcesToApply.assign(forcesToApply.size(),0.0);
+  bool wasforced=false;
+  forcesToApply.assign(forcesToApply.size(),0.0);
   for(int i=0; i<getNumberOfComponents(); ++i) {
     if( getPntrToComponent(i)->applyForce( forces ) ) {
       wasforced=true;
-      for(unsigned i=0; i<forces.size(); ++i) forcesToApply[i]+=forces[i];
+      for(unsigned i=0; i<forces.size(); ++i) {
+        forcesToApply[i]+=forces[i];
+      }
     }
   }
   if( wasforced ) {
-    unsigned ind=0; addForcesOnArguments( 0, forcesToApply, ind, getLabel() );
-    if( getNumberOfAtoms()>0 ) setForcesOnAtoms( forcesToApply, ind );
+    unsigned ind=0;
+    addForcesOnArguments( 0, forcesToApply, ind, getLabel() );
+    if( getNumberOfAtoms()>0 ) {
+      setForcesOnAtoms( forcesToApply, ind );
+    }
   }
 }
 
@@ -445,8 +459,7 @@ EMMI::EMMI(const ActionOptions&ao):
   nregres_(0), scale_(1.),
   dpcutoff_(15.0), nexp_(1000000), nanneal_(0),
   kanneal_(0.), anneal_(1.), prior_(1.), ovstride_(0),
-  do_reweight_(false), first_time_w_(true), decay_w_(1.)
-{
+  do_reweight_(false), first_time_w_(true), decay_w_(1.) {
   // periodic boundary conditions
   bool nopbc=!pbc_;
   parseFlag("NOPBC",nopbc);
@@ -463,33 +476,51 @@ EMMI::EMMI(const ActionOptions&ao):
   // type of data noise
   std::string noise;
   parse("NOISETYPE",noise);
-  if      (noise=="GAUSS")   noise_ = 0;
-  else if(noise=="OUTLIERS") noise_ = 1;
-  else if(noise=="MARGINAL") noise_ = 2;
-  else error("Unknown noise type!");
+  if      (noise=="GAUSS") {
+    noise_ = 0;
+  } else if(noise=="OUTLIERS") {
+    noise_ = 1;
+  } else if(noise=="MARGINAL") {
+    noise_ = 2;
+  } else {
+    error("Unknown noise type!");
+  }
 
   // minimum value for error
   double sigma_min;
   parse("SIGMA_MIN", sigma_min);
-  if(sigma_min<0) error("SIGMA_MIN should be greater or equal to zero");
+  if(sigma_min<0) {
+    error("SIGMA_MIN should be greater or equal to zero");
+  }
 
   // the following parameters must be specified with noise type 0 and 1
   double sigma_ini, dsigma;
   if(noise_!=2) {
     // initial value of the uncertainty
     parse("SIGMA0", sigma_ini);
-    if(sigma_ini<=0) error("you must specify a positive SIGMA0");
+    if(sigma_ini<=0) {
+      error("you must specify a positive SIGMA0");
+    }
     // MC parameters
     parse("DSIGMA", dsigma);
-    if(dsigma<0) error("you must specify a positive DSIGMA");
+    if(dsigma<0) {
+      error("you must specify a positive DSIGMA");
+    }
     parse("MC_STRIDE", MCstride_);
-    if(dsigma>0 && MCstride_<=0) error("you must specify a positive MC_STRIDE");
+    if(dsigma>0 && MCstride_<=0) {
+      error("you must specify a positive MC_STRIDE");
+    }
     // status file parameters
     parse("WRITE_STRIDE", statusstride_);
-    if(statusstride_==0) error("you must specify a positive WRITE_STRIDE");
+    if(statusstride_==0) {
+      error("you must specify a positive WRITE_STRIDE");
+    }
     parse("STATUS_FILE",  statusfilename_);
-    if(statusfilename_=="") statusfilename_ = "MISTATUS"+getLabel();
-    else                    statusfilename_ = statusfilename_+getLabel();
+    if(statusfilename_=="") {
+      statusfilename_ = "MISTATUS"+getLabel();
+    } else {
+      statusfilename_ = statusfilename_+getLabel();
+    }
   }
 
   // error file
@@ -513,7 +544,9 @@ EMMI::EMMI(const ActionOptions&ao):
   // simulated annealing stuff
   parse("ANNEAL", nanneal_);
   parse("ANNEAL_FACT", kanneal_);
-  if(nanneal_>0 && kanneal_<=1.0) error("with ANNEAL, ANNEAL_FACT must be greater than 1");
+  if(nanneal_>0 && kanneal_<=1.0) {
+    error("with ANNEAL, ANNEAL_FACT must be greater than 1");
+  }
 
   // regression stride
   parse("REGRESSION",nregres_);
@@ -523,8 +556,12 @@ EMMI::EMMI(const ActionOptions&ao):
     parse("REG_SCALE_MAX",scale_max_);
     parse("REG_DSCALE",dscale_);
     // checks
-    if(scale_max_<=scale_min_) error("with REGRESSION, REG_SCALE_MAX must be greater than REG_SCALE_MIN");
-    if(dscale_<=0.) error("with REGRESSION, REG_DSCALE must be positive");
+    if(scale_max_<=scale_min_) {
+      error("with REGRESSION, REG_SCALE_MAX must be greater than REG_SCALE_MIN");
+    }
+    if(dscale_<=0.) {
+      error("with REGRESSION, REG_DSCALE must be positive");
+    }
   }
 
   // scale factor
@@ -533,13 +570,19 @@ EMMI::EMMI(const ActionOptions&ao):
   // read map resolution
   double reso;
   parse("RESOLUTION", reso);
-  if(reso<=0.) error("RESOLUTION should be strictly positive");
+  if(reso<=0.) {
+    error("RESOLUTION should be strictly positive");
+  }
 
   // neighbor list stuff
   parse("NL_CUTOFF",nl_cutoff_);
-  if(nl_cutoff_<=0.0) error("NL_CUTOFF should be explicitly specified and positive");
+  if(nl_cutoff_<=0.0) {
+    error("NL_CUTOFF should be explicitly specified and positive");
+  }
   parse("NL_STRIDE",nl_stride_);
-  if(nl_stride_==0) error("NL_STRIDE should be explicitly specified and positive");
+  if(nl_stride_==0) {
+    error("NL_STRIDE should be explicitly specified and positive");
+  }
 
   // averaging or not
   parseFlag("NO_AVER",no_aver_);
@@ -547,7 +590,9 @@ EMMI::EMMI(const ActionOptions&ao):
   // write overlap file
   parse("WRITE_OV_STRIDE", ovstride_);
   parse("WRITE_OV", ovfilename_);
-  if(ovstride_>0 && ovfilename_=="") error("With WRITE_OV_STRIDE you must specify WRITE_OV");
+  if(ovstride_>0 && ovfilename_=="") {
+    error("With WRITE_OV_STRIDE you must specify WRITE_OV");
+  }
 
   // set parallel stuff
   size_=comm.Get_size();
@@ -570,11 +615,20 @@ EMMI::EMMI(const ActionOptions&ao):
 
   // Reweighting flag
   parseFlag("REWEIGHT", do_reweight_);
-  if(do_reweight_&&getNumberOfArguments()!=1) error("To REWEIGHT one must provide one single bias as an argument");
-  if(do_reweight_&&no_aver_) error("REWEIGHT cannot be used with NO_AVER");
-  if(do_reweight_&&nrep_<2) error("REWEIGHT can only be used in parallel with 2 or more replicas");
-  if(!getRestart()) average_weights_.resize(nrep_, 1./static_cast<double>(nrep_));
-  else average_weights_.resize(nrep_, 0.);
+  if(do_reweight_&&getNumberOfArguments()!=1) {
+    error("To REWEIGHT one must provide one single bias as an argument");
+  }
+  if(do_reweight_&&no_aver_) {
+    error("REWEIGHT cannot be used with NO_AVER");
+  }
+  if(do_reweight_&&nrep_<2) {
+    error("REWEIGHT can only be used in parallel with 2 or more replicas");
+  }
+  if(!getRestart()) {
+    average_weights_.resize(nrep_, 1./static_cast<double>(nrep_));
+  } else {
+    average_weights_.resize(nrep_, 0.);
+  }
 
   unsigned averaging=0;
   parse("AVERAGING", averaging);
@@ -585,10 +639,14 @@ EMMI::EMMI(const ActionOptions&ao):
   checkRead();
 
   log.printf("  atoms involved : ");
-  for(unsigned i=0; i<atoms.size(); ++i) log.printf("%d ",atoms[i].serial());
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf("%d ",atoms[i].serial());
+  }
   log.printf("\n");
   log.printf("  GMM data file : %s\n", GMM_file.c_str());
-  if(no_aver_) log.printf("  without ensemble averaging\n");
+  if(no_aver_) {
+    log.printf("  without ensemble averaging\n");
+  }
   log.printf("  type of data noise : %s\n", noise.c_str());
   log.printf("  neighbor list cutoff : %lf\n", nl_cutoff_);
   log.printf("  neighbor list stride : %u\n",  nl_stride_);
@@ -607,8 +665,12 @@ EMMI::EMMI(const ActionOptions&ao):
     log.printf("  reading/writing to status file : %s\n",statusfilename_.c_str());
     log.printf("  with stride : %u\n",statusstride_);
   }
-  if(errfile.size()>0) log.printf("  reading experimental errors from file : %s\n", errfile.c_str());
-  if(ovfile.size()>0)  log.printf("  reading experimental overlaps from file : %s\n", ovfile.c_str());
+  if(errfile.size()>0) {
+    log.printf("  reading experimental errors from file : %s\n", errfile.c_str());
+  }
+  if(ovfile.size()>0) {
+    log.printf("  reading experimental overlaps from file : %s\n", ovfile.c_str());
+  }
   log.printf("  temperature of the system in energy unit : %f\n",kbt_);
   log.printf("  prior exponent : %f\n",prior_);
   log.printf("  number of replicas for averaging: %u\n",nrep_);
@@ -633,14 +695,20 @@ EMMI::EMMI(const ActionOptions&ao):
   log.printf("  number of GMM components : %u\n", static_cast<unsigned>(GMM_d_m_.size()));
 
   // normalize atom weight map
-  if(norm_d <= 0.0) norm_d = accumulate(GMM_d_w_.begin(), GMM_d_w_.end(), 0.0);
+  if(norm_d <= 0.0) {
+    norm_d = accumulate(GMM_d_w_.begin(), GMM_d_w_.end(), 0.0);
+  }
   double norm_m = accumulate(GMM_m_w.begin(),  GMM_m_w.end(),  0.0);
   // renormalization
-  for(unsigned i=0; i<GMM_m_w_.size(); ++i) GMM_m_w_[i] *= norm_d / norm_m;
+  for(unsigned i=0; i<GMM_m_w_.size(); ++i) {
+    GMM_m_w_[i] *= norm_d / norm_m;
+  }
 
   // read experimental errors
   std::vector<double> exp_err;
-  if(errfile.size()>0) exp_err = read_exp_errors(errfile);
+  if(errfile.size()>0) {
+    exp_err = read_exp_errors(errfile);
+  }
 
   // get self overlaps between data GMM components
   if(ovfile.size()>0) {
@@ -664,8 +732,11 @@ EMMI::EMMI(const ActionOptions&ao):
       // GMM id
       int GMMid = GMM_d_grps_[Gid][i];
       // add to experimental error
-      if(errfile.size()>0) err.push_back(exp_err[GMMid]);
-      else                 err.push_back(0.);
+      if(errfile.size()>0) {
+        err.push_back(exp_err[GMMid]);
+      } else {
+        err.push_back(0.);
+      }
       // add to GMM overlap
       ovdd.push_back(ovdd_[GMMid]);
     }
@@ -690,7 +761,9 @@ EMMI::EMMI(const ActionOptions&ao):
   }
 
   // read status file if restarting
-  if(getRestart() && noise_!=2) read_status();
+  if(getRestart() && noise_!=2) {
+    read_status();
+  }
 
   // calculate auxiliary stuff
   calculate_useful_stuff(reso);
@@ -705,17 +778,27 @@ EMMI::EMMI(const ActionOptions&ao):
   GMM_d_cov_.clear();
 
   // add components
-  addComponentWithDerivatives("scoreb"); componentIsNotPeriodic("scoreb");
+  addComponentWithDerivatives("scoreb");
+  componentIsNotPeriodic("scoreb");
 
-  if(noise_!=2) {addComponent("acc"); componentIsNotPeriodic("acc");}
+  if(noise_!=2) {
+    addComponent("acc");
+    componentIsNotPeriodic("acc");
+  }
 
   if(nregres_>0) {
-    addComponent("scale");     componentIsNotPeriodic("scale");
-    addComponent("accscale");  componentIsNotPeriodic("accscale");
-    addComponent("enescale");  componentIsNotPeriodic("enescale");
+    addComponent("scale");
+    componentIsNotPeriodic("scale");
+    addComponent("accscale");
+    componentIsNotPeriodic("accscale");
+    addComponent("enescale");
+    componentIsNotPeriodic("enescale");
   }
 
-  if(nanneal_>0) {addComponent("anneal"); componentIsNotPeriodic("anneal");}
+  if(nanneal_>0) {
+    addComponent("anneal");
+    componentIsNotPeriodic("anneal");
+  }
 
   if(do_reweight_) {
     addComponent("biasDer");
@@ -728,15 +811,20 @@ EMMI::EMMI(const ActionOptions&ao):
   componentIsNotPeriodic("neff");
 
   for(unsigned i=0; i<sigma_.size(); ++i) {
-    std::string num; Tools::convert(i, num);
-    addComponent("sigma-"+num); componentIsNotPeriodic("sigma-"+num);
+    std::string num;
+    Tools::convert(i, num);
+    addComponent("sigma-"+num);
+    componentIsNotPeriodic("sigma-"+num);
     getPntrToComponent("sigma-"+num)->set(sigma_[i]);
   }
 
   // initialize random seed
   unsigned iseed;
-  if(rank_==0) iseed = time(NULL)+replica_;
-  else iseed = 0;
+  if(rank_==0) {
+    iseed = time(NULL)+replica_;
+  } else {
+    iseed = 0;
+  }
   comm.Sum(&iseed, 1);
   random_.setSeed(-iseed);
 
@@ -748,16 +836,20 @@ EMMI::EMMI(const ActionOptions&ao):
   log<<"  Bibliography "<<plumed.cite("Bonomi, Camilloni, Bioinformatics, 33, 3999 (2017)");
   log<<plumed.cite("Hanot, Bonomi, Greenberg, Sali, Nilges, Vendruscolo, Pellarin, bioRxiv doi: 10.1101/113951 (2017)");
   log<<plumed.cite("Bonomi, Pellarin, Vendruscolo, Biophys. J. 114, 1604 (2018)");
-  if(do_reweight_) log<<plumed.cite("Bonomi, Camilloni, Vendruscolo, Sci. Rep. 6, 31232 (2016)");
-  if(!no_aver_ && nrep_>1)log<<plumed.cite("Bonomi, Camilloni, Cavalli, Vendruscolo, Sci. Adv. 2, e150117 (2016)");
+  if(do_reweight_) {
+    log<<plumed.cite("Bonomi, Camilloni, Vendruscolo, Sci. Rep. 6, 31232 (2016)");
+  }
+  if(!no_aver_ && nrep_>1) {
+    log<<plumed.cite("Bonomi, Camilloni, Cavalli, Vendruscolo, Sci. Adv. 2, e150117 (2016)");
+  }
   log<<"\n";
 }
 
-void EMMI::write_model_overlap(long long int step)
-{
+void EMMI::write_model_overlap(long long int step) {
   OFile ovfile;
   ovfile.link(*this);
-  std::string num; Tools::convert(step,num);
+  std::string num;
+  Tools::convert(step,num);
   std::string name = ovfilename_+"-"+num;
   ovfile.open(name);
   ovfile.setHeavyFlush();
@@ -772,8 +864,7 @@ void EMMI::write_model_overlap(long long int step)
   ovfile.close();
 }
 
-double EMMI::get_median(std::vector<double> &v)
-{
+double EMMI::get_median(std::vector<double> &v) {
 // dimension of std::vector
   unsigned size = v.size();
 // in case of only one entry
@@ -791,8 +882,7 @@ double EMMI::get_median(std::vector<double> &v)
   }
 }
 
-void EMMI::read_status()
-{
+void EMMI::read_status() {
   double MDtime;
 // open file
   auto ifile = Tools::make_unique<IFile>();
@@ -802,7 +892,8 @@ void EMMI::read_status()
     while(ifile->scanField("MD_time", MDtime)) {
       for(unsigned i=0; i<sigma_.size(); ++i) {
         // convert i to std::string
-        std::string num; Tools::convert(i,num);
+        std::string num;
+        Tools::convert(i,num);
         // read entries
         ifile->scanField("s"+num, sigma_[i]);
       }
@@ -815,8 +906,7 @@ void EMMI::read_status()
   }
 }
 
-void EMMI::print_status(long long int step)
-{
+void EMMI::print_status(long long int step) {
 // if first time open the file
   if(first_status_) {
     first_status_ = false;
@@ -830,7 +920,8 @@ void EMMI::print_status(long long int step)
   statusfile_.printField("MD_time", MDtime);
   for(unsigned i=0; i<sigma_.size(); ++i) {
     // convert i to std::string
-    std::string num; Tools::convert(i,num);
+    std::string num;
+    Tools::convert(i,num);
     // print entry
     statusfile_.printField("s"+num, sigma_[i]);
   }
@@ -847,24 +938,31 @@ bool EMMI::doAccept(double oldE, double newE, double kbt) {
   } else {
     // otherwise extract random number
     double s = random_.RandU01();
-    if( s < std::exp(-delta) ) { accept = true; }
+    if( s < std::exp(-delta) ) {
+      accept = true;
+    }
   }
   return accept;
 }
 
-void EMMI::doMonteCarlo()
-{
+void EMMI::doMonteCarlo() {
   // extract random GMM group
   unsigned nGMM = static_cast<unsigned>(std::floor(random_.RandU01()*static_cast<double>(GMM_d_grps_.size())));
-  if(nGMM==GMM_d_grps_.size()) nGMM -= 1;
+  if(nGMM==GMM_d_grps_.size()) {
+    nGMM -= 1;
+  }
 
   // generate random move
   double shift = dsigma_[nGMM] * ( 2.0 * random_.RandU01() - 1.0 );
   // new sigma
   double new_s = sigma_[nGMM] + shift;
   // check boundaries
-  if(new_s > sigma_max_[nGMM]) {new_s = 2.0 * sigma_max_[nGMM] - new_s;}
-  if(new_s < sigma_min_[nGMM]) {new_s = 2.0 * sigma_min_[nGMM] - new_s;}
+  if(new_s > sigma_max_[nGMM]) {
+    new_s = 2.0 * sigma_max_[nGMM] - new_s;
+  }
+  if(new_s < sigma_min_[nGMM]) {
+    new_s = 2.0 * sigma_min_[nGMM] - new_s;
+  }
   // old s2
   double old_inv_s2 = 1.0 / sigma_[nGMM] / sigma_[nGMM];
   // new s2
@@ -918,7 +1016,9 @@ void EMMI::doMonteCarlo()
   }
   // local communication
   if(rank_!=0) {
-    for(unsigned i=0; i<sigma_.size(); ++i) sigma_[i] = 0.0;
+    for(unsigned i=0; i<sigma_.size(); ++i) {
+      sigma_[i] = 0.0;
+    }
     MCaccept_ = 0.0;
   }
   if(size_>1) {
@@ -927,12 +1027,12 @@ void EMMI::doMonteCarlo()
   }
 
   // update sigma output
-  std::string num; Tools::convert(nGMM, num);
+  std::string num;
+  Tools::convert(nGMM, num);
   getPntrToComponent("sigma-"+num)->set(sigma_[nGMM]);
 }
 
-std::vector<double> EMMI::read_exp_errors(const std::string & errfile)
-{
+std::vector<double> EMMI::read_exp_errors(const std::string & errfile) {
   int nexp, idcomp;
   double err;
   std::vector<double> exp_err;
@@ -948,7 +1048,8 @@ std::vector<double> EMMI::read_exp_errors(const std::string & errfile)
       double err_tot = 0.0;
       // cycle on number of experimental overlaps
       for(unsigned i=0; i<nexp; ++i) {
-        std::string ss; Tools::convert(i,ss);
+        std::string ss;
+        Tools::convert(i,ss);
         ifile->scanField("Err"+ss, err);
         // add to total error
         err_tot += err*err;
@@ -967,8 +1068,7 @@ std::vector<double> EMMI::read_exp_errors(const std::string & errfile)
   return exp_err;
 }
 
-std::vector<double> EMMI::read_exp_overlaps(const std::string & ovfile)
-{
+std::vector<double> EMMI::read_exp_overlaps(const std::string & ovfile) {
   int idcomp;
   double ov;
   std::vector<double> ovdd;
@@ -992,8 +1092,7 @@ std::vector<double> EMMI::read_exp_overlaps(const std::string & ovfile)
   return ovdd;
 }
 
-std::vector<double> EMMI::get_GMM_m(std::vector<AtomNumber> &atoms)
-{
+std::vector<double> EMMI::get_GMM_m(std::vector<AtomNumber> &atoms) {
   // list of weights - one per atom
   std::vector<double> GMM_m_w;
 
@@ -1051,24 +1150,25 @@ std::vector<double> EMMI::get_GMM_m(std::vector<AtomNumber> &atoms)
   return GMM_m_w;
 }
 
-void EMMI::check_GMM_d(const VectorGeneric<6> &cov, double w)
-{
+void EMMI::check_GMM_d(const VectorGeneric<6> &cov, double w) {
 
 // check if positive defined, by calculating the 3 leading principal minors
   double pm1 = cov[0];
   double pm2 = cov[0]*cov[3]-cov[1]*cov[1];
   double pm3 = cov[0]*(cov[3]*cov[5]-cov[4]*cov[4])-cov[1]*(cov[1]*cov[5]-cov[4]*cov[2])+cov[2]*(cov[1]*cov[4]-cov[3]*cov[2]);
 // apply Sylvester’s criterion
-  if(pm1<=0.0 || pm2<=0.0 || pm3<=0.0)
+  if(pm1<=0.0 || pm2<=0.0 || pm3<=0.0) {
     error("check data GMM: covariance matrix is not positive defined");
+  }
 
 // check if weight is positive
-  if(w<=0) error("check data GMM: weight must be positive");
+  if(w<=0) {
+    error("check data GMM: weight must be positive");
+  }
 }
 
 // read GMM data file in PLUMED format:
-void EMMI::get_GMM_d(const std::string & GMM_file)
-{
+void EMMI::get_GMM_d(const std::string & GMM_file) {
   VectorGeneric<6> cov;
 
 // open file
@@ -1093,7 +1193,9 @@ void EMMI::get_GMM_d(const std::string & GMM_file)
       // check input
       check_GMM_d(cov, w);
       // check beta
-      if(beta<0) error("Beta must be positive!");
+      if(beta<0) {
+        error("Beta must be positive!");
+      }
       // center of the Gaussian
       GMM_d_m_.push_back(Vector(m0,m1,m2));
       // covariance matrix
@@ -1114,13 +1216,14 @@ void EMMI::get_GMM_d(const std::string & GMM_file)
   GMM_d_grps_.resize(bu.size());
   // and fill it in
   for(unsigned i=0; i<GMM_d_beta_.size(); ++i) {
-    if(GMM_d_beta_[i]>=GMM_d_grps_.size()) error("Check Beta values");
+    if(GMM_d_beta_[i]>=GMM_d_grps_.size()) {
+      error("Check Beta values");
+    }
     GMM_d_grps_[GMM_d_beta_[i]].push_back(i);
   }
 }
 
-void EMMI::calculate_useful_stuff(double reso)
-{
+void EMMI::calculate_useful_stuff(double reso) {
   // We use the following definition for resolution:
   // the Fourier transform of the density distribution in real space
   // f(s) falls to 1/e of its maximum value at wavenumber 1/resolution
@@ -1133,10 +1236,15 @@ void EMMI::calculate_useful_stuff(double reso)
   Bave /= static_cast<double>(GMM_m_type_.size());
   // calculate blur factor
   double blur = 0.0;
-  if(reso*reso>Bave) blur = reso*reso-Bave;
-  else warning("PLUMED should not be used with maps at resolution better than 0.3 nm");
+  if(reso*reso>Bave) {
+    blur = reso*reso-Bave;
+  } else {
+    warning("PLUMED should not be used with maps at resolution better than 0.3 nm");
+  }
   // add blur to B
-  for(unsigned i=0; i<GMM_m_s_.size(); ++i) GMM_m_s_[i] += blur;
+  for(unsigned i=0; i<GMM_m_s_.size(); ++i) {
+    GMM_m_s_[i] += blur;
+  }
   // calculate average resolution
   double ave_res = 0.0;
   for(unsigned i=0; i<GMM_m_type_.size(); ++i) {
@@ -1154,13 +1262,18 @@ void EMMI::calculate_useful_stuff(double reso)
     // f(r) = A * (pi/B)**1.5 * exp(-pi**2/B*r**2)
     double s = std::sqrt ( 0.5 * GMM_m_s_[i] ) / pi;
     // covariance matrix for spherical Gaussian
-    cov[0]=s*s; cov[1]=0.0; cov[2]=0.0;
-    cov[3]=s*s; cov[4]=0.0;
+    cov[0]=s*s;
+    cov[1]=0.0;
+    cov[2]=0.0;
+    cov[3]=s*s;
+    cov[4]=0.0;
     cov[5]=s*s;
     // cycle on all data GMM
     for(unsigned j=0; j<GMM_d_m_.size(); ++j) {
       // we need the sum of the covariance matrices
-      for(unsigned k=0; k<6; ++k) sum[k] = cov[k] + GMM_d_cov_[j][k];
+      for(unsigned k=0; k<6; ++k) {
+        sum[k] = cov[k] + GMM_d_cov_[j][k];
+      }
       // and to calculate its determinant
       double det = sum[0]*(sum[3]*sum[5]-sum[4]*sum[4]);
       det -= sum[1]*(sum[1]*sum[5]-sum[4]*sum[2]);
@@ -1191,10 +1304,11 @@ void EMMI::calculate_useful_stuff(double reso)
 double EMMI::get_prefactor_inverse
 (const VectorGeneric<6> &GMM_cov_0, const VectorGeneric<6> &GMM_cov_1,
  double GMM_w_0, double GMM_w_1,
- VectorGeneric<6> &sum, VectorGeneric<6> &inv_sum)
-{
+ VectorGeneric<6> &sum, VectorGeneric<6> &inv_sum) {
 // we need the sum of the covariance matrices
-  for(unsigned k=0; k<6; ++k) sum[k] = GMM_cov_0[k] + GMM_cov_1[k];
+  for(unsigned k=0; k<6; ++k) {
+    sum[k] = GMM_cov_0[k] + GMM_cov_1[k];
+  }
 
 // and to calculate its determinant
   double det = sum[0]*(sum[3]*sum[5]-sum[4]*sum[4]);
@@ -1216,8 +1330,7 @@ double EMMI::get_prefactor_inverse
   return pre_fact;
 }
 
-double EMMI::get_self_overlap(unsigned id)
-{
+double EMMI::get_self_overlap(unsigned id) {
   double ov_tot = 0.0;
   VectorGeneric<6> sum, inv_sum;
   Vector ov_der;
@@ -1235,12 +1348,14 @@ double EMMI::get_self_overlap(unsigned id)
 
 // get overlap and derivatives
 double EMMI::get_overlap(const Vector &m_m, const Vector &d_m, double pre_fact,
-                         const VectorGeneric<6> &inv_cov_md, Vector &ov_der)
-{
+                         const VectorGeneric<6> &inv_cov_md, Vector &ov_der) {
   Vector md;
   // calculate std::vector difference m_m-d_m with/without pbc
-  if(pbc_) md = pbcDistance(d_m, m_m);
-  else     md = delta(d_m, m_m);
+  if(pbc_) {
+    md = pbcDistance(d_m, m_m);
+  } else {
+    md = delta(d_m, m_m);
+  }
   // calculate product of transpose of md and inv_cov_md
   double p_x = md[0]*inv_cov_md[0]+md[1]*inv_cov_md[1]+md[2]*inv_cov_md[2];
   double p_y = md[0]*inv_cov_md[1]+md[1]*inv_cov_md[3]+md[2]*inv_cov_md[4];
@@ -1256,12 +1371,14 @@ double EMMI::get_overlap(const Vector &m_m, const Vector &d_m, double pre_fact,
 
 // get the exponent of the overlap
 double EMMI::get_exp_overlap(const Vector &m_m, const Vector &d_m,
-                             const VectorGeneric<6> &inv_cov_md)
-{
+                             const VectorGeneric<6> &inv_cov_md) {
   Vector md;
   // calculate std::vector difference m_m-d_m with/without pbc
-  if(pbc_) md = pbcDistance(d_m, m_m);
-  else     md = delta(d_m, m_m);
+  if(pbc_) {
+    md = pbcDistance(d_m, m_m);
+  } else {
+    md = delta(d_m, m_m);
+  }
   // calculate product of transpose of md and inv_cov_md
   double p_x = md[0]*inv_cov_md[0]+md[1]*inv_cov_md[1]+md[2]*inv_cov_md[2];
   double p_y = md[0]*inv_cov_md[1]+md[1]*inv_cov_md[3]+md[2]*inv_cov_md[4];
@@ -1271,8 +1388,7 @@ double EMMI::get_exp_overlap(const Vector &m_m, const Vector &d_m,
   return ov;
 }
 
-void EMMI::update_neighbor_list()
-{
+void EMMI::update_neighbor_list() {
   // dimension of GMM and atom std::vectors
   unsigned GMM_d_size = GMM_d_m_.size();
   unsigned GMM_m_size = GMM_m_type_.size();
@@ -1297,7 +1413,9 @@ void EMMI::update_neighbor_list()
       // get index of 0.5*expov in tabulated exponential
       unsigned itab = static_cast<unsigned> (round( 0.5*expov/dexp_ ));
       // check boundaries and skip atom in case
-      if(itab >= tab_exp_.size()) continue;
+      if(itab >= tab_exp_.size()) {
+        continue;
+      }
       // in case calculate overlap
       double ov = pre_fact_[kaux] * tab_exp_[itab];
       // add to list
@@ -1308,7 +1426,9 @@ void EMMI::update_neighbor_list()
       ov_tot += ov;
     }
     // check if zero size -> ov_tot = 0
-    if(ov_l.size()==0) continue;
+    if(ov_l.size()==0) {
+      continue;
+    }
     // define cutoff
     double ov_cut = ov_tot * nl_cutoff_;
     // sort ov_l in ascending order
@@ -1318,12 +1438,16 @@ void EMMI::update_neighbor_list()
     for(unsigned i=0; i<ov_l.size(); ++i) {
       res += ov_l[i];
       // if exceeding the cutoff for overlap, stop
-      if(res >= ov_cut) break;
-      else ov_m.erase(ov_l[i]);
+      if(res >= ov_cut) {
+        break;
+      } else {
+        ov_m.erase(ov_l[i]);
+      }
     }
     // now add atoms to neighborlist
-    for(std::map<double, unsigned>::iterator it=ov_m.begin(); it!=ov_m.end(); ++it)
+    for(std::map<double, unsigned>::iterator it=ov_m.begin(); it!=ov_m.end(); ++it) {
       nl_l.push_back(id*GMM_m_size+it->second);
+    }
     // end cycle on GMM components in parallel
   }
   // find total dimension of neighborlist
@@ -1347,9 +1471,10 @@ void EMMI::update_neighbor_list()
   ovmd_der_.resize(tot_size);
 }
 
-void EMMI::prepare()
-{
-  if(getExchangeStep()) first_time_=true;
+void EMMI::prepare() {
+  if(getExchangeStep()) {
+    first_time_=true;
+  }
 }
 
 // overlap calculator
@@ -1361,8 +1486,12 @@ void EMMI::calculate_overlap() {
   }
 
   // clean temporary std::vectors
-  for(unsigned i=0; i<ovmd_.size(); ++i)     ovmd_[i] = 0.0;
-  for(unsigned i=0; i<ovmd_der_.size(); ++i) ovmd_der_[i] = Vector(0,0,0);
+  for(unsigned i=0; i<ovmd_.size(); ++i) {
+    ovmd_[i] = 0.0;
+  }
+  for(unsigned i=0; i<ovmd_der_.size(); ++i) {
+    ovmd_der_[i] = Vector(0,0,0);
+  }
 
   // we have to cycle over all model and data GMM components in the neighbor list
   unsigned GMM_d_size = GMM_d_m_.size();
@@ -1384,8 +1513,7 @@ void EMMI::calculate_overlap() {
   }
 }
 
-double EMMI::scaleEnergy(double s)
-{
+double EMMI::scaleEnergy(double s) {
   double ene = 0.0;
   for(unsigned i=0; i<ovdd_.size(); ++i) {
     ene += std::log( abs ( s * ovmd_ave_[i] - ovdd_[i] ) );
@@ -1393,8 +1521,7 @@ double EMMI::scaleEnergy(double s)
   return ene;
 }
 
-double EMMI::doRegression()
-{
+double EMMI::doRegression() {
 // standard MC parameters
   unsigned MCsteps = 100000;
   double kbtmin = 1.0;
@@ -1413,14 +1540,21 @@ double EMMI::doRegression()
 // MC loop
   for(unsigned istep=0; istep<MCsteps; ++istep) {
     // get temperature
-    if(istep%(ncold+nhot)<ncold) kbt = kbtmin;
-    else kbt = kbtmax;
+    if(istep%(ncold+nhot)<ncold) {
+      kbt = kbtmin;
+    } else {
+      kbt = kbtmax;
+    }
     // propose move in scale
     double ds = dscale_ * ( 2.0 * random_.RandU01() - 1.0 );
     double new_scale = scale + ds;
     // check boundaries
-    if(new_scale > scale_max_) {new_scale = 2.0 * scale_max_ - new_scale;}
-    if(new_scale < scale_min_) {new_scale = 2.0 * scale_min_ - new_scale;}
+    if(new_scale > scale_max_) {
+      new_scale = 2.0 * scale_max_ - new_scale;
+    }
+    if(new_scale < scale_min_) {
+      new_scale = 2.0 * scale_min_ - new_scale;
+    }
     // new energy
     double new_ene = scaleEnergy(new_scale);
     // accept or reject
@@ -1470,8 +1604,7 @@ double EMMI::doRegression()
   return scale_best;
 }
 
-double EMMI::get_annealing(long long int step)
-{
+double EMMI::get_annealing(long long int step) {
 // default no annealing
   double fact = 1.0;
 // position in annealing cycle
@@ -1480,21 +1613,28 @@ double EMMI::get_annealing(long long int step)
   double ncd = static_cast<double>(nc);
   double nn  = static_cast<double>(nanneal_);
 // set fact
-  if(nc>=nanneal_   && nc<2*nanneal_) fact = (kanneal_-1.0) / nn * ( ncd - nn ) + 1.0;
-  if(nc>=2*nanneal_ && nc<3*nanneal_) fact = kanneal_;
-  if(nc>=3*nanneal_)                  fact = (1.0-kanneal_) / nn * ( ncd - 3.0*nn) + kanneal_;
+  if(nc>=nanneal_   && nc<2*nanneal_) {
+    fact = (kanneal_-1.0) / nn * ( ncd - nn ) + 1.0;
+  }
+  if(nc>=2*nanneal_ && nc<3*nanneal_) {
+    fact = kanneal_;
+  }
+  if(nc>=3*nanneal_) {
+    fact = (1.0-kanneal_) / nn * ( ncd - 3.0*nn) + kanneal_;
+  }
   return fact;
 }
 
-void EMMI::get_weights(double &weight, double &norm, double &neff)
-{
+void EMMI::get_weights(double &weight, double &norm, double &neff) {
   const double dnrep = static_cast<double>(nrep_);
   // calculate the weights either from BIAS
   if(do_reweight_) {
     std::vector<double> bias(nrep_,0);
     if(rank_==0) {
       bias[replica_] = getArgument(0);
-      if(nrep_>1) multi_sim_comm.Sum(&bias[0], nrep_);
+      if(nrep_>1) {
+        multi_sim_comm.Sum(&bias[0], nrep_);
+      }
     }
     comm.Sum(&bias[0], nrep_);
 
@@ -1509,12 +1649,16 @@ void EMMI::get_weights(double &weight, double &norm, double &neff)
       }
     } else {
       first_time_w_ = false;
-      for(unsigned i=0; i<nrep_; ++i) average_weights_[i] = bias[i];
+      for(unsigned i=0; i<nrep_; ++i) {
+        average_weights_[i] = bias[i];
+      }
     }
 
     // set average back into bias and set norm to one
     const double maxbias = *(std::max_element(average_weights_.begin(), average_weights_.end()));
-    for(unsigned i=0; i<nrep_; ++i) bias[i] = std::exp((average_weights_[i]-maxbias)/kbt_);
+    for(unsigned i=0; i<nrep_; ++i) {
+      bias[i] = std::exp((average_weights_[i]-maxbias)/kbt_);
+    }
     // set local weight, norm and weight variance
     weight = bias[replica_];
     double w2=0.;
@@ -1533,8 +1677,7 @@ void EMMI::get_weights(double &weight, double &norm, double &neff)
   getPntrToComponent("neff")->set(neff);
 }
 
-void EMMI::calculate()
-{
+void EMMI::calculate() {
 
 // calculate CV
   calculate_overlap();
@@ -1549,15 +1692,23 @@ void EMMI::calculate()
   if(!no_aver_ && nrep_>1) {
     // if master node, calculate average across replicas
     if(rank_==0) {
-      for(unsigned i=0; i<ovmd_.size(); ++i) ovmd_ave_[i] = weight / norm * ovmd_[i];
+      for(unsigned i=0; i<ovmd_.size(); ++i) {
+        ovmd_ave_[i] = weight / norm * ovmd_[i];
+      }
       multi_sim_comm.Sum(&ovmd_ave_[0], ovmd_ave_.size());
     } else {
-      for(unsigned i=0; i<ovmd_ave_.size(); ++i) ovmd_ave_[i] = 0.0;
+      for(unsigned i=0; i<ovmd_ave_.size(); ++i) {
+        ovmd_ave_[i] = 0.0;
+      }
     }
     // local communication
-    if(size_>1) comm.Sum(&ovmd_ave_[0], ovmd_ave_.size());
+    if(size_>1) {
+      comm.Sum(&ovmd_ave_[0], ovmd_ave_.size());
+    }
   } else {
-    for(unsigned i=0; i<ovmd_.size(); ++i) ovmd_ave_[i] = ovmd_[i];
+    for(unsigned i=0; i<ovmd_.size(); ++i) {
+      ovmd_ave_[i] = ovmd_[i];
+    }
   }
 
   // get time step
@@ -1565,26 +1716,36 @@ void EMMI::calculate()
 
   // do regression
   if(nregres_>0) {
-    if(step%nregres_==0 && !getExchangeStep()) scale_ = doRegression();
+    if(step%nregres_==0 && !getExchangeStep()) {
+      scale_ = doRegression();
+    }
     // set scale component
     getPntrToComponent("scale")->set(scale_);
   }
 
   // write model overlap to file
-  if(ovstride_>0 && step%ovstride_==0) write_model_overlap(step);
+  if(ovstride_>0 && step%ovstride_==0) {
+    write_model_overlap(step);
+  }
 
   // clear energy and virial
   ene_ = 0.0;
   virial_.zero();
 
   // Gaussian noise
-  if(noise_==0) calculate_Gauss();
+  if(noise_==0) {
+    calculate_Gauss();
+  }
 
   // Outliers noise
-  if(noise_==1) calculate_Outliers();
+  if(noise_==1) {
+    calculate_Outliers();
+  }
 
   // Marginal noise
-  if(noise_==2) calculate_Marginal();
+  if(noise_==2) {
+    calculate_Marginal();
+  }
 
   // get annealing rescale factor
   if(nanneal_>0) {
@@ -1607,7 +1768,9 @@ void EMMI::calculate()
       multi_sim_comm.Sum(&ene_, 1);
     } else {
       // set der_GMMid derivatives and energy to zero
-      for(unsigned i=0; i<GMMid_der_av_.size(); ++i) GMMid_der_av_[i]=0.0;
+      for(unsigned i=0; i<GMMid_der_av_.size(); ++i) {
+        GMMid_der_av_[i]=0.0;
+      }
       ene_ = 0.0;
     }
     // local communication
@@ -1622,7 +1785,9 @@ void EMMI::calculate()
   }
 
   // clean temporary std::vector
-  for(unsigned i=0; i<atom_der_.size(); ++i) atom_der_[i] = Vector(0,0,0);
+  for(unsigned i=0; i<atom_der_.size(); ++i) {
+    atom_der_[i] = Vector(0,0,0);
+  }
 
   // get derivatives of bias with respect to atoms
   for(unsigned i=rank_; i<nl_.size(); i=i+size_) {
@@ -1632,8 +1797,11 @@ void EMMI::calculate()
     // chain rule + replica normalization
     Vector tot_der = GMMid_der_av_[id] * ovmd_der_[i] * scale_ / anneal_;
     Vector pos;
-    if(pbc_) pos = pbcDistance(GMM_d_m_[id], getPosition(im)) + GMM_d_m_[id];
-    else     pos = getPosition(im);
+    if(pbc_) {
+      pos = pbcDistance(GMM_d_m_[id], getPosition(im)) + GMM_d_m_[id];
+    } else {
+      pos = getPosition(im);
+    }
     // increment derivatives and virial
     atom_der_[im] += tot_der;
     virial_ += Tensor(pos, -tot_der);
@@ -1646,7 +1814,9 @@ void EMMI::calculate()
   }
 
   // set derivatives, virial, and score
-  for(unsigned i=0; i<atom_der_.size(); ++i) setAtomsDerivatives(getPntrToComponent("scoreb"), i, atom_der_[i]);
+  for(unsigned i=0; i<atom_der_.size(); ++i) {
+    setAtomsDerivatives(getPntrToComponent("scoreb"), i, atom_der_[i]);
+  }
   setBoxDerivatives(getPntrToComponent("scoreb"), virial_);
   getPntrToComponent("scoreb")->set(ene_);
 
@@ -1665,10 +1835,14 @@ void EMMI::calculate()
   if(noise_!=2) {
 
     // do Montecarlo
-    if(dsigma_[0]>0 && step%MCstride_==0 && !getExchangeStep()) doMonteCarlo();
+    if(dsigma_[0]>0 && step%MCstride_==0 && !getExchangeStep()) {
+      doMonteCarlo();
+    }
 
     // print status
-    if(step%statusstride_==0) print_status(step);
+    if(step%statusstride_==0) {
+      print_status(step);
+    }
 
     // calculate acceptance ratio
     double acc = MCaccept_ / MCtrials_;
@@ -1680,8 +1854,7 @@ void EMMI::calculate()
 
 }
 
-void EMMI::calculate_Gauss()
-{
+void EMMI::calculate_Gauss() {
   // cycle on all the GMM groups
   for(unsigned i=0; i<GMM_d_grps_.size(); ++i) {
     double eneg = 0.0;
@@ -1701,8 +1874,7 @@ void EMMI::calculate_Gauss()
   }
 }
 
-void EMMI::calculate_Outliers()
-{
+void EMMI::calculate_Outliers() {
   // cycle on all the GMM groups
   for(unsigned i=0; i<GMM_d_grps_.size(); ++i) {
     // cycle on all the members of the group
@@ -1722,8 +1894,7 @@ void EMMI::calculate_Outliers()
   }
 }
 
-void EMMI::calculate_Marginal()
-{
+void EMMI::calculate_Marginal() {
   // cycle on all the GMM groups
   for(unsigned i=0; i<GMM_d_grps_.size(); ++i) {
     // cycle on all the members of the group
diff --git a/src/isdb/EMMIVox.cpp b/src/isdb/EMMIVox.cpp
index ca84b9426f..828de9fd77 100644
--- a/src/isdb/EMMIVox.cpp
+++ b/src/isdb/EMMIVox.cpp
@@ -268,8 +268,7 @@ EMMIVOX::EMMIVOX(const ActionOptions&ao):
   bfactsig_(0.1), bfactnoc_(false), bfactread_(false),
   MCBstride_(1), MCBaccept_(0.), MCBtrials_(0.), bfactemin_(false),
   martini_(false), statusstride_(0), first_status_(true),
-  eps_(0.0001), mapstride_(0), gpu_(false)
-{
+  eps_(0.0001), mapstride_(0), gpu_(false) {
   // set constants
   inv_sqrt2_ = 1.0/sqrt(2.0);
   sqrt2_pi_  = sqrt(2.0 / M_PI);
@@ -287,23 +286,37 @@ EMMIVOX::EMMIVOX(const ActionOptions&ao):
   parse("NL_DIST_CUTOFF",nl_dist_cutoff_);
   parse("NL_GAUSS_CUTOFF",nl_gauss_cutoff_);
   // checks
-  if(nl_dist_cutoff_<=0. && nl_gauss_cutoff_<=0.) error("You must specify either NL_DIST_CUTOFF or NL_GAUSS_CUTOFF or both");
-  if(nl_gauss_cutoff_<=0.) nl_gauss_cutoff_ = 1.0e+10;
-  if(nl_dist_cutoff_<=0.) nl_dist_cutoff_ = 1.0e+10;
+  if(nl_dist_cutoff_<=0. && nl_gauss_cutoff_<=0.) {
+    error("You must specify either NL_DIST_CUTOFF or NL_GAUSS_CUTOFF or both");
+  }
+  if(nl_gauss_cutoff_<=0.) {
+    nl_gauss_cutoff_ = 1.0e+10;
+  }
+  if(nl_dist_cutoff_<=0.) {
+    nl_dist_cutoff_ = 1.0e+10;
+  }
   // neighbor list update stride
   parse("NL_STRIDE",nl_stride_);
-  if(nl_stride_<=0) error("NL_STRIDE must be explicitly specified and positive");
+  if(nl_stride_<=0) {
+    error("NL_STRIDE must be explicitly specified and positive");
+  }
 
   // minimum value for error
   double sigma_min = 0.2;
   parse("SIGMA_MIN", sigma_min);
-  if(sigma_min<0.) error("SIGMA_MIN must be greater or equal to zero");
+  if(sigma_min<0.) {
+    error("SIGMA_MIN must be greater or equal to zero");
+  }
 
   // status file parameters
   parse("WRITE_STRIDE", statusstride_);
-  if(statusstride_<=0) error("you must specify a positive WRITE_STRIDE");
+  if(statusstride_<=0) {
+    error("you must specify a positive WRITE_STRIDE");
+  }
   parse("STATUS_FILE",  statusfilename_);
-  if(statusfilename_=="") statusfilename_ = "EMMIStatus"+getLabel();
+  if(statusfilename_=="") {
+    statusfilename_ = "EMMIStatus"+getLabel();
+  }
 
   // integral of the experimetal density
   double norm_d;
@@ -329,16 +342,26 @@ EMMIVOX::EMMIVOX(const ActionOptions&ao):
     parse("BFACT_SIGMA",bfactsig_);
     parseFlag("BFACT_MINIMIZE",bfactemin_);
     // checks
-    if(MCBstride_<=0) error("you must specify a positive MCBFACT_STRIDE");
-    if(bfactmax_<=bfactmin_) error("you must specify a positive BFACT_MAX");
-    if(MCBstride_%nl_stride_!=0) error("MCBFACT_STRIDE must be multiple of NL_STRIDE");
-    if(bfactsig_<=0.) error("you must specify a positive BFACT_SIGMA");
+    if(MCBstride_<=0) {
+      error("you must specify a positive MCBFACT_STRIDE");
+    }
+    if(bfactmax_<=bfactmin_) {
+      error("you must specify a positive BFACT_MAX");
+    }
+    if(MCBstride_%nl_stride_!=0) {
+      error("MCBFACT_STRIDE must be multiple of NL_STRIDE");
+    }
+    if(bfactsig_<=0.) {
+      error("you must specify a positive BFACT_SIGMA");
+    }
   }
 
   // read map resolution
   double reso;
   parse("RESOLUTION", reso);
-  if(reso<=0.) error("RESOLUTION must be strictly positive");
+  if(reso<=0.) {
+    error("RESOLUTION must be strictly positive");
+  }
 
   // averaging or not
   parseFlag("NO_AVER",no_aver_);
@@ -349,7 +372,9 @@ EMMIVOX::EMMIVOX(const ActionOptions&ao):
   // write density file
   parse("WRITE_MAP_STRIDE", mapstride_);
   parse("WRITE_MAP", mapfilename_);
-  if(mapstride_>0 && mapfilename_=="") error("With WRITE_MAP_STRIDE you must specify WRITE_MAP");
+  if(mapstride_>0 && mapfilename_=="") {
+    error("With WRITE_MAP_STRIDE you must specify WRITE_MAP");
+  }
 
   // use GPU?
   parseFlag("GPU",gpu_);
@@ -369,7 +394,9 @@ EMMIVOX::EMMIVOX(const ActionOptions&ao):
 
   // set parallel stuff
   unsigned mpisize=comm.Get_size();
-  if(mpisize>1) error("EMMIVOX supports only OpenMP parallelization");
+  if(mpisize>1) {
+    error("EMMIVOX supports only OpenMP parallelization");
+  }
 
   // get number of replicas
   if(no_aver_) {
@@ -379,15 +406,26 @@ EMMIVOX::EMMIVOX(const ActionOptions&ao):
   }
   replica_ = multi_sim_comm.Get_rank();
 
-  if(nrep_>1 && dbfact_>0) error("Bfactor sampling not supported with ensemble averaging");
+  if(nrep_>1 && dbfact_>0) {
+    error("Bfactor sampling not supported with ensemble averaging");
+  }
 
   log.printf("  number of atoms involved : %u\n", atoms.size());
   log.printf("  experimental density map : %s\n", datafile.c_str());
-  if(no_aver_) log.printf("  without ensemble averaging\n");
-  if(gpu_) {log.printf("  running on GPU \n");}
-  else {log.printf("  running on CPU \n");}
-  if(nl_dist_cutoff_ <1.0e+10) log.printf("  neighbor list distance cutoff : %lf\n", nl_dist_cutoff_);
-  if(nl_gauss_cutoff_<1.0e+10) log.printf("  neighbor list Gaussian sigma cutoff : %lf\n", nl_gauss_cutoff_);
+  if(no_aver_) {
+    log.printf("  without ensemble averaging\n");
+  }
+  if(gpu_) {
+    log.printf("  running on GPU \n");
+  } else {
+    log.printf("  running on CPU \n");
+  }
+  if(nl_dist_cutoff_ <1.0e+10) {
+    log.printf("  neighbor list distance cutoff : %lf\n", nl_dist_cutoff_);
+  }
+  if(nl_gauss_cutoff_<1.0e+10) {
+    log.printf("  neighbor list Gaussian sigma cutoff : %lf\n", nl_gauss_cutoff_);
+  }
   log.printf("  neighbor list update stride : %u\n",  nl_stride_);
   log.printf("  minimum density error : %f\n", sigma_min);
   log.printf("  scale factor : %lf\n", scale_);
@@ -399,7 +437,9 @@ EMMIVOX::EMMIVOX(const ActionOptions&ao):
     log.printf("  stride MC move : %u\n", MCBstride_);
     log.printf("  using prior with sigma : %f\n", bfactsig_);
   }
-  if(bfactread_) log.printf("  reading Bfactors from file : %s\n", statusfilename_.c_str());
+  if(bfactread_) {
+    log.printf("  reading Bfactors from file : %s\n", statusfilename_.c_str());
+  }
   log.printf("  temperature of the system in energy unit : %f\n", kbt_);
   if(nrep_>1) {
     log.printf("  number of replicas for averaging: %u\n", nrep_);
@@ -409,7 +449,9 @@ EMMIVOX::EMMIVOX(const ActionOptions&ao):
     log.printf("  writing model density to file : %s\n", mapfilename_.c_str());
     log.printf("  with stride : %u\n", mapstride_);
   }
-  if(martini_) log.printf("  using Martini scattering factors\n");
+  if(martini_) {
+    log.printf("  using Martini scattering factors\n");
+  }
 
   // calculate model constant parameters
   std::vector<double> Model_w = get_Model_param(atoms);
@@ -455,7 +497,9 @@ EMMIVOX::EMMIVOX(const ActionOptions&ao):
   initialize_Bfactor(reso);
 
   // read status file if restarting
-  if(getRestart() || bfactread_) read_status();
+  if(getRestart() || bfactread_) {
+    read_status();
+  }
 
   // prepare auxiliary vectors
   get_auxiliary_vectors();
@@ -466,12 +510,22 @@ EMMIVOX::EMMIVOX(const ActionOptions&ao):
   score_der_.resize(ovdd_.size());
 
   // add components
-  addComponentWithDerivatives("scoreb"); componentIsNotPeriodic("scoreb");
-  addComponent("scale");                 componentIsNotPeriodic("scale");
-  addComponent("offset");                componentIsNotPeriodic("offset");
-  addComponent("kbt");                   componentIsNotPeriodic("kbt");
-  if(dbfact_>0)   {addComponent("accB"); componentIsNotPeriodic("accB");}
-  if(do_corr_)    {addComponent("corr"); componentIsNotPeriodic("corr");}
+  addComponentWithDerivatives("scoreb");
+  componentIsNotPeriodic("scoreb");
+  addComponent("scale");
+  componentIsNotPeriodic("scale");
+  addComponent("offset");
+  componentIsNotPeriodic("offset");
+  addComponent("kbt");
+  componentIsNotPeriodic("kbt");
+  if(dbfact_>0)   {
+    addComponent("accB");
+    componentIsNotPeriodic("accB");
+  }
+  if(do_corr_)    {
+    addComponent("corr");
+    componentIsNotPeriodic("corr");
+  }
 
   // initialize random seed
   unsigned iseed = time(NULL)+replica_;
@@ -483,12 +537,13 @@ EMMIVOX::EMMIVOX(const ActionOptions&ao):
   // print bibliography
   log<<"  Bibliography "<<plumed.cite("Bonomi, Camilloni, Bioinformatics, 33, 3999 (2017)");
   log<<plumed.cite("Hoff, Thomasen, Lindorff-Larsen, Bonomi, bioRxiv (2023) doi: 10.1101/2023.10.18.562710");
-  if(!no_aver_ && nrep_>1)log<<plumed.cite("Bonomi, Camilloni, Cavalli, Vendruscolo, Sci. Adv. 2, e150117 (2016)");
+  if(!no_aver_ && nrep_>1) {
+    log<<plumed.cite("Bonomi, Camilloni, Cavalli, Vendruscolo, Sci. Adv. 2, e150117 (2016)");
+  }
   log<<"\n";
 }
 
-void EMMIVOX::prepare_gpu()
-{
+void EMMIVOX::prepare_gpu() {
   // number of data points
   int nd = ovdd_.size();
   // 1) put ismin_ on device_t_
@@ -507,11 +562,11 @@ void EMMIVOX::prepare_gpu()
   Map_m_gpu_ = torch::from_blob(Map_m_gpu.data(), {3,nd}, torch::kFloat64).clone().to(torch::kFloat32).to(device_t_);
 }
 
-void EMMIVOX::write_model_density(long int step)
-{
+void EMMIVOX::write_model_density(long int step) {
   OFile ovfile;
   ovfile.link(*this);
-  std::string num; Tools::convert(step,num);
+  std::string num;
+  Tools::convert(step,num);
   std::string name = mapfilename_+"-"+num;
   ovfile.open(name);
   ovfile.setHeavyFlush();
@@ -526,8 +581,7 @@ void EMMIVOX::write_model_density(long int step)
   ovfile.close();
 }
 
-double EMMIVOX::get_median(std::vector<double> v)
-{
+double EMMIVOX::get_median(std::vector<double> v) {
 // dimension of vector
   unsigned size = v.size();
 // in case of only one entry
@@ -545,8 +599,7 @@ double EMMIVOX::get_median(std::vector<double> v)
   }
 }
 
-void EMMIVOX::read_status()
-{
+void EMMIVOX::read_status() {
   double MDtime;
 // open file
   IFile *ifile = new IFile();
@@ -564,10 +617,13 @@ void EMMIVOX::read_status()
           // key: pair of residue/chain IDs
           std::pair<unsigned,std::string> key = Model_rlist_[ir];
           // convert ires to std::string
-          std::string num; Tools::convert(key.first,num);
+          std::string num;
+          Tools::convert(key.first,num);
           // read entry
           std::string ch = key.second;
-          if(ch==" ") ch="";
+          if(ch==" ") {
+            ch="";
+          }
           ifile->scanField("bf-"+num+":"+ch, Model_b_[key]);
         }
       }
@@ -581,8 +637,7 @@ void EMMIVOX::read_status()
   delete ifile;
 }
 
-void EMMIVOX::print_status(long int step)
-{
+void EMMIVOX::print_status(long int step) {
 // if first time open the file
   if(first_status_) {
     first_status_ = false;
@@ -606,7 +661,8 @@ void EMMIVOX::print_status(long int step)
       // bfactor from map
       double bf = Model_b_[key];
       // convert ires to std::string
-      std::string num; Tools::convert(key.first,num);
+      std::string num;
+      Tools::convert(key.first,num);
       // print entry
       statusfile_.printField("bf-"+num+":"+key.second, bf);
     }
@@ -614,8 +670,7 @@ void EMMIVOX::print_status(long int step)
   statusfile_.printField();
 }
 
-bool EMMIVOX::doAccept(double oldE, double newE, double kbt)
-{
+bool EMMIVOX::doAccept(double oldE, double newE, double kbt) {
   bool accept = false;
   // calculate delta energy
   double delta = ( newE - oldE ) / kbt;
@@ -625,16 +680,19 @@ bool EMMIVOX::doAccept(double oldE, double newE, double kbt)
   } else {
     // otherwise extract random number
     double s = random_.RandU01();
-    if( s < exp(-delta) ) { accept = true; }
+    if( s < exp(-delta) ) {
+      accept = true;
+    }
   }
   return accept;
 }
 
-std::vector<double> EMMIVOX::get_Model_param(std::vector<AtomNumber> &atoms)
-{
+std::vector<double> EMMIVOX::get_Model_param(std::vector<AtomNumber> &atoms) {
   // check if MOLINFO line is present
   auto* moldat=plumed.getActionSet().selectLatest<GenericMolInfo*>(this);
-  if(!moldat) error("MOLINFO DATA not found\n");
+  if(!moldat) {
+    error("MOLINFO DATA not found\n");
+  }
   log<<"  MOLINFO DATA found with label " <<moldat->getLabel()<<", using proper atom names\n";
 
   // list of weights - one per atom
@@ -648,28 +706,70 @@ std::vector<double> EMMIVOX::get_Model_param(std::vector<AtomNumber> &atoms)
   // map between an atom type and an index
   std::map<std::string, unsigned> type_map;
   // atomistic types
-  type_map["C"]=0;  type_map["O"]=1;  type_map["N"]=2;
-  type_map["S"]=3;  type_map["P"]=4;  type_map["F"]=5;
-  type_map["NA"]=6; type_map["MG"]=7; type_map["CL"]=8;
-  type_map["CA"]=9; type_map["K"]=10; type_map["ZN"]=11;
+  type_map["C"]=0;
+  type_map["O"]=1;
+  type_map["N"]=2;
+  type_map["S"]=3;
+  type_map["P"]=4;
+  type_map["F"]=5;
+  type_map["NA"]=6;
+  type_map["MG"]=7;
+  type_map["CL"]=8;
+  type_map["CA"]=9;
+  type_map["K"]=10;
+  type_map["ZN"]=11;
   // Martini types
-  type_map["ALA_BB"]=12;    type_map["ALA_SC1"]=13;   type_map["CYS_BB"]=14;
-  type_map["CYS_SC1"]=15;   type_map["ASP_BB"]=16;    type_map["ASP_SC1"]=17;
-  type_map["GLU_BB"]=18;    type_map["GLU_SC1"]=19;   type_map["PHE_BB"]=20;
-  type_map["PHE_SC1"]=21;   type_map["PHE_SC2"]=22;   type_map["PHE_SC3"]=23;
-  type_map["GLY_BB"]=24;    type_map["HIS_BB"]=25;    type_map["HIS_SC1"]=26;
-  type_map["HIS_SC2"]=27;   type_map["HIS_SC3"]=28;   type_map["ILE_BB"]=29;
-  type_map["ILE_SC1"]=30;   type_map["LYS_BB"]=31;    type_map["LYS_SC1"]=32;
-  type_map["LYS_SC2"]=33;   type_map["LEU_BB"]=34;    type_map["LEU_SC1"]=35;
-  type_map["MET_BB"]=36;    type_map["MET_SC1"]=37;   type_map["ASN_BB"]=38;
-  type_map["ASN_SC1"]=39;   type_map["PRO_BB"]=40;    type_map["PRO_SC1"]=41;
-  type_map["GLN_BB"]=42;    type_map["GLN_SC1"]=43;   type_map["ARG_BB"]=44;
-  type_map["ARG_SC1"]=45;   type_map["ARG_SC2"]=46;   type_map["SER_BB"]=47;
-  type_map["SER_SC1"]=48;   type_map["THR_BB"]=49;    type_map["THR_SC1"]=50;
-  type_map["VAL_BB"]=51;    type_map["VAL_SC1"]=52;   type_map["TRP_BB"]=53;
-  type_map["TRP_SC1"]=54;   type_map["TRP_SC2"]=55;   type_map["TRP_SC3"]=56;
-  type_map["TRP_SC4"]=57;   type_map["TRP_SC5"]=58;   type_map["TYR_BB"]=59;
-  type_map["TYR_SC1"]=60;   type_map["TYR_SC2"]=61;   type_map["TYR_SC3"]=62;
+  type_map["ALA_BB"]=12;
+  type_map["ALA_SC1"]=13;
+  type_map["CYS_BB"]=14;
+  type_map["CYS_SC1"]=15;
+  type_map["ASP_BB"]=16;
+  type_map["ASP_SC1"]=17;
+  type_map["GLU_BB"]=18;
+  type_map["GLU_SC1"]=19;
+  type_map["PHE_BB"]=20;
+  type_map["PHE_SC1"]=21;
+  type_map["PHE_SC2"]=22;
+  type_map["PHE_SC3"]=23;
+  type_map["GLY_BB"]=24;
+  type_map["HIS_BB"]=25;
+  type_map["HIS_SC1"]=26;
+  type_map["HIS_SC2"]=27;
+  type_map["HIS_SC3"]=28;
+  type_map["ILE_BB"]=29;
+  type_map["ILE_SC1"]=30;
+  type_map["LYS_BB"]=31;
+  type_map["LYS_SC1"]=32;
+  type_map["LYS_SC2"]=33;
+  type_map["LEU_BB"]=34;
+  type_map["LEU_SC1"]=35;
+  type_map["MET_BB"]=36;
+  type_map["MET_SC1"]=37;
+  type_map["ASN_BB"]=38;
+  type_map["ASN_SC1"]=39;
+  type_map["PRO_BB"]=40;
+  type_map["PRO_SC1"]=41;
+  type_map["GLN_BB"]=42;
+  type_map["GLN_SC1"]=43;
+  type_map["ARG_BB"]=44;
+  type_map["ARG_SC1"]=45;
+  type_map["ARG_SC2"]=46;
+  type_map["SER_BB"]=47;
+  type_map["SER_SC1"]=48;
+  type_map["THR_BB"]=49;
+  type_map["THR_SC1"]=50;
+  type_map["VAL_BB"]=51;
+  type_map["VAL_SC1"]=52;
+  type_map["TRP_BB"]=53;
+  type_map["TRP_SC1"]=54;
+  type_map["TRP_SC2"]=55;
+  type_map["TRP_SC3"]=56;
+  type_map["TRP_SC4"]=57;
+  type_map["TRP_SC5"]=58;
+  type_map["TYR_BB"]=59;
+  type_map["TYR_SC1"]=60;
+  type_map["TYR_SC2"]=61;
+  type_map["TYR_SC3"]=62;
   type_map["TYR_SC4"]=63;
   // fill in sigma vector for atoms
   Model_s_.push_back(0.01*Vector5d(0.114,1.0825,5.4281,17.8811,51.1341));   // C
@@ -829,12 +929,24 @@ std::vector<double> EMMIVOX::get_Model_param(std::vector<AtomNumber> &atoms)
       // convert to std::string
       type_s = std::string(1,type);
       // special cases
-      if(name=="SOD" || name=="NA" || name =="Na") type_s = "NA";
-      if(name=="MG"  || name=="Mg")                type_s = "MG";
-      if(name=="CLA" || name=="CL" || name =="Cl") type_s = "CL";
-      if((resname=="CAL" || resname=="CA") && (name=="CAL" || name=="CA" || name =="C0")) type_s = "CA";
-      if(name=="POT" || name=="K")                 type_s = "K";
-      if(name=="ZN"  || name=="Zn")                type_s = "ZN";
+      if(name=="SOD" || name=="NA" || name =="Na") {
+        type_s = "NA";
+      }
+      if(name=="MG"  || name=="Mg") {
+        type_s = "MG";
+      }
+      if(name=="CLA" || name=="CL" || name =="Cl") {
+        type_s = "CL";
+      }
+      if((resname=="CAL" || resname=="CA") && (name=="CAL" || name=="CA" || name =="C0")) {
+        type_s = "CA";
+      }
+      if(name=="POT" || name=="K") {
+        type_s = "K";
+      }
+      if(name=="ZN"  || name=="Zn") {
+        type_s = "ZN";
+      }
     }
     // check if key in map
     if(type_map.find(type_s) != type_map.end()) {
@@ -847,7 +959,9 @@ std::vector<double> EMMIVOX::get_Model_param(std::vector<AtomNumber> &atoms)
       unsigned ires = moldat->getResidueNumber(atoms[i]);
       // and chain
       std::string c ("*");
-      if(!bfactnoc_) c = moldat->getChainID(atoms[i]);
+      if(!bfactnoc_) {
+        c = moldat->getChainID(atoms[i]);
+      }
       // define pair residue/chain IDs
       std::pair<unsigned,std::string> key = std::make_pair(ires,c);
       // add to map between residue/chain and list of atoms
@@ -864,16 +978,16 @@ std::vector<double> EMMIVOX::get_Model_param(std::vector<AtomNumber> &atoms)
   for(unsigned i=0; i<Model_res_.size(); ++i) {
     std::pair<unsigned,std::string> key = Model_res_[i];
     // search in Model_rlist_
-    if(find(Model_rlist_.begin(), Model_rlist_.end(), key) == Model_rlist_.end())
+    if(find(Model_rlist_.begin(), Model_rlist_.end(), key) == Model_rlist_.end()) {
       Model_rlist_.push_back(key);
+    }
   }
   // return weights
   return Model_w;
 }
 
 // read experimental data file in PLUMED format:
-void EMMIVOX::get_exp_data(const std::string &datafile)
-{
+void EMMIVOX::get_exp_data(const std::string &datafile) {
   Vector pos;
   double dens, err;
   int idcomp;
@@ -904,8 +1018,7 @@ void EMMIVOX::get_exp_data(const std::string &datafile)
   delete ifile;
 }
 
-void EMMIVOX::initialize_Bfactor(double reso)
-{
+void EMMIVOX::initialize_Bfactor(double reso) {
   double bfactini = 0.0;
   // if doing Bfactor Monte Carlo
   if(dbfact_>0) {
@@ -930,14 +1043,17 @@ void EMMIVOX::initialize_Bfactor(double reso)
 }
 
 // prepare auxiliary vectors
-void EMMIVOX::get_auxiliary_vectors()
-{
+void EMMIVOX::get_auxiliary_vectors() {
 // number of atoms
   unsigned natoms = Model_res_.size();
 // clear lists
-  pref_.clear(); invs2_.clear(); cut_.clear();
+  pref_.clear();
+  invs2_.clear();
+  cut_.clear();
 // resize
-  pref_.resize(natoms); invs2_.resize(natoms); cut_.resize(natoms);
+  pref_.resize(natoms);
+  invs2_.resize(natoms);
+  cut_.resize(natoms);
 // cycle on all atoms
   #pragma omp parallel for num_threads(OpenMP::getNumThreads())
   for(unsigned im=0; im<natoms; ++im) {
@@ -974,8 +1090,7 @@ void EMMIVOX::get_auxiliary_vectors()
   push_auxiliary_gpu();
 }
 
-void EMMIVOX::push_auxiliary_gpu()
-{
+void EMMIVOX::push_auxiliary_gpu() {
   // 1) create vector of pref_ and invs2_
   int natoms = Model_type_.size();
   std::vector<double> pref(5*natoms), invs2(5*natoms);
@@ -991,10 +1106,10 @@ void EMMIVOX::push_auxiliary_gpu()
   invs2_gpu_ = torch::from_blob(invs2.data(), {5,natoms}, torch::kFloat64).clone().to(torch::kFloat32).to(device_t_);
 }
 
-void EMMIVOX::get_close_residues()
-{
+void EMMIVOX::get_close_residues() {
   // clear neighbor list
-  nl_res_.clear(); nl_res_.resize(Model_rlist_.size());
+  nl_res_.clear();
+  nl_res_.resize(Model_rlist_.size());
 
   // loop in parallel
   #pragma omp parallel num_threads(OpenMP::getNumThreads())
@@ -1034,7 +1149,9 @@ void EMMIVOX::get_close_residues()
             }
           }
           // check if neighbor already found
-          if(neigh) break;
+          if(neigh) {
+            break;
+          }
         }
 
         // if neighbors, add to local list
@@ -1047,14 +1164,14 @@ void EMMIVOX::get_close_residues()
     // add to global list
     #pragma omp critical
     {
-      for(unsigned i=0; i<nl_res_.size(); ++i)
+      for(unsigned i=0; i<nl_res_.size(); ++i) {
         nl_res_[i].insert(nl_res_[i].end(), nl_res_l[i].begin(), nl_res_l[i].end());
+      }
     }
   }
 }
 
-void EMMIVOX::doMonteCarloBfact()
-{
+void EMMIVOX::doMonteCarloBfact() {
 // update residue neighbor list
   get_close_residues();
 
@@ -1069,8 +1186,12 @@ void EMMIVOX::doMonteCarloBfact()
     // propose move in bfactor
     double bfactnew = bfactold + dbfact_ * ( 2.0 * random_.RandU01() - 1.0 );
     // check boundaries
-    if(bfactnew > bfactmax_) {bfactnew = 2.0*bfactmax_ - bfactnew;}
-    if(bfactnew < bfactmin_) {bfactnew = 2.0*bfactmin_ - bfactnew;}
+    if(bfactnew > bfactmax_) {
+      bfactnew = 2.0*bfactmax_ - bfactnew;
+    }
+    if(bfactnew < bfactmin_) {
+      bfactnew = 2.0*bfactmin_ - bfactnew;
+    }
 
     // useful quantities
     std::map<unsigned, double> deltaov;
@@ -1109,8 +1230,9 @@ void EMMIVOX::doMonteCarloBfact()
       // add to global list
       #pragma omp critical
       {
-        for(std::map<unsigned,double>::iterator itov=deltaov_l.begin(); itov!=deltaov_l.end(); ++itov)
+        for(std::map<unsigned,double>::iterator itov=deltaov_l.begin(); itov!=deltaov_l.end(); ++itov) {
           deltaov[itov->first] += itov->second;
+        }
       }
     }
 
@@ -1172,7 +1294,9 @@ void EMMIVOX::doMonteCarloBfact()
     // accept or reject
     bool accept = false;
     if(bfactemin_) {
-      if(new_ene < old_ene) accept = true;
+      if(new_ene < old_ene) {
+        accept = true;
+      }
     } else {
       accept = doAccept(old_ene, new_ene, kbt_);
     }
@@ -1184,8 +1308,9 @@ void EMMIVOX::doMonteCarloBfact()
       // update bfactor
       Model_b_[key] = bfactnew;
       // change all the ovmd_ affected
-      for(std::map<unsigned,double>::iterator itov=deltaov.begin(); itov!=deltaov.end(); ++itov)
+      for(std::map<unsigned,double>::iterator itov=deltaov.begin(); itov!=deltaov.end(); ++itov) {
         ovmd_[itov->first] += itov->second;
+      }
     }
 
   } // end cycle on bfactors
@@ -1200,8 +1325,7 @@ void EMMIVOX::doMonteCarloBfact()
 
 // get overlap
 double EMMIVOX::get_overlap(const Vector &d_m, const Vector &m_m,
-                            const Vector5d &cfact, const Vector5d &m_s, double bfact)
-{
+                            const Vector5d &cfact, const Vector5d &m_s, double bfact) {
   // calculate vector difference
   Vector md = delta(m_m, d_m);
   // norm squared
@@ -1219,8 +1343,7 @@ double EMMIVOX::get_overlap(const Vector &d_m, const Vector &m_m,
   return ov_tot;
 }
 
-void EMMIVOX::update_neighbor_sphere()
-{
+void EMMIVOX::update_neighbor_sphere() {
   // number of atoms
   unsigned natoms = Model_type_.size();
   // clear neighbor sphere
@@ -1242,7 +1365,9 @@ void EMMIVOX::update_neighbor_sphere()
         // calculate distance
         double dist = delta(getPosition(im), d_m).modulo();
         // add to local list
-        if(dist<=2.0*cut_[im]) ns_l.push_back(std::make_pair(id,im));
+        if(dist<=2.0*cut_[im]) {
+          ns_l.push_back(std::make_pair(id,im));
+        }
       }
     }
     // add to global list
@@ -1251,8 +1376,7 @@ void EMMIVOX::update_neighbor_sphere()
   }
 }
 
-bool EMMIVOX::do_neighbor_sphere()
-{
+bool EMMIVOX::do_neighbor_sphere() {
   std::vector<double> dist(getPositions().size());
   bool update = false;
 
@@ -1264,14 +1388,15 @@ bool EMMIVOX::do_neighbor_sphere()
 
 // check if update or not
   double maxdist = *max_element(dist.begin(), dist.end());
-  if(maxdist>=1.0) update=true;
+  if(maxdist>=1.0) {
+    update=true;
+  }
 
 // return if update or not
   return update;
 }
 
-void EMMIVOX::update_neighbor_list()
-{
+void EMMIVOX::update_neighbor_list() {
   // number of atoms
   unsigned natoms = Model_type_.size();
   // clear neighbor list
@@ -1287,7 +1412,9 @@ void EMMIVOX::update_neighbor_list()
       // calculate distance
       double dist = delta(Map_m_[ns_[i].first], getPosition(ns_[i].second)).modulo();
       // add to local neighbour list
-      if(dist<=cut_[ns_[i].second]) nl_l.push_back(ns_[i]);
+      if(dist<=cut_[ns_[i].second]) {
+        nl_l.push_back(ns_[i]);
+      }
     }
     // add to global list
     #pragma omp critical
@@ -1302,7 +1429,8 @@ void EMMIVOX::update_neighbor_list()
   // in case of B-factors sampling - at the right step
   if(dbfact_>0 && getStep()%MCBstride_==0) {
     // clear vectors
-    Model_nb_.clear(); Model_nb_.resize(natoms);
+    Model_nb_.clear();
+    Model_nb_.resize(natoms);
     // cycle over the neighbor list to creat a list of voxels per atom
     #pragma omp parallel num_threads(OpenMP::getNumThreads())
     {
@@ -1315,8 +1443,9 @@ void EMMIVOX::update_neighbor_list()
       // add to global list
       #pragma omp critical
       {
-        for(unsigned i=0; i<natoms; ++i)
+        for(unsigned i=0; i<natoms; ++i) {
           Model_nb_[i].insert(Model_nb_[i].end(), Model_nb_l[i].begin(), Model_nb_l[i].end());
+        }
       }
     }
   }
@@ -1325,8 +1454,7 @@ void EMMIVOX::update_neighbor_list()
   update_gpu();
 }
 
-void EMMIVOX::update_gpu()
-{
+void EMMIVOX::update_gpu() {
   // dimension of neighbor list
   long long nl_size = nl_.size();
   // create useful vectors
@@ -1347,14 +1475,14 @@ void EMMIVOX::update_gpu()
   Map_m_nl_gpu_ = torch::index_select(Map_m_gpu_,1,nl_id_gpu_);
 }
 
-void EMMIVOX::prepare()
-{
-  if(getExchangeStep()) first_time_=true;
+void EMMIVOX::prepare() {
+  if(getExchangeStep()) {
+    first_time_=true;
+  }
 }
 
 // calculate forward model on gpu
-void EMMIVOX::calculate_fmod()
-{
+void EMMIVOX::calculate_fmod() {
   // number of atoms
   int natoms = Model_type_.size();
   // number of data points
@@ -1400,7 +1528,9 @@ void EMMIVOX::calculate_fmod()
     multi_sim_comm.Sum(&ovmd_[0], nd);
     // and divide by number of replicas
     double escale = 1.0 / static_cast<double>(nrep_);
-    for(int i=0; i<nd; ++i) ovmd_[i] *= escale;
+    for(int i=0; i<nd; ++i) {
+      ovmd_[i] *= escale;
+    }
     // put back on device
     ovmd_gpu_ = torch::from_blob(ovmd_.data(), {nd}, torch::kFloat64).to(torch::kFloat32).to(device_t_);
   }
@@ -1409,11 +1539,19 @@ void EMMIVOX::calculate_fmod()
   // this is needed only in certain situations
   long int step = getStep();
   bool do_comm = false;
-  if(mapstride_>0 && step%mapstride_==0) do_comm = true;
-  if(dbfact_>0    && step%MCBstride_==0) do_comm = true;
-  if(do_corr_) do_comm = true;
+  if(mapstride_>0 && step%mapstride_==0) {
+    do_comm = true;
+  }
+  if(dbfact_>0    && step%MCBstride_==0) {
+    do_comm = true;
+  }
+  if(do_corr_) {
+    do_comm = true;
+  }
   // in case of metainference: already communicated
-  if(!no_aver_ && nrep_>1) do_comm = false;
+  if(!no_aver_ && nrep_>1) {
+    do_comm = false;
+  }
   if(do_comm) {
     // communicate ovmd_gpu_ to CPU [1, nd]
     torch::Tensor ovmd_cpu = ovmd_gpu_.detach().to(torch::kCPU).to(torch::kFloat64);
@@ -1423,8 +1561,7 @@ void EMMIVOX::calculate_fmod()
 }
 
 // calculate score
-void EMMIVOX::calculate_score()
-{
+void EMMIVOX::calculate_score() {
   // number of atoms
   int natoms = Model_type_.size();
 
@@ -1463,7 +1600,9 @@ void EMMIVOX::calculate_score()
   torch::Tensor ene_cpu = ene.detach().to(torch::kCPU).to(torch::kFloat64);
   ene_ = *ene_cpu.data_ptr<double>();
   // with marginal, simply multiply by number of replicas!
-  if(!no_aver_ && nrep_>1) ene_ *= static_cast<double>(nrep_);
+  if(!no_aver_ && nrep_>1) {
+    ene_ *= static_cast<double>(nrep_);
+  }
   //
   // 2) communicate derivatives to CPU
   torch::Tensor atom_der_cpu = atoms_der_gpu.detach().to(torch::kCPU).to(torch::kFloat64);
@@ -1488,8 +1627,7 @@ void EMMIVOX::calculate_score()
   virial_ = virial;
 }
 
-void EMMIVOX::calculate()
-{
+void EMMIVOX::calculate() {
   // get time step
   long int step = getStep();
 
@@ -1500,10 +1638,15 @@ void EMMIVOX::calculate()
   if(first_time_ || getExchangeStep() || step%nl_stride_==0) {
     // check if time to update neighbor sphere
     bool update = false;
-    if(first_time_ || getExchangeStep()) update = true;
-    else update = do_neighbor_sphere();
+    if(first_time_ || getExchangeStep()) {
+      update = true;
+    } else {
+      update = do_neighbor_sphere();
+    }
     // update neighbor sphere
-    if(update) update_neighbor_sphere();
+    if(update) {
+      update_neighbor_sphere();
+    }
     // update neighbor list
     update_neighbor_list();
     // set flag
@@ -1517,9 +1660,13 @@ void EMMIVOX::calculate()
   if(dbfact_>0) {
     double acc = 0.0;
     // do Monte Carlo
-    if(step%MCBstride_==0 && !getExchangeStep() && step>0) doMonteCarloBfact();
+    if(step%MCBstride_==0 && !getExchangeStep() && step>0) {
+      doMonteCarloBfact();
+    }
     // calculate acceptance ratio
-    if(MCBtrials_>0) acc = MCBaccept_ / MCBtrials_;
+    if(MCBtrials_>0) {
+      acc = MCBaccept_ / MCBtrials_;
+    }
     // set value
     getPntrToComponent("accB")->set(acc);
   }
@@ -1532,21 +1679,28 @@ void EMMIVOX::calculate()
   score->set(ene_);
   setBoxDerivatives(score, virial_);
   #pragma omp parallel for
-  for(unsigned i=0; i<atom_der_.size(); ++i) setAtomsDerivatives(score, i, atom_der_[i]);
+  for(unsigned i=0; i<atom_der_.size(); ++i) {
+    setAtomsDerivatives(score, i, atom_der_[i]);
+  }
   // set scale and offset value
   getPntrToComponent("scale")->set(scale_);
   getPntrToComponent("offset")->set(offset_);
   // calculate correlation coefficient
-  if(do_corr_) calculate_corr();
+  if(do_corr_) {
+    calculate_corr();
+  }
   // PRINT other quantities to files
   // - status file
-  if(step%statusstride_==0) print_status(step);
+  if(step%statusstride_==0) {
+    print_status(step);
+  }
   // - density file
-  if(mapstride_>0 && step%mapstride_==0) write_model_density(step);
+  if(mapstride_>0 && step%mapstride_==0) {
+    write_model_density(step);
+  }
 }
 
-void EMMIVOX::calculate_corr()
-{
+void EMMIVOX::calculate_corr() {
 // number of data points
   double nd = static_cast<double>(ovdd_.size());
 // average ovmd_ and ovdd_
diff --git a/src/isdb/FretEfficiency.cpp b/src/isdb/FretEfficiency.cpp
index d1990695f3..a8e0ee2bdb 100644
--- a/src/isdb/FretEfficiency.cpp
+++ b/src/isdb/FretEfficiency.cpp
@@ -101,12 +101,12 @@ void FretEfficiency::registerKeywords( Keywords& keys ) {
 
 FretEfficiency::FretEfficiency(const ActionOptions&ao):
   PLUMED_COLVAR_INIT(ao),
-  pbc(true)
-{
+  pbc(true) {
   std::vector<AtomNumber> atoms;
   parseAtomList("ATOMS",atoms);
-  if(atoms.size()!=2)
+  if(atoms.size()!=2) {
     error("Number of specified atoms should be 2");
+  }
   parse("R0",R0_);
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
@@ -116,8 +116,11 @@ FretEfficiency::FretEfficiency(const ActionOptions&ao):
   log.printf("  between atoms %d %d\n",atoms[0].serial(),atoms[1].serial());
   log.printf("  with Forster radius set to %lf\n",R0_);
 
-  if(pbc) log.printf("  using periodic boundary conditions\n");
-  else    log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
 
   log << " Bibliography" << plumed.cite("Bonomi, Camilloni, Bioinformatics, 33, 3999 (2017)") << "\n";
 
@@ -131,7 +134,9 @@ FretEfficiency::FretEfficiency(const ActionOptions&ao):
 // calculator
 void FretEfficiency::calculate() {
 
-  if(pbc) makeWhole();
+  if(pbc) {
+    makeWhole();
+  }
 
   Vector distance=delta(getPosition(0),getPosition(1));
   const double dist_mod=distance.modulo();
diff --git a/src/isdb/Jcoupling.cpp b/src/isdb/Jcoupling.cpp
index 8f2ec44974..117e836be4 100644
--- a/src/isdb/Jcoupling.cpp
+++ b/src/isdb/Jcoupling.cpp
@@ -85,8 +85,7 @@ PRINT ARG=jhanst.*,jhan.* FILE=COLVAR STRIDE=100
 //+ENDPLUMEDOC
 
 class JCoupling :
-  public MetainferenceBase
-{
+  public MetainferenceBase {
 private:
   bool pbc;
   enum { HAN, HAHN, CCG, NCG, CUSTOM };
@@ -124,8 +123,7 @@ void JCoupling::registerKeywords(Keywords& keys) {
 
 JCoupling::JCoupling(const ActionOptions&ao):
   PLUMED_METAINF_INIT(ao),
-  pbc(true)
-{
+  pbc(true) {
   bool nopbc = !pbc;
   parseFlag("NOPBC", nopbc);
   pbc =! nopbc;
@@ -180,13 +178,21 @@ JCoupling::JCoupling(const ActionOptions&ao):
   coupl.resize( ncoupl_ );
   unsigned ntarget=0;
   for(unsigned i=0; i<ncoupl_; ++i) {
-    if( !parseNumbered( "COUPLING", i+1, coupl[i] ) ) break;
+    if( !parseNumbered( "COUPLING", i+1, coupl[i] ) ) {
+      break;
+    }
     ntarget++;
   }
   bool addcoupling=false;
-  if(ntarget!=ncoupl_ && ntarget!=0) error("found wrong number of COUPLING values");
-  if(ntarget==ncoupl_) addcoupling=true;
-  if(getDoScore()&&!addcoupling) error("with DOSCORE you need to set the COUPLING values");
+  if(ntarget!=ncoupl_ && ntarget!=0) {
+    error("found wrong number of COUPLING values");
+  }
+  if(ntarget==ncoupl_) {
+    addcoupling=true;
+  }
+  if(getDoScore()&&!addcoupling) {
+    error("with DOSCORE you need to set the COUPLING values");
+  }
 
   // For custom types we allow use of custom Karplus parameters
   if (jtype_ == CUSTOM) {
@@ -260,13 +266,15 @@ JCoupling::JCoupling(const ActionOptions&ao):
 
   if(!getDoScore()) {
     for (unsigned i = 0; i < ncoupl_; i++) {
-      std::string num; Tools::convert(i, num);
+      std::string num;
+      Tools::convert(i, num);
       addComponentWithDerivatives("j-" + num);
       componentIsNotPeriodic("j-" + num);
     }
   } else {
     for (unsigned i = 0; i < ncoupl_; i++) {
-      std::string num; Tools::convert(i, num);
+      std::string num;
+      Tools::convert(i, num);
       addComponent("j-" + num);
       componentIsNotPeriodic("j-" + num);
     }
@@ -274,7 +282,8 @@ JCoupling::JCoupling(const ActionOptions&ao):
 
   if (addcoupling||getDoScore()) {
     for (unsigned i = 0; i < ncoupl_; i++) {
-      std::string num; Tools::convert(i, num);
+      std::string num;
+      Tools::convert(i, num);
       addComponent("exp-" + num);
       componentIsNotPeriodic("exp-" + num);
       Value* comp = getPntrToComponent("exp-" + num);
@@ -291,9 +300,10 @@ JCoupling::JCoupling(const ActionOptions&ao):
   checkRead();
 }
 
-void JCoupling::calculate()
-{
-  if (pbc) makeWhole();
+void JCoupling::calculate() {
+  if (pbc) {
+    makeWhole();
+  }
   std::vector<Vector> deriv(ncoupl_*6);
   std::vector<double> j(ncoupl_,0.);
 
@@ -326,7 +336,9 @@ void JCoupling::calculate()
       dd1 *= derj;
       dd2 *= derj;
 
-      if(getDoScore()) setCalcData(r, j[r]);
+      if(getDoScore()) {
+        setCalcData(r, j[r]);
+      }
       deriv[a0] =  dd0;
       deriv[a0+1] = -dd0;
       deriv[a0+2] =  dd1;
@@ -363,7 +375,8 @@ void JCoupling::calculate()
   } else {
     for (unsigned r=0; r<ncoupl_; r++) {
       const unsigned a0 = 6*r;
-      std::string num; Tools::convert(r,num);
+      std::string num;
+      Tools::convert(r,num);
       Value* val=getPntrToComponent("j-"+num);
       val->set(j[r]);
       setAtomsDerivatives(val, a0, deriv[a0]);
@@ -386,7 +399,9 @@ void JCoupling::calculate()
 
 void JCoupling::update() {
   // write status file
-  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) writeStatus();
+  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) {
+    writeStatus();
+  }
 }
 
 }
diff --git a/src/isdb/Metainference.cpp b/src/isdb/Metainference.cpp
index 604a8de72e..f264da0c14 100644
--- a/src/isdb/Metainference.cpp
+++ b/src/isdb/Metainference.cpp
@@ -154,8 +154,7 @@ LABEL=spe
 */
 //+ENDPLUMEDOC
 
-class Metainference : public bias::Bias
-{
+class Metainference : public bias::Bias {
   // experimental values
   std::vector<double> parameters;
   // noise type
@@ -368,8 +367,7 @@ Metainference::Metainference(const ActionOptions&ao):
   N_optimized_step_(0),
   optimized_step_(0),
   sigmamax_opt_done_(false),
-  average_weights_stride_(1)
-{
+  average_weights_stride_(1) {
   bool noensemble = false;
   parseFlag("NOENSEMBLE", noensemble);
 
@@ -378,7 +376,9 @@ Metainference::Metainference(const ActionOptions&ao):
   if(master) {
     nrep_    = multi_sim_comm.Get_size();
     replica_ = multi_sim_comm.Get_rank();
-    if(noensemble) nrep_ = 1;
+    if(noensemble) {
+      nrep_ = 1;
+    }
   } else {
     nrep_    = 0;
     replica_ = 0;
@@ -390,19 +390,30 @@ Metainference::Metainference(const ActionOptions&ao):
   parse("SELECTOR", selector_);
   parse("NSELECT", nsel);
   // do checks
-  if(selector_.length()>0 && nsel<=1) error("With SELECTOR active, NSELECT must be greater than 1");
-  if(selector_.length()==0 && nsel>1) error("With NSELECT greater than 1, you must specify SELECTOR");
+  if(selector_.length()>0 && nsel<=1) {
+    error("With SELECTOR active, NSELECT must be greater than 1");
+  }
+  if(selector_.length()==0 && nsel>1) {
+    error("With NSELECT greater than 1, you must specify SELECTOR");
+  }
 
   // initialise firstTimeW
   firstTimeW.resize(nsel, true);
 
   // reweight implies a different number of arguments (the latest one must always be the bias)
   parseFlag("REWEIGHT", do_reweight_);
-  if(do_reweight_&&nrep_<2) error("REWEIGHT can only be used in parallel with 2 or more replicas");
-  if(!getRestart()) average_weights_.resize(nsel, std::vector<double> (nrep_, 1./static_cast<double>(nrep_)));
-  else average_weights_.resize(nsel, std::vector<double> (nrep_, 0.));
+  if(do_reweight_&&nrep_<2) {
+    error("REWEIGHT can only be used in parallel with 2 or more replicas");
+  }
+  if(!getRestart()) {
+    average_weights_.resize(nsel, std::vector<double> (nrep_, 1./static_cast<double>(nrep_)));
+  } else {
+    average_weights_.resize(nsel, std::vector<double> (nrep_, 0.));
+  }
   narg = getNumberOfArguments();
-  if(do_reweight_) narg--;
+  if(do_reweight_) {
+    narg--;
+  }
 
   unsigned averaging=0;
   parse("AVERAGING", averaging);
@@ -412,38 +423,57 @@ Metainference::Metainference(const ActionOptions&ao):
   }
 
   parseVector("PARAMETERS",parameters);
-  if(parameters.size()!=static_cast<unsigned>(narg)&&!parameters.empty())
+  if(parameters.size()!=static_cast<unsigned>(narg)&&!parameters.empty()) {
     error("Size of PARAMETERS array should be either 0 or the same as of the number of arguments in ARG1");
+  }
 
   std::vector<Value*> arg2;
   parseArgumentList("PARARG",arg2);
   if(!arg2.empty()) {
-    if(parameters.size()>0) error("It is not possible to use PARARG and PARAMETERS together");
-    if(arg2.size()!=narg) error("Size of PARARG array should be the same as number for arguments in ARG");
+    if(parameters.size()>0) {
+      error("It is not possible to use PARARG and PARAMETERS together");
+    }
+    if(arg2.size()!=narg) {
+      error("Size of PARARG array should be the same as number for arguments in ARG");
+    }
     for(unsigned i=0; i<arg2.size(); i++) {
       parameters.push_back(arg2[i]->get());
-      if(arg2[i]->hasDerivatives()==true) error("PARARG can only accept arguments without derivatives");
+      if(arg2[i]->hasDerivatives()==true) {
+        error("PARARG can only accept arguments without derivatives");
+      }
     }
   }
 
-  if(parameters.size()!=narg)
+  if(parameters.size()!=narg) {
     error("PARARG or PARAMETERS arrays should include the same number of elements as the arguments in ARG");
+  }
 
   std::string stringa_noise;
   parse("NOISETYPE",stringa_noise);
-  if(stringa_noise=="GAUSS")           noise_type_ = GAUSS;
-  else if(stringa_noise=="MGAUSS")     noise_type_ = MGAUSS;
-  else if(stringa_noise=="OUTLIERS")   noise_type_ = OUTLIERS;
-  else if(stringa_noise=="MOUTLIERS")  noise_type_ = MOUTLIERS;
-  else if(stringa_noise=="GENERIC")    noise_type_ = GENERIC;
-  else error("Unknown noise type!");
+  if(stringa_noise=="GAUSS") {
+    noise_type_ = GAUSS;
+  } else if(stringa_noise=="MGAUSS") {
+    noise_type_ = MGAUSS;
+  } else if(stringa_noise=="OUTLIERS") {
+    noise_type_ = OUTLIERS;
+  } else if(stringa_noise=="MOUTLIERS") {
+    noise_type_ = MOUTLIERS;
+  } else if(stringa_noise=="GENERIC") {
+    noise_type_ = GENERIC;
+  } else {
+    error("Unknown noise type!");
+  }
 
   if(noise_type_== GENERIC) {
     std::string stringa_like;
     parse("LIKELIHOOD",stringa_like);
-    if(stringa_like=="GAUSS") gen_likelihood_ = LIKE_GAUSS;
-    else if(stringa_like=="LOGN") gen_likelihood_ = LIKE_LOGN;
-    else error("Unknown likelihood type!");
+    if(stringa_like=="GAUSS") {
+      gen_likelihood_ = LIKE_GAUSS;
+    } else if(stringa_like=="LOGN") {
+      gen_likelihood_ = LIKE_LOGN;
+    } else {
+      error("Unknown likelihood type!");
+    }
 
     parse("DFTILDE",Dftilde_);
   }
@@ -451,35 +481,55 @@ Metainference::Metainference(const ActionOptions&ao):
   parse("WRITE_STRIDE",write_stride_);
   std::string status_file_name_;
   parse("STATUS_FILE",status_file_name_);
-  if(status_file_name_=="") status_file_name_ = "MISTATUS"+getLabel();
-  else                      status_file_name_ = status_file_name_+getLabel();
+  if(status_file_name_=="") {
+    status_file_name_ = "MISTATUS"+getLabel();
+  } else {
+    status_file_name_ = status_file_name_+getLabel();
+  }
 
   std::string stringa_optsigma;
   parse("OPTSIGMAMEAN", stringa_optsigma);
-  if(stringa_optsigma=="NONE")      do_optsigmamean_=0;
-  else if(stringa_optsigma=="SEM")  do_optsigmamean_=1;
-  else if(stringa_optsigma=="SEM_MAX")  do_optsigmamean_=2;
+  if(stringa_optsigma=="NONE") {
+    do_optsigmamean_=0;
+  } else if(stringa_optsigma=="SEM") {
+    do_optsigmamean_=1;
+  } else if(stringa_optsigma=="SEM_MAX") {
+    do_optsigmamean_=2;
+  }
 
   unsigned aver_max_steps=0;
   parse("SIGMA_MAX_STEPS", aver_max_steps);
-  if(aver_max_steps==0&&do_optsigmamean_==2) aver_max_steps=averaging*2000;
-  if(aver_max_steps>0&&do_optsigmamean_<2) error("SIGMA_MAX_STEPS can only be used together with OPTSIGMAMEAN=SEM_MAX");
-  if(aver_max_steps>0&&do_optsigmamean_==2) N_optimized_step_=aver_max_steps;
-  if(aver_max_steps>0&&aver_max_steps<averaging) error("SIGMA_MAX_STEPS must be greater than AVERAGING");
+  if(aver_max_steps==0&&do_optsigmamean_==2) {
+    aver_max_steps=averaging*2000;
+  }
+  if(aver_max_steps>0&&do_optsigmamean_<2) {
+    error("SIGMA_MAX_STEPS can only be used together with OPTSIGMAMEAN=SEM_MAX");
+  }
+  if(aver_max_steps>0&&do_optsigmamean_==2) {
+    N_optimized_step_=aver_max_steps;
+  }
+  if(aver_max_steps>0&&aver_max_steps<averaging) {
+    error("SIGMA_MAX_STEPS must be greater than AVERAGING");
+  }
 
   // resize std::vector for sigma_mean history
   sigma_mean2_last_.resize(nsel);
-  for(unsigned i=0; i<nsel; i++) sigma_mean2_last_[i].resize(narg);
+  for(unsigned i=0; i<nsel; i++) {
+    sigma_mean2_last_[i].resize(narg);
+  }
 
   std::vector<double> read_sigma_mean_;
   parseVector("SIGMA_MEAN0",read_sigma_mean_);
-  if(do_optsigmamean_==0 && read_sigma_mean_.size()==0 && !getRestart())
+  if(do_optsigmamean_==0 && read_sigma_mean_.size()==0 && !getRestart()) {
     error("If you don't use OPTSIGMAMEAN and you are not RESTARTING then you MUST SET SIGMA_MEAN0");
+  }
 
   if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
     if(read_sigma_mean_.size()==narg) {
       sigma_mean2_.resize(narg);
-      for(unsigned i=0; i<narg; i++) sigma_mean2_[i]=read_sigma_mean_[i]*read_sigma_mean_[i];
+      for(unsigned i=0; i<narg; i++) {
+        sigma_mean2_[i]=read_sigma_mean_[i]*read_sigma_mean_[i];
+      }
     } else if(read_sigma_mean_.size()==1) {
       sigma_mean2_.resize(narg,read_sigma_mean_[0]*read_sigma_mean_[0]);
     } else if(read_sigma_mean_.size()==0) {
@@ -488,7 +538,10 @@ Metainference::Metainference(const ActionOptions&ao):
       error("SIGMA_MEAN0 can accept either one single value or as many values as the arguments (with NOISETYPE=MGAUSS|MOUTLIERS)");
     }
     // set the initial value for the history
-    for(unsigned i=0; i<nsel; i++) for(unsigned j=0; j<narg; j++) sigma_mean2_last_[i][j].push_back(sigma_mean2_[j]);
+    for(unsigned i=0; i<nsel; i++)
+      for(unsigned j=0; j<narg; j++) {
+        sigma_mean2_last_[i][j].push_back(sigma_mean2_[j]);
+      }
   } else {
     if(read_sigma_mean_.size()==1) {
       sigma_mean2_.resize(1, read_sigma_mean_[0]*read_sigma_mean_[0]);
@@ -498,25 +551,36 @@ Metainference::Metainference(const ActionOptions&ao):
       error("If you want to use more than one SIGMA_MEAN0 you should use NOISETYPE=MGAUSS|MOUTLIERS");
     }
     // set the initial value for the history
-    for(unsigned i=0; i<nsel; i++) for(unsigned j=0; j<narg; j++) sigma_mean2_last_[i][j].push_back(sigma_mean2_[0]);
+    for(unsigned i=0; i<nsel; i++)
+      for(unsigned j=0; j<narg; j++) {
+        sigma_mean2_last_[i][j].push_back(sigma_mean2_[0]);
+      }
   }
 
   parseFlag("SCALEDATA", doscale_);
   if(doscale_) {
     std::string stringa_noise;
     parse("SCALE_PRIOR",stringa_noise);
-    if(stringa_noise=="GAUSSIAN")  scale_prior_ = SC_GAUSS;
-    else if(stringa_noise=="FLAT") scale_prior_ = SC_FLAT;
-    else error("Unknown SCALE_PRIOR type!");
+    if(stringa_noise=="GAUSSIAN") {
+      scale_prior_ = SC_GAUSS;
+    } else if(stringa_noise=="FLAT") {
+      scale_prior_ = SC_FLAT;
+    } else {
+      error("Unknown SCALE_PRIOR type!");
+    }
     parse("SCALE0",scale_);
     parse("DSCALE",Dscale_);
-    if(Dscale_<0.) error("DSCALE must be set when using SCALEDATA");
+    if(Dscale_<0.) {
+      error("DSCALE must be set when using SCALEDATA");
+    }
     if(scale_prior_==SC_GAUSS) {
       scale_mu_=scale_;
     } else {
       parse("SCALE_MIN",scale_min_);
       parse("SCALE_MAX",scale_max_);
-      if(scale_max_<scale_min_) error("SCALE_MAX and SCALE_MIN must be set when using SCALE_PRIOR=FLAT");
+      if(scale_max_<scale_min_) {
+        error("SCALE_MAX and SCALE_MIN must be set when using SCALE_PRIOR=FLAT");
+      }
     }
   }
 
@@ -524,19 +588,29 @@ Metainference::Metainference(const ActionOptions&ao):
   if(dooffset_) {
     std::string stringa_noise;
     parse("OFFSET_PRIOR",stringa_noise);
-    if(stringa_noise=="GAUSSIAN")  offset_prior_ = SC_GAUSS;
-    else if(stringa_noise=="FLAT") offset_prior_ = SC_FLAT;
-    else error("Unknown OFFSET_PRIOR type!");
+    if(stringa_noise=="GAUSSIAN") {
+      offset_prior_ = SC_GAUSS;
+    } else if(stringa_noise=="FLAT") {
+      offset_prior_ = SC_FLAT;
+    } else {
+      error("Unknown OFFSET_PRIOR type!");
+    }
     parse("OFFSET0",offset_);
     parse("DOFFSET",Doffset_);
     if(offset_prior_==SC_GAUSS) {
       offset_mu_=offset_;
-      if(Doffset_<0.) error("DOFFSET must be set when using OFFSET_PRIOR=GAUSS");
+      if(Doffset_<0.) {
+        error("DOFFSET must be set when using OFFSET_PRIOR=GAUSS");
+      }
     } else {
       parse("OFFSET_MIN",offset_min_);
       parse("OFFSET_MAX",offset_max_);
-      if(Doffset_<0) Doffset_ = 0.05*(offset_max_ - offset_min_);
-      if(offset_max_<offset_min_) error("OFFSET_MAX and OFFSET_MIN must be set when using OFFSET_PRIOR=FLAT");
+      if(Doffset_<0) {
+        Doffset_ = 0.05*(offset_max_ - offset_min_);
+      }
+      if(offset_max_<offset_min_) {
+        error("OFFSET_MAX and OFFSET_MIN must be set when using OFFSET_PRIOR=FLAT");
+      }
     }
   }
 
@@ -546,43 +620,59 @@ Metainference::Metainference(const ActionOptions&ao):
     // set flag
     doregres_zero_=true;
     // check if already sampling scale and offset
-    if(doscale_)  error("REGRES_ZERO and SCALEDATA are mutually exclusive");
-    if(dooffset_) error("REGRES_ZERO and ADDOFFSET are mutually exclusive");
+    if(doscale_) {
+      error("REGRES_ZERO and SCALEDATA are mutually exclusive");
+    }
+    if(dooffset_) {
+      error("REGRES_ZERO and ADDOFFSET are mutually exclusive");
+    }
   }
 
   std::vector<double> readsigma;
   parseVector("SIGMA0",readsigma);
-  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma.size()>1)
+  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma.size()>1) {
     error("If you want to use more than one SIGMA you should use NOISETYPE=MGAUSS|MOUTLIERS|GENERIC");
+  }
   if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
     sigma_.resize(readsigma.size());
     sigma_=readsigma;
-  } else sigma_.resize(1, readsigma[0]);
+  } else {
+    sigma_.resize(1, readsigma[0]);
+  }
 
   std::vector<double> readsigma_min;
   parseVector("SIGMA_MIN",readsigma_min);
-  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_min.size()>1)
+  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_min.size()>1) {
     error("If you want to use more than one SIGMA you should use NOISETYPE=MGAUSS|MOUTLIERS|GENERIC");
+  }
   if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
     sigma_min_.resize(readsigma_min.size());
     sigma_min_=readsigma_min;
-  } else sigma_min_.resize(1, readsigma_min[0]);
+  } else {
+    sigma_min_.resize(1, readsigma_min[0]);
+  }
 
   std::vector<double> readsigma_max;
   parseVector("SIGMA_MAX",readsigma_max);
-  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_max.size()>1)
+  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_max.size()>1) {
     error("If you want to use more than one SIGMA you should use NOISETYPE=MGAUSS|MOUTLIERS|GENERIC");
+  }
   if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
     sigma_max_.resize(readsigma_max.size());
     sigma_max_=readsigma_max;
-  } else sigma_max_.resize(1, readsigma_max[0]);
+  } else {
+    sigma_max_.resize(1, readsigma_max[0]);
+  }
 
-  if(sigma_max_.size()!=sigma_min_.size()) error("The number of values for SIGMA_MIN and SIGMA_MAX must be the same");
+  if(sigma_max_.size()!=sigma_min_.size()) {
+    error("The number of values for SIGMA_MIN and SIGMA_MAX must be the same");
+  }
 
   std::vector<double> read_dsigma;
   parseVector("DSIGMA",read_dsigma);
-  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_max.size()>1)
+  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_max.size()>1) {
     error("If you want to use more than one SIGMA you should use NOISETYPE=MGAUSS|MOUTLIERS|GENERIC");
+  }
   if(read_dsigma.size()>0) {
     Dsigma_.resize(read_dsigma.size());
     Dsigma_=read_dsigma;
@@ -596,7 +686,9 @@ Metainference::Metainference(const ActionOptions&ao):
   parse("MC_CHUNKSIZE", MCchunksize_);
   // get temperature
   kbt_ = getkBT();
-  if(kbt_==0.0) error("Unless the MD engine passes the temperature to plumed, you must specify it using TEMP");
+  if(kbt_==0.0) {
+    error("Unless the MD engine passes the temperature to plumed, you must specify it using TEMP");
+  }
 
   checkRead();
 
@@ -634,7 +726,9 @@ Metainference::Metainference(const ActionOptions&ao):
   restart_sfile.link(*this);
   if(getRestart()&&restart_sfile.FileExist(status_file_name_)) {
     firstTime = false;
-    for(unsigned i=0; i<nsel; i++) firstTimeW[i] = false;
+    for(unsigned i=0; i<nsel; i++) {
+      firstTimeW[i] = false;
+    }
     restart_sfile.open(status_file_name_);
     log.printf("  Restarting from %s\n", status_file_name_.c_str());
     double dummy;
@@ -648,7 +742,9 @@ Metainference::Metainference(const ActionOptions&ao):
       comm.Sum(dummy_time);
       for(unsigned i=1; i<nrep_; i++) {
         std::string msg = "METAINFERENCE restart files " + status_file_name_ + "  are not in sync";
-        if(dummy_time[i]!=dummy_time[0]) plumed_merror(msg);
+        if(dummy_time[i]!=dummy_time[0]) {
+          plumed_merror(msg);
+        }
       }
       // nsel
       for(unsigned i=0; i<sigma_mean2_last_.size(); i++) {
@@ -671,7 +767,9 @@ Metainference::Metainference(const ActionOptions&ao):
           Tools::convert(0,msg_j);
           std::string msg = msg_i+"_"+msg_j;
           restart_sfile.scanField("sigmaMean_"+msg,read_sm);
-          for(unsigned j=0; j<narg; j++) sigma_mean2_last_[i][j][0] = read_sm*read_sm;
+          for(unsigned j=0; j<narg; j++) {
+            sigma_mean2_last_[i][j][0] = read_sm*read_sm;
+          }
         }
       }
 
@@ -703,7 +801,9 @@ Metainference::Metainference(const ActionOptions&ao):
         restart_sfile.scanField("weight_"+msg,tmp_w);
         if(master) {
           average_weights_[i][replica_] = tmp_w;
-          if(nrep_>1) multi_sim_comm.Sum(&average_weights_[i][0], nrep_);
+          if(nrep_>1) {
+            multi_sim_comm.Sum(&average_weights_[i][0], nrep_);
+          }
         }
         comm.Sum(&average_weights_[i][0], nrep_);
       }
@@ -714,13 +814,19 @@ Metainference::Metainference(const ActionOptions&ao):
   }
 
   /* If DSIGMA is not yet initialised do it now */
-  for(unsigned i=0; i<sigma_max_.size(); i++) if(Dsigma_[i]==-1) Dsigma_[i] = 0.05*(sigma_max_[i] - sigma_min_[i]);
+  for(unsigned i=0; i<sigma_max_.size(); i++)
+    if(Dsigma_[i]==-1) {
+      Dsigma_[i] = 0.05*(sigma_max_[i] - sigma_min_[i]);
+    }
 
   switch(noise_type_) {
   case GENERIC:
     log.printf("  with general metainference ");
-    if(gen_likelihood_==LIKE_GAUSS) log.printf(" and a gaussian likelihood\n");
-    else if(gen_likelihood_==LIKE_LOGN) log.printf(" and a log-normal likelihood\n");
+    if(gen_likelihood_==LIKE_GAUSS) {
+      log.printf(" and a gaussian likelihood\n");
+    } else if(gen_likelihood_==LIKE_LOGN) {
+      log.printf(" and a log-normal likelihood\n");
+    }
     log.printf("  ensemble average parameter sampled with a step %lf of sigma_mean\n", Dftilde_);
     break;
   case GAUSS:
@@ -747,7 +853,9 @@ Metainference::Metainference(const ActionOptions&ao):
     comm.Sum(dummy_scale);
     for(unsigned i=1; i<nrep_; i++) {
       std::string msg = "The SCALE value must be the same for all replicas: check your input or restart file";
-      if(dummy_scale[i]!=dummy_scale[0]) plumed_merror(msg);
+      if(dummy_scale[i]!=dummy_scale[0]) {
+        plumed_merror(msg);
+      }
     }
     log.printf("  sampling a common scaling factor with:\n");
     log.printf("    initial scale parameter %f\n",scale_);
@@ -770,7 +878,9 @@ Metainference::Metainference(const ActionOptions&ao):
     comm.Sum(dummy_offset);
     for(unsigned i=1; i<nrep_; i++) {
       std::string msg = "The OFFSET value must be the same for all replicas: check your input or restart file";
-      if(dummy_offset[i]!=dummy_offset[0]) plumed_merror(msg);
+      if(dummy_offset[i]!=dummy_offset[0]) {
+        plumed_merror(msg);
+      }
     }
     log.printf("  sampling a common offset with:\n");
     log.printf("    initial offset parameter %f\n",offset_);
@@ -783,27 +893,38 @@ Metainference::Metainference(const ActionOptions&ao):
     }
   }
 
-  if(doregres_zero_)
+  if(doregres_zero_) {
     log.printf("  doing regression with zero intercept with stride: %d\n", nregres_zero_);
+  }
 
   log.printf("  number of experimental data points %u\n",narg);
   log.printf("  number of replicas %u\n",nrep_);
   log.printf("  initial data uncertainties");
-  for(unsigned i=0; i<sigma_.size(); ++i) log.printf(" %f", sigma_[i]);
+  for(unsigned i=0; i<sigma_.size(); ++i) {
+    log.printf(" %f", sigma_[i]);
+  }
   log.printf("\n");
   log.printf("  minimum data uncertainties");
-  for(unsigned i=0; i<sigma_.size(); ++i) log.printf(" %f",sigma_min_[i]);
+  for(unsigned i=0; i<sigma_.size(); ++i) {
+    log.printf(" %f",sigma_min_[i]);
+  }
   log.printf("\n");
   log.printf("  maximum data uncertainties");
-  for(unsigned i=0; i<sigma_.size(); ++i) log.printf(" %f",sigma_max_[i]);
+  for(unsigned i=0; i<sigma_.size(); ++i) {
+    log.printf(" %f",sigma_max_[i]);
+  }
   log.printf("\n");
   log.printf("  maximum MC move of data uncertainties");
-  for(unsigned i=0; i<sigma_.size(); ++i) log.printf(" %f",Dsigma_[i]);
+  for(unsigned i=0; i<sigma_.size(); ++i) {
+    log.printf(" %f",Dsigma_[i]);
+  }
   log.printf("\n");
   log.printf("  temperature of the system %f\n",kbt_);
   log.printf("  MC steps %u\n",MCsteps_);
   log.printf("  initial standard errors of the mean");
-  for(unsigned i=0; i<sigma_mean2_.size(); ++i) log.printf(" %f", std::sqrt(sigma_mean2_[i]));
+  for(unsigned i=0; i<sigma_mean2_.size(); ++i) {
+    log.printf(" %f", std::sqrt(sigma_mean2_[i]));
+  }
   log.printf("\n");
 
   if(do_reweight_) {
@@ -846,23 +967,29 @@ Metainference::Metainference(const ActionOptions&ao):
 
   if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
     for(unsigned i=0; i<sigma_mean2_.size(); ++i) {
-      std::string num; Tools::convert(i,num);
-      addComponent("sigmaMean-"+num); componentIsNotPeriodic("sigmaMean-"+num);
+      std::string num;
+      Tools::convert(i,num);
+      addComponent("sigmaMean-"+num);
+      componentIsNotPeriodic("sigmaMean-"+num);
       valueSigmaMean.push_back(getPntrToComponent("sigmaMean-"+num));
       getPntrToComponent("sigmaMean-"+num)->set(std::sqrt(sigma_mean2_[i]));
-      addComponent("sigma-"+num); componentIsNotPeriodic("sigma-"+num);
+      addComponent("sigma-"+num);
+      componentIsNotPeriodic("sigma-"+num);
       valueSigma.push_back(getPntrToComponent("sigma-"+num));
       getPntrToComponent("sigma-"+num)->set(sigma_[i]);
       if(noise_type_==GENERIC) {
-        addComponent("ftilde-"+num); componentIsNotPeriodic("ftilde-"+num);
+        addComponent("ftilde-"+num);
+        componentIsNotPeriodic("ftilde-"+num);
         valueFtilde.push_back(getPntrToComponent("ftilde-"+num));
       }
     }
   } else {
-    addComponent("sigmaMean"); componentIsNotPeriodic("sigmaMean");
+    addComponent("sigmaMean");
+    componentIsNotPeriodic("sigmaMean");
     valueSigmaMean.push_back(getPntrToComponent("sigmaMean"));
     getPntrToComponent("sigmaMean")->set(std::sqrt(sigma_mean2_[0]));
-    addComponent("sigma"); componentIsNotPeriodic("sigma");
+    addComponent("sigma");
+    componentIsNotPeriodic("sigma");
     valueSigma.push_back(getPntrToComponent("sigma"));
     getPntrToComponent("sigma")->set(sigma_[0]);
   }
@@ -883,7 +1010,9 @@ Metainference::Metainference(const ActionOptions&ao):
     // in this case we want the same seed everywhere
     auto ts = std::chrono::time_point_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now()).time_since_epoch().count();
     iseed = static_cast<unsigned>(ts);
-    if(master&&nrep_>1) multi_sim_comm.Bcast(iseed,0);
+    if(master&&nrep_>1) {
+      multi_sim_comm.Bcast(iseed,0);
+    }
     comm.Bcast(iseed,0);
     // this is used for scale and offset sampling and acceptance
     random[1].setSeed(-iseed);
@@ -905,20 +1034,24 @@ Metainference::Metainference(const ActionOptions&ao):
   }
 
   log<<"  Bibliography "<<plumed.cite("Bonomi, Camilloni, Cavalli, Vendruscolo, Sci. Adv. 2, e150117 (2016)");
-  if(do_reweight_) log<<plumed.cite("Bonomi, Camilloni, Vendruscolo, Sci. Rep. 6, 31232 (2016)");
-  if(do_optsigmamean_>0) log<<plumed.cite("Loehr, Jussupow, Camilloni, J. Chem. Phys. 146, 165102 (2017)");
+  if(do_reweight_) {
+    log<<plumed.cite("Bonomi, Camilloni, Vendruscolo, Sci. Rep. 6, 31232 (2016)");
+  }
+  if(do_optsigmamean_>0) {
+    log<<plumed.cite("Loehr, Jussupow, Camilloni, J. Chem. Phys. 146, 165102 (2017)");
+  }
   log<<plumed.cite("Bonomi, Camilloni, Bioinformatics, 33, 3999 (2017)");
   log<<"\n";
 }
 
-Metainference::~Metainference()
-{
-  if(sfile_.isOpen()) sfile_.close();
+Metainference::~Metainference() {
+  if(sfile_.isOpen()) {
+    sfile_.close();
+  }
 }
 
 double Metainference::getEnergySP(const std::vector<double> &mean, const std::vector<double> &sigma,
-                                  const double scale, const double offset)
-{
+                                  const double scale, const double offset) {
   const double scale2 = scale*scale;
   const double sm2    = sigma_mean2_[0];
   const double ss2    = sigma[0]*sigma[0] + scale2*sm2;
@@ -933,22 +1066,24 @@ double Metainference::getEnergySP(const std::vector<double> &mean, const std::ve
       const double a2 = 0.5*dev*dev + ss2;
       if(sm2 > 0.0) {
         ene += std::log(2.0*a2/(1.0-std::exp(-a2/sm2)));
-      }
-      else {
+      } else {
         ene += std::log(2.0*a2);
       }
     }
   }
   // add one single Jeffrey's prior and one normalisation per data point
   ene += 0.5*std::log(sss) + static_cast<double>(narg)*0.5*std::log(0.5*M_PI*M_PI/ss2);
-  if(doscale_ || doregres_zero_) ene += 0.5*std::log(sss);
-  if(dooffset_) ene += 0.5*std::log(sss);
+  if(doscale_ || doregres_zero_) {
+    ene += 0.5*std::log(sss);
+  }
+  if(dooffset_) {
+    ene += 0.5*std::log(sss);
+  }
   return kbt_ * ene;
 }
 
 double Metainference::getEnergySPE(const std::vector<double> &mean, const std::vector<double> &sigma,
-                                   const double scale, const double offset)
-{
+                                   const double scale, const double offset) {
   const double scale2 = scale*scale;
   double ene = 0.0;
   #pragma omp parallel num_threads(OpenMP::getNumThreads()) shared(ene)
@@ -962,20 +1097,22 @@ double Metainference::getEnergySPE(const std::vector<double> &mean, const std::v
       const double a2  = 0.5*dev*dev + ss2;
       if(sm2 > 0.0) {
         ene += 0.5*std::log(sss) + 0.5*std::log(0.5*M_PI*M_PI/ss2) + std::log(2.0*a2/(1.0-std::exp(-a2/sm2)));
-      }
-      else {
+      } else {
         ene += 0.5*std::log(sss) + 0.5*std::log(0.5*M_PI*M_PI/ss2) + std::log(2.0*a2);
       }
-      if(doscale_ || doregres_zero_)  ene += 0.5*std::log(sss);
-      if(dooffset_) ene += 0.5*std::log(sss);
+      if(doscale_ || doregres_zero_) {
+        ene += 0.5*std::log(sss);
+      }
+      if(dooffset_) {
+        ene += 0.5*std::log(sss);
+      }
     }
   }
   return kbt_ * ene;
 }
 
 double Metainference::getEnergyMIGEN(const std::vector<double> &mean, const std::vector<double> &ftilde, const std::vector<double> &sigma,
-                                     const double scale, const double offset)
-{
+                                     const double scale, const double offset) {
   double ene = 0.0;
   #pragma omp parallel num_threads(OpenMP::getNumThreads()) shared(ene)
   {
@@ -984,26 +1121,35 @@ double Metainference::getEnergyMIGEN(const std::vector<double> &mean, const std:
       const double inv_sb2  = 1./(sigma[i]*sigma[i]);
       const double inv_sm2  = 1./sigma_mean2_[i];
       double devb = 0;
-      if(gen_likelihood_==LIKE_GAUSS)     devb = scale*ftilde[i]-parameters[i]+offset;
-      else if(gen_likelihood_==LIKE_LOGN) devb = std::log(scale*ftilde[i]/parameters[i]);
+      if(gen_likelihood_==LIKE_GAUSS) {
+        devb = scale*ftilde[i]-parameters[i]+offset;
+      } else if(gen_likelihood_==LIKE_LOGN) {
+        devb = std::log(scale*ftilde[i]/parameters[i]);
+      }
       double devm = mean[i] - ftilde[i];
       // deviation + normalisation + jeffrey
       double normb = 0.;
-      if(gen_likelihood_==LIKE_GAUSS)     normb = -0.5*std::log(0.5/M_PI*inv_sb2);
-      else if(gen_likelihood_==LIKE_LOGN) normb = -0.5*std::log(0.5/M_PI*inv_sb2/(parameters[i]*parameters[i]));
+      if(gen_likelihood_==LIKE_GAUSS) {
+        normb = -0.5*std::log(0.5/M_PI*inv_sb2);
+      } else if(gen_likelihood_==LIKE_LOGN) {
+        normb = -0.5*std::log(0.5/M_PI*inv_sb2/(parameters[i]*parameters[i]));
+      }
       const double normm         = -0.5*std::log(0.5/M_PI*inv_sm2);
       const double jeffreys      = -0.5*std::log(2.*inv_sb2);
       ene += 0.5*devb*devb*inv_sb2 + 0.5*devm*devm*inv_sm2 + normb + normm + jeffreys;
-      if(doscale_ || doregres_zero_)  ene += jeffreys;
-      if(dooffset_) ene += jeffreys;
+      if(doscale_ || doregres_zero_) {
+        ene += jeffreys;
+      }
+      if(dooffset_) {
+        ene += jeffreys;
+      }
     }
   }
   return kbt_ * ene;
 }
 
 double Metainference::getEnergyGJ(const std::vector<double> &mean, const std::vector<double> &sigma,
-                                  const double scale, const double offset)
-{
+                                  const double scale, const double offset) {
   const double scale2  = scale*scale;
   const double inv_s2  = 1./(sigma[0]*sigma[0] + scale2*sigma_mean2_[0]);
   const double inv_sss = 1./(sigma[0]*sigma[0] + sigma_mean2_[0]);
@@ -1021,15 +1167,18 @@ double Metainference::getEnergyGJ(const std::vector<double> &mean, const std::ve
   const double jeffreys = -0.5*std::log(2.*inv_sss);
   // add Jeffrey's prior in case one sigma for all data points + one normalisation per datapoint
   ene += jeffreys + static_cast<double>(narg)*normalisation;
-  if(doscale_ || doregres_zero_)  ene += jeffreys;
-  if(dooffset_) ene += jeffreys;
+  if(doscale_ || doregres_zero_) {
+    ene += jeffreys;
+  }
+  if(dooffset_) {
+    ene += jeffreys;
+  }
 
   return kbt_ * ene;
 }
 
 double Metainference::getEnergyGJE(const std::vector<double> &mean, const std::vector<double> &sigma,
-                                   const double scale, const double offset)
-{
+                                   const double scale, const double offset) {
   const double scale2 = scale*scale;
 
   double ene = 0.0;
@@ -1044,15 +1193,18 @@ double Metainference::getEnergyGJE(const std::vector<double> &mean, const std::v
       const double normalisation = -0.5*std::log(0.5/M_PI*inv_s2);
       const double jeffreys      = -0.5*std::log(2.*inv_sss);
       ene += 0.5*dev*dev*inv_s2 + normalisation + jeffreys;
-      if(doscale_ || doregres_zero_)  ene += jeffreys;
-      if(dooffset_) ene += jeffreys;
+      if(doscale_ || doregres_zero_) {
+        ene += jeffreys;
+      }
+      if(dooffset_) {
+        ene += jeffreys;
+      }
     }
   }
   return kbt_ * ene;
 }
 
-void Metainference::moveTilde(const std::vector<double> &mean_, double &old_energy)
-{
+void Metainference::moveTilde(const std::vector<double> &mean_, double &old_energy) {
   std::vector<double> new_ftilde(sigma_.size());
   new_ftilde = ftilde_;
 
@@ -1083,8 +1235,7 @@ void Metainference::moveTilde(const std::vector<double> &mean_, double &old_ener
   }
 }
 
-void Metainference::moveScaleOffset(const std::vector<double> &mean_, double &old_energy)
-{
+void Metainference::moveScaleOffset(const std::vector<double> &mean_, double &old_energy) {
   double new_scale = scale_;
 
   if(doscale_) {
@@ -1093,8 +1244,12 @@ void Metainference::moveScaleOffset(const std::vector<double> &mean_, double &ol
       const double ds1 = Dscale_*r1;
       new_scale += ds1;
       // check boundaries
-      if(new_scale > scale_max_) {new_scale = 2.0 * scale_max_ - new_scale;}
-      if(new_scale < scale_min_) {new_scale = 2.0 * scale_min_ - new_scale;}
+      if(new_scale > scale_max_) {
+        new_scale = 2.0 * scale_max_ - new_scale;
+      }
+      if(new_scale < scale_min_) {
+        new_scale = 2.0 * scale_min_ - new_scale;
+      }
     } else {
       const double r1 = random[1].Gaussian();
       const double ds1 = 0.5*(scale_mu_-new_scale)+Dscale_*std::exp(1)/M_PI*r1;
@@ -1110,8 +1265,12 @@ void Metainference::moveScaleOffset(const std::vector<double> &mean_, double &ol
       const double ds1 = Doffset_*r1;
       new_offset += ds1;
       // check boundaries
-      if(new_offset > offset_max_) {new_offset = 2.0 * offset_max_ - new_offset;}
-      if(new_offset < offset_min_) {new_offset = 2.0 * offset_min_ - new_offset;}
+      if(new_offset > offset_max_) {
+        new_offset = 2.0 * offset_max_ - new_offset;
+      }
+      if(new_offset < offset_min_) {
+        new_offset = 2.0 * offset_min_ - new_offset;
+      }
     } else {
       const double r1 = random[1].Gaussian();
       const double ds1 = 0.5*(offset_mu_-new_offset)+Doffset_*std::exp(1)/M_PI*r1;
@@ -1145,7 +1304,9 @@ void Metainference::moveScaleOffset(const std::vector<double> &mean_, double &ol
   if(master) {
     totenergies[0] = old_energy;
     totenergies[1] = new_energy;
-    if(nrep_>1) multi_sim_comm.Sum(totenergies);
+    if(nrep_>1) {
+      multi_sim_comm.Sum(totenergies);
+    }
   } else {
     totenergies[0] = 0;
     totenergies[1] = 0;
@@ -1172,8 +1333,7 @@ void Metainference::moveScaleOffset(const std::vector<double> &mean_, double &ol
   }
 }
 
-void Metainference::moveSigmas(const std::vector<double> &mean_, double &old_energy, const unsigned i, const std::vector<unsigned> &indices, bool &breaknow)
-{
+void Metainference::moveSigmas(const std::vector<double> &mean_, double &old_energy, const unsigned i, const std::vector<unsigned> &indices, bool &breaknow) {
   std::vector<double> new_sigma(sigma_.size());
   new_sigma = sigma_;
 
@@ -1196,8 +1356,12 @@ void Metainference::moveSigmas(const std::vector<double> &mean_, double &old_ene
       const double ds2 = Dsigma_[index]*r2;
       new_sigma[index] = sigma_[index] + ds2;
       // check boundaries
-      if(new_sigma[index] > sigma_max_[index]) {new_sigma[index] = 2.0 * sigma_max_[index] - new_sigma[index];}
-      if(new_sigma[index] < sigma_min_[index]) {new_sigma[index] = 2.0 * sigma_min_[index] - new_sigma[index];}
+      if(new_sigma[index] > sigma_max_[index]) {
+        new_sigma[index] = 2.0 * sigma_max_[index] - new_sigma[index];
+      }
+      if(new_sigma[index] < sigma_min_[index]) {
+        new_sigma[index] = 2.0 * sigma_min_[index] - new_sigma[index];
+      }
     }
   } else {
     // change all sigmas
@@ -1206,8 +1370,12 @@ void Metainference::moveSigmas(const std::vector<double> &mean_, double &old_ene
       const double ds2 = Dsigma_[j]*r2;
       new_sigma[j] = sigma_[j] + ds2;
       // check boundaries
-      if(new_sigma[j] > sigma_max_[j]) {new_sigma[j] = 2.0 * sigma_max_[j] - new_sigma[j];}
-      if(new_sigma[j] < sigma_min_[j]) {new_sigma[j] = 2.0 * sigma_min_[j] - new_sigma[j];}
+      if(new_sigma[j] > sigma_max_[j]) {
+        new_sigma[j] = 2.0 * sigma_max_[j] - new_sigma[j];
+      }
+      if(new_sigma[j] < sigma_min_[j]) {
+        new_sigma[j] = 2.0 * sigma_min_[j] - new_sigma[j];
+      }
     }
   }
 
@@ -1254,8 +1422,7 @@ void Metainference::moveSigmas(const std::vector<double> &mean_, double &old_ene
   }
 }
 
-double Metainference::doMonteCarlo(const std::vector<double> &mean_)
-{
+double Metainference::doMonteCarlo(const std::vector<double> &mean_) {
   // calculate old energy with the updated coordinates
   double old_energy=0.;
 
@@ -1294,13 +1461,19 @@ double Metainference::doMonteCarlo(const std::vector<double> &mean_)
     for(unsigned i=0; i<MCsteps_; ++i) {
       MCtrial_++;
       // propose move for ftilde
-      if(noise_type_==GENERIC) moveTilde(mean_, old_energy);
+      if(noise_type_==GENERIC) {
+        moveTilde(mean_, old_energy);
+      }
       // propose move for scale and/or offset
-      if(doscale_||dooffset_) moveScaleOffset(mean_, old_energy);
+      if(doscale_||dooffset_) {
+        moveScaleOffset(mean_, old_energy);
+      }
       // propose move for sigma
       moveSigmas(mean_, old_energy, i, indices, breaknow);
       // exit from the loop if this is the case
-      if(breaknow) break;
+      if(breaknow) {
+        break;
+      }
     }
 
     /* save the result of the sampling */
@@ -1308,24 +1481,34 @@ double Metainference::doMonteCarlo(const std::vector<double> &mean_)
     if(noise_type_==GENERIC) {
       double accept = static_cast<double>(MCacceptFT_) / static_cast<double>(MCtrial_);
       valueAcceptFT->set(accept);
-      for(unsigned i=0; i<sigma_.size(); i++) valueFtilde[i]->set(ftilde_[i]);
+      for(unsigned i=0; i<sigma_.size(); i++) {
+        valueFtilde[i]->set(ftilde_[i]);
+      }
     }
     /* scale and offset */
-    if(doscale_ || doregres_zero_) valueScale->set(scale_);
-    if(dooffset_) valueOffset->set(offset_);
+    if(doscale_ || doregres_zero_) {
+      valueScale->set(scale_);
+    }
+    if(dooffset_) {
+      valueOffset->set(offset_);
+    }
     if(doscale_||dooffset_) {
       double accept = static_cast<double>(MCacceptScale_) / static_cast<double>(MCtrial_);
       valueAcceptScale->set(accept);
     }
     /* sigmas */
-    for(unsigned i=0; i<sigma_.size(); i++) valueSigma[i]->set(sigma_[i]);
+    for(unsigned i=0; i<sigma_.size(); i++) {
+      valueSigma[i]->set(sigma_[i]);
+    }
     double accept = static_cast<double>(MCaccept_) / static_cast<double>(MCtrial_);
     valueAccept->set(accept);
   }
 
   // here we sum the score over the replicas to get the full metainference score that we save as a bias
   if(master) {
-    if(nrep_>1) multi_sim_comm.Sum(old_energy);
+    if(nrep_>1) {
+      multi_sim_comm.Sum(old_energy);
+    }
   } else {
     old_energy=0;
   }
@@ -1342,8 +1525,7 @@ double Metainference::doMonteCarlo(const std::vector<double> &mean_)
 */
 
 void Metainference::getEnergyForceSP(const std::vector<double> &mean, const std::vector<double> &dmean_x,
-                                     const std::vector<double> &dmean_b)
-{
+                                     const std::vector<double> &dmean_b) {
   const double scale2 = scale_*scale_;
   const double sm2    = sigma_mean2_[0];
   const double ss2    = sigma_[0]*sigma_[0] + scale2*sm2;
@@ -1361,14 +1543,15 @@ void Metainference::getEnergyForceSP(const std::vector<double> &mean, const std:
           const double dt = 1./t;
           const double dit = 1./(1.-dt);
           f[i] = -scale_*dev*(dit/sm2 + 1./a2);
-        }
-        else {
+        } else {
           f[i] = -scale_*dev*(1./a2);
         }
       }
     }
     // collect contribution to forces and energy from other replicas
-    if(nrep_>1) multi_sim_comm.Sum(&f[0],narg);
+    if(nrep_>1) {
+      multi_sim_comm.Sum(&f[0],narg);
+    }
   }
   // intra-replica summation
   comm.Sum(&f[0],narg);
@@ -1386,8 +1569,7 @@ void Metainference::getEnergyForceSP(const std::vector<double> &mean, const std:
 }
 
 void Metainference::getEnergyForceSPE(const std::vector<double> &mean, const std::vector<double> &dmean_x,
-                                      const std::vector<double> &dmean_b)
-{
+                                      const std::vector<double> &dmean_b) {
   const double scale2 = scale_*scale_;
   std::vector<double> f(narg,0);
 
@@ -1405,14 +1587,15 @@ void Metainference::getEnergyForceSPE(const std::vector<double> &mean, const std
           const double dt  = 1./t;
           const double dit = 1./(1.-dt);
           f[i] = -scale_*dev*(dit/sm2 + 1./a2);
-        }
-        else {
+        } else {
           f[i] = -scale_*dev*(1./a2);
         }
       }
     }
     // collect contribution to forces and energy from other replicas
-    if(nrep_>1) multi_sim_comm.Sum(&f[0],narg);
+    if(nrep_>1) {
+      multi_sim_comm.Sum(&f[0],narg);
+    }
   }
   comm.Sum(&f[0],narg);
 
@@ -1429,14 +1612,15 @@ void Metainference::getEnergyForceSPE(const std::vector<double> &mean, const std
 }
 
 void Metainference::getEnergyForceGJ(const std::vector<double> &mean, const std::vector<double> &dmean_x,
-                                     const std::vector<double> &dmean_b)
-{
+                                     const std::vector<double> &dmean_b) {
   const double scale2 = scale_*scale_;
   double inv_s2=0.;
 
   if(master) {
     inv_s2 = 1./(sigma_[0]*sigma_[0] + scale2*sigma_mean2_[0]);
-    if(nrep_>1) multi_sim_comm.Sum(inv_s2);
+    if(nrep_>1) {
+      multi_sim_comm.Sum(inv_s2);
+    }
   }
   comm.Sum(inv_s2);
 
@@ -1459,14 +1643,17 @@ void Metainference::getEnergyForceGJ(const std::vector<double> &mean, const std:
 }
 
 void Metainference::getEnergyForceGJE(const std::vector<double> &mean, const std::vector<double> &dmean_x,
-                                      const std::vector<double> &dmean_b)
-{
+                                      const std::vector<double> &dmean_b) {
   const double scale2 = scale_*scale_;
   std::vector<double> inv_s2(sigma_.size(),0.);
 
   if(master) {
-    for(unsigned i=0; i<sigma_.size(); ++i) inv_s2[i] = 1./(sigma_[i]*sigma_[i] + scale2*sigma_mean2_[i]);
-    if(nrep_>1) multi_sim_comm.Sum(&inv_s2[0],sigma_.size());
+    for(unsigned i=0; i<sigma_.size(); ++i) {
+      inv_s2[i] = 1./(sigma_[i]*sigma_[i] + scale2*sigma_mean2_[i]);
+    }
+    if(nrep_>1) {
+      multi_sim_comm.Sum(&inv_s2[0],sigma_.size());
+    }
   }
   comm.Sum(&inv_s2[0],sigma_.size());
 
@@ -1488,8 +1675,7 @@ void Metainference::getEnergyForceGJE(const std::vector<double> &mean, const std
   }
 }
 
-void Metainference::getEnergyForceMIGEN(const std::vector<double> &mean, const std::vector<double> &dmean_x, const std::vector<double> &dmean_b)
-{
+void Metainference::getEnergyForceMIGEN(const std::vector<double> &mean, const std::vector<double> &dmean_x, const std::vector<double> &dmean_b) {
   std::vector<double> inv_s2(sigma_.size(),0.);
   std::vector<double> dev(sigma_.size(),0.);
   std::vector<double> dev2(sigma_.size(),0.);
@@ -1525,15 +1711,16 @@ void Metainference::getEnergyForceMIGEN(const std::vector<double> &mean, const s
   }
 }
 
-void Metainference::get_weights(const unsigned iselect, double &weight, double &norm, double &neff)
-{
+void Metainference::get_weights(const unsigned iselect, double &weight, double &norm, double &neff) {
   const double dnrep = static_cast<double>(nrep_);
   // calculate the weights either from BIAS
   if(do_reweight_) {
     std::vector<double> bias(nrep_,0);
     if(master) {
       bias[replica_] = getArgument(narg);
-      if(nrep_>1) multi_sim_comm.Sum(&bias[0], nrep_);
+      if(nrep_>1) {
+        multi_sim_comm.Sum(&bias[0], nrep_);
+      }
     }
     comm.Sum(&bias[0], nrep_);
 
@@ -1546,12 +1733,16 @@ void Metainference::get_weights(const unsigned iselect, double &weight, double &
       }
     } else {
       firstTimeW[iselect] = false;
-      for(unsigned i=0; i<nrep_; ++i) average_weights_[iselect][i] = bias[i];
+      for(unsigned i=0; i<nrep_; ++i) {
+        average_weights_[iselect][i] = bias[i];
+      }
     }
 
     // set average back into bias and set norm to one
     const double maxbias = *(std::max_element(average_weights_[iselect].begin(), average_weights_[iselect].end()));
-    for(unsigned i=0; i<nrep_; ++i) bias[i] = std::exp((average_weights_[iselect][i]-maxbias)/kbt_);
+    for(unsigned i=0; i<nrep_; ++i) {
+      bias[i] = std::exp((average_weights_[iselect][i]-maxbias)/kbt_);
+    }
     // set local weight, norm and weight variance
     weight = bias[replica_];
     double w2=0.;
@@ -1570,31 +1761,43 @@ void Metainference::get_weights(const unsigned iselect, double &weight, double &
   getPntrToComponent("neff")->set(neff);
 }
 
-void Metainference::get_sigma_mean(const unsigned iselect, const double weight, const double norm, const double neff, const std::vector<double> &mean)
-{
+void Metainference::get_sigma_mean(const unsigned iselect, const double weight, const double norm, const double neff, const std::vector<double> &mean) {
   const double dnrep    = static_cast<double>(nrep_);
   std::vector<double> sigma_mean2_tmp(sigma_mean2_.size(), 0.);
 
   if(do_optsigmamean_>0) {
     // remove first entry of the history std::vector
     if(sigma_mean2_last_[iselect][0].size()==optsigmamean_stride_&&optsigmamean_stride_>0)
-      for(unsigned i=0; i<narg; ++i) sigma_mean2_last_[iselect][i].erase(sigma_mean2_last_[iselect][i].begin());
+      for(unsigned i=0; i<narg; ++i) {
+        sigma_mean2_last_[iselect][i].erase(sigma_mean2_last_[iselect][i].begin());
+      }
     /* this is the current estimate of sigma mean for each argument
        there is one of this per argument in any case  because it is
        the maximum among these to be used in case of GAUSS/OUTLIER */
     std::vector<double> sigma_mean2_now(narg,0);
     if(master) {
-      for(unsigned i=0; i<narg; ++i) sigma_mean2_now[i] = weight*(getArgument(i)-mean[i])*(getArgument(i)-mean[i]);
-      if(nrep_>1) multi_sim_comm.Sum(&sigma_mean2_now[0], narg);
+      for(unsigned i=0; i<narg; ++i) {
+        sigma_mean2_now[i] = weight*(getArgument(i)-mean[i])*(getArgument(i)-mean[i]);
+      }
+      if(nrep_>1) {
+        multi_sim_comm.Sum(&sigma_mean2_now[0], narg);
+      }
     }
     comm.Sum(&sigma_mean2_now[0], narg);
-    for(unsigned i=0; i<narg; ++i) sigma_mean2_now[i] *= 1.0/(neff-1.)/norm;
+    for(unsigned i=0; i<narg; ++i) {
+      sigma_mean2_now[i] *= 1.0/(neff-1.)/norm;
+    }
 
     // add sigma_mean2 to history
     if(optsigmamean_stride_>0) {
-      for(unsigned i=0; i<narg; ++i) sigma_mean2_last_[iselect][i].push_back(sigma_mean2_now[i]);
+      for(unsigned i=0; i<narg; ++i) {
+        sigma_mean2_last_[iselect][i].push_back(sigma_mean2_now[i]);
+      }
     } else {
-      for(unsigned i=0; i<narg; ++i) if(sigma_mean2_now[i] > sigma_mean2_last_[iselect][i][0]) sigma_mean2_last_[iselect][i][0] = sigma_mean2_now[i];
+      for(unsigned i=0; i<narg; ++i)
+        if(sigma_mean2_now[i] > sigma_mean2_last_[iselect][i][0]) {
+          sigma_mean2_last_[iselect][i][0] = sigma_mean2_now[i];
+        }
     }
 
     if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
@@ -1605,13 +1808,17 @@ void Metainference::get_sigma_mean(const unsigned iselect, const double weight,
         valueSigmaMean[i]->set(std::sqrt(sigma_mean2_tmp[i]));
         if(noise_type_==GENERIC) {
           sigma_min_[i] = std::sqrt(sigma_mean2_tmp[i]);
-          if(sigma_[i] < sigma_min_[i]) sigma_[i] = sigma_min_[i];
+          if(sigma_[i] < sigma_min_[i]) {
+            sigma_[i] = sigma_min_[i];
+          }
         }
       }
     } else if(noise_type_==GAUSS||noise_type_==OUTLIERS) {
       // find maximum for each data point
       std::vector <double> max_values;
-      for(unsigned i=0; i<narg; ++i) max_values.push_back(*max_element(sigma_mean2_last_[iselect][i].begin(), sigma_mean2_last_[iselect][i].end()));
+      for(unsigned i=0; i<narg; ++i) {
+        max_values.push_back(*max_element(sigma_mean2_last_[iselect][i].begin(), sigma_mean2_last_[iselect][i].end()));
+      }
       // find maximum across data points
       const double max_now = *max_element(max_values.begin(), max_values.end());
       // set new value
@@ -1622,14 +1829,18 @@ void Metainference::get_sigma_mean(const unsigned iselect, const double weight,
     // start sigma max optimization
     if(do_optsigmamean_>1&&!sigmamax_opt_done_) {
       for(unsigned i=0; i<sigma_max_.size(); i++) {
-        if(sigma_max_est_[i]<sigma_mean2_tmp[i]&&optimized_step_>optsigmamean_stride_) sigma_max_est_[i]=sigma_mean2_tmp[i];
+        if(sigma_max_est_[i]<sigma_mean2_tmp[i]&&optimized_step_>optsigmamean_stride_) {
+          sigma_max_est_[i]=sigma_mean2_tmp[i];
+        }
         // ready to set once and for all the value of sigma_max
         if(optimized_step_==N_optimized_step_) {
           sigmamax_opt_done_=true;
           for(unsigned i=0; i<sigma_max_.size(); i++) {
             sigma_max_[i]=std::sqrt(sigma_max_est_[i]*dnrep);
             Dsigma_[i] = 0.05*(sigma_max_[i] - sigma_min_[i]);
-            if(sigma_[i]>sigma_max_[i]) sigma_[i]=sigma_max_[i];
+            if(sigma_[i]>sigma_max_[i]) {
+              sigma_[i]=sigma_max_[i];
+            }
           }
         }
       }
@@ -1651,22 +1862,29 @@ void Metainference::get_sigma_mean(const unsigned iselect, const double weight,
   sigma_mean2_ = sigma_mean2_tmp;
 }
 
-void Metainference::replica_averaging(const double weight, const double norm, std::vector<double> &mean, std::vector<double> &dmean_b)
-{
+void Metainference::replica_averaging(const double weight, const double norm, std::vector<double> &mean, std::vector<double> &dmean_b) {
   if(master) {
-    for(unsigned i=0; i<narg; ++i) mean[i] = weight/norm*getArgument(i);
-    if(nrep_>1) multi_sim_comm.Sum(&mean[0], narg);
+    for(unsigned i=0; i<narg; ++i) {
+      mean[i] = weight/norm*getArgument(i);
+    }
+    if(nrep_>1) {
+      multi_sim_comm.Sum(&mean[0], narg);
+    }
   }
   comm.Sum(&mean[0], narg);
   // set the derivative of the mean with respect to the bias
-  for(unsigned i=0; i<narg; ++i) dmean_b[i] = weight/norm/kbt_*(getArgument(i)-mean[i])/static_cast<double>(average_weights_stride_);
+  for(unsigned i=0; i<narg; ++i) {
+    dmean_b[i] = weight/norm/kbt_*(getArgument(i)-mean[i])/static_cast<double>(average_weights_stride_);
+  }
 
   // this is only for generic metainference
-  if(firstTime) {ftilde_ = mean; firstTime = false;}
+  if(firstTime) {
+    ftilde_ = mean;
+    firstTime = false;
+  }
 }
 
-void Metainference::do_regression_zero(const std::vector<double> &mean)
-{
+void Metainference::do_regression_zero(const std::vector<double> &mean) {
 // parameters[i] = scale_ * mean[i]: find scale_ with linear regression
   double num = 0.0;
   double den = 0.0;
@@ -1681,14 +1899,15 @@ void Metainference::do_regression_zero(const std::vector<double> &mean)
   }
 }
 
-void Metainference::calculate()
-{
+void Metainference::calculate() {
   // get step
   const long long int step = getStep();
 
   unsigned iselect = 0;
   // set the value of selector for  REM-like stuff
-  if(selector_.length()>0) iselect = static_cast<unsigned>(plumed.passMap[selector_]);
+  if(selector_.length()>0) {
+    iselect = static_cast<unsigned>(plumed.passMap[selector_]);
+  }
 
   /* 1) collect weights */
   double weight = 0.;
@@ -1709,7 +1928,9 @@ void Metainference::calculate()
   get_sigma_mean(iselect, weight, norm, neff, mean);
 
   // in case of regression with zero intercept, calculate scale
-  if(doregres_zero_ && step%nregres_zero_==0) do_regression_zero(mean);
+  if(doregres_zero_ && step%nregres_zero_==0) {
+    do_regression_zero(mean);
+  }
 
   /* 4) run monte carlo */
   double ene = doMonteCarlo(mean);
@@ -1736,8 +1957,7 @@ void Metainference::calculate()
   setBias(ene);
 }
 
-void Metainference::writeStatus()
-{
+void Metainference::writeStatus() {
   sfile_.rewind();
   sfile_.printField("time",getTimeStep()*getStep());
   //nsel
@@ -1794,7 +2014,9 @@ void Metainference::writeStatus()
 
 void Metainference::update() {
   // write status file
-  if(write_stride_>0&& (getStep()%write_stride_==0 || getCPT()) ) writeStatus();
+  if(write_stride_>0&& (getStep()%write_stride_==0 || getCPT()) ) {
+    writeStatus();
+  }
 }
 
 }
diff --git a/src/isdb/MetainferenceBase.cpp b/src/isdb/MetainferenceBase.cpp
index 6e9d230827..4da6add335 100644
--- a/src/isdb/MetainferenceBase.cpp
+++ b/src/isdb/MetainferenceBase.cpp
@@ -125,8 +125,7 @@ MetainferenceBase::MetainferenceBase(const ActionOptions&ao):
   N_optimized_step_(0),
   optimized_step_(0),
   sigmamax_opt_done_(false),
-  decay_w_(1.)
-{
+  decay_w_(1.) {
   parseFlag("DOSCORE", doscore_);
 
   bool noensemble = false;
@@ -137,7 +136,9 @@ MetainferenceBase::MetainferenceBase(const ActionOptions&ao):
   if(master) {
     nrep_    = multi_sim_comm.Get_size();
     replica_ = multi_sim_comm.Get_rank();
-    if(noensemble) nrep_ = 1;
+    if(noensemble) {
+      nrep_ = 1;
+    }
   } else {
     nrep_    = 0;
     replica_ = 0;
@@ -148,18 +149,29 @@ MetainferenceBase::MetainferenceBase(const ActionOptions&ao):
   parse("SELECTOR", selector_);
   parse("NSELECT", nsel_);
   // do checks
-  if(selector_.length()>0 && nsel_<=1) error("With SELECTOR active, NSELECT must be greater than 1");
-  if(selector_.length()==0 && nsel_>1) error("With NSELECT greater than 1, you must specify SELECTOR");
+  if(selector_.length()>0 && nsel_<=1) {
+    error("With SELECTOR active, NSELECT must be greater than 1");
+  }
+  if(selector_.length()==0 && nsel_>1) {
+    error("With NSELECT greater than 1, you must specify SELECTOR");
+  }
 
   // initialise firstTimeW
   firstTimeW.resize(nsel_, true);
 
   // reweight implies a different number of arguments (the latest one must always be the bias)
   parseFlag("REWEIGHT", do_reweight_);
-  if(do_reweight_&&getNumberOfArguments()!=1) error("To REWEIGHT one must provide one single bias as an argument");
-  if(do_reweight_&&nrep_<2) error("REWEIGHT can only be used in parallel with 2 or more replicas");
-  if(!getRestart()) average_weights_.resize(nsel_, std::vector<double> (nrep_, 1./static_cast<double>(nrep_)));
-  else average_weights_.resize(nsel_, std::vector<double> (nrep_, 0.));
+  if(do_reweight_&&getNumberOfArguments()!=1) {
+    error("To REWEIGHT one must provide one single bias as an argument");
+  }
+  if(do_reweight_&&nrep_<2) {
+    error("REWEIGHT can only be used in parallel with 2 or more replicas");
+  }
+  if(!getRestart()) {
+    average_weights_.resize(nsel_, std::vector<double> (nrep_, 1./static_cast<double>(nrep_)));
+  } else {
+    average_weights_.resize(nsel_, std::vector<double> (nrep_, 0.));
+  }
 
   unsigned averaging=0;
   parse("AVERAGING", averaging);
@@ -170,50 +182,79 @@ MetainferenceBase::MetainferenceBase(const ActionOptions&ao):
 
   std::string stringa_noise;
   parse("NOISETYPE",stringa_noise);
-  if(stringa_noise=="GAUSS")           noise_type_ = GAUSS;
-  else if(stringa_noise=="MGAUSS")     noise_type_ = MGAUSS;
-  else if(stringa_noise=="OUTLIERS")   noise_type_ = OUTLIERS;
-  else if(stringa_noise=="MOUTLIERS")  noise_type_ = MOUTLIERS;
-  else if(stringa_noise=="GENERIC")    noise_type_ = GENERIC;
-  else error("Unknown noise type!");
+  if(stringa_noise=="GAUSS") {
+    noise_type_ = GAUSS;
+  } else if(stringa_noise=="MGAUSS") {
+    noise_type_ = MGAUSS;
+  } else if(stringa_noise=="OUTLIERS") {
+    noise_type_ = OUTLIERS;
+  } else if(stringa_noise=="MOUTLIERS") {
+    noise_type_ = MOUTLIERS;
+  } else if(stringa_noise=="GENERIC") {
+    noise_type_ = GENERIC;
+  } else {
+    error("Unknown noise type!");
+  }
 
   if(noise_type_== GENERIC) {
     std::string stringa_like;
     parse("LIKELIHOOD",stringa_like);
-    if(stringa_like=="GAUSS") gen_likelihood_ = LIKE_GAUSS;
-    else if(stringa_like=="LOGN") gen_likelihood_ = LIKE_LOGN;
-    else error("Unknown likelihood type!");
+    if(stringa_like=="GAUSS") {
+      gen_likelihood_ = LIKE_GAUSS;
+    } else if(stringa_like=="LOGN") {
+      gen_likelihood_ = LIKE_LOGN;
+    } else {
+      error("Unknown likelihood type!");
+    }
 
     parse("DFTILDE",Dftilde_);
   }
 
   parse("WRITE_STRIDE",write_stride_);
   parse("STATUS_FILE",status_file_name_);
-  if(status_file_name_=="") status_file_name_ = "MISTATUS"+getLabel();
-  else                      status_file_name_ = status_file_name_+getLabel();
+  if(status_file_name_=="") {
+    status_file_name_ = "MISTATUS"+getLabel();
+  } else {
+    status_file_name_ = status_file_name_+getLabel();
+  }
 
   std::string stringa_optsigma;
   parse("OPTSIGMAMEAN", stringa_optsigma);
-  if(stringa_optsigma=="NONE")      do_optsigmamean_=0;
-  else if(stringa_optsigma=="SEM")  do_optsigmamean_=1;
-  else if(stringa_optsigma=="SEM_MAX")  do_optsigmamean_=2;
+  if(stringa_optsigma=="NONE") {
+    do_optsigmamean_=0;
+  } else if(stringa_optsigma=="SEM") {
+    do_optsigmamean_=1;
+  } else if(stringa_optsigma=="SEM_MAX") {
+    do_optsigmamean_=2;
+  }
 
   unsigned aver_max_steps=0;
   parse("SIGMA_MAX_STEPS", aver_max_steps);
-  if(aver_max_steps==0&&do_optsigmamean_==2) aver_max_steps=averaging*2000;
-  if(aver_max_steps>0&&do_optsigmamean_<2) error("SIGMA_MAX_STEPS can only be used together with OPTSIGMAMEAN=SEM_MAX");
-  if(aver_max_steps>0&&do_optsigmamean_==2) N_optimized_step_=aver_max_steps;
-  if(aver_max_steps>0&&aver_max_steps<averaging) error("SIGMA_MAX_STEPS must be greater than AVERAGING");
+  if(aver_max_steps==0&&do_optsigmamean_==2) {
+    aver_max_steps=averaging*2000;
+  }
+  if(aver_max_steps>0&&do_optsigmamean_<2) {
+    error("SIGMA_MAX_STEPS can only be used together with OPTSIGMAMEAN=SEM_MAX");
+  }
+  if(aver_max_steps>0&&do_optsigmamean_==2) {
+    N_optimized_step_=aver_max_steps;
+  }
+  if(aver_max_steps>0&&aver_max_steps<averaging) {
+    error("SIGMA_MAX_STEPS must be greater than AVERAGING");
+  }
 
   std::vector<double> read_sigma_mean_;
   parseVector("SIGMA_MEAN0",read_sigma_mean_);
-  if(do_optsigmamean_==0 && read_sigma_mean_.size()==0 && !getRestart() && doscore_)
+  if(do_optsigmamean_==0 && read_sigma_mean_.size()==0 && !getRestart() && doscore_) {
     error("If you don't use OPTSIGMAMEAN and you are not RESTARTING then you MUST SET SIGMA_MEAN0");
+  }
 
   if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
     if(read_sigma_mean_.size()>0) {
       sigma_mean2_.resize(read_sigma_mean_.size());
-      for(unsigned i=0; i<read_sigma_mean_.size(); i++) sigma_mean2_[i]=read_sigma_mean_[i]*read_sigma_mean_[i];
+      for(unsigned i=0; i<read_sigma_mean_.size(); i++) {
+        sigma_mean2_[i]=read_sigma_mean_[i]*read_sigma_mean_[i];
+      }
     } else {
       sigma_mean2_.resize(1,0.000001);
     }
@@ -231,18 +272,26 @@ MetainferenceBase::MetainferenceBase(const ActionOptions&ao):
   if(doscale_) {
     std::string stringa_noise;
     parse("SCALE_PRIOR",stringa_noise);
-    if(stringa_noise=="GAUSSIAN")  scale_prior_ = SC_GAUSS;
-    else if(stringa_noise=="FLAT") scale_prior_ = SC_FLAT;
-    else error("Unknown SCALE_PRIOR type!");
+    if(stringa_noise=="GAUSSIAN") {
+      scale_prior_ = SC_GAUSS;
+    } else if(stringa_noise=="FLAT") {
+      scale_prior_ = SC_FLAT;
+    } else {
+      error("Unknown SCALE_PRIOR type!");
+    }
     parse("SCALE0",scale_);
     parse("DSCALE",Dscale_);
-    if(Dscale_<0.) error("DSCALE must be set when using SCALEDATA");
+    if(Dscale_<0.) {
+      error("DSCALE must be set when using SCALEDATA");
+    }
     if(scale_prior_==SC_GAUSS) {
       scale_mu_=scale_;
     } else {
       parse("SCALE_MIN",scale_min_);
       parse("SCALE_MAX",scale_max_);
-      if(scale_max_<scale_min_) error("SCALE_MAX and SCALE_MIN must be set when using SCALE_PRIOR=FLAT");
+      if(scale_max_<scale_min_) {
+        error("SCALE_MAX and SCALE_MIN must be set when using SCALE_PRIOR=FLAT");
+      }
     }
   }
 
@@ -250,19 +299,29 @@ MetainferenceBase::MetainferenceBase(const ActionOptions&ao):
   if(dooffset_) {
     std::string stringa_noise;
     parse("OFFSET_PRIOR",stringa_noise);
-    if(stringa_noise=="GAUSSIAN")  offset_prior_ = SC_GAUSS;
-    else if(stringa_noise=="FLAT") offset_prior_ = SC_FLAT;
-    else error("Unknown OFFSET_PRIOR type!");
+    if(stringa_noise=="GAUSSIAN") {
+      offset_prior_ = SC_GAUSS;
+    } else if(stringa_noise=="FLAT") {
+      offset_prior_ = SC_FLAT;
+    } else {
+      error("Unknown OFFSET_PRIOR type!");
+    }
     parse("OFFSET0",offset_);
     parse("DOFFSET",Doffset_);
     if(offset_prior_==SC_GAUSS) {
       offset_mu_=offset_;
-      if(Doffset_<0.) error("DOFFSET must be set when using OFFSET_PRIOR=GAUSS");
+      if(Doffset_<0.) {
+        error("DOFFSET must be set when using OFFSET_PRIOR=GAUSS");
+      }
     } else {
       parse("OFFSET_MIN",offset_min_);
       parse("OFFSET_MAX",offset_max_);
-      if(Doffset_<0) Doffset_ = 0.05*(offset_max_ - offset_min_);
-      if(offset_max_<offset_min_) error("OFFSET_MAX and OFFSET_MIN must be set when using OFFSET_PRIOR=FLAT");
+      if(Doffset_<0) {
+        Doffset_ = 0.05*(offset_max_ - offset_min_);
+      }
+      if(offset_max_<offset_min_) {
+        error("OFFSET_MAX and OFFSET_MIN must be set when using OFFSET_PRIOR=FLAT");
+      }
     }
   }
 
@@ -272,43 +331,59 @@ MetainferenceBase::MetainferenceBase(const ActionOptions&ao):
     // set flag
     doregres_zero_=true;
     // check if already sampling scale and offset
-    if(doscale_)  error("REGRES_ZERO and SCALEDATA are mutually exclusive");
-    if(dooffset_) error("REGRES_ZERO and ADDOFFSET are mutually exclusive");
+    if(doscale_) {
+      error("REGRES_ZERO and SCALEDATA are mutually exclusive");
+    }
+    if(dooffset_) {
+      error("REGRES_ZERO and ADDOFFSET are mutually exclusive");
+    }
   }
 
   std::vector<double> readsigma;
   parseVector("SIGMA0",readsigma);
-  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma.size()>1)
+  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma.size()>1) {
     error("If you want to use more than one SIGMA you should use NOISETYPE=MGAUSS|MOUTLIERS|GENERIC");
+  }
   if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
     sigma_.resize(readsigma.size());
     sigma_=readsigma;
-  } else sigma_.resize(1, readsigma[0]);
+  } else {
+    sigma_.resize(1, readsigma[0]);
+  }
 
   std::vector<double> readsigma_min;
   parseVector("SIGMA_MIN",readsigma_min);
-  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_min.size()>1)
+  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_min.size()>1) {
     error("If you want to use more than one SIGMA you should use NOISETYPE=MGAUSS|MOUTLIERS|GENERIC");
+  }
   if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
     sigma_min_.resize(readsigma_min.size());
     sigma_min_=readsigma_min;
-  } else sigma_min_.resize(1, readsigma_min[0]);
+  } else {
+    sigma_min_.resize(1, readsigma_min[0]);
+  }
 
   std::vector<double> readsigma_max;
   parseVector("SIGMA_MAX",readsigma_max);
-  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_max.size()>1)
+  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_max.size()>1) {
     error("If you want to use more than one SIGMA you should use NOISETYPE=MGAUSS|MOUTLIERS|GENERIC");
+  }
   if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
     sigma_max_.resize(readsigma_max.size());
     sigma_max_=readsigma_max;
-  } else sigma_max_.resize(1, readsigma_max[0]);
+  } else {
+    sigma_max_.resize(1, readsigma_max[0]);
+  }
 
-  if(sigma_max_.size()!=sigma_min_.size()) error("The number of values for SIGMA_MIN and SIGMA_MAX must be the same");
+  if(sigma_max_.size()!=sigma_min_.size()) {
+    error("The number of values for SIGMA_MIN and SIGMA_MAX must be the same");
+  }
 
   std::vector<double> read_dsigma;
   parseVector("DSIGMA",read_dsigma);
-  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_max.size()>1)
+  if((noise_type_!=MGAUSS&&noise_type_!=MOUTLIERS&&noise_type_!=GENERIC)&&readsigma_max.size()>1) {
     error("If you want to use more than one SIGMA you should use NOISETYPE=MGAUSS|MOUTLIERS|GENERIC");
+  }
   if(read_dsigma.size()>0) {
     Dsigma_.resize(read_dsigma.size());
     Dsigma_=read_dsigma;
@@ -322,7 +397,9 @@ MetainferenceBase::MetainferenceBase(const ActionOptions&ao):
   parse("MC_CHUNKSIZE", MCchunksize_);
   // get temperature
   kbt_=getkBT();
-  if(kbt_==0.0&&doscore_) error("Unless the MD engine passes the temperature to plumed, you must specify it using TEMP");
+  if(kbt_==0.0&&doscore_) {
+    error("Unless the MD engine passes the temperature to plumed, you must specify it using TEMP");
+  }
 
   // initialize random seed
   unsigned iseed;
@@ -340,7 +417,9 @@ MetainferenceBase::MetainferenceBase(const ActionOptions&ao):
     // in this case we want the same seed everywhere
     auto ts = std::chrono::time_point_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now()).time_since_epoch().count();
     iseed = static_cast<unsigned>(ts);
-    if(master&&nrep_>1) multi_sim_comm.Bcast(iseed,0);
+    if(master&&nrep_>1) {
+      multi_sim_comm.Bcast(iseed,0);
+    }
     comm.Bcast(iseed,0);
     // this is used for scale and offset sampling and acceptance
     random[1].setSeed(-iseed);
@@ -363,24 +442,28 @@ MetainferenceBase::MetainferenceBase(const ActionOptions&ao):
 
 }
 
-MetainferenceBase::~MetainferenceBase()
-{
-  if(sfile_.isOpen()) sfile_.close();
+MetainferenceBase::~MetainferenceBase() {
+  if(sfile_.isOpen()) {
+    sfile_.close();
+  }
 }
 
-void MetainferenceBase::Initialise(const unsigned input)
-{
+void MetainferenceBase::Initialise(const unsigned input) {
   setNarg(input);
   if(narg!=parameters.size()) {
-    std::string num1; Tools::convert(parameters.size(),num1);
-    std::string num2; Tools::convert(narg,num2);
+    std::string num1;
+    Tools::convert(parameters.size(),num1);
+    std::string num2;
+    Tools::convert(narg,num2);
     std::string msg = "The number of experimental values " + num1 +" must be the same of the calculated values " + num2;
     error(msg);
   }
 
   // resize std::vector for sigma_mean history
   sigma_mean2_last_.resize(nsel_);
-  for(unsigned i=0; i<nsel_; i++) sigma_mean2_last_[i].resize(narg);
+  for(unsigned i=0; i<nsel_; i++) {
+    sigma_mean2_last_[i].resize(narg);
+  }
   if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
     if(sigma_mean2_.size()==1) {
       double tmp = sigma_mean2_[0];
@@ -389,10 +472,16 @@ void MetainferenceBase::Initialise(const unsigned input)
       error("SIGMA_MEAN0 can accept either one single value or as many values as the number of arguments (with NOISETYPE=MGAUSS|MOUTLIERS|GENERIC)");
     }
     // set the initial value for the history
-    for(unsigned i=0; i<nsel_; i++) for(unsigned j=0; j<narg; j++) sigma_mean2_last_[i][j].push_back(sigma_mean2_[j]);
+    for(unsigned i=0; i<nsel_; i++)
+      for(unsigned j=0; j<narg; j++) {
+        sigma_mean2_last_[i][j].push_back(sigma_mean2_[j]);
+      }
   } else {
     // set the initial value for the history
-    for(unsigned i=0; i<nsel_; i++) for(unsigned j=0; j<narg; j++) sigma_mean2_last_[i][j].push_back(sigma_mean2_[0]);
+    for(unsigned i=0; i<nsel_; i++)
+      for(unsigned j=0; j<narg; j++) {
+        sigma_mean2_last_[i][j].push_back(sigma_mean2_[0]);
+      }
   }
 
   // set sigma_bias
@@ -429,7 +518,9 @@ void MetainferenceBase::Initialise(const unsigned input)
   restart_sfile.link(*this);
   if(getRestart()&&restart_sfile.FileExist(status_file_name_)) {
     firstTime = false;
-    for(unsigned i=0; i<nsel_; i++) firstTimeW[i] = false;
+    for(unsigned i=0; i<nsel_; i++) {
+      firstTimeW[i] = false;
+    }
     restart_sfile.open(status_file_name_);
     log.printf("  Restarting from %s\n", status_file_name_.c_str());
     double dummy;
@@ -443,7 +534,9 @@ void MetainferenceBase::Initialise(const unsigned input)
       comm.Sum(dummy_time);
       for(unsigned i=1; i<nrep_; i++) {
         std::string msg = "METAINFERENCE restart files " + status_file_name_ + "  are not in sync";
-        if(dummy_time[i]!=dummy_time[0]) plumed_merror(msg);
+        if(dummy_time[i]!=dummy_time[0]) {
+          plumed_merror(msg);
+        }
       }
       // nsel
       for(unsigned i=0; i<sigma_mean2_last_.size(); i++) {
@@ -466,7 +559,9 @@ void MetainferenceBase::Initialise(const unsigned input)
           Tools::convert(0,msg_j);
           std::string msg = msg_i+"_"+msg_j;
           restart_sfile.scanField("sigmaMean_"+msg,read_sm);
-          for(unsigned j=0; j<narg; j++) sigma_mean2_last_[i][j][0] = read_sm*read_sm;
+          for(unsigned j=0; j<narg; j++) {
+            sigma_mean2_last_[i][j][0] = read_sm*read_sm;
+          }
         }
       }
 
@@ -498,7 +593,9 @@ void MetainferenceBase::Initialise(const unsigned input)
         restart_sfile.scanField("weight_"+msg,tmp_w);
         if(master) {
           average_weights_[i][replica_] = tmp_w;
-          if(nrep_>1) multi_sim_comm.Sum(&average_weights_[i][0], nrep_);
+          if(nrep_>1) {
+            multi_sim_comm.Sum(&average_weights_[i][0], nrep_);
+          }
         }
         comm.Sum(&average_weights_[i][0], nrep_);
       }
@@ -509,7 +606,10 @@ void MetainferenceBase::Initialise(const unsigned input)
   }
 
   /* If DSIGMA is not yet initialised do it now */
-  for(unsigned i=0; i<sigma_max_.size(); i++) if(Dsigma_[i]==-1) Dsigma_[i] = 0.05*(sigma_max_[i] - sigma_min_[i]);
+  for(unsigned i=0; i<sigma_max_.size(); i++)
+    if(Dsigma_[i]==-1) {
+      Dsigma_[i] = 0.05*(sigma_max_[i] - sigma_min_[i]);
+    }
 
   addComponentWithDerivatives("score");
   componentIsNotPeriodic("score");
@@ -555,23 +655,29 @@ void MetainferenceBase::Initialise(const unsigned input)
 
   if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
     for(unsigned i=0; i<sigma_mean2_.size(); ++i) {
-      std::string num; Tools::convert(i,num);
-      addComponent("sigmaMean-"+num); componentIsNotPeriodic("sigmaMean-"+num);
+      std::string num;
+      Tools::convert(i,num);
+      addComponent("sigmaMean-"+num);
+      componentIsNotPeriodic("sigmaMean-"+num);
       valueSigmaMean.push_back(getPntrToComponent("sigmaMean-"+num));
       getPntrToComponent("sigmaMean-"+num)->set(std::sqrt(sigma_mean2_[i]));
-      addComponent("sigma-"+num); componentIsNotPeriodic("sigma-"+num);
+      addComponent("sigma-"+num);
+      componentIsNotPeriodic("sigma-"+num);
       valueSigma.push_back(getPntrToComponent("sigma-"+num));
       getPntrToComponent("sigma-"+num)->set(sigma_[i]);
       if(noise_type_==GENERIC) {
-        addComponent("ftilde-"+num); componentIsNotPeriodic("ftilde-"+num);
+        addComponent("ftilde-"+num);
+        componentIsNotPeriodic("ftilde-"+num);
         valueFtilde.push_back(getPntrToComponent("ftilde-"+num));
       }
     }
   } else {
-    addComponent("sigmaMean"); componentIsNotPeriodic("sigmaMean");
+    addComponent("sigmaMean");
+    componentIsNotPeriodic("sigmaMean");
     valueSigmaMean.push_back(getPntrToComponent("sigmaMean"));
     getPntrToComponent("sigmaMean")->set(std::sqrt(sigma_mean2_[0]));
-    addComponent("sigma"); componentIsNotPeriodic("sigma");
+    addComponent("sigma");
+    componentIsNotPeriodic("sigma");
     valueSigma.push_back(getPntrToComponent("sigma"));
     getPntrToComponent("sigma")->set(sigma_[0]);
   }
@@ -579,8 +685,11 @@ void MetainferenceBase::Initialise(const unsigned input)
   switch(noise_type_) {
   case GENERIC:
     log.printf("  with general metainference ");
-    if(gen_likelihood_==LIKE_GAUSS) log.printf(" and a gaussian likelihood\n");
-    else if(gen_likelihood_==LIKE_LOGN) log.printf(" and a log-normal likelihood\n");
+    if(gen_likelihood_==LIKE_GAUSS) {
+      log.printf(" and a gaussian likelihood\n");
+    } else if(gen_likelihood_==LIKE_LOGN) {
+      log.printf(" and a log-normal likelihood\n");
+    }
     log.printf("  ensemble average parameter sampled with a step %lf of sigma_mean\n", Dftilde_);
     break;
   case GAUSS:
@@ -607,7 +716,9 @@ void MetainferenceBase::Initialise(const unsigned input)
     comm.Sum(dummy_scale);
     for(unsigned i=1; i<nrep_; i++) {
       std::string msg = "The SCALE value must be the same for all replicas: check your input or restart file";
-      if(dummy_scale[i]!=dummy_scale[0]) plumed_merror(msg);
+      if(dummy_scale[i]!=dummy_scale[0]) {
+        plumed_merror(msg);
+      }
     }
     log.printf("  sampling a common scaling factor with:\n");
     log.printf("    initial scale parameter %f\n",scale_);
@@ -630,7 +741,9 @@ void MetainferenceBase::Initialise(const unsigned input)
     comm.Sum(dummy_offset);
     for(unsigned i=1; i<nrep_; i++) {
       std::string msg = "The OFFSET value must be the same for all replicas: check your input or restart file";
-      if(dummy_offset[i]!=dummy_offset[0]) plumed_merror(msg);
+      if(dummy_offset[i]!=dummy_offset[0]) {
+        plumed_merror(msg);
+      }
     }
     log.printf("  sampling a common offset with:\n");
     log.printf("    initial offset parameter %f\n",offset_);
@@ -643,27 +756,38 @@ void MetainferenceBase::Initialise(const unsigned input)
     }
   }
 
-  if(doregres_zero_)
+  if(doregres_zero_) {
     log.printf("  doing regression with zero intercept with stride: %d\n", nregres_zero_);
+  }
 
   log.printf("  number of experimental data points %u\n",narg);
   log.printf("  number of replicas %u\n",nrep_);
   log.printf("  initial data uncertainties");
-  for(unsigned i=0; i<sigma_.size(); ++i) log.printf(" %f", sigma_[i]);
+  for(unsigned i=0; i<sigma_.size(); ++i) {
+    log.printf(" %f", sigma_[i]);
+  }
   log.printf("\n");
   log.printf("  minimum data uncertainties");
-  for(unsigned i=0; i<sigma_.size(); ++i) log.printf(" %f",sigma_min_[i]);
+  for(unsigned i=0; i<sigma_.size(); ++i) {
+    log.printf(" %f",sigma_min_[i]);
+  }
   log.printf("\n");
   log.printf("  maximum data uncertainties");
-  for(unsigned i=0; i<sigma_.size(); ++i) log.printf(" %f",sigma_max_[i]);
+  for(unsigned i=0; i<sigma_.size(); ++i) {
+    log.printf(" %f",sigma_max_[i]);
+  }
   log.printf("\n");
   log.printf("  maximum MC move of data uncertainties");
-  for(unsigned i=0; i<sigma_.size(); ++i) log.printf(" %f",Dsigma_[i]);
+  for(unsigned i=0; i<sigma_.size(); ++i) {
+    log.printf(" %f",Dsigma_[i]);
+  }
   log.printf("\n");
   log.printf("  temperature of the system %f\n",kbt_);
   log.printf("  MC steps %u\n",MCsteps_);
   log.printf("  initial standard errors of the mean");
-  for(unsigned i=0; i<sigma_mean2_.size(); ++i) log.printf(" %f", std::sqrt(sigma_mean2_[i]));
+  for(unsigned i=0; i<sigma_mean2_.size(); ++i) {
+    log.printf(" %f", std::sqrt(sigma_mean2_[i]));
+  }
   log.printf("\n");
 
   //resize the number of metainference derivatives and the number of back-calculated data
@@ -671,22 +795,26 @@ void MetainferenceBase::Initialise(const unsigned input)
   calc_data_.resize(narg, 0.);
 
   log<<"  Bibliography "<<plumed.cite("Bonomi, Camilloni, Cavalli, Vendruscolo, Sci. Adv. 2, e150117 (2016)");
-  if(do_reweight_) log<<plumed.cite("Bonomi, Camilloni, Vendruscolo, Sci. Rep. 6, 31232 (2016)");
-  if(do_optsigmamean_>0) log<<plumed.cite("Loehr, Jussupow, Camilloni, J. Chem. Phys. 146, 165102 (2017)");
+  if(do_reweight_) {
+    log<<plumed.cite("Bonomi, Camilloni, Vendruscolo, Sci. Rep. 6, 31232 (2016)");
+  }
+  if(do_optsigmamean_>0) {
+    log<<plumed.cite("Loehr, Jussupow, Camilloni, J. Chem. Phys. 146, 165102 (2017)");
+  }
   log<<plumed.cite("Bonomi, Camilloni, Bioinformatics, 33, 3999 (2017)");
   log<<"\n";
 }
 
-void MetainferenceBase::Selector()
-{
+void MetainferenceBase::Selector() {
   iselect = 0;
   // set the value of selector for  REM-like stuff
-  if(selector_.length()>0) iselect = static_cast<unsigned>(plumed.passMap[selector_]);
+  if(selector_.length()>0) {
+    iselect = static_cast<unsigned>(plumed.passMap[selector_]);
+  }
 }
 
 double MetainferenceBase::getEnergySP(const std::vector<double> &mean, const std::vector<double> &sigma,
-                                      const double scale, const double offset)
-{
+                                      const double scale, const double offset) {
   const double scale2 = scale*scale;
   const double sm2    = sigma_mean2_[0];
   const double ss2    = sigma[0]*sigma[0] + scale2*sm2;
@@ -701,22 +829,24 @@ double MetainferenceBase::getEnergySP(const std::vector<double> &mean, const std
       const double a2 = 0.5*dev*dev + ss2;
       if(sm2 > 0.0) {
         ene += std::log(2.0*a2/(1.0-std::exp(-a2/sm2)));
-      }
-      else {
+      } else {
         ene += std::log(2.0*a2);
       }
     }
   }
   // add one single Jeffrey's prior and one normalisation per data point
   ene += 0.5*std::log(sss) + static_cast<double>(narg)*0.5*std::log(0.5*M_PI*M_PI/ss2);
-  if(doscale_ || doregres_zero_) ene += 0.5*std::log(sss);
-  if(dooffset_) ene += 0.5*std::log(sss);
+  if(doscale_ || doregres_zero_) {
+    ene += 0.5*std::log(sss);
+  }
+  if(dooffset_) {
+    ene += 0.5*std::log(sss);
+  }
   return kbt_ * ene;
 }
 
 double MetainferenceBase::getEnergySPE(const std::vector<double> &mean, const std::vector<double> &sigma,
-                                       const double scale, const double offset)
-{
+                                       const double scale, const double offset) {
   const double scale2 = scale*scale;
   double ene = 0.0;
   #pragma omp parallel num_threads(OpenMP::getNumThreads()) shared(ene)
@@ -730,20 +860,22 @@ double MetainferenceBase::getEnergySPE(const std::vector<double> &mean, const st
       const double a2  = 0.5*dev*dev + ss2;
       if(sm2 > 0.0) {
         ene += 0.5*std::log(sss) + 0.5*std::log(0.5*M_PI*M_PI/ss2) + std::log(2.0*a2/(1.0-std::exp(-a2/sm2)));
-      }
-      else {
+      } else {
         ene += 0.5*std::log(sss) + 0.5*std::log(0.5*M_PI*M_PI/ss2) + std::log(2.0*a2);
       }
-      if(doscale_ || doregres_zero_)  ene += 0.5*std::log(sss);
-      if(dooffset_) ene += 0.5*std::log(sss);
+      if(doscale_ || doregres_zero_) {
+        ene += 0.5*std::log(sss);
+      }
+      if(dooffset_) {
+        ene += 0.5*std::log(sss);
+      }
     }
   }
   return kbt_ * ene;
 }
 
 double MetainferenceBase::getEnergyMIGEN(const std::vector<double> &mean, const std::vector<double> &ftilde, const std::vector<double> &sigma,
-    const double scale, const double offset)
-{
+    const double scale, const double offset) {
   double ene = 0.0;
   #pragma omp parallel num_threads(OpenMP::getNumThreads()) shared(ene)
   {
@@ -752,26 +884,35 @@ double MetainferenceBase::getEnergyMIGEN(const std::vector<double> &mean, const
       const double inv_sb2  = 1./(sigma[i]*sigma[i]);
       const double inv_sm2  = 1./sigma_mean2_[i];
       double devb = 0;
-      if(gen_likelihood_==LIKE_GAUSS)     devb = scale*ftilde[i]-parameters[i]+offset;
-      else if(gen_likelihood_==LIKE_LOGN) devb = std::log(scale*ftilde[i]/parameters[i]);
+      if(gen_likelihood_==LIKE_GAUSS) {
+        devb = scale*ftilde[i]-parameters[i]+offset;
+      } else if(gen_likelihood_==LIKE_LOGN) {
+        devb = std::log(scale*ftilde[i]/parameters[i]);
+      }
       double devm = mean[i] - ftilde[i];
       // deviation + normalisation + jeffrey
       double normb = 0.;
-      if(gen_likelihood_==LIKE_GAUSS)     normb = -0.5*std::log(0.5/M_PI*inv_sb2);
-      else if(gen_likelihood_==LIKE_LOGN) normb = -0.5*std::log(0.5/M_PI*inv_sb2/(parameters[i]*parameters[i]));
+      if(gen_likelihood_==LIKE_GAUSS) {
+        normb = -0.5*std::log(0.5/M_PI*inv_sb2);
+      } else if(gen_likelihood_==LIKE_LOGN) {
+        normb = -0.5*std::log(0.5/M_PI*inv_sb2/(parameters[i]*parameters[i]));
+      }
       const double normm         = -0.5*std::log(0.5/M_PI*inv_sm2);
       const double jeffreys      = -0.5*std::log(2.*inv_sb2);
       ene += 0.5*devb*devb*inv_sb2 + 0.5*devm*devm*inv_sm2 + normb + normm + jeffreys;
-      if(doscale_ || doregres_zero_)  ene += jeffreys;
-      if(dooffset_) ene += jeffreys;
+      if(doscale_ || doregres_zero_) {
+        ene += jeffreys;
+      }
+      if(dooffset_) {
+        ene += jeffreys;
+      }
     }
   }
   return kbt_ * ene;
 }
 
 double MetainferenceBase::getEnergyGJ(const std::vector<double> &mean, const std::vector<double> &sigma,
-                                      const double scale, const double offset)
-{
+                                      const double scale, const double offset) {
   const double scale2  = scale*scale;
   const double inv_s2  = 1./(sigma[0]*sigma[0] + scale2*sigma_mean2_[0]);
   const double inv_sss = 1./(sigma[0]*sigma[0] + sigma_mean2_[0]);
@@ -789,15 +930,18 @@ double MetainferenceBase::getEnergyGJ(const std::vector<double> &mean, const std
   const double jeffreys = -0.5*std::log(2.*inv_sss);
   // add Jeffrey's prior in case one sigma for all data points + one normalisation per datapoint
   ene += jeffreys + static_cast<double>(narg)*normalisation;
-  if(doscale_ || doregres_zero_)  ene += jeffreys;
-  if(dooffset_) ene += jeffreys;
+  if(doscale_ || doregres_zero_) {
+    ene += jeffreys;
+  }
+  if(dooffset_) {
+    ene += jeffreys;
+  }
 
   return kbt_ * ene;
 }
 
 double MetainferenceBase::getEnergyGJE(const std::vector<double> &mean, const std::vector<double> &sigma,
-                                       const double scale, const double offset)
-{
+                                       const double scale, const double offset) {
   const double scale2 = scale*scale;
 
   double ene = 0.0;
@@ -812,15 +956,18 @@ double MetainferenceBase::getEnergyGJE(const std::vector<double> &mean, const st
       const double normalisation = -0.5*std::log(0.5/M_PI*inv_s2);
       const double jeffreys      = -0.5*std::log(2.*inv_sss);
       ene += 0.5*dev*dev*inv_s2 + normalisation + jeffreys;
-      if(doscale_ || doregres_zero_)  ene += jeffreys;
-      if(dooffset_) ene += jeffreys;
+      if(doscale_ || doregres_zero_) {
+        ene += jeffreys;
+      }
+      if(dooffset_) {
+        ene += jeffreys;
+      }
     }
   }
   return kbt_ * ene;
 }
 
-void MetainferenceBase::moveTilde(const std::vector<double> &mean_, double &old_energy)
-{
+void MetainferenceBase::moveTilde(const std::vector<double> &mean_, double &old_energy) {
   std::vector<double> new_ftilde(sigma_.size());
   new_ftilde = ftilde_;
 
@@ -851,8 +998,7 @@ void MetainferenceBase::moveTilde(const std::vector<double> &mean_, double &old_
   }
 }
 
-void MetainferenceBase::moveScaleOffset(const std::vector<double> &mean_, double &old_energy)
-{
+void MetainferenceBase::moveScaleOffset(const std::vector<double> &mean_, double &old_energy) {
   double new_scale = scale_;
 
   if(doscale_) {
@@ -861,8 +1007,12 @@ void MetainferenceBase::moveScaleOffset(const std::vector<double> &mean_, double
       const double ds1 = Dscale_*r1;
       new_scale += ds1;
       // check boundaries
-      if(new_scale > scale_max_) {new_scale = 2.0 * scale_max_ - new_scale;}
-      if(new_scale < scale_min_) {new_scale = 2.0 * scale_min_ - new_scale;}
+      if(new_scale > scale_max_) {
+        new_scale = 2.0 * scale_max_ - new_scale;
+      }
+      if(new_scale < scale_min_) {
+        new_scale = 2.0 * scale_min_ - new_scale;
+      }
     } else {
       const double r1 = random[1].Gaussian();
       const double ds1 = 0.5*(scale_mu_-new_scale)+Dscale_*std::exp(1)/M_PI*r1;
@@ -878,8 +1028,12 @@ void MetainferenceBase::moveScaleOffset(const std::vector<double> &mean_, double
       const double ds1 = Doffset_*r1;
       new_offset += ds1;
       // check boundaries
-      if(new_offset > offset_max_) {new_offset = 2.0 * offset_max_ - new_offset;}
-      if(new_offset < offset_min_) {new_offset = 2.0 * offset_min_ - new_offset;}
+      if(new_offset > offset_max_) {
+        new_offset = 2.0 * offset_max_ - new_offset;
+      }
+      if(new_offset < offset_min_) {
+        new_offset = 2.0 * offset_min_ - new_offset;
+      }
     } else {
       const double r1 = random[1].Gaussian();
       const double ds1 = 0.5*(offset_mu_-new_offset)+Doffset_*std::exp(1)/M_PI*r1;
@@ -913,7 +1067,9 @@ void MetainferenceBase::moveScaleOffset(const std::vector<double> &mean_, double
   if(master) {
     totenergies[0] = old_energy;
     totenergies[1] = new_energy;
-    if(nrep_>1) multi_sim_comm.Sum(totenergies);
+    if(nrep_>1) {
+      multi_sim_comm.Sum(totenergies);
+    }
   } else {
     totenergies[0] = 0;
     totenergies[1] = 0;
@@ -940,8 +1096,7 @@ void MetainferenceBase::moveScaleOffset(const std::vector<double> &mean_, double
   }
 }
 
-void MetainferenceBase::moveSigmas(const std::vector<double> &mean_, double &old_energy, const unsigned i, const std::vector<unsigned> &indices, bool &breaknow)
-{
+void MetainferenceBase::moveSigmas(const std::vector<double> &mean_, double &old_energy, const unsigned i, const std::vector<unsigned> &indices, bool &breaknow) {
   std::vector<double> new_sigma(sigma_.size());
   new_sigma = sigma_;
 
@@ -964,8 +1119,12 @@ void MetainferenceBase::moveSigmas(const std::vector<double> &mean_, double &old
       const double ds2 = Dsigma_[index]*r2;
       new_sigma[index] = sigma_[index] + ds2;
       // check boundaries
-      if(new_sigma[index] > sigma_max_[index]) {new_sigma[index] = 2.0 * sigma_max_[index] - new_sigma[index];}
-      if(new_sigma[index] < sigma_min_[index]) {new_sigma[index] = 2.0 * sigma_min_[index] - new_sigma[index];}
+      if(new_sigma[index] > sigma_max_[index]) {
+        new_sigma[index] = 2.0 * sigma_max_[index] - new_sigma[index];
+      }
+      if(new_sigma[index] < sigma_min_[index]) {
+        new_sigma[index] = 2.0 * sigma_min_[index] - new_sigma[index];
+      }
     }
   } else {
     // change all sigmas
@@ -974,8 +1133,12 @@ void MetainferenceBase::moveSigmas(const std::vector<double> &mean_, double &old
       const double ds2 = Dsigma_[j]*r2;
       new_sigma[j] = sigma_[j] + ds2;
       // check boundaries
-      if(new_sigma[j] > sigma_max_[j]) {new_sigma[j] = 2.0 * sigma_max_[j] - new_sigma[j];}
-      if(new_sigma[j] < sigma_min_[j]) {new_sigma[j] = 2.0 * sigma_min_[j] - new_sigma[j];}
+      if(new_sigma[j] > sigma_max_[j]) {
+        new_sigma[j] = 2.0 * sigma_max_[j] - new_sigma[j];
+      }
+      if(new_sigma[j] < sigma_min_[j]) {
+        new_sigma[j] = 2.0 * sigma_min_[j] - new_sigma[j];
+      }
     }
   }
 
@@ -1022,8 +1185,7 @@ void MetainferenceBase::moveSigmas(const std::vector<double> &mean_, double &old
   }
 }
 
-double MetainferenceBase::doMonteCarlo(const std::vector<double> &mean_)
-{
+double MetainferenceBase::doMonteCarlo(const std::vector<double> &mean_) {
   // calculate old energy with the updated coordinates
   double old_energy=0.;
 
@@ -1062,13 +1224,19 @@ double MetainferenceBase::doMonteCarlo(const std::vector<double> &mean_)
     for(unsigned i=0; i<MCsteps_; ++i) {
       MCtrial_++;
       // propose move for ftilde
-      if(noise_type_==GENERIC) moveTilde(mean_, old_energy);
+      if(noise_type_==GENERIC) {
+        moveTilde(mean_, old_energy);
+      }
       // propose move for scale and/or offset
-      if(doscale_||dooffset_) moveScaleOffset(mean_, old_energy);
+      if(doscale_||dooffset_) {
+        moveScaleOffset(mean_, old_energy);
+      }
       // propose move for sigma
       moveSigmas(mean_, old_energy, i, indices, breaknow);
       // exit from the loop if this is the case
-      if(breaknow) break;
+      if(breaknow) {
+        break;
+      }
     }
 
     /* save the result of the sampling */
@@ -1076,24 +1244,34 @@ double MetainferenceBase::doMonteCarlo(const std::vector<double> &mean_)
     if(noise_type_==GENERIC) {
       double accept = static_cast<double>(MCacceptFT_) / static_cast<double>(MCtrial_);
       valueAcceptFT->set(accept);
-      for(unsigned i=0; i<sigma_.size(); i++) valueFtilde[i]->set(ftilde_[i]);
+      for(unsigned i=0; i<sigma_.size(); i++) {
+        valueFtilde[i]->set(ftilde_[i]);
+      }
     }
     /* scale and offset */
-    if(doscale_ || doregres_zero_) valueScale->set(scale_);
-    if(dooffset_) valueOffset->set(offset_);
+    if(doscale_ || doregres_zero_) {
+      valueScale->set(scale_);
+    }
+    if(dooffset_) {
+      valueOffset->set(offset_);
+    }
     if(doscale_||dooffset_) {
       double accept = static_cast<double>(MCacceptScale_) / static_cast<double>(MCtrial_);
       valueAcceptScale->set(accept);
     }
     /* sigmas */
-    for(unsigned i=0; i<sigma_.size(); i++) valueSigma[i]->set(sigma_[i]);
+    for(unsigned i=0; i<sigma_.size(); i++) {
+      valueSigma[i]->set(sigma_[i]);
+    }
     double accept = static_cast<double>(MCaccept_) / static_cast<double>(MCtrial_);
     valueAccept->set(accept);
   }
 
   // here we sum the score over the replicas to get the full metainference score that we save as a bias
   if(master) {
-    if(nrep_>1) multi_sim_comm.Sum(old_energy);
+    if(nrep_>1) {
+      multi_sim_comm.Sum(old_energy);
+    }
   } else {
     old_energy=0;
   }
@@ -1110,8 +1288,7 @@ double MetainferenceBase::doMonteCarlo(const std::vector<double> &mean_)
 */
 
 void MetainferenceBase::getEnergyForceSP(const std::vector<double> &mean, const std::vector<double> &dmean_x,
-    const std::vector<double> &dmean_b)
-{
+    const std::vector<double> &dmean_b) {
   const double scale2 = scale_*scale_;
   const double sm2    = sigma_mean2_[0];
   const double ss2    = sigma_[0]*sigma_[0] + scale2*sm2;
@@ -1129,14 +1306,15 @@ void MetainferenceBase::getEnergyForceSP(const std::vector<double> &mean, const
           const double dt = 1./t;
           const double dit = 1./(1.-dt);
           f[i] = -scale_*dev*(dit/sm2 + 1./a2);
-        }
-        else {
+        } else {
           f[i] = -scale_*dev*(1./a2);
         }
       }
     }
     // collect contribution to forces and energy from other replicas
-    if(nrep_>1) multi_sim_comm.Sum(&f[0],narg);
+    if(nrep_>1) {
+      multi_sim_comm.Sum(&f[0],narg);
+    }
   }
   // intra-replica summation
   comm.Sum(&f[0],narg);
@@ -1154,8 +1332,7 @@ void MetainferenceBase::getEnergyForceSP(const std::vector<double> &mean, const
 }
 
 void MetainferenceBase::getEnergyForceSPE(const std::vector<double> &mean, const std::vector<double> &dmean_x,
-    const std::vector<double> &dmean_b)
-{
+    const std::vector<double> &dmean_b) {
   const double scale2 = scale_*scale_;
   std::vector<double> f(narg,0);
 
@@ -1173,14 +1350,15 @@ void MetainferenceBase::getEnergyForceSPE(const std::vector<double> &mean, const
           const double dt  = 1./t;
           const double dit = 1./(1.-dt);
           f[i] = -scale_*dev*(dit/sm2 + 1./a2);
-        }
-        else {
+        } else {
           f[i] = -scale_*dev*(1./a2);
         }
       }
     }
     // collect contribution to forces and energy from other replicas
-    if(nrep_>1) multi_sim_comm.Sum(&f[0],narg);
+    if(nrep_>1) {
+      multi_sim_comm.Sum(&f[0],narg);
+    }
   }
   comm.Sum(&f[0],narg);
 
@@ -1197,14 +1375,15 @@ void MetainferenceBase::getEnergyForceSPE(const std::vector<double> &mean, const
 }
 
 void MetainferenceBase::getEnergyForceGJ(const std::vector<double> &mean, const std::vector<double> &dmean_x,
-    const std::vector<double> &dmean_b)
-{
+    const std::vector<double> &dmean_b) {
   const double scale2 = scale_*scale_;
   double inv_s2=0.;
 
   if(master) {
     inv_s2 = 1./(sigma_[0]*sigma_[0] + scale2*sigma_mean2_[0]);
-    if(nrep_>1) multi_sim_comm.Sum(inv_s2);
+    if(nrep_>1) {
+      multi_sim_comm.Sum(inv_s2);
+    }
   }
   comm.Sum(inv_s2);
 
@@ -1227,14 +1406,17 @@ void MetainferenceBase::getEnergyForceGJ(const std::vector<double> &mean, const
 }
 
 void MetainferenceBase::getEnergyForceGJE(const std::vector<double> &mean, const std::vector<double> &dmean_x,
-    const std::vector<double> &dmean_b)
-{
+    const std::vector<double> &dmean_b) {
   const double scale2 = scale_*scale_;
   std::vector<double> inv_s2(sigma_.size(),0.);
 
   if(master) {
-    for(unsigned i=0; i<sigma_.size(); ++i) inv_s2[i] = 1./(sigma_[i]*sigma_[i] + scale2*sigma_mean2_[i]);
-    if(nrep_>1) multi_sim_comm.Sum(&inv_s2[0],sigma_.size());
+    for(unsigned i=0; i<sigma_.size(); ++i) {
+      inv_s2[i] = 1./(sigma_[i]*sigma_[i] + scale2*sigma_mean2_[i]);
+    }
+    if(nrep_>1) {
+      multi_sim_comm.Sum(&inv_s2[0],sigma_.size());
+    }
   }
   comm.Sum(&inv_s2[0],sigma_.size());
 
@@ -1256,8 +1438,7 @@ void MetainferenceBase::getEnergyForceGJE(const std::vector<double> &mean, const
   }
 }
 
-void MetainferenceBase::getEnergyForceMIGEN(const std::vector<double> &mean, const std::vector<double> &dmean_x, const std::vector<double> &dmean_b)
-{
+void MetainferenceBase::getEnergyForceMIGEN(const std::vector<double> &mean, const std::vector<double> &dmean_x, const std::vector<double> &dmean_b) {
   std::vector<double> inv_s2(sigma_.size(),0.);
   std::vector<double> dev(sigma_.size(),0.);
   std::vector<double> dev2(sigma_.size(),0.);
@@ -1293,15 +1474,16 @@ void MetainferenceBase::getEnergyForceMIGEN(const std::vector<double> &mean, con
   }
 }
 
-void MetainferenceBase::get_weights(double &weight, double &norm, double &neff)
-{
+void MetainferenceBase::get_weights(double &weight, double &norm, double &neff) {
   const double dnrep = static_cast<double>(nrep_);
   // calculate the weights either from BIAS
   if(do_reweight_) {
     std::vector<double> bias(nrep_,0);
     if(master) {
       bias[replica_] = getArgument(0);
-      if(nrep_>1) multi_sim_comm.Sum(&bias[0], nrep_);
+      if(nrep_>1) {
+        multi_sim_comm.Sum(&bias[0], nrep_);
+      }
     }
     comm.Sum(&bias[0], nrep_);
 
@@ -1313,12 +1495,16 @@ void MetainferenceBase::get_weights(double &weight, double &norm, double &neff)
       }
     } else {
       firstTimeW[iselect] = false;
-      for(unsigned i=0; i<nrep_; ++i) average_weights_[iselect][i] = bias[i];
+      for(unsigned i=0; i<nrep_; ++i) {
+        average_weights_[iselect][i] = bias[i];
+      }
     }
 
     // set average back into bias and set norm to one
     const double maxbias = *(std::max_element(average_weights_[iselect].begin(), average_weights_[iselect].end()));
-    for(unsigned i=0; i<nrep_; ++i) bias[i] = std::exp((average_weights_[iselect][i]-maxbias)/kbt_);
+    for(unsigned i=0; i<nrep_; ++i) {
+      bias[i] = std::exp((average_weights_[iselect][i]-maxbias)/kbt_);
+    }
     // set local weight, norm and weight variance
     weight = bias[replica_];
     double w2=0.;
@@ -1337,31 +1523,43 @@ void MetainferenceBase::get_weights(double &weight, double &norm, double &neff)
   getPntrToComponent("neff")->set(neff);
 }
 
-void MetainferenceBase::get_sigma_mean(const double weight, const double norm, const double neff, const std::vector<double> &mean)
-{
+void MetainferenceBase::get_sigma_mean(const double weight, const double norm, const double neff, const std::vector<double> &mean) {
   const double dnrep    = static_cast<double>(nrep_);
   std::vector<double> sigma_mean2_tmp(sigma_mean2_.size());
 
   if(do_optsigmamean_>0) {
     // remove first entry of the history std::vector
     if(sigma_mean2_last_[iselect][0].size()==optsigmamean_stride_&&optsigmamean_stride_>0)
-      for(unsigned i=0; i<narg; ++i) sigma_mean2_last_[iselect][i].erase(sigma_mean2_last_[iselect][i].begin());
+      for(unsigned i=0; i<narg; ++i) {
+        sigma_mean2_last_[iselect][i].erase(sigma_mean2_last_[iselect][i].begin());
+      }
     /* this is the current estimate of sigma mean for each argument
        there is one of this per argument in any case  because it is
        the maximum among these to be used in case of GAUSS/OUTLIER */
     std::vector<double> sigma_mean2_now(narg,0);
     if(master) {
-      for(unsigned i=0; i<narg; ++i) sigma_mean2_now[i] = weight*(calc_data_[i]-mean[i])*(calc_data_[i]-mean[i]);
-      if(nrep_>1) multi_sim_comm.Sum(&sigma_mean2_now[0], narg);
+      for(unsigned i=0; i<narg; ++i) {
+        sigma_mean2_now[i] = weight*(calc_data_[i]-mean[i])*(calc_data_[i]-mean[i]);
+      }
+      if(nrep_>1) {
+        multi_sim_comm.Sum(&sigma_mean2_now[0], narg);
+      }
     }
     comm.Sum(&sigma_mean2_now[0], narg);
-    for(unsigned i=0; i<narg; ++i) sigma_mean2_now[i] *= 1.0/(neff-1.)/norm;
+    for(unsigned i=0; i<narg; ++i) {
+      sigma_mean2_now[i] *= 1.0/(neff-1.)/norm;
+    }
 
     // add sigma_mean2 to history
     if(optsigmamean_stride_>0) {
-      for(unsigned i=0; i<narg; ++i) sigma_mean2_last_[iselect][i].push_back(sigma_mean2_now[i]);
+      for(unsigned i=0; i<narg; ++i) {
+        sigma_mean2_last_[iselect][i].push_back(sigma_mean2_now[i]);
+      }
     } else {
-      for(unsigned i=0; i<narg; ++i) if(sigma_mean2_now[i] > sigma_mean2_last_[iselect][i][0]) sigma_mean2_last_[iselect][i][0] = sigma_mean2_now[i];
+      for(unsigned i=0; i<narg; ++i)
+        if(sigma_mean2_now[i] > sigma_mean2_last_[iselect][i][0]) {
+          sigma_mean2_last_[iselect][i][0] = sigma_mean2_now[i];
+        }
     }
 
     if(noise_type_==MGAUSS||noise_type_==MOUTLIERS||noise_type_==GENERIC) {
@@ -1372,13 +1570,17 @@ void MetainferenceBase::get_sigma_mean(const double weight, const double norm, c
         valueSigmaMean[i]->set(std::sqrt(sigma_mean2_tmp[i]));
         if(noise_type_==GENERIC) {
           sigma_min_[i] = std::sqrt(sigma_mean2_tmp[i]);
-          if(sigma_[i] < sigma_min_[i]) sigma_[i] = sigma_min_[i];
+          if(sigma_[i] < sigma_min_[i]) {
+            sigma_[i] = sigma_min_[i];
+          }
         }
       }
     } else if(noise_type_==GAUSS||noise_type_==OUTLIERS) {
       // find maximum for each data point
       std::vector <double> max_values;
-      for(unsigned i=0; i<narg; ++i) max_values.push_back(*max_element(sigma_mean2_last_[iselect][i].begin(), sigma_mean2_last_[iselect][i].end()));
+      for(unsigned i=0; i<narg; ++i) {
+        max_values.push_back(*max_element(sigma_mean2_last_[iselect][i].begin(), sigma_mean2_last_[iselect][i].end()));
+      }
       // find maximum across data points
       const double max_now = *max_element(max_values.begin(), max_values.end());
       // set new value
@@ -1389,14 +1591,18 @@ void MetainferenceBase::get_sigma_mean(const double weight, const double norm, c
     // start sigma max optimization
     if(do_optsigmamean_>1&&!sigmamax_opt_done_) {
       for(unsigned i=0; i<sigma_max_.size(); i++) {
-        if(sigma_max_est_[i]<sigma_mean2_tmp[i]&&optimized_step_>optsigmamean_stride_) sigma_max_est_[i]=sigma_mean2_tmp[i];
+        if(sigma_max_est_[i]<sigma_mean2_tmp[i]&&optimized_step_>optsigmamean_stride_) {
+          sigma_max_est_[i]=sigma_mean2_tmp[i];
+        }
         // ready to set once and for all the value of sigma_max
         if(optimized_step_==N_optimized_step_) {
           sigmamax_opt_done_=true;
           for(unsigned i=0; i<sigma_max_.size(); i++) {
             sigma_max_[i]=std::sqrt(sigma_max_est_[i]*dnrep);
             Dsigma_[i] = 0.05*(sigma_max_[i] - sigma_min_[i]);
-            if(sigma_[i]>sigma_max_[i]) sigma_[i]=sigma_max_[i];
+            if(sigma_[i]>sigma_max_[i]) {
+              sigma_[i]=sigma_max_[i];
+            }
           }
         }
       }
@@ -1418,22 +1624,29 @@ void MetainferenceBase::get_sigma_mean(const double weight, const double norm, c
   sigma_mean2_ = sigma_mean2_tmp;
 }
 
-void MetainferenceBase::replica_averaging(const double weight, const double norm, std::vector<double> &mean, std::vector<double> &dmean_b)
-{
+void MetainferenceBase::replica_averaging(const double weight, const double norm, std::vector<double> &mean, std::vector<double> &dmean_b) {
   if(master) {
-    for(unsigned i=0; i<narg; ++i) mean[i] = weight/norm*calc_data_[i];
-    if(nrep_>1) multi_sim_comm.Sum(&mean[0], narg);
+    for(unsigned i=0; i<narg; ++i) {
+      mean[i] = weight/norm*calc_data_[i];
+    }
+    if(nrep_>1) {
+      multi_sim_comm.Sum(&mean[0], narg);
+    }
   }
   comm.Sum(&mean[0], narg);
   // set the derivative of the mean with respect to the bias
-  for(unsigned i=0; i<narg; ++i) dmean_b[i] = weight/norm/kbt_*(calc_data_[i]-mean[i])*decay_w_;
+  for(unsigned i=0; i<narg; ++i) {
+    dmean_b[i] = weight/norm/kbt_*(calc_data_[i]-mean[i])*decay_w_;
+  }
 
   // this is only for generic metainference
-  if(firstTime) {ftilde_ = mean; firstTime = false;}
+  if(firstTime) {
+    ftilde_ = mean;
+    firstTime = false;
+  }
 }
 
-void MetainferenceBase::do_regression_zero(const std::vector<double> &mean)
-{
+void MetainferenceBase::do_regression_zero(const std::vector<double> &mean) {
 // parameters[i] = scale_ * mean[i]: find scale_ with linear regression
   double num = 0.0;
   double den = 0.0;
@@ -1448,8 +1661,7 @@ void MetainferenceBase::do_regression_zero(const std::vector<double> &mean)
   }
 }
 
-double MetainferenceBase::getScore()
-{
+double MetainferenceBase::getScore() {
   /* Metainference */
   /* 1) collect weights */
   double weight = 0.;
@@ -1470,7 +1682,9 @@ double MetainferenceBase::getScore()
   get_sigma_mean(weight, norm, neff, mean);
 
   // in case of regression with zero intercept, calculate scale
-  if(doregres_zero_ && getStep()%nregres_zero_==0) do_regression_zero(mean);
+  if(doregres_zero_ && getStep()%nregres_zero_==0) {
+    do_regression_zero(mean);
+  }
 
   /* 4) run monte carlo */
   double ene = doMonteCarlo(mean);
@@ -1497,9 +1711,10 @@ double MetainferenceBase::getScore()
   return ene;
 }
 
-void MetainferenceBase::writeStatus()
-{
-  if(!doscore_) return;
+void MetainferenceBase::writeStatus() {
+  if(!doscore_) {
+    return;
+  }
   sfile_.rewind();
   sfile_.printField("time",getTimeStep()*getStep());
   //nsel
diff --git a/src/isdb/MetainferenceBase.h b/src/isdb/MetainferenceBase.h
index 6767d0b425..5615eefa59 100644
--- a/src/isdb/MetainferenceBase.h
+++ b/src/isdb/MetainferenceBase.h
@@ -44,8 +44,7 @@ information as to how to go about implementing a new Metainference action.
 class MetainferenceBase :
   public ActionAtomistic,
   public ActionWithArguments,
-  public ActionWithValue
-{
+  public ActionWithValue {
 private:
   std::vector<double> forces;
   std::vector<double> forcesToApply;
@@ -209,62 +208,57 @@ class MetainferenceBase :
 };
 
 inline
-void MetainferenceBase::setNarg(const unsigned input)
-{
+void MetainferenceBase::setNarg(const unsigned input) {
   narg = input;
 }
 
 inline
-bool MetainferenceBase::getDoScore()
-{
+bool MetainferenceBase::getDoScore() {
   return doscore_;
 }
 
 inline
-unsigned MetainferenceBase::getWstride()
-{
+unsigned MetainferenceBase::getWstride() {
   return write_stride_;
 }
 
 inline
-unsigned MetainferenceBase::getNarg()
-{
+unsigned MetainferenceBase::getNarg() {
   return narg;
 }
 
 inline
-void MetainferenceBase::setMetaDer(const unsigned index, const double der)
-{
+void MetainferenceBase::setMetaDer(const unsigned index, const double der) {
   metader_[index] = der;
 }
 
 inline
-double MetainferenceBase::getMetaDer(const unsigned index)
-{
+double MetainferenceBase::getMetaDer(const unsigned index) {
   return metader_[index];
 }
 
 inline
-double MetainferenceBase::getCalcData(const unsigned index)
-{
+double MetainferenceBase::getCalcData(const unsigned index) {
   return calc_data_[index];
 }
 
 inline
-void MetainferenceBase::setCalcData(const unsigned index, const double datum)
-{
+void MetainferenceBase::setCalcData(const unsigned index, const double datum) {
   calc_data_[index] = datum;
 }
 
 inline
-void MetainferenceBase::setCalcData(const std::vector<double>& data)
-{
-  for(unsigned i=0; i<data.size(); i++) calc_data_[i] = data[i];
+void MetainferenceBase::setCalcData(const std::vector<double>& data) {
+  for(unsigned i=0; i<data.size(); i++) {
+    calc_data_[i] = data[i];
+  }
 }
 
 inline
 void MetainferenceBase::setParameters(const std::vector<double>& input) {
-  for(unsigned i=0; i<input.size(); i++) parameters.push_back(input[i]);
+  for(unsigned i=0; i<input.size(); i++) {
+    parameters.push_back(input[i]);
+  }
 }
 
 inline
@@ -289,8 +283,11 @@ void MetainferenceBase::setDerivatives() {
   }
 
   // Resize all derivative arrays
-  forces.resize( nder ); forcesToApply.resize( nder );
-  for(int i=0; i<getNumberOfComponents(); ++i) getPntrToComponent(i)->resizeDerivatives(nder);
+  forces.resize( nder );
+  forcesToApply.resize( nder );
+  for(int i=0; i<getNumberOfComponents(); ++i) {
+    getPntrToComponent(i)->resizeDerivatives(nder);
+  }
 }
 
 inline
@@ -326,27 +323,39 @@ void MetainferenceBase::calculateNumericalDerivatives( ActionWithValue* a=NULL )
   if( getNumberOfAtoms()>0 ) {
     Matrix<double> save_derivatives( getNumberOfComponents(), getNumberOfArguments() );
     for(int j=0; j<getNumberOfComponents(); ++j) {
-      for(unsigned i=0; i<getNumberOfArguments(); ++i) if(getPntrToComponent(j)->hasDerivatives()) save_derivatives(j,i)=getPntrToComponent(j)->getDerivative(i);
+      for(unsigned i=0; i<getNumberOfArguments(); ++i)
+        if(getPntrToComponent(j)->hasDerivatives()) {
+          save_derivatives(j,i)=getPntrToComponent(j)->getDerivative(i);
+        }
     }
     calculateAtomicNumericalDerivatives( a, getNumberOfArguments() );
     for(int j=0; j<getNumberOfComponents(); ++j) {
-      for(unsigned i=0; i<getNumberOfArguments(); ++i) if(getPntrToComponent(j)->hasDerivatives()) getPntrToComponent(j)->addDerivative( i, save_derivatives(j,i) );
+      for(unsigned i=0; i<getNumberOfArguments(); ++i)
+        if(getPntrToComponent(j)->hasDerivatives()) {
+          getPntrToComponent(j)->addDerivative( i, save_derivatives(j,i) );
+        }
     }
   }
 }
 
 inline
 void MetainferenceBase::apply() {
-  bool wasforced=false; forcesToApply.assign(forcesToApply.size(),0.0);
+  bool wasforced=false;
+  forcesToApply.assign(forcesToApply.size(),0.0);
   for(int i=0; i<getNumberOfComponents(); ++i) {
     if( getPntrToComponent(i)->applyForce( forces ) ) {
       wasforced=true;
-      for(unsigned i=0; i<forces.size(); ++i) forcesToApply[i]+=forces[i];
+      for(unsigned i=0; i<forces.size(); ++i) {
+        forcesToApply[i]+=forces[i];
+      }
     }
   }
   if( wasforced ) {
-    unsigned ind=0; addForcesOnArguments( 0, forcesToApply, ind, getLabel() );
-    if( getNumberOfAtoms()>0 ) setForcesOnAtoms( forcesToApply, ind );
+    unsigned ind=0;
+    addForcesOnArguments( 0, forcesToApply, ind, getLabel() );
+    if( getNumberOfAtoms()>0 ) {
+      setForcesOnAtoms( forcesToApply, ind );
+    }
   }
 }
 
diff --git a/src/isdb/NOE.cpp b/src/isdb/NOE.cpp
index 6db09fb287..98b80979f3 100644
--- a/src/isdb/NOE.cpp
+++ b/src/isdb/NOE.cpp
@@ -65,8 +65,7 @@ PRINT ARG=noes.* FILE=colvar
 //+ENDPLUMEDOC
 
 class NOE :
-  public MetainferenceBase
-{
+  public MetainferenceBase {
 private:
   bool             pbc;
   std::vector<unsigned> nga;
@@ -99,8 +98,7 @@ void NOE::registerKeywords( Keywords& keys ) {
 
 NOE::NOE(const ActionOptions&ao):
   PLUMED_METAINF_INIT(ao),
-  pbc(true)
-{
+  pbc(true) {
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
@@ -109,21 +107,33 @@ NOE::NOE(const ActionOptions&ao):
   std::vector<AtomNumber> t, ga_lista, gb_lista;
   for(int i=1;; ++i ) {
     parseAtomList("GROUPA", i, t );
-    if( t.empty() ) break;
-    for(unsigned j=0; j<t.size(); j++) ga_lista.push_back(t[j]);
+    if( t.empty() ) {
+      break;
+    }
+    for(unsigned j=0; j<t.size(); j++) {
+      ga_lista.push_back(t[j]);
+    }
     nga.push_back(t.size());
     t.resize(0);
   }
   std::vector<unsigned> ngb;
   for(int i=1;; ++i ) {
     parseAtomList("GROUPB", i, t );
-    if( t.empty() ) break;
-    for(unsigned j=0; j<t.size(); j++) gb_lista.push_back(t[j]);
+    if( t.empty() ) {
+      break;
+    }
+    for(unsigned j=0; j<t.size(); j++) {
+      gb_lista.push_back(t[j]);
+    }
     ngb.push_back(t.size());
-    if(ngb[i-1]!=nga[i-1]) error("The same number of atoms is expected for the same GROUPA-GROUPB couple");
+    if(ngb[i-1]!=nga[i-1]) {
+      error("The same number of atoms is expected for the same GROUPA-GROUPB couple");
+    }
     t.resize(0);
   }
-  if(nga.size()!=ngb.size()) error("There should be the same number of GROUPA and GROUPB keywords");
+  if(nga.size()!=ngb.size()) {
+    error("There should be the same number of GROUPA and GROUPB keywords");
+  }
   // Create neighbour lists
   nl=Tools::make_unique<NeighborList>(ga_lista,gb_lista,false,true,pbc,getPbc(),comm);
 
@@ -132,13 +142,21 @@ NOE::NOE(const ActionOptions&ao):
   noedist.resize( nga.size() );
   unsigned ntarget=0;
   for(unsigned i=0; i<nga.size(); ++i) {
-    if( !parseNumbered( "NOEDIST", i+1, noedist[i] ) ) break;
+    if( !parseNumbered( "NOEDIST", i+1, noedist[i] ) ) {
+      break;
+    }
     ntarget++;
   }
   bool addexp=false;
-  if(ntarget!=nga.size() && ntarget!=0) error("found wrong number of NOEDIST values");
-  if(ntarget==nga.size()) addexp=true;
-  if(getDoScore()&&!addexp) error("with DOSCORE you need to set the NOEDIST values");
+  if(ntarget!=nga.size() && ntarget!=0) {
+    error("found wrong number of NOEDIST values");
+  }
+  if(ntarget==nga.size()) {
+    addexp=true;
+  }
+  if(getDoScore()&&!addexp) {
+    error("with DOSCORE you need to set the NOEDIST values");
+  }
 
   // Output details of all contacts
   unsigned index=0;
@@ -151,20 +169,25 @@ NOE::NOE(const ActionOptions&ao):
   }
   tot_size = index;
 
-  if(pbc)      log.printf("  using periodic boundary conditions\n");
-  else         log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
 
   log << " Bibliography" << plumed.cite("Bonomi, Camilloni, Bioinformatics, 33, 3999 (2017)") << "\n";
 
   if(!getDoScore()) {
     for(unsigned i=0; i<nga.size(); i++) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponentWithDerivatives("noe-"+num);
       componentIsNotPeriodic("noe-"+num);
     }
     if(addexp) {
       for(unsigned i=0; i<nga.size(); i++) {
-        std::string num; Tools::convert(i,num);
+        std::string num;
+        Tools::convert(i,num);
         addComponent("exp-"+num);
         componentIsNotPeriodic("exp-"+num);
         Value* comp=getPntrToComponent("exp-"+num);
@@ -173,12 +196,14 @@ NOE::NOE(const ActionOptions&ao):
     }
   } else {
     for(unsigned i=0; i<nga.size(); i++) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponent("noe-"+num);
       componentIsNotPeriodic("noe-"+num);
     }
     for(unsigned i=0; i<nga.size(); i++) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponent("exp-"+num);
       componentIsNotPeriodic("exp-"+num);
       Value* comp=getPntrToComponent("exp-"+num);
@@ -195,8 +220,7 @@ NOE::NOE(const ActionOptions&ao):
   checkRead();
 }
 
-void NOE::calculate()
-{
+void NOE::calculate() {
   const unsigned ngasz=nga.size();
   std::vector<Vector> deriv(tot_size, Vector{0,0,0});
 
@@ -205,8 +229,11 @@ void NOE::calculate()
     Tensor dervir;
     double noe=0;
     unsigned index=0;
-    for(unsigned k=0; k<i; k++) index+=nga[k];
-    std::string num; Tools::convert(i,num);
+    for(unsigned k=0; k<i; k++) {
+      index+=nga[k];
+    }
+    std::string num;
+    Tools::convert(i,num);
     Value* val=getPntrToComponent("noe-"+num);
     // cycle over equivalent atoms
     for(unsigned j=0; j<nga[i]; j++) {
@@ -214,8 +241,11 @@ void NOE::calculate()
       const unsigned i1=nl->getClosePair(index+j).second;
 
       Vector distance;
-      if(pbc) distance=pbcDistance(getPosition(i0),getPosition(i1));
-      else    distance=delta(getPosition(i0),getPosition(i1));
+      if(pbc) {
+        distance=pbcDistance(getPosition(i0),getPosition(i1));
+      } else {
+        distance=delta(getPosition(i0),getPosition(i1));
+      }
 
       const double ir2=1./distance.modulo2();
       const double ir6=ir2*ir2*ir2;
@@ -232,7 +262,9 @@ void NOE::calculate()
     val->set(noe);
     if(!getDoScore()) {
       setBoxDerivatives(val, dervir);
-    } else setCalcData(i, noe);
+    } else {
+      setCalcData(i, noe);
+    }
   }
 
   if(getDoScore()) {
@@ -245,15 +277,20 @@ void NOE::calculate()
     Value* val=getPntrToComponent("score");
     for(unsigned i=0; i<ngasz; i++) {
       unsigned index=0;
-      for(unsigned k=0; k<i; k++) index+=nga[k];
+      for(unsigned k=0; k<i; k++) {
+        index+=nga[k];
+      }
       // cycle over equivalent atoms
       for(unsigned j=0; j<nga[i]; j++) {
         const unsigned i0=nl->getClosePair(index+j).first;
         const unsigned i1=nl->getClosePair(index+j).second;
 
         Vector distance;
-        if(pbc) distance=pbcDistance(getPosition(i0),getPosition(i1));
-        else    distance=delta(getPosition(i0),getPosition(i1));
+        if(pbc) {
+          distance=pbcDistance(getPosition(i0),getPosition(i1));
+        } else {
+          distance=delta(getPosition(i0),getPosition(i1));
+        }
 
         dervir += Tensor(distance,deriv[index+j]*getMetaDer(i));
         setAtomsDerivatives(val, i0,  deriv[index+j]*getMetaDer(i));
@@ -266,7 +303,9 @@ void NOE::calculate()
 
 void NOE::update() {
   // write status file
-  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) writeStatus();
+  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) {
+    writeStatus();
+  }
 }
 
 }
diff --git a/src/isdb/PRE.cpp b/src/isdb/PRE.cpp
index 98a9a0e292..8b7903fc7a 100644
--- a/src/isdb/PRE.cpp
+++ b/src/isdb/PRE.cpp
@@ -68,8 +68,7 @@ PRINT ARG=HN_pre.* FILE=PRE.dat STRIDE=1
 //+ENDPLUMEDOC
 
 class PRE :
-  public MetainferenceBase
-{
+  public MetainferenceBase {
 private:
   bool             pbc;
   bool             doratio;
@@ -110,8 +109,7 @@ void PRE::registerKeywords( Keywords& keys ) {
 PRE::PRE(const ActionOptions&ao):
   PLUMED_METAINF_INIT(ao),
   pbc(true),
-  doratio(true)
-{
+  doratio(true) {
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
@@ -122,14 +120,21 @@ PRE::PRE(const ActionOptions&ao):
 
   std::vector<AtomNumber> atom;
   parseAtomList("SPINLABEL",atom);
-  if(atom.size()!=1) error("Number of specified atom should be 1");
+  if(atom.size()!=1) {
+    error("Number of specified atom should be 1");
+  }
 
   // Read in the atoms
   std::vector<AtomNumber> t, ga_lista, gb_lista;
   for(int i=1;; ++i ) {
     parseAtomList("GROUPA", i, t );
-    if( t.empty() ) break;
-    for(unsigned j=0; j<t.size(); j++) {ga_lista.push_back(t[j]); gb_lista.push_back(atom[0]);}
+    if( t.empty() ) {
+      break;
+    }
+    for(unsigned j=0; j<t.size(); j++) {
+      ga_lista.push_back(t[j]);
+      gb_lista.push_back(atom[0]);
+    }
     nga.push_back(t.size());
     t.resize(0);
   }
@@ -139,27 +144,39 @@ PRE::PRE(const ActionOptions&ao):
   if(doratio) {
     unsigned ntarget=0;
     for(unsigned i=0; i<nga.size(); ++i) {
-      if( !parseNumbered( "RTWO", i+1, rtwo[i] ) ) break;
+      if( !parseNumbered( "RTWO", i+1, rtwo[i] ) ) {
+        break;
+      }
       ntarget++;
     }
     if( ntarget==0 ) {
       parse("RTWO",rtwo[0]);
-      for(unsigned i=1; i<nga.size(); ++i) rtwo[i]=rtwo[0];
-    } else if( ntarget!=nga.size() ) error("found wrong number of RTWO values");
+      for(unsigned i=1; i<nga.size(); ++i) {
+        rtwo[i]=rtwo[0];
+      }
+    } else if( ntarget!=nga.size() ) {
+      error("found wrong number of RTWO values");
+    }
   }
 
   double tauc=0.;
   parse("TAUC",tauc);
-  if(tauc==0.) error("TAUC must be set");
+  if(tauc==0.) {
+    error("TAUC must be set");
+  }
 
   double omega=0.;
   parse("OMEGA",omega);
-  if(omega==0.) error("OMEGA must be set");
+  if(omega==0.) {
+    error("OMEGA must be set");
+  }
 
   inept=0.;
   if(doratio) {
     parse("INEPT",inept);
-    if(inept==0.) error("INEPT must be set");
+    if(inept==0.) {
+      error("INEPT must be set");
+    }
     inept *= 0.001; // ms2s
   }
 
@@ -176,13 +193,21 @@ PRE::PRE(const ActionOptions&ao):
   exppre.resize( nga.size() );
   unsigned ntarget=0;
   for(unsigned i=0; i<nga.size(); ++i) {
-    if( !parseNumbered( "PREINT", i+1, exppre[i] ) ) break;
+    if( !parseNumbered( "PREINT", i+1, exppre[i] ) ) {
+      break;
+    }
     ntarget++;
   }
   bool addexp=false;
-  if(ntarget!=nga.size() && ntarget!=0) error("found wrong number of PREINT values");
-  if(ntarget==nga.size()) addexp=true;
-  if(getDoScore()&&!addexp) error("with DOSCORE you need to set the PREINT values");
+  if(ntarget!=nga.size() && ntarget!=0) {
+    error("found wrong number of PREINT values");
+  }
+  if(ntarget==nga.size()) {
+    addexp=true;
+  }
+  if(getDoScore()&&!addexp) {
+    error("with DOSCORE you need to set the PREINT values");
+  }
 
   // Create neighbour lists
   nl=Tools::make_unique<NeighborList>(gb_lista,ga_lista,false,true,pbc,getPbc(),comm);
@@ -201,20 +226,25 @@ PRE::PRE(const ActionOptions&ao):
   }
   tot_size = index;
 
-  if(pbc)      log.printf("  using periodic boundary conditions\n");
-  else         log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
 
   log << " Bibliography" << plumed.cite("Bonomi, Camilloni, Bioinformatics, 33, 3999 (2017)") << "\n";
 
   if(!getDoScore()) {
     for(unsigned i=0; i<nga.size(); i++) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponentWithDerivatives("pre-"+num);
       componentIsNotPeriodic("pre-"+num);
     }
     if(addexp) {
       for(unsigned i=0; i<nga.size(); i++) {
-        std::string num; Tools::convert(i,num);
+        std::string num;
+        Tools::convert(i,num);
         addComponent("exp-"+num);
         componentIsNotPeriodic("exp-"+num);
         Value* comp=getPntrToComponent("exp-"+num);
@@ -223,12 +253,14 @@ PRE::PRE(const ActionOptions&ao):
     }
   } else {
     for(unsigned i=0; i<nga.size(); i++) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponent("pre-"+num);
       componentIsNotPeriodic("pre-"+num);
     }
     for(unsigned i=0; i<nga.size(); i++) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponent("exp-"+num);
       componentIsNotPeriodic("exp-"+num);
       Value* comp=getPntrToComponent("exp-"+num);
@@ -245,8 +277,7 @@ PRE::PRE(const ActionOptions&ao):
   checkRead();
 }
 
-void PRE::calculate()
-{
+void PRE::calculate() {
   std::vector<Vector> deriv(tot_size, Vector{0,0,0});
   std::vector<double> fact(nga.size(), 0.);
 
@@ -256,9 +287,12 @@ void PRE::calculate()
     Tensor dervir;
     double pre=0;
     unsigned index=0;
-    for(unsigned k=0; k<i; k++) index+=nga[k];
+    for(unsigned k=0; k<i; k++) {
+      index+=nga[k];
+    }
     const double c_aver=constant/static_cast<double>(nga[i]);
-    std::string num; Tools::convert(i,num);
+    std::string num;
+    Tools::convert(i,num);
     Value* val=getPntrToComponent("pre-"+num);
     // cycle over equivalent atoms
     for(unsigned j=0; j<nga[i]; j++) {
@@ -267,8 +301,11 @@ void PRE::calculate()
       const unsigned i1=nl->getClosePair(index+j).second;
 
       Vector distance;
-      if(pbc) distance=pbcDistance(getPosition(i0),getPosition(i1));
-      else    distance=delta(getPosition(i0),getPosition(i1));
+      if(pbc) {
+        distance=pbcDistance(getPosition(i0),getPosition(i1));
+      } else {
+        distance=delta(getPosition(i0),getPosition(i1));
+      }
 
       const double r2=distance.modulo2();
       const double r6=r2*r2*r2;
@@ -278,7 +315,9 @@ void PRE::calculate()
 
       pre += tmpir6;
       deriv[index+j] = -tmpir8*distance;
-      if(!getDoScore()) dervir   +=  Tensor(distance,deriv[index+j]);
+      if(!getDoScore()) {
+        dervir   +=  Tensor(distance,deriv[index+j]);
+      }
     }
     double tmpratio;
     if(!doratio) {
@@ -298,7 +337,9 @@ void PRE::calculate()
         setAtomsDerivatives(val, i0,  fact[i]*deriv[index+j]);
         setAtomsDerivatives(val, i1, -fact[i]*deriv[index+j]);
       }
-    } else setCalcData(i, ratio);
+    } else {
+      setCalcData(i, ratio);
+    }
   }
 
   if(getDoScore()) {
@@ -311,15 +352,20 @@ void PRE::calculate()
     Value* val=getPntrToComponent("score");
     for(unsigned i=0; i<nga.size(); i++) {
       unsigned index=0;
-      for(unsigned k=0; k<i; k++) index+=nga[k];
+      for(unsigned k=0; k<i; k++) {
+        index+=nga[k];
+      }
       // cycle over equivalent atoms
       for(unsigned j=0; j<nga[i]; j++) {
         const unsigned i0=nl->getClosePair(index+j).first;
         const unsigned i1=nl->getClosePair(index+j).second;
 
         Vector distance;
-        if(pbc) distance=pbcDistance(getPosition(i0),getPosition(i1));
-        else    distance=delta(getPosition(i0),getPosition(i1));
+        if(pbc) {
+          distance=pbcDistance(getPosition(i0),getPosition(i1));
+        } else {
+          distance=delta(getPosition(i0),getPosition(i1));
+        }
 
         dervir += Tensor(distance,fact[i]*deriv[index+j]*getMetaDer(i));
         setAtomsDerivatives(val, i0,  fact[i]*deriv[index+j]*getMetaDer(i));
@@ -332,7 +378,9 @@ void PRE::calculate()
 
 void PRE::update() {
   // write status file
-  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) writeStatus();
+  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) {
+    writeStatus();
+  }
 }
 
 }
diff --git a/src/isdb/RDC.cpp b/src/isdb/RDC.cpp
index 6c51df81e6..95eb8a3d46 100644
--- a/src/isdb/RDC.cpp
+++ b/src/isdb/RDC.cpp
@@ -172,8 +172,7 @@ PRINT ARG=st.corr,pcse.bias FILE=colvar
 //+ENDPLUMEDOC
 
 class RDC :
-  public MetainferenceBase
-{
+  public MetainferenceBase {
 private:
   double         Const;
   double         mu_s;
@@ -246,8 +245,7 @@ RDC::RDC(const ActionOptions&ao):
   Const(1.),
   mu_s(1.),
   scale(1.),
-  pbc(true)
-{
+  pbc(true) {
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
@@ -255,16 +253,22 @@ RDC::RDC(const ActionOptions&ao):
   const double RDCConst = 0.3356806;
   const double PCSConst = 1.0;
 
-  if( getName().find("RDC")!=std::string::npos) { Const *= RDCConst; }
-  else if( getName().find("PCS")!=std::string::npos) { Const *= PCSConst; }
+  if( getName().find("RDC")!=std::string::npos) {
+    Const *= RDCConst;
+  } else if( getName().find("PCS")!=std::string::npos) {
+    Const *= PCSConst;
+  }
 
   // Read in the atoms
   std::vector<AtomNumber> t, atoms;
   for(int i=1;; ++i ) {
     parseAtomList("ATOMS", i, t );
-    if( t.empty() ) break;
+    if( t.empty() ) {
+      break;
+    }
     if( t.size()!=2 ) {
-      std::string ss; Tools::convert(i,ss);
+      std::string ss;
+      Tools::convert(i,ss);
       error("ATOMS" + ss + " keyword has the wrong number of atoms");
     }
     atoms.push_back(t[0]);
@@ -276,38 +280,58 @@ RDC::RDC(const ActionOptions&ao):
 
   // Read in GYROMAGNETIC constants
   parse("GYROM", mu_s);
-  if(mu_s==0.) error("GYROM cannot be 0");
+  if(mu_s==0.) {
+    error("GYROM cannot be 0");
+  }
 
   // Read in SCALING factors
   parse("SCALE", scale);
-  if(scale==0.) error("SCALE cannot be 0");
+  if(scale==0.) {
+    error("SCALE cannot be 0");
+  }
 
   svd=false;
   parseFlag("SVD",svd);
 #ifndef __PLUMED_HAS_GSL
-  if(svd) error("You CANNOT use SVD without GSL. Recompile PLUMED with GSL!\n");
+  if(svd) {
+    error("You CANNOT use SVD without GSL. Recompile PLUMED with GSL!\n");
+  }
 #endif
-  if(svd&&getDoScore()) error("It is not possible to use SVD and METAINFERENCE together");
+  if(svd&&getDoScore()) {
+    error("It is not possible to use SVD and METAINFERENCE together");
+  }
 
   // Optionally add an experimental value
   coupl.resize( ndata );
   unsigned ntarget=0;
   for(unsigned i=0; i<ndata; ++i) {
-    if( !parseNumbered( "COUPLING", i+1, coupl[i] ) ) break;
+    if( !parseNumbered( "COUPLING", i+1, coupl[i] ) ) {
+      break;
+    }
     ntarget++;
   }
   bool addexp=false;
-  if(ntarget!=ndata && ntarget!=0) error("found wrong number of COUPLING values");
-  if(ntarget==ndata) addexp=true;
-  if(getDoScore()&&!addexp) error("with DOSCORE you need to set the COUPLING values");
-  if(svd&&!addexp) error("with SVD you need to set the COUPLING values");
+  if(ntarget!=ndata && ntarget!=0) {
+    error("found wrong number of COUPLING values");
+  }
+  if(ntarget==ndata) {
+    addexp=true;
+  }
+  if(getDoScore()&&!addexp) {
+    error("with DOSCORE you need to set the COUPLING values");
+  }
+  if(svd&&!addexp) {
+    error("with SVD you need to set the COUPLING values");
+  }
 
 
   // Output details of all contacts
   log.printf("  Gyromagnetic moment is %f. Scaling factor is %f.",mu_s,scale);
   for(unsigned i=0; i<ndata; ++i) {
     log.printf("  The %uth Bond Dipolar Coupling is calculated from atoms : %d %d.", i+1, atoms[2*i].serial(), atoms[2*i+1].serial());
-    if(addexp) log.printf(" Experimental coupling is %f.", coupl[i]);
+    if(addexp) {
+      log.printf(" Experimental coupling is %f.", coupl[i]);
+    }
     log.printf("\n");
   }
 
@@ -319,13 +343,15 @@ RDC::RDC(const ActionOptions&ao):
 
   if(!getDoScore()&&!svd) {
     for(unsigned i=0; i<ndata; i++) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponentWithDerivatives("rdc-"+num);
       componentIsNotPeriodic("rdc-"+num);
     }
     if(addexp) {
       for(unsigned i=0; i<ndata; i++) {
-        std::string num; Tools::convert(i,num);
+        std::string num;
+        Tools::convert(i,num);
         addComponent("exp-"+num);
         componentIsNotPeriodic("exp-"+num);
         Value* comp=getPntrToComponent("exp-"+num);
@@ -334,12 +360,14 @@ RDC::RDC(const ActionOptions&ao):
     }
   } else {
     for(unsigned i=0; i<ndata; i++) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponentWithDerivatives("rdc-"+num);
       componentIsNotPeriodic("rdc-"+num);
     }
     for(unsigned i=0; i<ndata; i++) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponent("exp-"+num);
       componentIsNotPeriodic("exp-"+num);
       Value* comp=getPntrToComponent("exp-"+num);
@@ -348,12 +376,18 @@ RDC::RDC(const ActionOptions&ao):
   }
 
   if(svd) {
-    addComponent("Sxx"); componentIsNotPeriodic("Sxx");
-    addComponent("Syy"); componentIsNotPeriodic("Syy");
-    addComponent("Szz"); componentIsNotPeriodic("Szz");
-    addComponent("Sxy"); componentIsNotPeriodic("Sxy");
-    addComponent("Sxz"); componentIsNotPeriodic("Sxz");
-    addComponent("Syz"); componentIsNotPeriodic("Syz");
+    addComponent("Sxx");
+    componentIsNotPeriodic("Sxx");
+    addComponent("Syy");
+    componentIsNotPeriodic("Syy");
+    addComponent("Szz");
+    componentIsNotPeriodic("Szz");
+    addComponent("Sxy");
+    componentIsNotPeriodic("Sxy");
+    addComponent("Sxz");
+    componentIsNotPeriodic("Sxz");
+    addComponent("Syz");
+    componentIsNotPeriodic("Syz");
   }
 
   requestAtoms(atoms, false);
@@ -365,8 +399,7 @@ RDC::RDC(const ActionOptions&ao):
   checkRead();
 }
 
-void RDC::do_svd()
-{
+void RDC::do_svd() {
 #ifdef __PLUMED_HAS_GSL
   gsl_vector_unique_ptr rdc_vec(gsl_vector_alloc(coupl.size())),
                         S(gsl_vector_alloc(5)),
@@ -385,8 +418,11 @@ void RDC::do_svd()
   std::vector<double> dmax(coupl.size());
   for(unsigned r=0; r<getNumberOfAtoms(); r+=2) {
     Vector  distance;
-    if(pbc) distance = pbcDistance(getPosition(r),getPosition(r+1));
-    else    distance = delta(getPosition(r),getPosition(r+1));
+    if(pbc) {
+      distance = pbcDistance(getPosition(r),getPosition(r+1));
+    } else {
+      distance = delta(getPosition(r),getPosition(r+1));
+    }
     double d    = distance.modulo();
     double d2   = d*d;
     double d3   = d2*d;
@@ -437,8 +473,7 @@ void RDC::do_svd()
 #endif
 }
 
-void RDC::calculate()
-{
+void RDC::calculate() {
   if(svd) {
     do_svd();
     return;
@@ -452,12 +487,14 @@ void RDC::calculate()
   #pragma omp parallel num_threads(OpenMP::getNumThreads())
   {
     #pragma omp for
-    for(unsigned r=0; r<N; r+=2)
-    {
+    for(unsigned r=0; r<N; r+=2) {
       const unsigned index=r/2;
       Vector  distance;
-      if(pbc) distance   = pbcDistance(getPosition(r),getPosition(r+1));
-      else    distance   = delta(getPosition(r),getPosition(r+1));
+      if(pbc) {
+        distance   = pbcDistance(getPosition(r),getPosition(r+1));
+      } else {
+        distance   = delta(getPosition(r),getPosition(r+1));
+      }
       const double d2    = distance.modulo2();
       const double ind   = 1./std::sqrt(d2);
       const double ind2  = 1./d2;
@@ -477,14 +514,17 @@ void RDC::calculate()
       dRDC[index][1] *= prod_xy;
       dRDC[index][2] *= prod_z;
 
-      std::string num; Tools::convert(index,num);
+      std::string num;
+      Tools::convert(index,num);
       Value* val=getPntrToComponent("rdc-"+num);
       val->set(rdc);
       if(!getDoScore()) {
         setBoxDerivatives(val, Tensor(distance,dRDC[index]));
         setAtomsDerivatives(val, r,  dRDC[index]);
         setAtomsDerivatives(val, r+1, -dRDC[index]);
-      } else setCalcData(index, rdc);
+      } else {
+        setCalcData(index, rdc);
+      }
     }
   }
 
@@ -496,12 +536,14 @@ void RDC::calculate()
 
     /* calculate final derivatives */
     Value* val=getPntrToComponent("score");
-    for(unsigned r=0; r<N; r+=2)
-    {
+    for(unsigned r=0; r<N; r+=2) {
       const unsigned index=r/2;
       Vector  distance;
-      if(pbc) distance   = pbcDistance(getPosition(r),getPosition(r+1));
-      else    distance   = delta(getPosition(r),getPosition(r+1));
+      if(pbc) {
+        distance   = pbcDistance(getPosition(r),getPosition(r+1));
+      } else {
+        distance   = delta(getPosition(r),getPosition(r+1));
+      }
       const Vector der = dRDC[index]*getMetaDer(index);
       dervir += Tensor(distance, der);
       setAtomsDerivatives(val, r,  der);
@@ -513,7 +555,9 @@ void RDC::calculate()
 
 void RDC::update() {
   // write status file
-  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) writeStatus();
+  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) {
+    writeStatus();
+  }
 }
 
 }
diff --git a/src/isdb/Rescale.cpp b/src/isdb/Rescale.cpp
index 705b8a762e..f29ffd9232 100644
--- a/src/isdb/Rescale.cpp
+++ b/src/isdb/Rescale.cpp
@@ -114,8 +114,7 @@ PRINT FILE=COLVAR ARG=* STRIDE=100
 */
 //+ENDPLUMEDOC
 
-class Rescale : public bias::Bias
-{
+class Rescale : public bias::Bias {
   // gamma parameter
   std::vector<double> gamma_;
   double         w0_;
@@ -185,8 +184,7 @@ void Rescale::registerKeywords(Keywords& keys) {
 Rescale::Rescale(const ActionOptions&ao):
   PLUMED_BIAS_INIT(ao),
   nores_(0), Biaspace_(1), first_bias_(true),
-  MCsteps_(1), MCstride_(1), MCfirst_(-1), MCaccgamma_(0)
-{
+  MCsteps_(1), MCstride_(1), MCfirst_(-1), MCaccgamma_(0) {
   // set up replica stuff
   if(comm.Get_rank()==0) {
     nrep_    = multi_sim_comm.Get_size();
@@ -211,19 +209,23 @@ Rescale::Rescale(const ActionOptions&ao):
 
   // number of bias
   parse("NOT_RESCALED", nores_);
-  if(nores_>0 && nores_!=nbin) error("The number of non scaled arguments must be equal to either 0 or the number of bins");
+  if(nores_>0 && nores_!=nbin) {
+    error("The number of non scaled arguments must be equal to either 0 or the number of bins");
+  }
 
   // maximum value of rescale
   std::vector<double> max_rescale;
   parseVector("MAX_RESCALE", max_rescale);
   // check dimension of max_rescale
-  if(max_rescale.size()!=(getNumberOfArguments()-nores_))
+  if(max_rescale.size()!=(getNumberOfArguments()-nores_)) {
     error("Size of MAX_RESCALE array must be equal to the number of arguments that will to be scaled");
+  }
 
   // calculate exponents
   double igamma_max = static_cast<double>(nbin);
-  for(unsigned i=0; i<max_rescale.size(); ++i)
+  for(unsigned i=0; i<max_rescale.size(); ++i) {
     expo_.push_back(std::log(max_rescale[i])/std::log(igamma_max));
+  }
 
   // allocate gamma grid and set bias to zero
   for(unsigned i=0; i<nbin; ++i) {
@@ -239,16 +241,20 @@ Rescale::Rescale(const ActionOptions&ao):
 
   // create vectors of shared arguments
   // by default they are all shared
-  for(unsigned i=0; i<getNumberOfArguments(); ++i) shared_.push_back(1);
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    shared_.push_back(1);
+  }
   // share across replicas or not
   std::vector<unsigned> not_shared;
   parseVector("NOT_SHARED", not_shared);
   // and change the non-shared
   for(unsigned i=0; i<not_shared.size(); ++i) {
-    if((not_shared[i]-1)>=(getNumberOfArguments()-nores_) && nrep_>1)
+    if((not_shared[i]-1)>=(getNumberOfArguments()-nores_) && nrep_>1) {
       error("NOT_RESCALED args must always be shared when using multiple replicas");
-    if((not_shared[i]-1)>=getNumberOfArguments())
+    }
+    if((not_shared[i]-1)>=getNumberOfArguments()) {
       error("NOT_SHARED args should be lower than total number of arguments");
+    }
     shared_[not_shared[i]-1] = 0;
   }
 
@@ -271,7 +277,9 @@ Rescale::Rescale(const ActionOptions&ao):
   log.printf("  name of the SELECTOR use for this action %s\n",selector_.c_str());
   log.printf("  number of bins in grid %u\n",nbin);
   log.printf("  number of arguments that will not be scaled %u\n",nores_);
-  if(nrep_>1) log<<"  number of arguments that will not be summed across replicas "<<not_shared.size()<<"\n";
+  if(nrep_>1) {
+    log<<"  number of arguments that will not be summed across replicas "<<not_shared.size()<<"\n";
+  }
   log.printf("  biasfactor %f\n",biasf_);
   log.printf("  initial hills height %f\n",w0_);
   log.printf("  stride to write bias to file %u\n",Biasstride_);
@@ -285,24 +293,27 @@ Rescale::Rescale(const ActionOptions&ao):
 
 
   // add components
-  addComponent("igamma");   componentIsNotPeriodic("igamma");
-  addComponent("accgamma"); componentIsNotPeriodic("accgamma");
-  addComponent("wtbias");   componentIsNotPeriodic("wtbias");
+  addComponent("igamma");
+  componentIsNotPeriodic("igamma");
+  addComponent("accgamma");
+  componentIsNotPeriodic("accgamma");
+  addComponent("wtbias");
+  componentIsNotPeriodic("wtbias");
 
   // initialize random seed
   srand (time(NULL));
 
   // read bias if restarting
-  if(getRestart()) read_bias();
+  if(getRestart()) {
+    read_bias();
+  }
 }
 
-Rescale::~Rescale()
-{
+Rescale::~Rescale() {
   Biasfile_.close();
 }
 
-void Rescale::read_bias()
-{
+void Rescale::read_bias() {
 // open file
   auto ifile=Tools::make_unique<IFile>();
   ifile->link(*this);
@@ -329,24 +340,29 @@ void Rescale::read_bias()
   }
 }
 
-unsigned Rescale::proposeMove(unsigned x, unsigned xmin, unsigned xmax)
-{
+unsigned Rescale::proposeMove(unsigned x, unsigned xmin, unsigned xmax) {
   int xmin_i = static_cast<int>(xmin);
   int xmax_i = static_cast<int>(xmax);
   int dx;
   int r = rand() % 2;
-  if( r % 2 == 0 ) dx = +1;
-  else             dx = -1;
+  if( r % 2 == 0 ) {
+    dx = +1;
+  } else {
+    dx = -1;
+  }
 // new index, integer
   int x_new = static_cast<int>(x) + dx;
 // check boundaries
-  if(x_new >= xmax_i) x_new = xmax_i-1;
-  if(x_new <  xmin_i) x_new = xmin_i;
+  if(x_new >= xmax_i) {
+    x_new = xmax_i-1;
+  }
+  if(x_new <  xmin_i) {
+    x_new = xmin_i;
+  }
   return static_cast<unsigned>(x_new);
 }
 
-bool Rescale::doAccept(double oldE, double newE)
-{
+bool Rescale::doAccept(double oldE, double newE) {
   bool accept = false;
   // calculate delta energy
   double delta = ( newE - oldE ) / kbt_;
@@ -356,14 +372,15 @@ bool Rescale::doAccept(double oldE, double newE)
   } else {
     // otherwise extract random number
     double s = static_cast<double>(rand()) / RAND_MAX;
-    if( s < std::exp(-delta) ) { accept = true; }
+    if( s < std::exp(-delta) ) {
+      accept = true;
+    }
   }
   return accept;
 }
 
 void Rescale::doMonteCarlo(unsigned igamma, double oldE,
-                           const std::vector<double> & args, const std::vector<double> & bargs)
-{
+                           const std::vector<double> & args, const std::vector<double> & bargs) {
   double oldB, newB;
 
 // cycle on MC steps
@@ -395,7 +412,9 @@ void Rescale::doMonteCarlo(unsigned igamma, double oldE,
   }
 // send values of gamma to all replicas
   if(comm.Get_rank()==0) {
-    if(multi_sim_comm.Get_rank()!=0) igamma = 0;
+    if(multi_sim_comm.Get_rank()!=0) {
+      igamma = 0;
+    }
     multi_sim_comm.Sum(&igamma, 1);
   } else {
     igamma = 0;
@@ -407,8 +426,7 @@ void Rescale::doMonteCarlo(unsigned igamma, double oldE,
   plumed.passMap[selector_]=static_cast<double>(igamma);
 }
 
-void Rescale::print_bias(long long int step)
-{
+void Rescale::print_bias(long long int step) {
 // if first time open the file
   if(first_bias_) {
     first_bias_ = false;
@@ -433,8 +451,7 @@ void Rescale::print_bias(long long int step)
   Biasfile_.printField();
 }
 
-void Rescale::calculate()
-{
+void Rescale::calculate() {
   // get the current value of the selector
   unsigned igamma = static_cast<unsigned>(plumed.passMap[selector_]);
 
@@ -445,9 +462,14 @@ void Rescale::calculate()
     double arg = getArgument(i);
     // sum shared arguments across replicas
     if(shared_[i]==1) {
-      if(comm.Get_rank()==0) multi_sim_comm.Sum(arg);
-      else                   arg = 0.0;
-      if(comm.Get_size()>1)  comm.Sum(arg);
+      if(comm.Get_rank()==0) {
+        multi_sim_comm.Sum(arg);
+      } else {
+        arg = 0.0;
+      }
+      if(comm.Get_size()>1) {
+        comm.Sum(arg);
+      }
     }
     // put into all_args
     all_args[i] = arg;
@@ -455,12 +477,20 @@ void Rescale::calculate()
 
   // now separate terms that should be rescaled
   std::vector<double> args;
-  if(getNumberOfArguments()-nores_>0) args.resize(getNumberOfArguments()-nores_);
-  for(unsigned i=0; i<args.size(); ++i)  args[i]  = all_args[i];
+  if(getNumberOfArguments()-nores_>0) {
+    args.resize(getNumberOfArguments()-nores_);
+  }
+  for(unsigned i=0; i<args.size(); ++i) {
+    args[i]  = all_args[i];
+  }
   // and terms that should not
   std::vector<double> bargs;
-  if(nores_>0) bargs.resize(nores_);
-  for(unsigned i=0; i<bargs.size(); ++i) bargs[i] = all_args[i+args.size()];
+  if(nores_>0) {
+    bargs.resize(nores_);
+  }
+  for(unsigned i=0; i<bargs.size(); ++i) {
+    bargs[i] = all_args[i+args.size()];
+  }
 
   // calculate energy and forces, only on rescaled terms
   double ene = 0.0;
@@ -473,7 +503,9 @@ void Rescale::calculate()
   }
 
   // set to zero on the others
-  for(unsigned i=0; i<bargs.size(); ++i) setOutputForce(i+args.size(), 0.0);
+  for(unsigned i=0; i<bargs.size(); ++i) {
+    setOutputForce(i+args.size(), 0.0);
+  }
 
   // set value of the bias
   setBias(ene);
@@ -483,14 +515,18 @@ void Rescale::calculate()
   getPntrToComponent("igamma")->set(igamma);
   // get time step
   long long int step = getStep();
-  if(MCfirst_==-1) MCfirst_=step;
+  if(MCfirst_==-1) {
+    MCfirst_=step;
+  }
   // calculate gamma acceptance
   double MCtrials = std::floor(static_cast<double>(step-MCfirst_) / static_cast<double>(MCstride_))+1.0;
   double accgamma = static_cast<double>(MCaccgamma_) / static_cast<double>(MCsteps_) / MCtrials;
   getPntrToComponent("accgamma")->set(accgamma);
 
   // do MC at the right time step
-  if(step%MCstride_==0&&!getExchangeStep()) doMonteCarlo(igamma, ene, args, bargs);
+  if(step%MCstride_==0&&!getExchangeStep()) {
+    doMonteCarlo(igamma, ene, args, bargs);
+  }
 
   // add well-tempered like bias
   if(step%Biaspace_==0) {
@@ -502,7 +538,9 @@ void Rescale::calculate()
   }
 
   // print bias
-  if(step%Biasstride_==0) print_bias(step);
+  if(step%Biasstride_==0) {
+    print_bias(step);
+  }
 
 }
 
diff --git a/src/isdb/SAXS.cpp b/src/isdb/SAXS.cpp
index ef207bb92e..b9c972180f 100644
--- a/src/isdb/SAXS.cpp
+++ b/src/isdb/SAXS.cpp
@@ -241,8 +241,7 @@ PRINT ARG=(SANS\.q-.*),(SANS\.exp-.*) FILE=sansdata STRIDE=1
 //+ENDPLUMEDOC
 
 class SAXS :
-  public MetainferenceBase
-{
+  public MetainferenceBase {
 private:
   enum { H, C, N, O, P, S, NTT };
   enum { ALA_BB, ARG_BB, ARG_SC1, ARG_SC2, ASN_BB, ASN_SC1, ASP_BB, ASP_SC1, CYS_BB, CYS_SC1,
@@ -481,10 +480,12 @@ SAXS::SAXS(const ActionOptions&ao):
   gpu(false),
   onebead(false),
   isFirstStep(true),
-  deviceid(-1)
-{
-  if( getName().find("SAXS")!=std::string::npos) { saxs=true; }
-  else if( getName().find("SANS")!=std::string::npos) { saxs=false; }
+  deviceid(-1) {
+  if( getName().find("SAXS")!=std::string::npos) {
+    saxs=true;
+  } else if( getName().find("SANS")!=std::string::npos) {
+    saxs=false;
+  }
 
   std::vector<AtomNumber> atoms;
   parseAtomList("ATOMS",atoms);
@@ -495,21 +496,30 @@ SAXS::SAXS(const ActionOptions&ao):
   bool nopbc=!pbc;
   parseFlag("NOPBC",nopbc);
   pbc=!nopbc;
-  if(pbc)      log.printf("  using periodic boundary conditions\n");
-  else         log.printf("  without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("  using periodic boundary conditions\n");
+  } else {
+    log.printf("  without periodic boundary conditions\n");
+  }
 
   parseFlag("GPU",gpu);
 #ifndef  __PLUMED_HAS_ARRAYFIRE
-  if(gpu) error("To use the GPU mode PLUMED must be compiled with ARRAYFIRE");
+  if(gpu) {
+    error("To use the GPU mode PLUMED must be compiled with ARRAYFIRE");
+  }
 #endif
 
   parse("DEVICEID",deviceid);
 #ifdef  __PLUMED_HAS_ARRAYFIRE
   if(gpu&&comm.Get_rank()==0) {
     // if not set try to check the one set by the API
-    if(deviceid==-1) deviceid=plumed.getGpuDeviceId();
+    if(deviceid==-1) {
+      deviceid=plumed.getGpuDeviceId();
+    }
     // if still not set use 0
-    if(deviceid==-1) deviceid=0;
+    if(deviceid==-1) {
+      deviceid=0;
+    }
 #ifdef  __PLUMED_HAS_ARRAYFIRE_CUDA
     af::setDevice(afcu::getNativeId(deviceid));
 #elif   __PLUMED_HAS_ARRAYFIRE_OCL
@@ -523,24 +533,42 @@ SAXS::SAXS(const ActionOptions&ao):
 
   bool atomistic=false;
   parseFlag("ATOMISTIC",atomistic);
-  if(atomistic) log.printf("  using ATOMISTIC form factors\n");
+  if(atomistic) {
+    log.printf("  using ATOMISTIC form factors\n");
+  }
   bool martini=false;
   parseFlag("MARTINI",martini);
-  if(martini) log.printf("  using MARTINI form factors\n");
+  if(martini) {
+    log.printf("  using MARTINI form factors\n");
+  }
   onebead=false;
   parseFlag("ONEBEAD",onebead);
-  if(onebead) log.printf("  using ONEBEAD form factors\n");
+  if(onebead) {
+    log.printf("  using ONEBEAD form factors\n");
+  }
   bool fromfile=false;
   std::string parametersfile;
   parse("PARAMETERSFILE",parametersfile);
-  if (parametersfile.length() != 0) fromfile=true;
-  if(fromfile) log.printf("  will read form factors from file\n");
+  if (parametersfile.length() != 0) {
+    fromfile=true;
+  }
+  if(fromfile) {
+    log.printf("  will read form factors from file\n");
+  }
   parseFlag("ABSOLUTE",absolute);
 
-  if(martini&&atomistic) error("You cannot use MARTINI and ATOMISTIC at the same time");
-  if(martini&&onebead) error("You cannot use MARTINI and ONEBEAD at the same time");
-  if(onebead&&atomistic) error("You cannot use ONEBEAD and ATOMISTIC at the same time");
-  if((martini)&&(!saxs)) error("MARTINI cannot be used with SANS");
+  if(martini&&atomistic) {
+    error("You cannot use MARTINI and ATOMISTIC at the same time");
+  }
+  if(martini&&onebead) {
+    error("You cannot use MARTINI and ONEBEAD at the same time");
+  }
+  if(onebead&&atomistic) {
+    error("You cannot use ONEBEAD and ATOMISTIC at the same time");
+  }
+  if((martini)&&(!saxs)) {
+    error("MARTINI cannot be used with SANS");
+  }
   if((fromfile)&&((atomistic)||(martini)||(onebead))) {
     error("You cannot read parameters from file and use ATOMISTIC/MARTINI/ONEBEAD");
   }
@@ -548,17 +576,27 @@ SAXS::SAXS(const ActionOptions&ao):
   unsigned ntarget=0;
   for(unsigned i=0;; ++i) {
     double t_list;
-    if( !parseNumbered( "QVALUE", i+1, t_list) ) break;
-    if(t_list<=0.) error("QVALUE cannot be less or equal to zero!\n");
-    if(onebead&&t_list>0.3) error("ONEBEAD mapping QVALUE must be smaller or equal to 0.3");
+    if( !parseNumbered( "QVALUE", i+1, t_list) ) {
+      break;
+    }
+    if(t_list<=0.) {
+      error("QVALUE cannot be less or equal to zero!\n");
+    }
+    if(onebead&&t_list>0.3) {
+      error("ONEBEAD mapping QVALUE must be smaller or equal to 0.3");
+    }
     q_list.push_back(t_list);
     ntarget++;
   }
   const unsigned numq = ntarget;
 
   for(unsigned i=0; i<numq; ++i) {
-    if(q_list[i]==0.) error("it is not possible to set q=0\n");
-    if(i>0&&q_list[i]<q_list[i-1]) error("QVALUE must be in ascending order");
+    if(q_list[i]==0.) {
+      error("it is not possible to set q=0\n");
+    }
+    if(i>0&&q_list[i]<q_list[i-1]) {
+      error("QVALUE must be in ascending order");
+    }
     log.printf("  my q: %lf \n",q_list[i]);
   }
 
@@ -569,36 +607,58 @@ SAXS::SAXS(const ActionOptions&ao):
   double scale_expint=1.;
   parse("SCALE_EXPINT",scale_expint);
 
-  if((!atomistic&&absolute)||(absolute&&scale_expint!=1)) error("ABSOLUTE can be used only combined with ATOMISTIC without SCALE_EXPINT");
-  if(atomistic) log.printf("  Scale for intensities: %s\n", absolute ? "absolute" : "normalised");
+  if((!atomistic&&absolute)||(absolute&&scale_expint!=1)) {
+    error("ABSOLUTE can be used only combined with ATOMISTIC without SCALE_EXPINT");
+  }
+  if(atomistic) {
+    log.printf("  Scale for intensities: %s\n", absolute ? "absolute" : "normalised");
+  }
 
   double correction = 0.00;
   parse("SOLVATION_CORRECTION", correction);
   rho_corr=rho-correction;
-  if(onebead) log.printf("  Solvation density contribution: %lf\n", correction);
-  if((atomistic||martini||fromfile)&&(rho_corr!=rho)) log.printf("  Solvation density contribution is taken into account in ONEBEAD only\n");
+  if(onebead) {
+    log.printf("  Solvation density contribution: %lf\n", correction);
+  }
+  if((atomistic||martini||fromfile)&&(rho_corr!=rho)) {
+    log.printf("  Solvation density contribution is taken into account in ONEBEAD only\n");
+  }
 
   solv_stride = 10;
   parse("SOLVATION_STRIDE", solv_stride);
-  if(solv_stride < 1.) error("SOLVATION_STRIDE must be greater than 0");
-  if(onebead&&(rho_corr!=rho)) log.printf("  SASA calculation stride: %u\n", solv_stride);
+  if(solv_stride < 1.) {
+    error("SOLVATION_STRIDE must be greater than 0");
+  }
+  if(onebead&&(rho_corr!=rho)) {
+    log.printf("  SASA calculation stride: %u\n", solv_stride);
+  }
 
   sasa_cutoff = 1.0;
   parse("SASA_CUTOFF", sasa_cutoff);
-  if(sasa_cutoff <= 0.) error("SASA_CUTOFF must be greater than 0");
+  if(sasa_cutoff <= 0.) {
+    error("SASA_CUTOFF must be greater than 0");
+  }
 
   deuter_conc = 0.;
   parse("DEUTER_CONC", deuter_conc);
-  if ((deuter_conc)&&(fromfile)) error("DEUTER_CONC cannot be used with PARAMETERSFILE");
-  if(deuter_conc < 0. || deuter_conc > 1.) error("DEUTER_CONC must be in 0-1 range");
-  if ((atomistic||onebead)&&(!saxs)) log.printf("  Solvent deuterium fraction: %lf/1.000000\n", deuter_conc);
+  if ((deuter_conc)&&(fromfile)) {
+    error("DEUTER_CONC cannot be used with PARAMETERSFILE");
+  }
+  if(deuter_conc < 0. || deuter_conc > 1.) {
+    error("DEUTER_CONC must be in 0-1 range");
+  }
+  if ((atomistic||onebead)&&(!saxs)) {
+    log.printf("  Solvent deuterium fraction: %lf/1.000000\n", deuter_conc);
+  }
 
   PDB pdb;
   if(onebead) {
     std::string template_name;
     parse("TEMPLATE",template_name);
     log.printf("  Template for ONEBEAD mapping conversion: %s\n", template_name.c_str());
-    if( !pdb.read(template_name,usingNaturalUnits(),1.) ) plumed_merror("missing input file " + template_name);
+    if( !pdb.read(template_name,usingNaturalUnits(),1.) ) {
+      plumed_merror("missing input file " + template_name);
+    }
   }
 
   // preliminary mapping for onebead representation
@@ -642,10 +702,14 @@ SAXS::SAXS(const ActionOptions&ao):
       parameter.resize(size);
       ntarget=0;
       for(unsigned i=0; i<size; ++i) {
-        if( !parseNumberedVector( "PARAMETERS", i+1, parameter[i]) ) break;
+        if( !parseNumberedVector( "PARAMETERS", i+1, parameter[i]) ) {
+          break;
+        }
         ntarget++;
       }
-      if( ntarget!=size ) error("found wrong number of parameter std::vectors");
+      if( ntarget!=size ) {
+        error("found wrong number of parameter std::vectors");
+      }
       FF_tmp.resize(numq,std::vector<long double>(size));
       for(unsigned i=0; i<size; ++i) {
         atoi[i]=i;
@@ -655,18 +719,23 @@ SAXS::SAXS(const ActionOptions&ao):
           }
         }
       }
-      for(unsigned i=0; i<size; ++i) Iq0+=parameter[i][0];
+      for(unsigned i=0; i<size; ++i) {
+        Iq0+=parameter[i][0];
+      }
       Iq0 *= Iq0;
-    }
-    else { // SANS
+    } else { // SANS
       std::vector<long double> parameter;
       parameter.resize(size);
       ntarget=0;
       for(unsigned i=0; i<size; ++i) {
-        if( !parseNumbered( "PARAMETERS", i+1, parameter[i]) ) break;
+        if( !parseNumbered( "PARAMETERS", i+1, parameter[i]) ) {
+          break;
+        }
         ntarget++;
       }
-      if( ntarget!=size ) error("found wrong number of parameter std::vectors");
+      if( ntarget!=size ) {
+        error("found wrong number of parameter std::vectors");
+      }
       FF_tmp.resize(numq,std::vector<long double>(size));
       for(unsigned i=0; i<size; ++i) {
         atoi[i]=i;
@@ -674,7 +743,9 @@ SAXS::SAXS(const ActionOptions&ao):
           FF_tmp[k][i]+= parameter[i];
         }
       }
-      for(unsigned i=0; i<size; ++i) Iq0+=parameter[i];
+      for(unsigned i=0; i<size; ++i) {
+        Iq0+=parameter[i];
+      }
       Iq0 *= Iq0;
     }
   } else if (fromfile) { // read PARAMETERS from user-provided file
@@ -692,14 +763,23 @@ SAXS::SAXS(const ActionOptions&ao):
       while(ifile.getline(line)) {
         Tools::ltrim(line);
         Tools::trimComments(line);
-        if (line.empty()) continue;
-        if (ntarget > size) error("PARAMETERSFILE has more PARAMETERS than there are scattering centers");
-        std::string num; Tools::convert(ntarget+1,num);
+        if (line.empty()) {
+          continue;
+        }
+        if (ntarget > size) {
+          error("PARAMETERSFILE has more PARAMETERS than there are scattering centers");
+        }
+        std::string num;
+        Tools::convert(ntarget+1,num);
         std::vector<std::string> lineread{line};
-        if (!Tools::parseVector(lineread, "PARAMETERS"+num, parameter[ntarget], -1)) error("Missing PARAMETERS or PARAMETERS not sorted");
+        if (!Tools::parseVector(lineread, "PARAMETERS"+num, parameter[ntarget], -1)) {
+          error("Missing PARAMETERS or PARAMETERS not sorted");
+        }
         ntarget++;
       }
-      if( ntarget!=size ) error("found wrong number of PARAMETERS in file");
+      if( ntarget!=size ) {
+        error("found wrong number of PARAMETERS in file");
+      }
 
       for(unsigned i=0; i<size; ++i) {
         atoi[i]=i;
@@ -709,7 +789,9 @@ SAXS::SAXS(const ActionOptions&ao):
           }
         }
       }
-      for(unsigned i=0; i<size; ++i) Iq0+=parameter[i][0];
+      for(unsigned i=0; i<size; ++i) {
+        Iq0+=parameter[i][0];
+      }
       Iq0 *= Iq0;
     } else { // SANS
       FF_tmp.resize(numq,std::vector<long double>(size));
@@ -722,20 +804,31 @@ SAXS::SAXS(const ActionOptions&ao):
       while(ifile.getline(line)) {
         Tools::ltrim(line);
         Tools::trimComments(line);
-        if (line.empty()) continue;
-        if (ntarget > size) error("PARAMETERSFILE has more PARAMETERS than there are scattering centers");
-        std::string num; Tools::convert(ntarget+1,num);
+        if (line.empty()) {
+          continue;
+        }
+        if (ntarget > size) {
+          error("PARAMETERSFILE has more PARAMETERS than there are scattering centers");
+        }
+        std::string num;
+        Tools::convert(ntarget+1,num);
         std::vector<std::string> lineread{line};
         long double scatlen;
         atoi[ntarget]=ntarget;
-        if (!Tools::parse(lineread, "PARAMETERS"+num, scatlen, -1)) error("Missing PARAMETERS or PARAMETERS not sorted");
+        if (!Tools::parse(lineread, "PARAMETERS"+num, scatlen, -1)) {
+          error("Missing PARAMETERS or PARAMETERS not sorted");
+        }
         for(unsigned k=0; k<numq; ++k) {
           FF_tmp[k][ntarget] = scatlen;
         }
         ntarget++;
       }
-      if( ntarget!=size ) error("found wrong number of PARAMETERS in file");
-      for(unsigned i=0; i<size; ++i) Iq0+=FF_tmp[0][i];
+      if( ntarget!=size ) {
+        error("found wrong number of PARAMETERS in file");
+      }
+      for(unsigned i=0; i<size; ++i) {
+        Iq0+=FF_tmp[0][i];
+      }
       Iq0 *= Iq0;
     }
   } else if(onebead) {
@@ -816,12 +909,17 @@ SAXS::SAXS(const ActionOptions&ao):
         }
       }
     }
-    for(unsigned i=0; i<size; ++i) Iq0+=parameter[atoi[i]][0];
+    for(unsigned i=0; i<size; ++i) {
+      Iq0+=parameter[atoi[i]][0];
+    }
     Iq0 *= Iq0;
   } else if(atomistic) {
     FF_tmp.resize(numq,std::vector<long double>(NTT));
-    if(saxs) Iq0=calculateAFF(atoms, FF_tmp, rho);
-    else Iq0=calculateAFFsans(atoms, FF_tmp, deuter_conc);
+    if(saxs) {
+      Iq0=calculateAFF(atoms, FF_tmp, rho);
+    } else {
+      Iq0=calculateAFFsans(atoms, FF_tmp, deuter_conc);
+    }
     Iq0 *= Iq0;
   }
 
@@ -830,31 +928,53 @@ SAXS::SAXS(const ActionOptions&ao):
   expint.resize( numq );
   ntarget=0;
   for(unsigned i=0; i<numq; ++i) {
-    if( !parseNumbered( "EXPINT", i+1, expint[i] ) ) break;
+    if( !parseNumbered( "EXPINT", i+1, expint[i] ) ) {
+      break;
+    }
     ntarget++;
   }
-  std::transform(expint.begin(), expint.begin() + ntarget, expint.begin(), [scale_expint](double x) { return x / scale_expint; });
+  std::transform(expint.begin(), expint.begin() + ntarget, expint.begin(), [scale_expint](double x) {
+    return x / scale_expint;
+  });
   bool exp=false;
-  if(ntarget!=numq && ntarget!=0) error("found wrong number of EXPINT values");
-  if(ntarget==numq) exp=true;
-  if(getDoScore()&&!exp) error("with DOSCORE you need to set the EXPINT values");
+  if(ntarget!=numq && ntarget!=0) {
+    error("found wrong number of EXPINT values");
+  }
+  if(ntarget==numq) {
+    exp=true;
+  }
+  if(getDoScore()&&!exp) {
+    error("with DOSCORE you need to set the EXPINT values");
+  }
 
   sigma_res.resize( numq );
   resolution=false;
   ntarget=0;
   for(unsigned i=0; i<numq; ++i) {
-    if( !parseNumbered( "SIGMARES", i+1, sigma_res[i] ) ) break;
+    if( !parseNumbered( "SIGMARES", i+1, sigma_res[i] ) ) {
+      break;
+    }
     ntarget++;
   }
-  if(ntarget!=numq && ntarget!=0) error("found wrong number of SIGMARES values");
-  if(ntarget==numq) resolution=true;
+  if(ntarget!=numq && ntarget!=0) {
+    error("found wrong number of SIGMARES values");
+  }
+  if(ntarget==numq) {
+    resolution=true;
+  }
 
-  if(gpu && resolution) error("Resolution function is not supported in GPUs");
+  if(gpu && resolution) {
+    error("Resolution function is not supported in GPUs");
+  }
 
   Nj = 10;
   parse("N", Nj);
-  if (Nj < 2) error("N should be larger than 1");
-  if (resolution) log.printf("  Resolution function with N: %d\n", Nj);
+  if (Nj < 2) {
+    error("N should be larger than 1");
+  }
+  if (resolution) {
+    log.printf("  Resolution function with N: %d\n", Nj);
+  }
 
   if(!gpu) {
     FF_rank.resize(numq);
@@ -878,8 +998,12 @@ SAXS::SAXS(const ActionOptions&ao):
     }
     for(unsigned k=0; k<numq; ++k) {
       if(!onebead) {
-        for(unsigned i=0; i<size; ++i) FF_value[i][k] = static_cast<double>(FF_tmp[k][atoi[i]])/(std::sqrt(Iq0));
-        for(unsigned i=0; i<size; ++i) FF_rank[k] += FF_value[i][k]*FF_value[i][k];
+        for(unsigned i=0; i<size; ++i) {
+          FF_value[i][k] = static_cast<double>(FF_tmp[k][atoi[i]])/(std::sqrt(Iq0));
+        }
+        for(unsigned i=0; i<size; ++i) {
+          FF_rank[k] += FF_value[i][k]*FF_value[i][k];
+        }
       } else {
         if(saxs) {
           for(unsigned i=0; i<n_atom_types; ++i) {
@@ -944,13 +1068,15 @@ SAXS::SAXS(const ActionOptions&ao):
 
   if(!getDoScore()) {
     for(unsigned i=0; i<numq; ++i) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponentWithDerivatives("q-"+num);
       componentIsNotPeriodic("q-"+num);
     }
     if(exp) {
       for(unsigned i=0; i<numq; ++i) {
-        std::string num; Tools::convert(i,num);
+        std::string num;
+        Tools::convert(i,num);
         addComponent("exp-"+num);
         componentIsNotPeriodic("exp-"+num);
         Value* comp=getPntrToComponent("exp-"+num);
@@ -959,12 +1085,14 @@ SAXS::SAXS(const ActionOptions&ao):
     }
   } else {
     for(unsigned i=0; i<numq; ++i) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponent("q-"+num);
       componentIsNotPeriodic("q-"+num);
     }
     for(unsigned i=0; i<numq; ++i) {
-      std::string num; Tools::convert(i,num);
+      std::string num;
+      Tools::convert(i,num);
       addComponent("exp-"+num);
       componentIsNotPeriodic("exp-"+num);
       Value* comp=getPntrToComponent("exp-"+num);
@@ -975,7 +1103,9 @@ SAXS::SAXS(const ActionOptions&ao):
   // convert units to nm^-1
   for(unsigned i=0; i<numq; ++i) {
     q_list[i]=q_list[i]*10.0;    // factor 10 to convert from A^-1 to nm^-1
-    if (resolution) sigma_res[i]=sigma_res[i]*10.0;
+    if (resolution) {
+      sigma_res[i]=sigma_res[i]*10.0;
+    }
   }
 
   // compute resolution function after converting units
@@ -1016,8 +1146,7 @@ SAXS::SAXS(const ActionOptions&ao):
 }
 
 // calculates SASA neighbor list
-void SAXS::calcNlist(std::vector<std::vector<int> > &Nlist)
-{
+void SAXS::calcNlist(std::vector<std::vector<int> > &Nlist) {
   unsigned natoms = getNumberOfAtoms();
   for(unsigned i = 0; i < natoms; ++i) {
     if (LCPOparam[i].size()>0) {
@@ -1078,24 +1207,30 @@ void SAXS::sasa_calculate(std::vector<bool> &solv_res) {
       }
     }
     #pragma omp critical
-    { // combining private_sasares into sasares
+    {
+      // combining private_sasares into sasares
       for (unsigned i = 0; i < nres; ++i) {
         sasares[i] += private_sasares[i];
       }
     }
   }
   for(unsigned i=0; i<nres; ++i) { // updating solv_res based on sasares
-    if(sasares[i]>sasa_cutoff) solv_res[i] = 1;
-    else solv_res[i] = 0;
+    if(sasares[i]>sasa_cutoff) {
+      solv_res[i] = 1;
+    } else {
+      solv_res[i] = 0;
+    }
   }
 }
 
-void SAXS::calculate_gpu(std::vector<Vector> &pos, std::vector<Vector> &deriv)
-{
+void SAXS::calculate_gpu(std::vector<Vector> &pos, std::vector<Vector> &deriv) {
 #ifdef __PLUMED_HAS_ARRAYFIRE
   unsigned size;
-  if(onebead) size = nres;
-  else size = getNumberOfAtoms();
+  if(onebead) {
+    size = nres;
+  } else {
+    size = getNumberOfAtoms();
+  }
   const unsigned numq = q_list.size();
 
   std::vector<float> sum;
@@ -1195,10 +1330,13 @@ void SAXS::calculate_gpu(std::vector<Vector> &pos, std::vector<Vector> &deriv)
   comm.Bcast(sum, 0);
 
   for(unsigned k=0; k<numq; ++k) {
-    std::string num; Tools::convert(k,num);
+    std::string num;
+    Tools::convert(k,num);
     Value* val=getPntrToComponent("q-"+num);
     val->set(sum[k]);
-    if(getDoScore()) setCalcData(k, sum[k]);
+    if(getDoScore()) {
+      setCalcData(k, sum[k]);
+    }
     for(unsigned i=0; i<size; ++i) {
       const unsigned di = k*size*3+i*3;
       deriv[k*size+i] = Vector(2.*dd[di+0],2.*dd[di+1],2.*dd[di+2]);
@@ -1207,11 +1345,13 @@ void SAXS::calculate_gpu(std::vector<Vector> &pos, std::vector<Vector> &deriv)
 #endif
 }
 
-void SAXS::calculate_cpu(std::vector<Vector> &pos, std::vector<Vector> &deriv)
-{
+void SAXS::calculate_cpu(std::vector<Vector> &pos, std::vector<Vector> &deriv) {
   unsigned size;
-  if(onebead) size = nres;
-  else size = getNumberOfAtoms();
+  if(onebead) {
+    size = nres;
+  } else {
+    size = getNumberOfAtoms();
+  }
   const unsigned numq = q_list.size();
 
   unsigned stride = comm.Get_size();
@@ -1255,8 +1395,12 @@ void SAXS::calculate_cpu(std::vector<Vector> &pos, std::vector<Vector> &deriv)
     }
     #pragma omp critical
     if(nt>1) {
-      for(unsigned i=0; i<deriv.size(); ++i) deriv[i]+=omp_deriv[i];
-      for(unsigned k=0; k<numq; ++k) sum[k]+=omp_sum[k];
+      for(unsigned i=0; i<deriv.size(); ++i) {
+        deriv[i]+=omp_deriv[i];
+      }
+      for(unsigned k=0; k<numq; ++k) {
+        sum[k]+=omp_sum[k];
+      }
     }
   }
 
@@ -1323,16 +1467,20 @@ void SAXS::calculate_cpu(std::vector<Vector> &pos, std::vector<Vector> &deriv)
 
   for (unsigned k=0; k<numq; ++k) {
     sum[k]+=FF_rank[k];
-    std::string num; Tools::convert(k,num);
+    std::string num;
+    Tools::convert(k,num);
     Value* val=getPntrToComponent("q-"+num);
     val->set(sum[k]);
-    if(getDoScore()) setCalcData(k, sum[k]);
+    if(getDoScore()) {
+      setCalcData(k, sum[k]);
+    }
   }
 }
 
-void SAXS::calculate()
-{
-  if(pbc) makeWhole();
+void SAXS::calculate() {
+  if(pbc) {
+    makeWhole();
+  }
 
   const size_t size = getNumberOfAtoms();
   const size_t numq = q_list.size();
@@ -1341,7 +1489,9 @@ void SAXS::calculate()
   std::vector<Vector> aa_deriv(size);
 
   size_t beads_size = size;
-  if(onebead) beads_size = nres;
+  if(onebead) {
+    beads_size = nres;
+  }
   // these are the derivatives particle,q
   std::vector<Vector> bd_deriv(numq*beads_size);
 
@@ -1369,7 +1519,9 @@ void SAXS::calculate()
     if(saxs) {
       if(getStep()%solv_stride == 0 || isFirstStep) {
         isFirstStep = 0;
-        if(rho_corr!=rho) sasa_calculate(solv_res);
+        if(rho_corr!=rho) {
+          sasa_calculate(solv_res);
+        }
         Iq0=0.;
         for(unsigned i=0; i<nres; ++i) {
           if(solv_res[i] == 1 ) {
@@ -1412,7 +1564,9 @@ void SAXS::calculate()
       double rho_sans_corr = rho_corr * solv_sc_length;
       if(getStep()%solv_stride == 0 || isFirstStep) {
         isFirstStep = 0;
-        if(deuter_conc!=0.||rho != rho_corr) sasa_calculate(solv_res);
+        if(deuter_conc!=0.||rho != rho_corr) {
+          sasa_calculate(solv_res);
+        }
         Iq0=0.;
         for(unsigned i=0; i<nres; ++i) {
           if(solv_res[i] == 1 ) {
@@ -1470,8 +1624,11 @@ void SAXS::calculate()
     aa_deriv = std::vector<Vector>(size,(Vector(1,1,1)));
   }
 
-  if(gpu) calculate_gpu(beads_pos, bd_deriv);
-  else calculate_cpu(beads_pos, bd_deriv);
+  if(gpu) {
+    calculate_gpu(beads_pos, bd_deriv);
+  } else {
+    calculate_cpu(beads_pos, bd_deriv);
+  }
 
   if(getDoScore()) {
     /* Metainference */
@@ -1484,7 +1641,8 @@ void SAXS::calculate()
     Tensor deriv_box;
     Value* val;
     if(!getDoScore()) {
-      std::string num; Tools::convert(k,num);
+      std::string num;
+      Tools::convert(k,num);
       val=getPntrToComponent("q-"+num);
 
       if(onebead) {
@@ -1542,11 +1700,14 @@ void SAXS::calculate()
 
 void SAXS::update() {
   // write status file
-  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) writeStatus();
+  if(getWstride()>0&& (getStep()%getWstride()==0 || getCPT()) ) {
+    writeStatus();
+  }
 }
 
 unsigned SAXS::getOnebeadMapping(const PDB &pdb, const std::vector<AtomNumber> &atoms) {
-  std::vector<std::string> chains; pdb.getChainNames( chains );
+  std::vector<std::string> chains;
+  pdb.getChainNames( chains );
   std::vector<std::vector<std::string> > AtomResidueName;
 
   // cycle over chains
@@ -1560,7 +1721,8 @@ unsigned SAXS::getOnebeadMapping(const PDB &pdb, const std::vector<AtomNumber> &
       std::string Rname = pdb.getResidueName(res, chains[i]);
       Rname.erase(std::remove_if(Rname.begin(), Rname.end(), ::isspace),Rname.end());
       std::vector<AtomNumber> res_atoms = pdb.getAtomsInResidue(res, chains[i]);
-      std::vector<unsigned> tmp_residue_atom; tmp_residue_atom.resize(3,0);
+      std::vector<unsigned> tmp_residue_atom;
+      tmp_residue_atom.resize(3,0);
       // cycle over atoms
       for(unsigned a=0; a<res_atoms.size(); a++) {
         // operations shared among all beads
@@ -1576,13 +1738,19 @@ unsigned SAXS::getOnebeadMapping(const PDB &pdb, const std::vector<AtomNumber> &
         } else {
           type = Aname.at(1);
         }
-        if (type == 'H') atoms_masses.push_back(1.008);
-        else if(type == 'C') atoms_masses.push_back(12.011);
-        else if(type == 'N') atoms_masses.push_back(14.007);
-        else if(type == 'O') atoms_masses.push_back(15.999);
-        else if(type == 'S') atoms_masses.push_back(32.065);
-        else if(type == 'P') atoms_masses.push_back(30.974);
-        else {
+        if (type == 'H') {
+          atoms_masses.push_back(1.008);
+        } else if(type == 'C') {
+          atoms_masses.push_back(12.011);
+        } else if(type == 'N') {
+          atoms_masses.push_back(14.007);
+        } else if(type == 'O') {
+          atoms_masses.push_back(15.999);
+        } else if(type == 'S') {
+          atoms_masses.push_back(32.065);
+        } else if(type == 'P') {
+          atoms_masses.push_back(30.974);
+        } else {
           error("Unknown element in mass extraction\n");
         }
         if(pdb.allowedResidue("protein",Rname)) {
@@ -1617,7 +1785,9 @@ unsigned SAXS::getOnebeadMapping(const PDB &pdb, const std::vector<AtomNumber> &
             tmp_residue_atom[2]++;
           }
           // error
-          else error("Atom name "+Aname+" cannot be indexed to any bead. Check the PDB.");
+          else {
+            error("Atom name "+Aname+" cannot be indexed to any bead. Check the PDB.");
+          }
         }
       }
       if(pdb.allowedResidue("protein",Rname)) {
@@ -1625,7 +1795,9 @@ unsigned SAXS::getOnebeadMapping(const PDB &pdb, const std::vector<AtomNumber> &
       } else {
         atoms_per_bead.push_back(tmp_residue_atom[0]);
         atoms_per_bead.push_back(tmp_residue_atom[1]);
-        if(tmp_residue_atom[2]>0) atoms_per_bead.push_back(tmp_residue_atom[2]);
+        if(tmp_residue_atom[2]>0) {
+          atoms_per_bead.push_back(tmp_residue_atom[2]);
+        }
       }
     }
   }
@@ -1633,8 +1805,7 @@ unsigned SAXS::getOnebeadMapping(const PDB &pdb, const std::vector<AtomNumber> &
   return atoms_per_bead.size();
 }
 
-void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &parameter)
-{
+void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &parameter) {
   parameter[ALA_BB].push_back(9.045);
   parameter[ALA_BB].push_back(-0.098114);
   parameter[ALA_BB].push_back(7.54281);
@@ -2707,7 +2878,9 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
       if(Rname=="ALA") {
         if(Aname=="BB") {
           atoi[i]=ALA_BB;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="ARG") {
         if(Aname=="BB") {
           atoi[i]=ARG_BB;
@@ -2715,41 +2888,55 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=ARG_SC1;
         } else if(Aname=="SC2") {
           atoi[i]=ARG_SC2;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="ASN") {
         if(Aname=="BB") {
           atoi[i]=ASN_BB;
         } else if(Aname=="SC1") {
           atoi[i]=ASN_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="ASP") {
         if(Aname=="BB") {
           atoi[i]=ASP_BB;
         } else if(Aname=="SC1") {
           atoi[i]=ASP_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="CYS") {
         if(Aname=="BB") {
           atoi[i]=CYS_BB;
         } else if(Aname=="SC1") {
           atoi[i]=CYS_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="GLN") {
         if(Aname=="BB") {
           atoi[i]=GLN_BB;
         } else if(Aname=="SC1") {
           atoi[i]=GLN_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="GLU") {
         if(Aname=="BB") {
           atoi[i]=GLU_BB;
         } else if(Aname=="SC1") {
           atoi[i]=GLU_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="GLY") {
         if(Aname=="BB") {
           atoi[i]=GLY_BB;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="HIS") {
         if(Aname=="BB") {
           atoi[i]=HIS_BB;
@@ -2759,19 +2946,25 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=HIS_SC2;
         } else if(Aname=="SC3") {
           atoi[i]=HIS_SC3;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="ILE") {
         if(Aname=="BB") {
           atoi[i]=ILE_BB;
         } else if(Aname=="SC1") {
           atoi[i]=ILE_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="LEU") {
         if(Aname=="BB") {
           atoi[i]=LEU_BB;
         } else if(Aname=="SC1") {
           atoi[i]=LEU_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="LYS") {
         if(Aname=="BB") {
           atoi[i]=LYS_BB;
@@ -2779,13 +2972,17 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=LYS_SC1;
         } else if(Aname=="SC2") {
           atoi[i]=LYS_SC2;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="MET") {
         if(Aname=="BB") {
           atoi[i]=MET_BB;
         } else if(Aname=="SC1") {
           atoi[i]=MET_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="PHE") {
         if(Aname=="BB") {
           atoi[i]=PHE_BB;
@@ -2795,25 +2992,33 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=PHE_SC2;
         } else if(Aname=="SC3") {
           atoi[i]=PHE_SC3;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="PRO") {
         if(Aname=="BB") {
           atoi[i]=PRO_BB;
         } else if(Aname=="SC1") {
           atoi[i]=PRO_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="SER") {
         if(Aname=="BB") {
           atoi[i]=SER_BB;
         } else if(Aname=="SC1") {
           atoi[i]=SER_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="THR") {
         if(Aname=="BB") {
           atoi[i]=THR_BB;
         } else if(Aname=="SC1") {
           atoi[i]=THR_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="TRP") {
         if(Aname=="BB") {
           atoi[i]=TRP_BB;
@@ -2825,7 +3030,9 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=TRP_SC3;
         } else if(Aname=="SC4") {
           atoi[i]=TRP_SC4;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="TYR") {
         if(Aname=="BB") {
           atoi[i]=TYR_BB;
@@ -2835,13 +3042,17 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=TYR_SC2;
         } else if(Aname=="SC3") {
           atoi[i]=TYR_SC3;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="VAL") {
         if(Aname=="BB") {
           atoi[i]=VAL_BB;
         } else if(Aname=="SC1") {
           atoi[i]=VAL_SC1;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="  A") {
         if(Aname=="BB1") {
           atoi[i]=A_BB1;
@@ -2865,7 +3076,9 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=A_TE3;
         } else if(Aname=="TE5") {
           atoi[i]=A_TE5;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="  C") {
         if(Aname=="BB1") {
           atoi[i]=C_BB1;
@@ -2887,7 +3100,9 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=C_TE3;
         } else if(Aname=="TE5") {
           atoi[i]=C_TE5;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="  G") {
         if(Aname=="BB1") {
           atoi[i]=G_BB1;
@@ -2911,7 +3126,9 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=G_TE3;
         } else if(Aname=="TE5") {
           atoi[i]=G_TE5;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname=="  U") {
         if(Aname=="BB1") {
           atoi[i]=U_BB1;
@@ -2933,7 +3150,9 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=U_TE3;
         } else if(Aname=="TE5") {
           atoi[i]=U_TE5;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname==" DA") {
         if(Aname=="BB1") {
           atoi[i]=DA_BB1;
@@ -2957,7 +3176,9 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=DA_TE3;
         } else if(Aname=="TE5") {
           atoi[i]=DA_TE5;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname==" DC") {
         if(Aname=="BB1") {
           atoi[i]=DC_BB1;
@@ -2979,7 +3200,9 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=DC_TE3;
         } else if(Aname=="TE5") {
           atoi[i]=DC_TE5;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname==" DG") {
         if(Aname=="BB1") {
           atoi[i]=DG_BB1;
@@ -3003,7 +3226,9 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=DG_TE3;
         } else if(Aname=="TE5") {
           atoi[i]=DG_TE5;
-        } else error("Atom name not known: "+Aname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
       } else if(Rname==" DT") {
         if(Aname=="BB1") {
           atoi[i]=DT_BB1;
@@ -3025,16 +3250,19 @@ void SAXS::getMartiniFFparam(const std::vector<AtomNumber> &atoms, std::vector<s
           atoi[i]=DT_TE3;
         } else if(Aname=="TE5") {
           atoi[i]=DT_TE5;
-        } else error("Atom name not known: "+Aname);
-      } else error("Residue not known: "+Rname);
+        } else {
+          error("Atom name not known: "+Aname);
+        }
+      } else {
+        error("Residue not known: "+Rname);
+      }
     }
   } else {
     error("MOLINFO DATA not found\n");
   }
 }
 
-void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &parameter_vac, std::vector<std::vector<long double> > &parameter_mix, std::vector<std::vector<long double> > &parameter_solv, const std::vector<unsigned> & residue_atom)
-{
+void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &parameter_vac, std::vector<std::vector<long double> > &parameter_mix, std::vector<std::vector<long double> > &parameter_solv, const std::vector<unsigned> & residue_atom) {
 
   parameter_solv[TRP].push_back(60737.60249988003);
   parameter_solv[TRP].push_back(-77.75716755173752);
@@ -3956,7 +4184,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                  Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                  Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - G3
     } else if(Rname=="G3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -3974,7 +4204,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - G5
     } else if(Rname=="G5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -3989,7 +4221,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - GT
     } else if(Rname=="GT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -4007,7 +4241,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                  Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                  Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - U
     } else if(Rname=="U") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -4024,7 +4260,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                  Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                  Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - U3
     } else if(Rname=="U3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -4041,7 +4279,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                 Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - U5
     } else if(Rname=="U5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -4055,7 +4295,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                 Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - UT
     } else if(Rname=="UT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -4072,7 +4314,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                  Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                  Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - A
     } else if(Rname=="A") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -4090,7 +4334,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - A3
     } else if(Rname=="A3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -4108,7 +4354,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - A5
     } else if(Rname=="A5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -4123,7 +4371,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - AT
     } else if(Rname=="AT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -4141,7 +4391,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - C
     } else if(Rname=="C") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -4158,7 +4410,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - C3
     } else if(Rname=="C3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -4175,7 +4429,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - C5
     } else if(Rname=="C5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -4189,7 +4445,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - CT
     } else if(Rname=="CT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -4206,7 +4464,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - G
     } else if(Rname=="DG") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -4224,7 +4484,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - G3
     } else if(Rname=="DG3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -4242,7 +4504,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - G5
     } else if(Rname=="DG5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -4257,7 +4521,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - GT
     } else if(Rname=="DGT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -4275,7 +4541,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - T
     } else if(Rname=="DT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -4293,7 +4561,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - T3
     } else if(Rname=="DT3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -4311,7 +4581,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - T5
     } else if(Rname=="DT5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -4326,7 +4598,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - TT
     } else if(Rname=="DTT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -4344,7 +4618,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - A
     } else if(Rname=="DA") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -4362,7 +4638,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - A3
     } else if(Rname=="DA3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -4380,7 +4658,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - A5
     } else if(Rname=="DA5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -4395,7 +4675,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - AT
     } else if(Rname=="DAT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -4413,7 +4695,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - C
     } else if(Rname=="DC") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -4430,7 +4714,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - C3
     } else if(Rname=="DC3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -4447,7 +4733,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - C5
     } else if(Rname=="DC5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -4461,7 +4749,9 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - CT
     } else if(Rname=="DCT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -4478,13 +4768,16 @@ void SAXS::getOnebeadparam(const PDB &pdb, const std::vector<AtomNumber> &atoms,
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
-    } else error("Residue not known: "+Rname);
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
+    } else {
+      error("Residue not known: "+Rname);
+    }
   }
 }
 
-void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &parameter_vac_H, std::vector<std::vector<long double> > &parameter_mix_H, std::vector<std::vector<long double> > &parameter_solv_H)
-{
+void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &parameter_vac_H, std::vector<std::vector<long double> > &parameter_mix_H, std::vector<std::vector<long double> > &parameter_solv_H) {
   parameter_solv_H[TRP].push_back(60737.60249988011);
   parameter_solv_H[TRP].push_back(-77.77344118516487);
   parameter_solv_H[TRP].push_back(-205962.80436572764);
@@ -5407,7 +5700,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                  Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                  Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - G3
     } else if(Rname=="G3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -5425,7 +5720,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - G5
     } else if(Rname=="G5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -5440,7 +5737,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - GT
     } else if(Rname=="GT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -5458,7 +5757,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                  Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                  Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - U
     } else if(Rname=="U") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -5475,7 +5776,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                  Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                  Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - U3
     } else if(Rname=="U3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -5492,7 +5795,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                 Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - U5
     } else if(Rname=="U5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -5506,7 +5811,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                 Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - UT
     } else if(Rname=="UT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -5523,7 +5830,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                  Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                  Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - A
     } else if(Rname=="A") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -5541,7 +5850,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - A3
     } else if(Rname=="A3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -5559,7 +5870,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - A5
     } else if(Rname=="A5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -5574,7 +5887,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - AT
     } else if(Rname=="AT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -5592,7 +5907,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - C
     } else if(Rname=="C") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -5609,7 +5926,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - C3
     } else if(Rname=="C3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -5626,7 +5945,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - C5
     } else if(Rname=="C5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -5640,7 +5961,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - CT
     } else if(Rname=="CT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -5657,7 +5980,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - G
     } else if(Rname=="DG") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -5675,7 +6000,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - G3
     } else if(Rname=="DG3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -5693,7 +6020,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - G5
     } else if(Rname=="DG5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -5708,7 +6037,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - GT
     } else if(Rname=="DGT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -5726,7 +6057,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - T
     } else if(Rname=="DT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -5744,7 +6077,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - T3
     } else if(Rname=="DT3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -5762,7 +6097,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - T5
     } else if(Rname=="DT5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -5777,7 +6114,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - TT
     } else if(Rname=="DTT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -5795,7 +6134,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - A
     } else if(Rname=="DA") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -5813,7 +6154,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - A3
     } else if(Rname=="DA3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -5831,7 +6174,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - A5
     } else if(Rname=="DA5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -5846,7 +6191,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - AT
     } else if(Rname=="DAT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -5864,7 +6211,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - C
     } else if(Rname=="DC") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -5881,7 +6230,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - C3
     } else if(Rname=="DC3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -5898,7 +6249,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - C5
     } else if(Rname=="DC5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -5912,7 +6265,9 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - CT
     } else if(Rname=="DCT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -5929,13 +6284,17 @@ void SAXS::getOnebeadparam_sansH(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
-    } else error("Residue not known: "+Rname);
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
+    } else {
+      error("Residue not known: "+Rname);
+    }
   }
 }
 
-void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &parameter_vac_D, std::vector<std::vector<long double> > &parameter_mix_D)
-{ // parameter_solv is identical in SAXS/SANS_H/SANS_D since it depends exclusively on param_v. For that reason we kept param_solv only in SAXS and SANS_H.
+void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &parameter_vac_D, std::vector<std::vector<long double> > &parameter_mix_D) {
+  // parameter_solv is identical in SAXS/SANS_H/SANS_D since it depends exclusively on param_v. For that reason we kept param_solv only in SAXS and SANS_H.
   parameter_mix_D[TRP].push_back(8105.740500119327);
   parameter_mix_D[TRP].push_back(-41.785616935469804);
   parameter_mix_D[TRP].push_back(-25456.92790554363);
@@ -6576,7 +6935,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                  Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                  Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - G3
     } else if(Rname=="G3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -6594,7 +6955,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - G5
     } else if(Rname=="G5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -6609,7 +6972,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - GT
     } else if(Rname=="GT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -6627,7 +6992,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                  Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                  Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - U
     } else if(Rname=="U") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -6644,7 +7011,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                  Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                  Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - U3
     } else if(Rname=="U3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -6661,7 +7030,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                 Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - U5
     } else if(Rname=="U5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -6675,7 +7046,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                 Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - UT
     } else if(Rname=="UT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -6692,7 +7065,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                  Aname=="C4" || Aname=="O4"  || Aname=="C5" || Aname=="C6" ||
                  Aname=="H3" || Aname=="H5"  || Aname=="H6") {
         atoi[residue_atom[i]]=BASE_U;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - A
     } else if(Rname=="A") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -6710,7 +7085,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - A3
     } else if(Rname=="A3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -6728,7 +7105,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - A5
     } else if(Rname=="A5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -6743,7 +7122,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - AT
     } else if(Rname=="AT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -6761,7 +7142,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - C
     } else if(Rname=="C") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -6778,7 +7161,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - C3
     } else if(Rname=="C3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -6795,7 +7180,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - C5
     } else if(Rname=="C5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -6809,7 +7196,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // RNA - CT
     } else if(Rname=="CT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -6826,7 +7215,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - G
     } else if(Rname=="DG") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -6844,7 +7235,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - G3
     } else if(Rname=="DG3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -6862,7 +7255,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - G5
     } else if(Rname=="DG5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -6877,7 +7272,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - GT
     } else if(Rname=="DGT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -6895,7 +7292,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="N7" || Aname=="C8"  || Aname=="N9" || Aname=="H1" ||
                 Aname=="H8" || Aname=="H21" || Aname=="H22" ) {
         atoi[residue_atom[i]]=BASE_G;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - T
     } else if(Rname=="DT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -6913,7 +7312,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - T3
     } else if(Rname=="DT3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -6931,7 +7332,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - T5
     } else if(Rname=="DT5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -6946,7 +7349,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - TT
     } else if(Rname=="DTT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -6964,7 +7369,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C7"  || Aname=="H3"  || Aname=="H6"  || Aname=="H71" ||
                 Aname=="H72" || Aname=="H73" ) {
         atoi[residue_atom[i]]=BASE_T;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - A
     } else if(Rname=="DA") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -6982,7 +7389,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - A3
     } else if(Rname=="DA3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -7000,7 +7409,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - A5
     } else if(Rname=="DA5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -7015,7 +7426,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - AT
     } else if(Rname=="DAT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -7033,7 +7446,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C8"  || Aname=="N9" || Aname=="H2" || Aname=="H8" ||
                 Aname=="H61" || Aname=="H62" ) {
         atoi[residue_atom[i]]=BASE_A;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - C
     } else if(Rname=="DC") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="HP" ||
@@ -7050,7 +7465,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - C3
     } else if(Rname=="DC3") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3" ||
@@ -7067,7 +7484,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - C5
     } else if(Rname=="DC5") {
       if( Aname=="O5'"  || Aname=="C5'"  || Aname=="O4'"  || Aname=="C4'"  ||
@@ -7081,7 +7500,9 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
       // DNA - CT
     } else if(Rname=="DCT") {
       if( Aname=="P"   || Aname=="OP1" || Aname=="OP2" || Aname=="OP3"  ||
@@ -7098,13 +7519,16 @@ void SAXS::getOnebeadparam_sansD(const PDB &pdb, const std::vector<AtomNumber> &
                 Aname=="C4" || Aname=="N4" || Aname=="C5"  || Aname=="C6" ||
                 Aname=="H5" || Aname=="H6" || Aname=="H41" || Aname=="H42" ) {
         atoi[residue_atom[i]]=BASE_C;
-      } else error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
-    } else error("Residue not known: "+Rname);
+      } else {
+        error("Atom name "+Aname+" is not defined for residue "+Rname+". Check the PDB.");
+      }
+    } else {
+      error("Residue not known: "+Rname);
+    }
   }
 }
 
-double SAXS::calculateAFF(const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &FF_tmp, const double rho)
-{
+double SAXS::calculateAFF(const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &FF_tmp, const double rho) {
   std::map<std::string, unsigned> AA_map;
   AA_map["H"] = H;
   AA_map["C"] = C;
@@ -7123,41 +7547,83 @@ double SAXS::calculateAFF(const std::vector<AtomNumber> &atoms, std::vector<std:
   param_c.resize(NTT);
   param_v.resize(NTT);
 
-  param_a[H][0] = 0.493002; param_b[H][0] = 10.5109; param_c[H] = 0.003038;
-  param_a[H][1] = 0.322912; param_b[H][1] = 26.1257; param_v[H] = 5.15;
-  param_a[H][2] = 0.140191; param_b[H][2] = 3.14236;
-  param_a[H][3] = 0.040810; param_b[H][3] = 57.7997;
-  param_a[H][4] = 0.0;      param_b[H][4] = 1.0;
-
-  param_a[C][0] = 2.31000; param_b[C][0] = 20.8439; param_c[C] = 0.215600;
-  param_a[C][1] = 1.02000; param_b[C][1] = 10.2075; param_v[C] = 16.44;
-  param_a[C][2] = 1.58860; param_b[C][2] = 0.56870;
-  param_a[C][3] = 0.86500; param_b[C][3] = 51.6512;
-  param_a[C][4] = 0.0;     param_b[C][4] = 1.0;
-
-  param_a[N][0] = 12.2126; param_b[N][0] = 0.00570; param_c[N] = -11.529;
-  param_a[N][1] = 3.13220; param_b[N][1] = 9.89330; param_v[N] = 2.49;
-  param_a[N][2] = 2.01250; param_b[N][2] = 28.9975;
-  param_a[N][3] = 1.16630; param_b[N][3] = 0.58260;
-  param_a[N][4] = 0.0;     param_b[N][4] = 1.0;
-
-  param_a[O][0] = 3.04850; param_b[O][0] = 13.2771; param_c[O] = 0.250800 ;
-  param_a[O][1] = 2.28680; param_b[O][1] = 5.70110; param_v[O] = 9.13;
-  param_a[O][2] = 1.54630; param_b[O][2] = 0.32390;
-  param_a[O][3] = 0.86700; param_b[O][3] = 32.9089;
-  param_a[O][4] = 0.0;     param_b[O][4] = 1.0;
-
-  param_a[P][0] = 6.43450; param_b[P][0] = 1.90670; param_c[P] = 1.11490;
-  param_a[P][1] = 4.17910; param_b[P][1] = 27.1570; param_v[P] = 5.73;
-  param_a[P][2] = 1.78000; param_b[P][2] = 0.52600;
-  param_a[P][3] = 1.49080; param_b[P][3] = 68.1645;
-  param_a[P][4] = 0.0;     param_b[P][4] = 1.0;
-
-  param_a[S][0] = 6.90530; param_b[S][0] = 1.46790; param_c[S] = 0.866900;
-  param_a[S][1] = 5.20340; param_b[S][1] = 22.2151; param_v[S] = 19.86;
-  param_a[S][2] = 1.43790; param_b[S][2] = 0.25360;
-  param_a[S][3] = 1.58630; param_b[S][3] = 56.1720;
-  param_a[S][4] = 0.0;     param_b[S][4] = 1.0;
+  param_a[H][0] = 0.493002;
+  param_b[H][0] = 10.5109;
+  param_c[H] = 0.003038;
+  param_a[H][1] = 0.322912;
+  param_b[H][1] = 26.1257;
+  param_v[H] = 5.15;
+  param_a[H][2] = 0.140191;
+  param_b[H][2] = 3.14236;
+  param_a[H][3] = 0.040810;
+  param_b[H][3] = 57.7997;
+  param_a[H][4] = 0.0;
+  param_b[H][4] = 1.0;
+
+  param_a[C][0] = 2.31000;
+  param_b[C][0] = 20.8439;
+  param_c[C] = 0.215600;
+  param_a[C][1] = 1.02000;
+  param_b[C][1] = 10.2075;
+  param_v[C] = 16.44;
+  param_a[C][2] = 1.58860;
+  param_b[C][2] = 0.56870;
+  param_a[C][3] = 0.86500;
+  param_b[C][3] = 51.6512;
+  param_a[C][4] = 0.0;
+  param_b[C][4] = 1.0;
+
+  param_a[N][0] = 12.2126;
+  param_b[N][0] = 0.00570;
+  param_c[N] = -11.529;
+  param_a[N][1] = 3.13220;
+  param_b[N][1] = 9.89330;
+  param_v[N] = 2.49;
+  param_a[N][2] = 2.01250;
+  param_b[N][2] = 28.9975;
+  param_a[N][3] = 1.16630;
+  param_b[N][3] = 0.58260;
+  param_a[N][4] = 0.0;
+  param_b[N][4] = 1.0;
+
+  param_a[O][0] = 3.04850;
+  param_b[O][0] = 13.2771;
+  param_c[O] = 0.250800 ;
+  param_a[O][1] = 2.28680;
+  param_b[O][1] = 5.70110;
+  param_v[O] = 9.13;
+  param_a[O][2] = 1.54630;
+  param_b[O][2] = 0.32390;
+  param_a[O][3] = 0.86700;
+  param_b[O][3] = 32.9089;
+  param_a[O][4] = 0.0;
+  param_b[O][4] = 1.0;
+
+  param_a[P][0] = 6.43450;
+  param_b[P][0] = 1.90670;
+  param_c[P] = 1.11490;
+  param_a[P][1] = 4.17910;
+  param_b[P][1] = 27.1570;
+  param_v[P] = 5.73;
+  param_a[P][2] = 1.78000;
+  param_b[P][2] = 0.52600;
+  param_a[P][3] = 1.49080;
+  param_b[P][3] = 68.1645;
+  param_a[P][4] = 0.0;
+  param_b[P][4] = 1.0;
+
+  param_a[S][0] = 6.90530;
+  param_b[S][0] = 1.46790;
+  param_c[S] = 0.866900;
+  param_a[S][1] = 5.20340;
+  param_b[S][1] = 22.2151;
+  param_v[S] = 19.86;
+  param_a[S][2] = 1.43790;
+  param_b[S][2] = 0.25360;
+  param_a[S][3] = 1.58630;
+  param_b[S][3] = 56.1720;
+  param_a[S][4] = 0.0;
+  param_b[S][4] = 1.0;
 
   auto* moldat=plumed.getActionSet().selectLatest<GenericMolInfo*>(this);
 
@@ -7197,7 +7663,9 @@ double SAXS::calculateAFF(const std::vector<AtomNumber> &atoms, std::vector<std:
       if(AA_map.find(type_s) != AA_map.end()) {
         const unsigned index=AA_map[type_s];
         atoi[i] = AA_map[type_s];
-        for(unsigned j=0; j<4; ++j) Iq0 += param_a[index][j];
+        for(unsigned j=0; j<4; ++j) {
+          Iq0 += param_a[index][j];
+        }
         Iq0 = Iq0 -rho*param_v[index] + param_c[index];
       } else {
         error("Wrong atom type "+type_s+" from atom name "+name+"\n");
@@ -7206,13 +7674,14 @@ double SAXS::calculateAFF(const std::vector<AtomNumber> &atoms, std::vector<std:
   } else {
     error("MOLINFO DATA not found\n");
   }
-  if(absolute) Iq0 = 1;
+  if(absolute) {
+    Iq0 = 1;
+  }
 
   return Iq0;
 }
 
-double SAXS::calculateAFFsans(const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &FF_tmp, const double deuter_conc)
-{
+double SAXS::calculateAFFsans(const std::vector<AtomNumber> &atoms, std::vector<std::vector<long double> > &FF_tmp, const double deuter_conc) {
   std::map<std::string, unsigned> AA_map;
   AA_map["H"] = H;
   AA_map["C"] = C;
@@ -7227,13 +7696,19 @@ double SAXS::calculateAFFsans(const std::vector<AtomNumber> &atoms, std::vector<
   param_b.resize(NTT);
   param_v.resize(NTT);
 
-  param_b[H] = -0.374; param_v[H] = 5.15;
+  param_b[H] = -0.374;
+  param_v[H] = 5.15;
   // param_b[D] = 0.667;
-  param_b[C] =  0.665;  param_v[C] = 16.44;
-  param_b[N] =  0.94;   param_v[N] = 2.49;
-  param_b[O] =  0.580;  param_v[O] = 9.13;
-  param_b[P] =  0.51;   param_v[P] = 5.73;
-  param_b[S] =  0.28;   param_v[S] = 19.86;
+  param_b[C] =  0.665;
+  param_v[C] = 16.44;
+  param_b[N] =  0.94;
+  param_v[N] = 2.49;
+  param_b[O] =  0.580;
+  param_v[O] = 9.13;
+  param_b[P] =  0.51;
+  param_v[P] = 5.73;
+  param_b[S] =  0.28;
+  param_v[S] = 19.86;
 
   double solv_sc_length = 0.1*(param_b[O] + 2.*((1. - deuter_conc) * param_b[H] + deuter_conc * 0.667)); // per water electron (10 electrons)
 
@@ -7278,7 +7753,9 @@ double SAXS::calculateAFFsans(const std::vector<AtomNumber> &atoms, std::vector<
   } else {
     error("MOLINFO DATA not found\n");
   }
-  if(absolute) Iq0 = 1;
+  if(absolute) {
+    Iq0 = 1;
+  }
 
   return Iq0;
 }
@@ -8488,12 +8965,10 @@ std::map<std::string, std::vector<double> > SAXS::setupLCPOparam() {
 }
 
 // assigns LCPO parameters to each atom reading from database
-void SAXS::readLCPOparam(const std::vector<std::vector<std::string> > &AtomResidueName, unsigned natoms)
-{
+void SAXS::readLCPOparam(const std::vector<std::vector<std::string> > &AtomResidueName, unsigned natoms) {
   std::map<std::string, std::vector<double> > lcpomap = setupLCPOparam();
 
-  for(unsigned i=0; i<natoms; ++i)
-  {
+  for(unsigned i=0; i<natoms; ++i) {
     if ((AtomResidueName[0][i][0]=='O') || (AtomResidueName[0][i][0]=='N') || (AtomResidueName[0][i][0]=='C') || (AtomResidueName[0][i][0]=='S' || (AtomResidueName[0][i][0]=='P'))) {
       std::string identifier = AtomResidueName[1][i]+"_"+AtomResidueName[0][i];
       std::vector<double> LCPOparamVector = lcpomap.at(identifier);
@@ -8530,8 +9005,7 @@ void SAXS::readLCPOparam(const std::vector<std::vector<std::string> > &AtomResid
   }
 }
 
-void SAXS::resolution_function()
-{
+void SAXS::resolution_function() {
   const unsigned numq = q_list.size();
 
   // only OpenMP because numq might be smaller than the number of ranks
@@ -8554,12 +9028,12 @@ void SAXS::resolution_function()
 // i0e function from cephes
 // compute I0(x) * exp (-x), with I0 being the modified Bessel function
 // of first kind and zeroth order.
-inline double SAXS::i0e(double x)
-{
+inline double SAXS::i0e(double x) {
   double y = 0.0;
 
-  if (x < 0)
+  if (x < 0) {
     x = -x;
+  }
   if (x <= 8.0) {
     y = (x/2.0) - 2.0;
     return chbevl(y, A);
@@ -8568,8 +9042,7 @@ inline double SAXS::i0e(double x)
   return chbevl(32.0/x - 2.0, B) / sqrt(x);
 }
 
-double SAXS::chbevl(double x, const std::vector<double> &coeffs)
-{
+double SAXS::chbevl(double x, const std::vector<double> &coeffs) {
   double b0, b1, b2;
   unsigned n = coeffs.size();
 
@@ -8585,10 +9058,11 @@ double SAXS::chbevl(double x, const std::vector<double> &coeffs)
   return 0.5 * (b0 - b2);
 }
 
-inline double SAXS::interpolation(std::vector<SplineCoeffs> &coeffs, double x)
-{
+inline double SAXS::interpolation(std::vector<SplineCoeffs> &coeffs, double x) {
   unsigned s = 0;
-  while ((x >= q_list[s+1]) && (s+1 < q_list.size()-1)) s++;
+  while ((x >= q_list[s+1]) && (s+1 < q_list.size()-1)) {
+    s++;
+  }
 
   double dx = x - coeffs[s].x;
   return coeffs[s].a + coeffs[s].b*dx + coeffs[s].c*dx*dx + coeffs[s].d*dx*dx*dx;
@@ -8596,8 +9070,7 @@ inline double SAXS::interpolation(std::vector<SplineCoeffs> &coeffs, double x)
 
 // natural bc cubic spline implementation from the Wikipedia algorithm
 // modified from https://stackoverflow.com/a/19216702/3254658
-std::vector<SAXS::SplineCoeffs> SAXS::spline_coeffs(std::vector<double> &x, std::vector<double> &y)
-{
+std::vector<SAXS::SplineCoeffs> SAXS::spline_coeffs(std::vector<double> &x, std::vector<double> &y) {
   unsigned n = x.size()-1;
   std::vector<double> a;
   a.insert(a.begin(), y.begin(), y.end());
@@ -8605,13 +9078,15 @@ std::vector<SAXS::SplineCoeffs> SAXS::spline_coeffs(std::vector<double> &x, std:
   std::vector<double> d(n);
   std::vector<double> h;
 
-  for(unsigned i=0; i<n; i++)
+  for(unsigned i=0; i<n; i++) {
     h.push_back(x[i+1]-x[i]);
+  }
 
   std::vector<double> alpha;
   alpha.push_back(0);
-  for(unsigned i=1; i<n; i++)
+  for(unsigned i=1; i<n; i++) {
     alpha.push_back( 3*(a[i+1]-a[i])/h[i] - 3*(a[i]-a[i-1])/h[i-1]  );
+  }
 
   std::vector<double> c(n+1);
   std::vector<double> l(n+1);
diff --git a/src/isdb/Select.cpp b/src/isdb/Select.cpp
index 1b933c2b43..4304bc56d8 100644
--- a/src/isdb/Select.cpp
+++ b/src/isdb/Select.cpp
@@ -66,8 +66,7 @@ PRINT ARG=pbactive STRIDE=100 FILE=COLVAR
 */
 //+ENDPLUMEDOC
 
-class Select : public function::Function
-{
+class Select : public function::Function {
   std::string selector_;
 
 public:
@@ -86,12 +85,12 @@ void Select::registerKeywords(Keywords& keys) {
 }
 
 Select::Select(const ActionOptions&ao):
-  Action(ao), Function(ao)
-{
+  Action(ao), Function(ao) {
   // name of selector
   parse("SELECTOR", selector_);
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
   checkRead();
 
   log.printf("  select based on %s\n",selector_.c_str());
@@ -99,15 +98,18 @@ Select::Select(const ActionOptions&ao):
 
 }
 
-void Select::calculate()
-{
+void Select::calculate() {
   unsigned iselect = static_cast<unsigned>(plumed.passMap[selector_]);
 
   // check if iselect is smaller than the number of arguments
-  if(iselect>=getNumberOfArguments()) error("the value of the SELECTOR is greater than the number of arguments!");
+  if(iselect>=getNumberOfArguments()) {
+    error("the value of the SELECTOR is greater than the number of arguments!");
+  }
 
   // put all the derivatives to zero
-  for(unsigned i=0; i<getNumberOfArguments(); ++i) setDerivative(i, 0.0);
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    setDerivative(i, 0.0);
+  }
 
   // set value and derivative for selected argument
   setValue(getArgument(iselect));
diff --git a/src/isdb/Selector.cpp b/src/isdb/Selector.cpp
index f3e2e959c7..aebc76b445 100644
--- a/src/isdb/Selector.cpp
+++ b/src/isdb/Selector.cpp
@@ -60,8 +60,7 @@ PRINT FILE=COLVAR ARG=* STRIDE=100
 //+ENDPLUMEDOC
 
 class Selector:
-  public Action
-{
+  public Action {
 public:
   static void registerKeywords( Keywords& keys );
   explicit Selector(const ActionOptions&ao);
@@ -78,8 +77,7 @@ void Selector::registerKeywords( Keywords& keys ) {
 }
 
 Selector::Selector(const ActionOptions&ao):
-  Action(ao)
-{
+  Action(ao) {
   std::string name;
   parse("NAME", name);
   double value;
diff --git a/src/isdb/Shadow.cpp b/src/isdb/Shadow.cpp
index 314c4a7945..fd0ffd0f09 100644
--- a/src/isdb/Shadow.cpp
+++ b/src/isdb/Shadow.cpp
@@ -120,8 +120,7 @@ void Shadow::registerKeywords( Keywords& keys ) {
 
 Shadow::Shadow(const ActionOptions&ao):
   PLUMED_COLVAR_INIT(ao),
-  isreference_(false), nupdate_(1), pbc_(true), first_time_(true)
-{
+  isreference_(false), nupdate_(1), pbc_(true), first_time_(true) {
   // list of atoms
   std::vector<AtomNumber> atoms;
   parseAtomList("ATOMS",atoms);
@@ -156,22 +155,26 @@ Shadow::Shadow(const ActionOptions&ao):
   checkRead();
 
   log.printf("  atoms involved : ");
-  for(unsigned i=0; i<atoms.size(); ++i) log.printf("%d ",atoms[i].serial());
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf("%d ",atoms[i].serial());
+  }
   log.printf("\n");
   log.printf("  stride for updating reference coordinates : %d\n", nupdate_);
   log.printf("  number of replicas : %d\n", nrep);
   log.printf("  replica id : %d\n", replica);
-  if(isreference_) log.printf("  this is the reference replica\n");
+  if(isreference_) {
+    log.printf("  this is the reference replica\n");
+  }
 
   // add value and set periodicity
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
 
   // request atoms
   requestAtoms(atoms);
 }
 
-void Shadow::update_reference()
-{
+void Shadow::update_reference() {
 // number of atoms
   unsigned natoms = getNumberOfAtoms();
 // initialize rmsd variables
@@ -183,12 +186,16 @@ void Shadow::update_reference()
 // if master openmp task
   if(rank_==0) {
     // if reference replica
-    if(isreference_) reference = getPositions();
+    if(isreference_) {
+      reference = getPositions();
+    }
     // share coordinates
     multi_sim_comm.Sum(&reference[0][0], 3*natoms);
   }
 // now intra replica (openmp) communication
-  if(size_>1) comm.Sum(&reference[0][0], 3*natoms);
+  if(size_>1) {
+    comm.Sum(&reference[0][0], 3*natoms);
+  }
 
 // clear the rmsd object
   rmsd_.clear();
@@ -196,10 +203,11 @@ void Shadow::update_reference()
   rmsd_.set(align,displace,reference,"OPTIMAL");
 }
 
-void Shadow::calculate()
-{
+void Shadow::calculate() {
   // make whole
-  if(pbc_) makeWhole();
+  if(pbc_) {
+    makeWhole();
+  }
 
   // if it is time, update reference coordinates
   if(first_time_ || getStep()%nupdate_==0) {
@@ -215,7 +223,9 @@ void Shadow::calculate()
   setValue(rmsd);
   // if this is not the reference replica, add derivatives
   if(!isreference_) {
-    for(unsigned i=0; i<getNumberOfAtoms(); ++i) setAtomsDerivatives(i, derivatives[i]);
+    for(unsigned i=0; i<getNumberOfAtoms(); ++i) {
+      setAtomsDerivatives(i, derivatives[i]);
+    }
   }
   // set virial
   setBoxDerivativesNoPbc();
diff --git a/src/landmarks/CollectFrames.cpp b/src/landmarks/CollectFrames.cpp
index 2aa9ed21d6..e70b815e9b 100644
--- a/src/landmarks/CollectFrames.cpp
+++ b/src/landmarks/CollectFrames.cpp
@@ -57,31 +57,50 @@ void CollectFrames::registerKeywords( Keywords& keys ) {
   keys.add("optional","LOGWEIGHTS","list of actions that calculates log weights that should be used to weight configurations when calculating averages");
   keys.addOutputComponent("data","default","the data that is being collected by this action");
   keys.addOutputComponent("logweights","default","the logarithms of the weights of the data points");
-  keys.needsAction("POSITION"); keys.needsAction("CONCATENATE"); keys.needsAction("MEAN"); keys.needsAction("CUSTOM");
-  keys.needsAction("CONCATENATE"); keys.needsAction("COLLECT"); keys.needsAction("TRANSPOSE"); keys.needsAction("RMSD_VECTOR");
-  keys.needsAction("COMBINE"); keys.needsAction("VSTACK"); keys.needsAction("CONSTANT");
+  keys.needsAction("POSITION");
+  keys.needsAction("CONCATENATE");
+  keys.needsAction("MEAN");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("CONCATENATE");
+  keys.needsAction("COLLECT");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("RMSD_VECTOR");
+  keys.needsAction("COMBINE");
+  keys.needsAction("VSTACK");
+  keys.needsAction("CONSTANT");
 }
 
 std::string CollectFrames::fixArgumentName( const std::string& argin ) {
-  std::string argout = argin; std::size_t dot=argin.find(".");
-  if( dot!=std::string::npos ) argout = argin.substr(0,dot) + "_" + argin.substr(dot+1);
+  std::string argout = argin;
+  std::size_t dot=argin.find(".");
+  if( dot!=std::string::npos ) {
+    argout = argin.substr(0,dot) + "_" + argin.substr(dot+1);
+  }
   return argout;
 }
 
 CollectFrames::CollectFrames( const ActionOptions& ao ):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string stride, clearstride; parse("STRIDE",stride); parse("CLEAR",clearstride);
-  std::vector<std::string> argn; parseVector("ARG",argn); std::vector<Value*> theargs;
+  ActionShortcut(ao) {
+  std::string stride, clearstride;
+  parse("STRIDE",stride);
+  parse("CLEAR",clearstride);
+  std::vector<std::string> argn;
+  parseVector("ARG",argn);
+  std::vector<Value*> theargs;
   ActionWithArguments::interpretArgumentList( argn, plumed.getActionSet(), this, theargs );
-  std::string indices; parse("ATOMS",indices);
-  if( theargs.size()==0 && indices.length()==0 ) error("no arguments or atoms were specified for collection");
+  std::string indices;
+  parse("ATOMS",indices);
+  if( theargs.size()==0 && indices.length()==0 ) {
+    error("no arguments or atoms were specified for collection");
+  }
 
   // Create the values to collect the atomic positions
   if( indices.length()>0 ) {
     // Collect reference position
-    readInputLine( getShortcutLabel() + "_getposx: POSITION ATOMS=" + indices ); std::string align; parse("ALIGN",align);
+    readInputLine( getShortcutLabel() + "_getposx: POSITION ATOMS=" + indices );
+    std::string align;
+    parse("ALIGN",align);
     readInputLine( getShortcutLabel() + "_getpos: CONCATENATE ARG=" + getShortcutLabel() + "_getposx.x," + getShortcutLabel() + "_getposx.y," + getShortcutLabel() + "_getposx.z");
     // Find atomic center
     readInputLine( getShortcutLabel() + "_cposx: MEAN ARG=" + getShortcutLabel() + "_getposx.x PERIODIC=NO");
@@ -100,37 +119,62 @@ CollectFrames::CollectFrames( const ActionOptions& ao ):
     // Add the reference position to the RMSD displacement
     readInputLine( getShortcutLabel() + "_fpos: COMBINE ARG=" + getShortcutLabel() + "_refposT," + getShortcutLabel() + "_rmsd.disp PERIODIC=NO");
     // Store the reference data
-    std::string suffix = "_atomdata"; if( theargs.size()==0 ) suffix = "_data";
+    std::string suffix = "_atomdata";
+    if( theargs.size()==0 ) {
+      suffix = "_data";
+    }
     readInputLine( getShortcutLabel() + suffix + ": COLLECT TYPE=matrix ARG=" + getShortcutLabel() + "_fpos STRIDE=" + stride + " CLEAR=" + clearstride );
   }
 
   // Create all the collect actions for arguments
   for(unsigned i=0; i<theargs.size(); ++i) {
-    if( theargs[i]->getNumberOfValues()!=theargs[0]->getNumberOfValues() ) error("mismatch between number of arguments calculated by each collected argument");
+    if( theargs[i]->getNumberOfValues()!=theargs[0]->getNumberOfValues() ) {
+      error("mismatch between number of arguments calculated by each collected argument");
+    }
     readInputLine( getShortcutLabel() + "_" + fixArgumentName( theargs[i]->getName() ) + ": COLLECT ARG=" + theargs[i]->getName() + " STRIDE=" + stride + " CLEAR=" + clearstride );
   }
   // Make a list of collect actions
   if( theargs.size()>0 ) {
     std::string allcol = getShortcutLabel() + "_" + fixArgumentName( theargs[0]->getName() );
-    for(unsigned i=1; i<theargs.size(); ++i) allcol += "," + getShortcutLabel() + "_" + fixArgumentName( theargs[i]->getName() );
+    for(unsigned i=1; i<theargs.size(); ++i) {
+      allcol += "," + getShortcutLabel() + "_" + fixArgumentName( theargs[i]->getName() );
+    }
     // And transfer everything to a matrix
-    std::string suffix = "_argdata"; if( indices.length()==0 ) suffix = "_data";
+    std::string suffix = "_argdata";
+    if( indices.length()==0 ) {
+      suffix = "_data";
+    }
     readInputLine( getShortcutLabel() + suffix + ": VSTACK ARG=" + allcol );
   }
   // Merge all the collected data together into a single matrix
-  if( theargs.size()>0 && indices.length()>0 ) readInputLine( getShortcutLabel() + "_data: CONCATENATE MATRIX11=" + getShortcutLabel() + "_atomdata MATRIX12=" + getShortcutLabel() + "_argdata");
+  if( theargs.size()>0 && indices.length()>0 ) {
+    readInputLine( getShortcutLabel() + "_data: CONCATENATE MATRIX11=" + getShortcutLabel() + "_atomdata MATRIX12=" + getShortcutLabel() + "_argdata");
+  }
 
   // Now get the logweights
-  std::vector<std::string> logw; parseVector("LOGWEIGHTS",logw); std::vector<Value*> thew;
-  if( logw.size()>0 ) ActionWithArguments::interpretArgumentList( logw, plumed.getActionSet(), this, thew );
-  if( logw.size()>1 ) error("maximum of one argument should be specified for logweights");
+  std::vector<std::string> logw;
+  parseVector("LOGWEIGHTS",logw);
+  std::vector<Value*> thew;
+  if( logw.size()>0 ) {
+    ActionWithArguments::interpretArgumentList( logw, plumed.getActionSet(), this, thew );
+  }
+  if( logw.size()>1 ) {
+    error("maximum of one argument should be specified for logweights");
+  }
 
   if( logw.size()==0 ) {
-    std::string zeros="0"; if( theargs.size()>0 ) { for(unsigned i=1; i<theargs[0]->getNumberOfValues(); ++i) zeros += ",0"; }
+    std::string zeros="0";
+    if( theargs.size()>0 ) {
+      for(unsigned i=1; i<theargs[0]->getNumberOfValues(); ++i) {
+        zeros += ",0";
+      }
+    }
     readInputLine( getShortcutLabel() + "_cweight: CONSTANT VALUE=" + zeros );
     readInputLine( getShortcutLabel() + "_logweights: COLLECT ARG=" + getShortcutLabel() + "_cweight STRIDE=" + stride + " CLEAR=" + clearstride );
   } else {
-    if( theargs[0]->getNumberOfValues()!=thew[0]->getNumberOfValues() ) error("mismatch between number of weights and number of collected arguments");
+    if( theargs[0]->getNumberOfValues()!=thew[0]->getNumberOfValues() ) {
+      error("mismatch between number of weights and number of collected arguments");
+    }
     readInputLine( getShortcutLabel() + "_logweights: COLLECT ARG=" + thew[0]->getName() + " STRIDE=" + stride + " CLEAR=" + clearstride );
   }
   // And finally create a value that contains as many ones as there are data points (this is used if we want to do Classical MDS
diff --git a/src/landmarks/FarthestPointSampling.cpp b/src/landmarks/FarthestPointSampling.cpp
index 119a982cce..700fad7ae7 100644
--- a/src/landmarks/FarthestPointSampling.cpp
+++ b/src/landmarks/FarthestPointSampling.cpp
@@ -42,11 +42,15 @@ class FarthestPointSampling : public matrixtools::MatrixOperationBase {
 public:
   static void registerKeywords( Keywords& keys );
   explicit FarthestPointSampling( const ActionOptions& ao );
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
   void prepare() override ;
   void calculate() override ;
   void apply() override {}
-  double getForceOnMatrixElement( const unsigned& jrow, const unsigned& krow ) const { plumed_merror("this should not be called"); }
+  double getForceOnMatrixElement( const unsigned& jrow, const unsigned& krow ) const {
+    plumed_merror("this should not be called");
+  }
 };
 
 PLUMED_REGISTER_ACTION(FarthestPointSampling,"FARTHEST_POINT_SAMPLING")
@@ -60,37 +64,57 @@ void FarthestPointSampling::registerKeywords( Keywords& keys ) {
 
 FarthestPointSampling::FarthestPointSampling( const ActionOptions& ao ):
   Action(ao),
-  MatrixOperationBase(ao)
-{
-  if( getPntrToArgument(0)->getShape()[0]!=getPntrToArgument(0)->getShape()[1] ) error("input to this argument should be a square matrix of dissimilarities");
-  parse("NZEROS",nlandmarks); parse("SEED",seed);
+  MatrixOperationBase(ao) {
+  if( getPntrToArgument(0)->getShape()[0]!=getPntrToArgument(0)->getShape()[1] ) {
+    error("input to this argument should be a square matrix of dissimilarities");
+  }
+  parse("NZEROS",nlandmarks);
+  parse("SEED",seed);
   log.printf("  selecting %d landmark points \n", nlandmarks );
 
-  std::vector<unsigned> shape(1); shape[0] = getPntrToArgument(0)->getShape()[0];
-  addValue( shape ); setNotPeriodic(); getPntrToComponent(0)->buildDataStore();
+  std::vector<unsigned> shape(1);
+  shape[0] = getPntrToArgument(0)->getShape()[0];
+  addValue( shape );
+  setNotPeriodic();
+  getPntrToComponent(0)->buildDataStore();
 }
 
 void FarthestPointSampling::prepare() {
   Value* myval = getPntrToComponent(0);
   if( myval->getShape()[0]!=getPntrToArgument(0)->getShape()[0] ) {
-    std::vector<unsigned> shape(1); shape[0] = getPntrToArgument(0)->getShape()[0]; myval->setShape(shape);
+    std::vector<unsigned> shape(1);
+    shape[0] = getPntrToArgument(0)->getShape()[0];
+    myval->setShape(shape);
+  }
+  for(unsigned i=0; i<nlandmarks; ++i) {
+    myval->set( i, 0.0 );
+  }
+  for(unsigned i=nlandmarks; i<myval->getShape()[0]; ++i) {
+    myval->set( i, 1.0 );
   }
-  for(unsigned i=0; i<nlandmarks; ++i) myval->set( i, 0.0 );
-  for(unsigned i=nlandmarks; i<myval->getShape()[0]; ++i) myval->set( i, 1.0 );
 }
 
 void FarthestPointSampling::calculate() {
-  Value* myval=getPntrToComponent(0); unsigned npoints = getPntrToArgument(0)->getShape()[0];
-  for(unsigned i=0; i<npoints; ++i) myval->set( i, 1.0 );
+  Value* myval=getPntrToComponent(0);
+  unsigned npoints = getPntrToArgument(0)->getShape()[0];
+  for(unsigned i=0; i<npoints; ++i) {
+    myval->set( i, 1.0 );
+  }
   std::vector<unsigned> landmarks( nlandmarks );
 
   // Select first point at random
-  Random random; random.setSeed(-seed); double rand=random.RandU01();
-  landmarks[0] = std::floor( npoints*rand ); myval->set( landmarks[0], 0 );
+  Random random;
+  random.setSeed(-seed);
+  double rand=random.RandU01();
+  landmarks[0] = std::floor( npoints*rand );
+  myval->set( landmarks[0], 0 );
 
   // Now find distance to all other points (N.B. We can use squared distances here for speed)
-  Matrix<double> distances( nlandmarks, npoints ); Value* myarg = getPntrToArgument(0);
-  for(unsigned i=0; i<npoints; ++i) distances(0,i) = myarg->get( landmarks[0]*npoints + i );
+  Matrix<double> distances( nlandmarks, npoints );
+  Value* myarg = getPntrToArgument(0);
+  for(unsigned i=0; i<npoints; ++i) {
+    distances(0,i) = myarg->get( landmarks[0]*npoints + i );
+  }
 
   // Now find all other landmarks
   for(unsigned i=1; i<nlandmarks; ++i) {
@@ -99,12 +123,19 @@ void FarthestPointSampling::calculate() {
     for(unsigned j=0; j<npoints; ++j) {
       double mind=distances(0,j);
       for(unsigned k=1; k<i; ++k) {
-        if( distances(k,j)<mind ) { mind=distances(k,j); }
+        if( distances(k,j)<mind ) {
+          mind=distances(k,j);
+        }
+      }
+      if( mind>maxd ) {
+        maxd=mind;
+        landmarks[i]=j;
       }
-      if( mind>maxd ) { maxd=mind; landmarks[i]=j; }
     }
     myval->set( landmarks[i], 0 );
-    for(unsigned k=0; k<npoints; ++k) distances(i,k) = myarg->get( landmarks[i]*npoints + k );
+    for(unsigned k=0; k<npoints; ++k) {
+      distances(i,k) = myarg->get( landmarks[i]*npoints + k );
+    }
   }
 }
 
diff --git a/src/landmarks/LandmarkSelection.cpp b/src/landmarks/LandmarkSelection.cpp
index 87214d8596..4358fac406 100644
--- a/src/landmarks/LandmarkSelection.cpp
+++ b/src/landmarks/LandmarkSelection.cpp
@@ -78,61 +78,99 @@ void LandmarkSelection::registerKeywords( Keywords& keys ) {
   keys.addOutputComponent("logweights","ARG","the logarithms of the weights of the data points");
   keys.addOutputComponent("rectdissims","DISSIMILARITIES","a rectangular matrix containing the distances between the landmark points and the rest of the points");
   keys.addOutputComponent("sqrdissims","DISSIMILARITIES","a square matrix containing the distances between each pair of landmark points");
-  keys.needsAction("LOGSUMEXP"); keys.needsAction("TRANSPOSE"); keys.needsAction("DISSIMILARITIES");
-  keys.needsAction("ONES"); keys.needsAction("CREATE_MASK"); keys.needsAction("FARTHEST_POINT_SAMPLING");
-  keys.needsAction("SELECT_WITH_MASK"); keys.needsAction("COMBINE"); keys.needsAction("VORONOI");
-  keys.needsAction("MATRIX_PRODUCT"); keys.needsAction("CUSTOM");
+  keys.needsAction("LOGSUMEXP");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("DISSIMILARITIES");
+  keys.needsAction("ONES");
+  keys.needsAction("CREATE_MASK");
+  keys.needsAction("FARTHEST_POINT_SAMPLING");
+  keys.needsAction("SELECT_WITH_MASK");
+  keys.needsAction("COMBINE");
+  keys.needsAction("VORONOI");
+  keys.needsAction("MATRIX_PRODUCT");
+  keys.needsAction("CUSTOM");
 }
 
 LandmarkSelection::LandmarkSelection( const ActionOptions& ao ):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string nlandmarks; parse("NLANDMARKS",nlandmarks); bool novoronoi; parseFlag("NOVORONOI",novoronoi);
-
-  bool nodissims; parseFlag("NODISSIMILARITIES",nodissims);
-  std::string argn, dissims; parse("ARG",argn); parse("DISSIMILARITIES",dissims);
+  ActionShortcut(ao) {
+  std::string nlandmarks;
+  parse("NLANDMARKS",nlandmarks);
+  bool novoronoi;
+  parseFlag("NOVORONOI",novoronoi);
+
+  bool nodissims;
+  parseFlag("NODISSIMILARITIES",nodissims);
+  std::string argn, dissims;
+  parse("ARG",argn);
+  parse("DISSIMILARITIES",dissims);
   if( argn.length()>0 ) {
     ActionShortcut* as = plumed.getActionSet().getShortcutActionWithLabel( argn );
-    if( !as || as->getName()!="COLLECT_FRAMES" ) error("found no COLLECT_FRAMES action with label " + argn );
+    if( !as || as->getName()!="COLLECT_FRAMES" ) {
+      error("found no COLLECT_FRAMES action with label " + argn );
+    }
     // Get the weights
     readInputLine( getShortcutLabel() + "_allweights: LOGSUMEXP ARG=" + argn + "_logweights");
   }
   if( dissims.length()>0 ) {
     ActionWithValue* ds = plumed.getActionSet().selectWithLabel<ActionWithValue*>( dissims );
-    if( (ds->copyOutput(0))->getRank()!=2 ) error("input for dissimilarities shoudl be a matrix");
+    if( (ds->copyOutput(0))->getRank()!=2 ) {
+      error("input for dissimilarities shoudl be a matrix");
+    }
     // Calculate the dissimilarities if the user didn't specify them
   } else if( !nodissims ) {
-    readInputLine( getShortcutLabel() + "_" + argn + "_dataT: TRANSPOSE ARG=" + argn + "_data"); dissims = getShortcutLabel() + "_dissims";
+    readInputLine( getShortcutLabel() + "_" + argn + "_dataT: TRANSPOSE ARG=" + argn + "_data");
+    dissims = getShortcutLabel() + "_dissims";
     readInputLine( getShortcutLabel() + "_dissims: DISSIMILARITIES SQUARED ARG=" + argn + "_data," + getShortcutLabel() + "_" + argn + "_dataT");
   }
   // This deals with a corner case whereby users have a matrix of dissimilarities but no corresponding coordinates for these frames
   if( argn.length()==0 && dissims.size()>0 ) {
     ActionWithValue* ds = plumed.getActionSet().selectWithLabel<ActionWithValue*>( dissims );
-    if( ds->getName()!="CONSTANT" || (ds->copyOutput(0))->getRank()!=2 ) error("set ARG as well as DISSIMILARITIES");
-    std::string size; Tools::convert(  (ds->copyOutput(0))->getShape()[0], size );
+    if( ds->getName()!="CONSTANT" || (ds->copyOutput(0))->getRank()!=2 ) {
+      error("set ARG as well as DISSIMILARITIES");
+    }
+    std::string size;
+    Tools::convert(  (ds->copyOutput(0))->getShape()[0], size );
     readInputLine( getShortcutLabel() + "_allweights: ONES SIZE=" + size );
   }
 
   if( getName()=="LANDMARK_SELECT_STRIDE" ) {
     readInputLine( getShortcutLabel() + "_mask: CREATE_MASK ARG=" + getShortcutLabel() + "_allweights TYPE=stride NZEROS=" + nlandmarks );
   } else if( getName()=="LANDMARK_SELECT_RANDOM" ) {
-    if( argn.length()==0 ) error("must set COLLECT_FRAMES object for landmark selection using ARG keyword");
-    std::string seed; parse("SEED",seed); if( seed.length()>0 ) seed = " SEED=" + seed;
+    if( argn.length()==0 ) {
+      error("must set COLLECT_FRAMES object for landmark selection using ARG keyword");
+    }
+    std::string seed;
+    parse("SEED",seed);
+    if( seed.length()>0 ) {
+      seed = " SEED=" + seed;
+    }
     readInputLine( getShortcutLabel() + "_mask: CREATE_MASK ARG=" + getShortcutLabel() + "_allweights TYPE=random NZEROS=" + nlandmarks + seed );
   } else if( getName()=="LANDMARK_SELECT_FPS" ) {
-    if( dissims.length()==0 ) error("dissimiarities must be defined to use FPS sampling");
-    std::string seed; parse("SEED",seed); if( seed.length()>0 ) seed = " SEED=" + seed;
+    if( dissims.length()==0 ) {
+      error("dissimiarities must be defined to use FPS sampling");
+    }
+    std::string seed;
+    parse("SEED",seed);
+    if( seed.length()>0 ) {
+      seed = " SEED=" + seed;
+    }
     readInputLine( getShortcutLabel() + "_mask: FARTHEST_POINT_SAMPLING ARG=" + dissims + " NZEROS=" + nlandmarks + seed );
   }
 
-  if( argn.length()>0 ) readInputLine( getShortcutLabel() + "_data: SELECT_WITH_MASK ARG=" + argn + "_data ROW_MASK=" + getShortcutLabel() + "_mask");
+  if( argn.length()>0 ) {
+    readInputLine( getShortcutLabel() + "_data: SELECT_WITH_MASK ARG=" + argn + "_data ROW_MASK=" + getShortcutLabel() + "_mask");
+  }
 
-  unsigned nland; Tools::convert( nlandmarks, nland );
+  unsigned nland;
+  Tools::convert( nlandmarks, nland );
   if( dissims.length()>0 ) {
     ActionWithValue* ds = plumed.getActionSet().selectWithLabel<ActionWithValue*>( dissims );
     if( (ds->copyOutput(0))->getShape()[0]==nland ) {
-      if( !novoronoi ) { warning("cannot use voronoi procedure to give weights as not all distances between points are known"); novoronoi=true; }
+      if( !novoronoi ) {
+        warning("cannot use voronoi procedure to give weights as not all distances between points are known");
+        novoronoi=true;
+      }
       readInputLine( getShortcutLabel() + "_sqrdissims: COMBINE ARG=" + dissims + " PERIODIC=NO");
     } else {
       readInputLine( getShortcutLabel() + "_rmask: CREATE_MASK ARG=" + getShortcutLabel() + "_allweights TYPE=nomask");
@@ -148,11 +186,15 @@ LandmarkSelection::LandmarkSelection( const ActionOptions& ao ):
     readInputLine( getShortcutLabel() + "_weights: TRANSPOSE ARG=" + getShortcutLabel() + "_weightsT");
     readInputLine( getShortcutLabel() + "_logweights: CUSTOM ARG=" + getShortcutLabel() + "_weights FUNC=log(x) PERIODIC=NO");
   } else if( argn.length()>0 ) {
-    if( !novoronoi ) warning("cannot use voronoi procedure to give weights to landmark points as DISSIMILARITIES was not set");
+    if( !novoronoi ) {
+      warning("cannot use voronoi procedure to give weights to landmark points as DISSIMILARITIES was not set");
+    }
     readInputLine( getShortcutLabel() + "_logweights: SELECT_WITH_MASK ARG=" + argn + "_logweights MASK=" + getShortcutLabel() + "_mask");
   }
   // Create the vector of ones that is needed by Classical MDS
-  if( argn.length()>0 ) readInputLine( getShortcutLabel() + "_ones: SELECT_WITH_MASK ARG=" + argn + "_ones MASK=" + getShortcutLabel() + "_mask");
+  if( argn.length()>0 ) {
+    readInputLine( getShortcutLabel() + "_ones: SELECT_WITH_MASK ARG=" + argn + "_ones MASK=" + getShortcutLabel() + "_mask");
+  }
 }
 
 }
diff --git a/src/landmarks/LogSumExp.cpp b/src/landmarks/LogSumExp.cpp
index 9423a1e7ac..62bf7a1dbe 100644
--- a/src/landmarks/LogSumExp.cpp
+++ b/src/landmarks/LogSumExp.cpp
@@ -50,16 +50,18 @@ void LogSumExp::registerKeywords( Keywords& keys ) {
   ActionShortcut::registerKeywords( keys );
   keys.add("compulsory","ARG","the vector of logweights that you would like to normalise using the logsumexp trick");
   keys.setValueDescription("the logarithms of the input weights logweights that are computed with the log-sum weights formula");
-  keys.needsAction("HIGHEST"); keys.needsAction("CUSTOM"); keys.needsAction("SUM");
+  keys.needsAction("HIGHEST");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("SUM");
 }
 
 
 LogSumExp::LogSumExp( const ActionOptions& ao ):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Find the argument name
-  std::string argn; parse("ARG",argn);
+  std::string argn;
+  parse("ARG",argn);
   // Find the maximum weight
   readInputLine( getShortcutLabel() + "_maxlogweight: HIGHEST ARG=" + argn );
   readInputLine( getShortcutLabel() + "_maxweight: CUSTOM ARG=" + getShortcutLabel() + "_maxlogweight FUNC=exp(x) PERIODIC=NO");
diff --git a/src/logmfd/LogMFD.cpp b/src/logmfd/LogMFD.cpp
index 1ddc9b561d..9ed5029121 100644
--- a/src/logmfd/LogMFD.cpp
+++ b/src/logmfd/LogMFD.cpp
@@ -585,8 +585,7 @@ LogMFD::LogMFD( const ActionOptions& ao ):
   ffict(getNumberOfArguments(),0.0),
   fict_ave(getNumberOfArguments(),0.0),
   fictValue(getNumberOfArguments(),NULL),
-  vfictValue(getNumberOfArguments(),NULL)
-{
+  vfictValue(getNumberOfArguments(),NULL) {
   backup.fict.resize(getNumberOfArguments(),0.0);
   backup.vfict.resize(getNumberOfArguments(),0.0);
   backup.ffict.resize(getNumberOfArguments(),0.0);
@@ -626,15 +625,13 @@ LogMFD::LogMFD( const ActionOptions& ao ):
     parseVector("WORK",vwork);
     // initial work of this replica
     work = vwork[multi_sim_comm.Get_rank()];
-  }
-  else {
+  } else {
     work = 0.0;
   }
 
   if( kbtpd>=0.0 ) {
     kbtpd *= getKBoltzmann();
-  }
-  else {
+  } else {
     kbtpd = kbt;
   }
 
@@ -646,11 +643,9 @@ LogMFD::LogMFD( const ActionOptions& ao ):
   if(alpha == 0.0 && gamma == 0.0) {
     alpha = 4.0;
     gamma = 1 / alpha;
-  }
-  else if(alpha != 0.0 && gamma == 0.0) {
+  } else if(alpha != 0.0 && gamma == 0.0) {
     gamma = 1 / alpha;
-  }
-  else if(alpha == 0.0 && gamma != 0.0) {
+  } else if(alpha == 0.0 && gamma != 0.0) {
     alpha = 1 / gamma;
   }
 
@@ -660,23 +655,22 @@ LogMFD::LogMFD( const ActionOptions& ao ):
   if( multi_sim_comm.Get_size()>1 ) {
     if( TAMD ) {
       log.printf("TAMD-PD, replica parallel of TAMD, no logarithmic flattening.\n");
-    }
-    else {
+    } else {
       log.printf("LogPD, replica parallel of LogMFD.\n");
     }
     log.printf("number of replica : %d.\n", multi_sim_comm.Get_size() );
-  }
-  else {
+  } else {
     if( TAMD ) {
       log.printf("TAMD, no logarithmic flattening.\n");
-    }
-    else {
+    } else {
       log.printf("LogMFD, logarithmic flattening.\n");
     }
   }
 
   log.printf("  with harmonic force constant      ");
-  for(unsigned i=0; i<kappa.size(); i++) log.printf(" %f",kappa[i]);
+  for(unsigned i=0; i<kappa.size(); i++) {
+    log.printf(" %f",kappa[i]);
+  }
   log.printf("\n");
 
   log.printf("  with interval of cv(ideal) update ");
@@ -702,23 +696,33 @@ LogMFD::LogMFD( const ActionOptions& ao ):
   log.printf("\n");
 
   log.printf("  with mass of cv(ideal)");
-  for(unsigned i=0; i<mfict.size(); i++) log.printf(" %f", mfict[i]);
+  for(unsigned i=0; i<mfict.size(); i++) {
+    log.printf(" %f", mfict[i]);
+  }
   log.printf("\n");
 
   log.printf("  with initial value of cv(ideal)");
-  for(unsigned i=0; i<fict.size(); i++) log.printf(" %f", fict[i]);
+  for(unsigned i=0; i<fict.size(); i++) {
+    log.printf(" %f", fict[i]);
+  }
   log.printf("\n");
 
   log.printf("  with initial velocity of cv(ideal)");
-  for(unsigned i=0; i<vfict.size(); i++) log.printf(" %f", vfict[i]);
+  for(unsigned i=0; i<vfict.size(); i++) {
+    log.printf(" %f", vfict[i]);
+  }
   log.printf("\n");
 
   log.printf("  with maximum value of cv(ideal)    ");
-  for(unsigned i=0; i<fict_max.size(); i++) log.printf(" %f",fict_max[i]);
+  for(unsigned i=0; i<fict_max.size(); i++) {
+    log.printf(" %f",fict_max[i]);
+  }
   log.printf("\n");
 
   log.printf("  with minimum value of cv(ideal)    ");
-  for(unsigned i=0; i<fict_min.size(); i++) log.printf(" %f",fict_min[i]);
+  for(unsigned i=0; i<fict_min.size(); i++) {
+    log.printf(" %f",fict_min[i]);
+  }
   log.printf("\n");
 
   log.printf("  and kbt                           ");
@@ -734,8 +738,7 @@ LogMFD::LogMFD( const ActionOptions& ao ):
       std::string a,b;
       getPntrToArgument(i)->getDomain(a,b);
       componentIsPeriodic(comp,a,b);
-    }
-    else {
+    } else {
       componentIsNotPeriodic(comp);
     }
     fictValue[i] = getPntrToComponent(comp);
@@ -763,7 +766,9 @@ void LogMFD::calculate() {
 
     // set initial values of fictitious variables if they were not specified.
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-      if( fict[i] != -999.0 ) continue; // -999 means no initial values given in plumed.dat
+      if( fict[i] != -999.0 ) {
+        continue;  // -999 means no initial values given in plumed.dat
+      }
 
       // use the collective variables as the initial of the fictitious variable.
       fict[i] = getArgument(i);
@@ -788,8 +793,7 @@ void LogMFD::calculate() {
       const double pot = TAMD ? flog : sgn(flog)*gamma * std::log1p( alpha*fabs(flog) );
       // invariant
       hlog = pot + ekin;
-    }
-    else if(thermostat == "NVT") {
+    } else if(thermostat == "NVT") {
       const double nkt = getNumberOfArguments()*kbt;
       // kinetic energy
       const double ekin = calcEkin();
@@ -799,8 +803,7 @@ void LogMFD::calculate() {
       const double pot = TAMD ? flog : sgn(flog)*gamma * std::log1p( alpha*fabs(flog) );
       // invariant
       hlog = pot + ekin + ekin_bath;
-    }
-    else if(thermostat == "VS") {
+    } else if(thermostat == "VS") {
       // kinetic energy
       const double ekin = calcEkin();
       if( ekin == 0.0 ) { // this means VFICT is not given.
@@ -808,8 +811,7 @@ void LogMFD::calculate() {
         for(unsigned i=0; i<getNumberOfArguments(); ++i) {
           vfict[i] = sqrt(kbt/mfict[i]);
         }
-      }
-      else {
+      } else {
         const double nkt = getNumberOfArguments()*kbt;
         const double svs = sqrt(nkt/ekin/2);
         for(unsigned i=0; i<getNumberOfArguments(); ++i) {
@@ -833,8 +835,7 @@ void LogMFD::calculate() {
       if( multi_sim_comm.Get_size()>1 ) {
         fprintf(outlog, "# LogPD, replica parallel of LogMFD\n");
         fprintf(outlog, "# number of replica : %d\n", multi_sim_comm.Get_size() );
-      }
-      else {
+      } else {
         fprintf(outlog, "# LogMFD\n");
       }
 
@@ -923,7 +924,9 @@ void LogMFD::calculate() {
    bounces back variables, updates free energy, and record logs.
 */
 void LogMFD::update() {
-  if( (getStep()-step_initial)%interval != interval-1 ) return;
+  if( (getStep()-step_initial)%interval != interval-1 ) {
+    return;
+  }
 
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
     backup.fict[i]  =  fict[i];
@@ -975,11 +978,9 @@ void LogMFD::update() {
   // update fictitious variables
   if(thermostat == "NVE") {
     updateNVE();
-  }
-  else if(thermostat == "NVT") {
+  } else if(thermostat == "NVT") {
     updateNVT();
-  }
-  else if(thermostat == "VS") {
+  } else if(thermostat == "VS") {
     updateVS();
   }
 
@@ -1163,8 +1164,7 @@ void LogMFD::calcMeanForce() {
     // here, work is reduced by work_min to avoid all exp(-work/kbt)s disconverge
     if( kbtpd == 0.0 ) {
       weight = work==work_min ? 1.0 : 0.0;
-    }
-    else {
+    } else {
       weight = exp(-(work-work_min)/kbtpd);
     }
 
@@ -1211,15 +1211,12 @@ double LogMFD::calcFlog() {
 
   if (thermostat == "NVE") {
     pot = hlog - ekin;
-  }
-  else if (thermostat == "NVT") {
+  } else if (thermostat == "NVT") {
     const double ekin_bath = 0.5*veta*veta*meta+xeta*nkt;
     pot = hlog - ekin - ekin_bath;
-  }
-  else if (thermostat == "VS") {
+  } else if (thermostat == "VS") {
     pot = phivs;
-  }
-  else {
+  } else {
     pot = 0.0; // never occurs
   }
 
diff --git a/src/main/main.cpp b/src/main/main.cpp
index a73199235a..4ddcf932d7 100644
--- a/src/main/main.cpp
+++ b/src/main/main.cpp
@@ -37,12 +37,20 @@ int main(int argc,char**argv) {
 #ifdef __PLUMED_HAS_MPI
   bool nompi=false;
   for(unsigned iarg=1; iarg<argc; iarg++) {
-    if(!std::strcmp(argv[iarg],"--no-mpi")) nompi=true;
-    if(!std::strcmp(argv[iarg],"--mpi"))    nompi=false;
+    if(!std::strcmp(argv[iarg],"--no-mpi")) {
+      nompi=true;
+    }
+    if(!std::strcmp(argv[iarg],"--mpi")) {
+      nompi=false;
+    }
 // stop at first non-option
-    if(argv[iarg] && argv[iarg][0]!='-') break;
+    if(argv[iarg] && argv[iarg][0]!='-') {
+      break;
+    }
+  }
+  if(!nompi) {
+    MPI_Init(&argc,&argv);
   }
-  if(!nompi) MPI_Init(&argc,&argv);
 #endif
   int ret=0;
 
@@ -65,7 +73,9 @@ int main(int argc,char**argv) {
   }
 
 #ifdef __PLUMED_HAS_MPI
-  if(!nompi) MPI_Finalize();
+  if(!nompi) {
+    MPI_Finalize();
+  }
 #endif
   return ret;
 }
diff --git a/src/mapping/AdaptivePath.cpp b/src/mapping/AdaptivePath.cpp
index 0acce615cf..2ca863c6c0 100644
--- a/src/mapping/AdaptivePath.cpp
+++ b/src/mapping/AdaptivePath.cpp
@@ -95,7 +95,8 @@ class AdaptivePath : public ActionShortcut {
 PLUMED_REGISTER_ACTION(AdaptivePath,"ADAPTIVE_PATH")
 
 void AdaptivePath::registerKeywords( Keywords& keys ) {
-  ActionShortcut::registerKeywords( keys ); Path::registerInputFileKeywords( keys );
+  ActionShortcut::registerKeywords( keys );
+  Path::registerInputFileKeywords( keys );
   keys.add("optional","PROPERTY","read in path coordinates by finding option with this label in remark of pdb frames");
   keys.add("compulsory","FIXED","the positions in the list of input frames of the two path nodes whose positions remain fixed during the path optimization");
   keys.add("compulsory","HALFLIFE","-1","the number of MD steps after which a previously measured path distance weighs only 50 percent in the average. This option may increase convergence by allowing to forget the memory of a bad initial guess path. The default is to set this to infinity");
@@ -105,61 +106,119 @@ void AdaptivePath::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","FMT","%f","the format to use for output files");
   keys.add("compulsory","WSTRIDE","frequency with which to write out the path");
   keys.setValueDescription("the position along and from the adaptive path");
-  keys.needsAction("GEOMETRIC_PATH"); keys.needsAction("AVERAGE_PATH_DISPLACEMENT");
-  keys.needsAction("REPARAMETERIZE_PATH"); keys.needsAction("DUMPPDB");
-  keys.needsAction("PDB2CONSTANT"); keys.needsAction("DISPLACEMENT"); keys.needsAction("CONSTANT");
+  keys.needsAction("GEOMETRIC_PATH");
+  keys.needsAction("AVERAGE_PATH_DISPLACEMENT");
+  keys.needsAction("REPARAMETERIZE_PATH");
+  keys.needsAction("DUMPPDB");
+  keys.needsAction("PDB2CONSTANT");
+  keys.needsAction("DISPLACEMENT");
+  keys.needsAction("CONSTANT");
 }
 
 AdaptivePath::AdaptivePath(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in the arguments
-  std::vector<std::string> argnames; parseVector("ARG",argnames);
-  std::string reference_data, metric, mtype; parse("TYPE", mtype);
-  std::string reference; parse("REFERENCE",reference);
-  FILE* fp=std::fopen(reference.c_str(),"r"); PDB mypdb; if(!fp) error("could not open reference file " + reference );
-  bool do_read=mypdb.readFromFilepointer(fp,false,0.1); if( !do_read ) error("missing file " + reference );
+  std::vector<std::string> argnames;
+  parseVector("ARG",argnames);
+  std::string reference_data, metric, mtype;
+  parse("TYPE", mtype);
+  std::string reference;
+  parse("REFERENCE",reference);
+  FILE* fp=std::fopen(reference.c_str(),"r");
+  PDB mypdb;
+  if(!fp) {
+    error("could not open reference file " + reference );
+  }
+  bool do_read=mypdb.readFromFilepointer(fp,false,0.1);
+  if( !do_read ) {
+    error("missing file " + reference );
+  }
   // Create list of reference configurations that PLUMED will use
   Path::readInputFrames( reference, mtype, argnames, true, this, reference_data );
   // Now get coordinates on spath
-  std::vector<std::string> pnames; parseVector("PROPERTY",pnames); Path::readPropertyInformation( pnames, getShortcutLabel(), reference, this );
+  std::vector<std::string> pnames;
+  parseVector("PROPERTY",pnames);
+  Path::readPropertyInformation( pnames, getShortcutLabel(), reference, this );
   // Create action that computes the geometric path variablesa
-  std::string propstr = getShortcutLabel() + "_ind"; if( pnames.size()>0 ) propstr = pnames[0] + "_ref";
-  if( argnames.size()>0 ) readInputLine( getShortcutLabel() + ": GEOMETRIC_PATH ARG=" + getShortcutLabel() + "_data " + " PROPERTY=" + propstr + " REFERENCE=" + reference_data + " METRIC={DIFFERENCE}");
-  else {
-    std::string num, align_str, displace_str; Tools::convert( mypdb.getOccupancy()[0], align_str ); Tools::convert( mypdb.getBeta()[0], displace_str );
-    for(unsigned j=1; j<mypdb.getAtomNumbers().size(); ++j ) { Tools::convert( mypdb.getOccupancy()[j], num ); align_str += "," + num; Tools::convert( mypdb.getBeta()[0], num ); displace_str += "," + num; }
+  std::string propstr = getShortcutLabel() + "_ind";
+  if( pnames.size()>0 ) {
+    propstr = pnames[0] + "_ref";
+  }
+  if( argnames.size()>0 ) {
+    readInputLine( getShortcutLabel() + ": GEOMETRIC_PATH ARG=" + getShortcutLabel() + "_data " + " PROPERTY=" + propstr + " REFERENCE=" + reference_data + " METRIC={DIFFERENCE}");
+  } else {
+    std::string num, align_str, displace_str;
+    Tools::convert( mypdb.getOccupancy()[0], align_str );
+    Tools::convert( mypdb.getBeta()[0], displace_str );
+    for(unsigned j=1; j<mypdb.getAtomNumbers().size(); ++j ) {
+      Tools::convert( mypdb.getOccupancy()[j], num );
+      align_str += "," + num;
+      Tools::convert( mypdb.getBeta()[0], num );
+      displace_str += "," + num;
+    }
     metric = "RMSD_VECTOR DISPLACEMENT TYPE=" + mtype + " ALIGN=" + align_str + " DISPLACE=" + displace_str;
     readInputLine( getShortcutLabel() + ": GEOMETRIC_PATH ARG=" + getShortcutLabel() + "_data.disp " + " PROPERTY=" +  propstr + " REFERENCE=" + reference_data + " METRIC={" + metric + "} METRIC_COMPONENT=disp");
   }
   // Create the object to accumulate the average path displacements
-  std::string update, halflife; parse("HALFLIFE",halflife); parse("UPDATE",update); std::string refframes = " REFERENCE=" + getShortcutLabel() + "_pos";
-  if( argnames.size()>0 ) readInputLine( getShortcutLabel() + "_disp: AVERAGE_PATH_DISPLACEMENT ARG=" + getShortcutLabel() + "_data HALFLIFE=" + halflife + " CLEAR=" + update + " METRIC={DIFFERENCE} REFERENCE=" + reference_data );
-  else readInputLine( getShortcutLabel() + "_disp: AVERAGE_PATH_DISPLACEMENT ARG=" + getShortcutLabel() + "_data.disp HALFLIFE=" + halflife + " CLEAR=" + update + " METRIC={" + metric + "} METRIC_COMPONENT=disp REFERENCE=" + reference_data );
+  std::string update, halflife;
+  parse("HALFLIFE",halflife);
+  parse("UPDATE",update);
+  std::string refframes = " REFERENCE=" + getShortcutLabel() + "_pos";
+  if( argnames.size()>0 ) {
+    readInputLine( getShortcutLabel() + "_disp: AVERAGE_PATH_DISPLACEMENT ARG=" + getShortcutLabel() + "_data HALFLIFE=" + halflife + " CLEAR=" + update + " METRIC={DIFFERENCE} REFERENCE=" + reference_data );
+  } else {
+    readInputLine( getShortcutLabel() + "_disp: AVERAGE_PATH_DISPLACEMENT ARG=" + getShortcutLabel() + "_data.disp HALFLIFE=" + halflife + " CLEAR=" + update + " METRIC={" + metric + "} METRIC_COMPONENT=disp REFERENCE=" + reference_data );
+  }
 
   // Create the object to update the path
-  std::string fixedn; parse("FIXED",fixedn); std::string component="METRIC_COMPONENT=disp"; if( argnames.size()>0 ) { metric="DIFFERENCE"; component=""; }
-  if( fixedn.length()>0 ) readInputLine("REPARAMETERIZE_PATH DISPLACE_FRAMES=" + getShortcutLabel() + "_disp FIXED=" + fixedn + " STRIDE=" + update + " METRIC={" + metric + "} " + component + " REFERENCE=" + reference_data );
-  else readInputLine("REPARAMETERIZE_PATH DISPLACE_FRAMES=" + getShortcutLabel() + "_disp STRIDE=" + update + " METRIC={" + metric + "} " + component + " REFERENCE=" + reference_data );
+  std::string fixedn;
+  parse("FIXED",fixedn);
+  std::string component="METRIC_COMPONENT=disp";
+  if( argnames.size()>0 ) {
+    metric="DIFFERENCE";
+    component="";
+  }
+  if( fixedn.length()>0 ) {
+    readInputLine("REPARAMETERIZE_PATH DISPLACE_FRAMES=" + getShortcutLabel() + "_disp FIXED=" + fixedn + " STRIDE=" + update + " METRIC={" + metric + "} " + component + " REFERENCE=" + reference_data );
+  } else {
+    readInputLine("REPARAMETERIZE_PATH DISPLACE_FRAMES=" + getShortcutLabel() + "_disp STRIDE=" + update + " METRIC={" + metric + "} " + component + " REFERENCE=" + reference_data );
+  }
 
   // Information for write out
-  std::string wfilename; parse("WFILE",wfilename);
+  std::string wfilename;
+  parse("WFILE",wfilename);
   if( wfilename.length()>0 ) {
     // This just gets the atom numbers for output
     std::string atomstr;
     if( argnames.size()==0 ) {
-      FILE* fp=std::fopen(reference.c_str(),"r"); double fake_unit=0.1; PDB mypdb; bool do_read=mypdb.readFromFilepointer(fp,false,fake_unit);
-      std::string num; Tools::convert( mypdb.getAtomNumbers()[0].serial(), atomstr );
-      for(unsigned j=1; j<mypdb.getAtomNumbers().size(); ++j ) { Tools::convert( mypdb.getAtomNumbers()[j].serial(), num ); atomstr += "," + num; }
+      FILE* fp=std::fopen(reference.c_str(),"r");
+      double fake_unit=0.1;
+      PDB mypdb;
+      bool do_read=mypdb.readFromFilepointer(fp,false,fake_unit);
+      std::string num;
+      Tools::convert( mypdb.getAtomNumbers()[0].serial(), atomstr );
+      for(unsigned j=1; j<mypdb.getAtomNumbers().size(); ++j ) {
+        Tools::convert( mypdb.getAtomNumbers()[j].serial(), num );
+        atomstr += "," + num;
+      }
     }
 
-    if( wfilename.find(".pdb")==std::string::npos ) error("output must be to a pdb file");
-    std::string ofmt, pframes, wstride; parse("WSTRIDE",wstride); parse("FMT",ofmt);
+    if( wfilename.find(".pdb")==std::string::npos ) {
+      error("output must be to a pdb file");
+    }
+    std::string ofmt, pframes, wstride;
+    parse("WSTRIDE",wstride);
+    parse("FMT",ofmt);
     if( argnames.size()>0 ) {
-      std::string argstr = argnames[0]; for(unsigned i=1; i<argnames.size(); ++i) argstr += "," + argnames[i];
+      std::string argstr = argnames[0];
+      for(unsigned i=1; i<argnames.size(); ++i) {
+        argstr += "," + argnames[i];
+      }
       readInputLine("DUMPPDB DESCRIPTION=PATH STRIDE=" + wstride + " FMT=" + ofmt + " FILE=" + wfilename + " ARG=" + reference_data );
-    } else readInputLine("DUMPPDB DESCRIPTION=PATH STRIDE=" + wstride + " FMT=" + ofmt + " FILE=" + wfilename + " ATOMS=" + reference_data + " ATOM_INDICES=" + atomstr );
+    } else {
+      readInputLine("DUMPPDB DESCRIPTION=PATH STRIDE=" + wstride + " FMT=" + ofmt + " FILE=" + wfilename + " ATOMS=" + reference_data + " ATOM_INDICES=" + atomstr );
+    }
   }
   log<<"  Bibliography "<<plumed.cite("Diaz Leines and Ensing, Phys. Rev. Lett. 109, 020601 (2012)")<<"\n";
 }
diff --git a/src/mapping/GeometricPath.cpp b/src/mapping/GeometricPath.cpp
index bdd6d14acd..761f6f96cf 100644
--- a/src/mapping/GeometricPath.cpp
+++ b/src/mapping/GeometricPath.cpp
@@ -44,36 +44,49 @@ class GeometricPath : public ActionWithVector {
   explicit GeometricPath(const ActionOptions&);
   unsigned getNumberOfDerivatives() override ;
   void calculate() override ;
-  void performTask( const unsigned& current, MultiValue& myvals ) const override { plumed_error(); }
+  void performTask( const unsigned& current, MultiValue& myvals ) const override {
+    plumed_error();
+  }
 };
 
 PLUMED_REGISTER_ACTION(GeometricPath,"GEOMETRIC_PATH")
 
 void GeometricPath::registerKeywords(Keywords& keys) {
-  ActionWithVector::registerKeywords(keys); keys.use("ARG");
+  ActionWithVector::registerKeywords(keys);
+  keys.use("ARG");
   PathProjectionCalculator::registerKeywords(keys);
   keys.add("compulsory","PROPERTY","the coordinates we are projecting these points onto");
   keys.addOutputComponent("s","default","the position on the path");
   keys.addOutputComponent("z","default","the distance from the path");
-  keys.needsAction("GEOMETRIC_PATH"); keys.needsAction("PDB2CONSTANT");
+  keys.needsAction("GEOMETRIC_PATH");
+  keys.needsAction("PDB2CONSTANT");
 }
 
 GeometricPath::GeometricPath(const ActionOptions&ao):
   Action(ao),
   ActionWithVector(ao),
-  path_projector(this)
-{
+  path_projector(this) {
   plumed_assert( !actionInChain() );
   // Get the coordinates in the low dimensional space
-  std::vector<std::string> pcoord; parseVector("PROPERTY", pcoord ); std::vector<Value*> theprop;
+  std::vector<std::string> pcoord;
+  parseVector("PROPERTY", pcoord );
+  std::vector<Value*> theprop;
   ActionWithArguments::interpretArgumentList( pcoord, plumed.getActionSet(), this, theprop );
-  if( theprop.size()!=1 ) error("did not find property to project on");
-  if( theprop[0]->getNumberOfValues()!=getPntrToArgument(0)->getShape()[0] ) error("mismatch between number of frames and property of interest");
+  if( theprop.size()!=1 ) {
+    error("did not find property to project on");
+  }
+  if( theprop[0]->getNumberOfValues()!=getPntrToArgument(0)->getShape()[0] ) {
+    error("mismatch between number of frames and property of interest");
+  }
   log.printf("  projecting onto : %s \n", theprop[0]->getName().c_str() );
-  std::vector<Value*> args( getArguments() ); args.push_back( theprop[0] ); requestArguments( args );
+  std::vector<Value*> args( getArguments() );
+  args.push_back( theprop[0] );
+  requestArguments( args );
   // Create the values to store the output
-  addComponentWithDerivatives("s"); componentIsNotPeriodic("s");
-  addComponentWithDerivatives("z"); componentIsNotPeriodic("z");
+  addComponentWithDerivatives("s");
+  componentIsNotPeriodic("s");
+  addComponentWithDerivatives("z");
+  componentIsNotPeriodic("z");
 }
 
 unsigned GeometricPath::getNumberOfDerivatives() {
@@ -81,37 +94,64 @@ unsigned GeometricPath::getNumberOfDerivatives() {
 }
 
 void GeometricPath::calculate() {
-  unsigned k=0, iclose1=0, iclose2=0; double v1v1=0, v3v3=0;
+  unsigned k=0, iclose1=0, iclose2=0;
+  double v1v1=0, v3v3=0;
   unsigned nrows = getPntrToArgument(0)->getShape()[0];
   unsigned ncols = getPntrToArgument(0)->getShape()[1];
   for(unsigned i=0; i<nrows; ++i) {
     double dist = 0;
     for(unsigned j=0; j<ncols; ++j) {
       double tmp = getPntrToArgument(0)->get(k);
-      dist += tmp*tmp; k++;
+      dist += tmp*tmp;
+      k++;
+    }
+    if( i==0 ) {
+      v1v1 = dist;
+      iclose1 = 0;
+    } else if( dist<v1v1 ) {
+      v3v3=v1v1;
+      v1v1=dist;
+      iclose2=iclose1;
+      iclose1=i;
+    } else if( i==1 ) {
+      v3v3=dist;
+      iclose2=1;
+    } else if( dist<v3v3 ) {
+      v3v3=dist;
+      iclose2=i;
     }
-    if( i==0 ) { v1v1 = dist; iclose1 = 0; }
-    else if( dist<v1v1 ) { v3v3=v1v1; v1v1=dist; iclose2=iclose1; iclose1=i; }
-    else if( i==1 ) { v3v3=dist; iclose2=1; }
-    else if( dist<v3v3 ) { v3v3=dist; iclose2=i; }
   }
   // And find third closest point
   int isign = iclose1 - iclose2;
-  if( isign>1 ) isign=1; else if( isign<-1 ) isign=-1;
+  if( isign>1 ) {
+    isign=1;
+  } else if( isign<-1 ) {
+    isign=-1;
+  }
   int iclose3 = iclose1 + isign;
-  unsigned ifrom=iclose1, ito=iclose3; if( iclose3<0 || iclose3>=nrows ) { ifrom=iclose2; ito=iclose1; }
+  unsigned ifrom=iclose1, ito=iclose3;
+  if( iclose3<0 || iclose3>=nrows ) {
+    ifrom=iclose2;
+    ito=iclose1;
+  }
 
   // And calculate projection of vector connecting current point to closest frame on vector connecting nearest two frames
-  std::vector<double> displace; path_projector.getDisplaceVector( ifrom, ito, displace );
-  double v2v2=0, v1v2=0; k=ncols*iclose1;
-  for(unsigned i=0; i<displace.size(); ++i) { v2v2 += displace[i]*displace[i]; v1v2 += displace[i]*getPntrToArgument(0)->get(k+i); }
+  std::vector<double> displace;
+  path_projector.getDisplaceVector( ifrom, ito, displace );
+  double v2v2=0, v1v2=0;
+  k=ncols*iclose1;
+  for(unsigned i=0; i<displace.size(); ++i) {
+    v2v2 += displace[i]*displace[i];
+    v1v2 += displace[i]*getPntrToArgument(0)->get(k+i);
+  }
 
   // This computes s value
   double spacing = getPntrToArgument(1)->get(iclose1) - getPntrToArgument(1)->get(iclose2);
   double root = sqrt( v1v2*v1v2 - v2v2 * ( v1v1 - v3v3) );
   double dx = 0.5 * ( (root + v1v2) / v2v2 - 1.);
   double path_s = getPntrToArgument(1)->get(iclose1) + spacing * dx;
-  Value* sp = getPntrToComponent(0); sp->set( path_s );
+  Value* sp = getPntrToComponent(0);
+  sp->set( path_s );
   if( !doNotCalculateDerivatives() ) {
     for(unsigned i=0; i<ncols; ++i) {
       sp->addDerivative( ncols*iclose1 + i, 0.5*spacing*(v1v2*displace[i]/v2v2 - getPntrToArgument(0)->get(ncols*iclose1 + i))/root + 0.5*spacing*displace[i]/v2v2 );
@@ -120,10 +160,17 @@ void GeometricPath::calculate() {
   }
 
   // This computes z value
-  path_projector.getDisplaceVector( iclose2, iclose1, displace ); double v4v4=0, proj=0; k=ncols*iclose1;
-  for(unsigned i=0; i<displace.size(); ++i) { v4v4 += displace[i]*displace[i]; proj += displace[i]*getPntrToArgument(0)->get(k+i); }
-  double path_z = v1v1 + dx*dx*v4v4 - 2*dx*proj; path_z = sqrt(path_z);
-  Value* zp = getPntrToComponent(1); zp->set( path_z );
+  path_projector.getDisplaceVector( iclose2, iclose1, displace );
+  double v4v4=0, proj=0;
+  k=ncols*iclose1;
+  for(unsigned i=0; i<displace.size(); ++i) {
+    v4v4 += displace[i]*displace[i];
+    proj += displace[i]*getPntrToArgument(0)->get(k+i);
+  }
+  double path_z = v1v1 + dx*dx*v4v4 - 2*dx*proj;
+  path_z = sqrt(path_z);
+  Value* zp = getPntrToComponent(1);
+  zp->set( path_z );
   if( !doNotCalculateDerivatives() ) {
     for(unsigned i=0; i<ncols; ++i) {
       zp->addDerivative( ncols*iclose1 + i, (1/path_z)*(getPntrToArgument(0)->get(ncols*iclose1 + i) +
diff --git a/src/mapping/GeometricPathShortcut.cpp b/src/mapping/GeometricPathShortcut.cpp
index beecdea35c..ac7d58438d 100644
--- a/src/mapping/GeometricPathShortcut.cpp
+++ b/src/mapping/GeometricPathShortcut.cpp
@@ -45,31 +45,58 @@ class GeometricPathShortcut : public ActionShortcut {
 PLUMED_REGISTER_ACTION(GeometricPathShortcut,"GPATH")
 
 void GeometricPathShortcut::registerKeywords( Keywords& keys ) {
-  ActionShortcut::registerKeywords( keys ); Path::registerInputFileKeywords( keys );
+  ActionShortcut::registerKeywords( keys );
+  Path::registerInputFileKeywords( keys );
   keys.add("optional","PROPERTY","read in path coordinates by finding option with this label in remark of pdb frames");
   keys.addOutputComponent("s","default","the position on the path");
   keys.addOutputComponent("z","default","the distance from the path");
-  keys.needsAction("DISPLACEMENT"); keys.needsAction("GEOMETRIC_PATH"); keys.needsAction("PDB2CONSTANT"); keys.needsAction("CONSTANT");
+  keys.needsAction("DISPLACEMENT");
+  keys.needsAction("GEOMETRIC_PATH");
+  keys.needsAction("PDB2CONSTANT");
+  keys.needsAction("CONSTANT");
 }
 
 GeometricPathShortcut::GeometricPathShortcut( const ActionOptions& ao ):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string mtype, reference_data; std::vector<std::string> argnames; parseVector("ARG",argnames); parse("TYPE", mtype);
+  ActionShortcut(ao) {
+  std::string mtype, reference_data;
+  std::vector<std::string> argnames;
+  parseVector("ARG",argnames);
+  parse("TYPE", mtype);
   // Create list of reference configurations that PLUMED will use
-  std::string reference; parse("REFERENCE",reference);
-  FILE* fp=std::fopen(reference.c_str(),"r"); PDB mypdb; if(!fp) error("could not open reference file " + reference );
-  bool do_read=mypdb.readFromFilepointer(fp,false,0.1); if( !do_read ) error("missing file " + reference );
+  std::string reference;
+  parse("REFERENCE",reference);
+  FILE* fp=std::fopen(reference.c_str(),"r");
+  PDB mypdb;
+  if(!fp) {
+    error("could not open reference file " + reference );
+  }
+  bool do_read=mypdb.readFromFilepointer(fp,false,0.1);
+  if( !do_read ) {
+    error("missing file " + reference );
+  }
   Path::readInputFrames( reference, mtype, argnames, true, this, reference_data );
   // Now get coordinates on spath
-  std::vector<std::string> pnames; parseVector("PROPERTY",pnames); Path::readPropertyInformation( pnames, getShortcutLabel(), reference, this );
+  std::vector<std::string> pnames;
+  parseVector("PROPERTY",pnames);
+  Path::readPropertyInformation( pnames, getShortcutLabel(), reference, this );
   // Create action that computes the geometric path variablesa
-  std::string propstr = getShortcutLabel() + "_ind"; if( pnames.size()>0 ) propstr = pnames[0] + "_ref";
-  if( argnames.size()>0 ) readInputLine( getShortcutLabel() + ": GEOMETRIC_PATH ARG=" + getShortcutLabel() + "_data " + " PROPERTY=" + propstr + " REFERENCE=" + reference_data + " METRIC={DIFFERENCE}");
-  else {
-    std::string num, align_str, displace_str; Tools::convert( mypdb.getOccupancy()[0], align_str ); Tools::convert( mypdb.getBeta()[0], displace_str );
-    for(unsigned j=1; j<mypdb.getAtomNumbers().size(); ++j ) { Tools::convert( mypdb.getOccupancy()[j], num ); align_str += "," + num; Tools::convert( mypdb.getBeta()[0], num ); displace_str += "," + num; }
+  std::string propstr = getShortcutLabel() + "_ind";
+  if( pnames.size()>0 ) {
+    propstr = pnames[0] + "_ref";
+  }
+  if( argnames.size()>0 ) {
+    readInputLine( getShortcutLabel() + ": GEOMETRIC_PATH ARG=" + getShortcutLabel() + "_data " + " PROPERTY=" + propstr + " REFERENCE=" + reference_data + " METRIC={DIFFERENCE}");
+  } else {
+    std::string num, align_str, displace_str;
+    Tools::convert( mypdb.getOccupancy()[0], align_str );
+    Tools::convert( mypdb.getBeta()[0], displace_str );
+    for(unsigned j=1; j<mypdb.getAtomNumbers().size(); ++j ) {
+      Tools::convert( mypdb.getOccupancy()[j], num );
+      align_str += "," + num;
+      Tools::convert( mypdb.getBeta()[0], num );
+      displace_str += "," + num;
+    }
     std::string metric = "RMSD_VECTOR DISPLACEMENT TYPE=" + mtype + " ALIGN=" + align_str + " DISPLACE=" + displace_str;
     readInputLine( getShortcutLabel() + ": GEOMETRIC_PATH ARG=" + getShortcutLabel() + "_data.disp " + " PROPERTY=" +  propstr + " REFERENCE=" + reference_data + " METRIC={" + metric + "} METRIC_COMPONENT=disp");
   }
diff --git a/src/mapping/PCAVars.cpp b/src/mapping/PCAVars.cpp
index 8d8637670e..8a83236ea7 100644
--- a/src/mapping/PCAVars.cpp
+++ b/src/mapping/PCAVars.cpp
@@ -185,55 +185,99 @@ void PCAVars::registerKeywords( Keywords& keys ) {
   keys.addFlag("NOPBC",false,"do not use periodic boundary conditions when computing this quantity");
   keys.addOutputComponent("eig","default","the projections on the eigenvalues");
   keys.addOutputComponent("residual","default","the residual distance that is not projected on any of the eigenvalues");
-  keys.needsAction("RMSD"); keys.needsAction("PDB2CONSTANT"); keys.needsAction("TRANSPOSE");
-  keys.needsAction("EUCLIDEAN_DISTANCE"); keys.needsAction("CONCATENATE"); keys.needsAction("COMBINE"); keys.needsAction("CONSTANT");
-  keys.needsAction("COMBINE"); keys.needsAction("MATRIX_VECTOR_PRODUCT"); keys.needsAction("CUSTOM"); keys.needsAction("SUM");
+  keys.needsAction("RMSD");
+  keys.needsAction("PDB2CONSTANT");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("EUCLIDEAN_DISTANCE");
+  keys.needsAction("CONCATENATE");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("COMBINE");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("SUM");
   keys.needsAction("SELECT_COMPONENTS");
 }
 
 PCAVars::PCAVars( const ActionOptions& ao ):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string reference; parse("REFERENCE",reference);
+  ActionShortcut(ao) {
+  std::string reference;
+  parse("REFERENCE",reference);
   // Create the object that holds the atomic positions by reading the first frame
-  FILE* fp=std::fopen(reference.c_str(),"r"); PDB pdb; if(!fp) error("could not open reference file " + reference );
-  bool do_read=pdb.readFromFilepointer(fp,false,0.1); if( !do_read ) plumed_merror("missing file " + reference );
-  std::string mtype; parse("TYPE",mtype);
+  FILE* fp=std::fopen(reference.c_str(),"r");
+  PDB pdb;
+  if(!fp) {
+    error("could not open reference file " + reference );
+  }
+  bool do_read=pdb.readFromFilepointer(fp,false,0.1);
+  if( !do_read ) {
+    plumed_merror("missing file " + reference );
+  }
+  std::string mtype;
+  parse("TYPE",mtype);
 
   if( pdb.getPositions().size()>0 ) {
     // And now create the rmsd object
     std::string rmsd_line =  getShortcutLabel() + "_at: RMSD DISPLACEMENT SQUARED NUMBER=1 REFERENCE=" + reference;
-    bool nopbc; parseFlag("NOPBC",nopbc); if(nopbc) rmsd_line += " NOPBC";
+    bool nopbc;
+    parseFlag("NOPBC",nopbc);
+    if(nopbc) {
+      rmsd_line += " NOPBC";
+    }
     // Now create the RMSD object
     readInputLine( rmsd_line + " TYPE=" + mtype );
   }
-  std::vector<std::string> argnames; parseVector("ARG",argnames); unsigned nargs=0; std::string instargs, refargs; std::vector<Value*> theargs;
-  if( argnames.size()>0 ) ActionWithArguments::interpretArgumentList( argnames, plumed.getActionSet(), this, theargs );
+  std::vector<std::string> argnames;
+  parseVector("ARG",argnames);
+  unsigned nargs=0;
+  std::string instargs, refargs;
+  std::vector<Value*> theargs;
+  if( argnames.size()>0 ) {
+    ActionWithArguments::interpretArgumentList( argnames, plumed.getActionSet(), this, theargs );
+  }
   for(unsigned i=0; i<theargs.size(); ++i) {
-    std::string iargn = Path::fixArgumentName( theargs[i]->getName() ); nargs += theargs[i]->getNumberOfValues();
+    std::string iargn = Path::fixArgumentName( theargs[i]->getName() );
+    nargs += theargs[i]->getNumberOfValues();
     if( theargs[i]->getNumberOfValues()>1 ) {
       readInputLine( getShortcutLabel() + "_ref_" + iargn + "T: PDB2CONSTANT NUMBER=1 REFERENCE=" + reference + " ARG=" + theargs[i]->getName() );
       readInputLine( getShortcutLabel() + "_ref_" + iargn + ": TRANSPOSE ARG=" + getShortcutLabel() + "_ref_" + iargn + "T");
-    } else readInputLine( getShortcutLabel() + "_ref_" + iargn + ": PDB2CONSTANT NUMBER=1 REFERENCE=" + reference + " ARG=" + theargs[i]->getName() );
-    if( i==0 ) { instargs=" ARG1=" + theargs[i]->getName(); refargs=" ARG2=" + getShortcutLabel() + "_ref_" + iargn; }
-    else { instargs +="," + theargs[i]->getName(); refargs +="," + getShortcutLabel() + "_ref_" + iargn; }
+    } else {
+      readInputLine( getShortcutLabel() + "_ref_" + iargn + ": PDB2CONSTANT NUMBER=1 REFERENCE=" + reference + " ARG=" + theargs[i]->getName() );
+    }
+    if( i==0 ) {
+      instargs=" ARG1=" + theargs[i]->getName();
+      refargs=" ARG2=" + getShortcutLabel() + "_ref_" + iargn;
+    } else {
+      instargs +="," + theargs[i]->getName();
+      refargs +="," + getShortcutLabel() + "_ref_" + iargn;
+    }
+  }
+  if( theargs.size()>0 ) {
+    readInputLine( getShortcutLabel() + "_argdist: EUCLIDEAN_DISTANCE SQUARED" + instargs + refargs );
   }
-  if( theargs.size()>0 ) readInputLine( getShortcutLabel() + "_argdist: EUCLIDEAN_DISTANCE SQUARED" + instargs + refargs );
   if( pdb.getPositions().size()>0 && theargs.size()>0 ) {
     readInputLine( getShortcutLabel() + ": CONCATENATE ARG=" + getShortcutLabel() + "_at.disp," + getShortcutLabel() + "_argdist_diffT");
     readInputLine( getShortcutLabel() + "_dist: COMBINE ARG=" + getShortcutLabel() + "_at.dist," + getShortcutLabel() + "_argdist PERIODIC=NO");
   }
 
   // Get the displace stuff
-  std::vector<double> displace( pdb.getBeta() ); double dtot = 0;
-  for(unsigned i=0; i<displace.size(); ++i) dtot += displace[i];
-  for(unsigned i=0; i<displace.size(); ++i) displace[i] = displace[i] / dtot;
+  std::vector<double> displace( pdb.getBeta() );
+  double dtot = 0;
+  for(unsigned i=0; i<displace.size(); ++i) {
+    dtot += displace[i];
+  }
+  for(unsigned i=0; i<displace.size(); ++i) {
+    displace[i] = displace[i] / dtot;
+  }
 
   // Now read in the directions and create matheval objects to compute the pca components
-  unsigned nfram=0, ncomp=0; std::string pvec;
+  unsigned nfram=0, ncomp=0;
+  std::string pvec;
   while( do_read ) {
-    std::vector<double> argdir(nargs); PDB mypdb; do_read=mypdb.readFromFilepointer(fp,plumed.usingNaturalUnits(),0.1/plumed.getUnits().getLength());
+    std::vector<double> argdir(nargs);
+    PDB mypdb;
+    do_read=mypdb.readFromFilepointer(fp,plumed.usingNaturalUnits(),0.1/plumed.getUnits().getLength());
     if( do_read ) {
       nfram++;
       // Normalize the eigenvector in the input
@@ -246,10 +290,17 @@ PCAVars::PCAVars( const ActionOptions& ao ):
       unsigned k=0;
       for(unsigned i=0; i<theargs.size(); ++i) {
         std::vector<double> argval( theargs[i]->getNumberOfValues() );
-        if( !mypdb.getArgumentValue(theargs[i]->getName(), argval) ) error("argument " + theargs[i]->getName() + " was not set in pdb input");
-        for(unsigned j=0; j<argval.size(); ++j) { argdir[k] = argval[j]; norm += argdir[k]*argdir[k]; k++; }
+        if( !mypdb.getArgumentValue(theargs[i]->getName(), argval) ) {
+          error("argument " + theargs[i]->getName() + " was not set in pdb input");
+        }
+        for(unsigned j=0; j<argval.size(); ++j) {
+          argdir[k] = argval[j];
+          norm += argdir[k]*argdir[k];
+          k++;
+        }
       }
-      norm = sqrt( norm ); std::vector<double> normed_coeffs( 3*mypdb.getPositions().size() );
+      norm = sqrt( norm );
+      std::vector<double> normed_coeffs( 3*mypdb.getPositions().size() );
       for(unsigned i=0; i<mypdb.getPositions().size(); ++i) {
         if( mtype=="SIMPLE" ) {
           normed_coeffs[0*mypdb.getPositions().size()+i] = mypdb.getPositions()[i][0] / norm;
@@ -263,35 +314,63 @@ PCAVars::PCAVars( const ActionOptions& ao ):
       }
       std::string coeff1;
       if( mypdb.getPositions().size()>0 ) {
-        if( nfram==1 ) Tools::convert( normed_coeffs[0], pvec );
-        else { Tools::convert( normed_coeffs[0], coeff1 ); pvec += "," + coeff1; }
+        if( nfram==1 ) {
+          Tools::convert( normed_coeffs[0], pvec );
+        } else {
+          Tools::convert( normed_coeffs[0], coeff1 );
+          pvec += "," + coeff1;
+        }
         for(unsigned i=1; i<normed_coeffs.size(); ++i) {
           Tools::convert( normed_coeffs[i], coeff1 );
           pvec += "," + coeff1;
         }
-        for(unsigned i=0; i<argdir.size(); ++i) { Tools::convert( argdir[i] / norm, coeff1 ); pvec += "," + coeff1; }
+        for(unsigned i=0; i<argdir.size(); ++i) {
+          Tools::convert( argdir[i] / norm, coeff1 );
+          pvec += "," + coeff1;
+        }
       } else if( theargs.size()>0 ) {
-        if( nfram==1 ) Tools::convert( argdir[0] / norm, pvec );
-        else { Tools::convert( argdir[0] / norm, coeff1 ); pvec += "," + coeff1; }
-        for(unsigned i=1; i<argdir.size(); ++i) { Tools::convert( argdir[i] / norm, coeff1 ); pvec += "," + coeff1; }
+        if( nfram==1 ) {
+          Tools::convert( argdir[0] / norm, pvec );
+        } else {
+          Tools::convert( argdir[0] / norm, coeff1 );
+          pvec += "," + coeff1;
+        }
+        for(unsigned i=1; i<argdir.size(); ++i) {
+          Tools::convert( argdir[i] / norm, coeff1 );
+          pvec += "," + coeff1;
+        }
       }
       ncomp = 3*mypdb.getPositions().size() + nargs;
-    } else { break; }
+    } else {
+      break;
+    }
   }
-  std::fclose(fp); std::string neig, ncols; Tools::convert( nfram, neig ); Tools::convert( ncomp, ncols );
+  std::fclose(fp);
+  std::string neig, ncols;
+  Tools::convert( nfram, neig );
+  Tools::convert( ncomp, ncols );
   readInputLine( getShortcutLabel() + "_peig: CONSTANT VALUES=" + pvec + " NROWS=" + neig + " NCOLS=" + ncols );
-  if( pdb.getPositions().size()>0 && theargs.size()>0 ) readInputLine( getShortcutLabel() + "_eig: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_peig," + getShortcutLabel() );
-  else if( pdb.getPositions().size()>0 ) readInputLine( getShortcutLabel() + "_eig: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_peig," + getShortcutLabel() + "_at.disp");
-  else if( theargs.size()>0 ) readInputLine( getShortcutLabel() + "_eig: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_peig," + getShortcutLabel() + "_argdist_diffT");
+  if( pdb.getPositions().size()>0 && theargs.size()>0 ) {
+    readInputLine( getShortcutLabel() + "_eig: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_peig," + getShortcutLabel() );
+  } else if( pdb.getPositions().size()>0 ) {
+    readInputLine( getShortcutLabel() + "_eig: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_peig," + getShortcutLabel() + "_at.disp");
+  } else if( theargs.size()>0 ) {
+    readInputLine( getShortcutLabel() + "_eig: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_peig," + getShortcutLabel() + "_argdist_diffT");
+  }
   for(unsigned i=0; i<nfram; ++i) {
-    std::string num; Tools::convert( i+1, num );
+    std::string num;
+    Tools::convert( i+1, num );
     readInputLine( getShortcutLabel() + "_eig-" + num + ": SELECT_COMPONENTS ARG=" + getShortcutLabel() + "_eig COMPONENTS=" + num );
   }
   readInputLine( getShortcutLabel() + "_eig2: CUSTOM ARG=" + getShortcutLabel() + "_eig FUNC=x*x PERIODIC=NO");
   readInputLine( getShortcutLabel() + "_eigsum2: SUM ARG=" +  getShortcutLabel() + "_eig2 PERIODIC=NO");
-  if( pdb.getPositions().size()>0 && theargs.size()>0 ) readInputLine( getShortcutLabel() + "_residual: CUSTOM ARG=" + getShortcutLabel() + "_dist," + getShortcutLabel() + "_eigsum2 FUNC=sqrt(x-y) PERIODIC=NO");
-  else if( pdb.getPositions().size()>0 ) readInputLine( getShortcutLabel() + "_residual: CUSTOM ARG=" + getShortcutLabel() + "_at.dist," + getShortcutLabel() + "_eigsum2 FUNC=sqrt(x-y) PERIODIC=NO");
-  else if( theargs.size()>0 ) readInputLine( getShortcutLabel() + "_residual: CUSTOM ARG=" + getShortcutLabel() + "_argdist," + getShortcutLabel() + "_eigsum2 FUNC=sqrt(x-y) PERIODIC=NO");
+  if( pdb.getPositions().size()>0 && theargs.size()>0 ) {
+    readInputLine( getShortcutLabel() + "_residual: CUSTOM ARG=" + getShortcutLabel() + "_dist," + getShortcutLabel() + "_eigsum2 FUNC=sqrt(x-y) PERIODIC=NO");
+  } else if( pdb.getPositions().size()>0 ) {
+    readInputLine( getShortcutLabel() + "_residual: CUSTOM ARG=" + getShortcutLabel() + "_at.dist," + getShortcutLabel() + "_eigsum2 FUNC=sqrt(x-y) PERIODIC=NO");
+  } else if( theargs.size()>0 ) {
+    readInputLine( getShortcutLabel() + "_residual: CUSTOM ARG=" + getShortcutLabel() + "_argdist," + getShortcutLabel() + "_eigsum2 FUNC=sqrt(x-y) PERIODIC=NO");
+  }
 }
 
 }
diff --git a/src/mapping/Path.cpp b/src/mapping/Path.cpp
index aab10ade2f..9f5e345c70 100644
--- a/src/mapping/Path.cpp
+++ b/src/mapping/Path.cpp
@@ -209,7 +209,8 @@ PLUMED_REGISTER_ACTION(Path,"PATH")
 PLUMED_REGISTER_ACTION(Path,"GPROPERTYMAP")
 
 void Path::registerKeywords( Keywords& keys ) {
-  ActionShortcut::registerKeywords( keys ); Path::registerInputFileKeywords( keys );
+  ActionShortcut::registerKeywords( keys );
+  Path::registerInputFileKeywords( keys );
   keys.add("optional","PROPERTY","the property to be used in the index. This should be in the REMARK of the reference");
   keys.add("compulsory","LAMBDA","the lambda parameter is needed for smoothing, is in the units of plumed");
   keys.addOutputComponent("gspath","GPATH","the position along the path calculated using the geometric formula");
@@ -229,34 +230,57 @@ void Path::registerInputFileKeywords( Keywords& keys ) {
   keys.addFlag("NOSPATH",false,"do not calculate the spath CV");
   keys.addFlag("NOZPATH",false,"do not calculate the zpath CV");
   keys.addFlag("GPATH",false,"calculate the trigonometric path");
-  keys.needsAction("DRMSD"); keys.needsAction("RMSD"); keys.needsAction("LOWEST"); keys.needsAction("GPATH");
-  keys.needsAction("EUCLIDEAN_DISTANCE"); keys.needsAction("CUSTOM"); keys.needsAction("SUM"); keys.needsAction("COMBINE");
-  keys.needsAction("NORMALIZED_EUCLIDEAN_DISTANCE"); keys.needsAction("PDB2CONSTANT"); keys.needsAction("CONSTANT");
+  keys.needsAction("DRMSD");
+  keys.needsAction("RMSD");
+  keys.needsAction("LOWEST");
+  keys.needsAction("GPATH");
+  keys.needsAction("EUCLIDEAN_DISTANCE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("SUM");
+  keys.needsAction("COMBINE");
+  keys.needsAction("NORMALIZED_EUCLIDEAN_DISTANCE");
+  keys.needsAction("PDB2CONSTANT");
+  keys.needsAction("CONSTANT");
 }
 
 Path::Path( const ActionOptions& ao ):
   Action(ao),
-  ActionShortcut(ao)
-{
-  bool nospath, nozpath, gpath; parseFlag("NOSPATH",nospath); parseFlag("NOZPATH",nozpath); parseFlag("GPATH",gpath);
+  ActionShortcut(ao) {
+  bool nospath, nozpath, gpath;
+  parseFlag("NOSPATH",nospath);
+  parseFlag("NOZPATH",nozpath);
+  parseFlag("GPATH",gpath);
   if( gpath ) {
     readInputLine( getShortcutLabel() + "_gpath: GPATH " + convertInputLineToString() );
     readInputLine( getShortcutLabel() + "_gspath: COMBINE ARG=" + getShortcutLabel() + "_gpath.s PERIODIC=NO");
     readInputLine( getShortcutLabel() + "_gzpath: COMBINE ARG=" + getShortcutLabel() + "_gpath.z PERIODIC=NO");
   }
-  if( nospath && nozpath ) return;
+  if( nospath && nozpath ) {
+    return;
+  }
   // Setup the properties
   std::vector<std::string> properties, pnames;
-  if( getName()=="PATH") { properties.resize(1); }
-  else { parseVector("PROPERTY",pnames); properties.resize( pnames.size() ); }
-  std::string type, reference_data, reference; parse("REFERENCE",reference);
-  std::vector<std::string> argnames; parseVector("ARG",argnames); parse("TYPE",type);
-  if( type.find("DRMSD")!=std::string::npos ) readInputLine( getShortcutLabel() + "_data: DRMSD SQUARED TYPE=" + type + " REFERENCE=" + reference );
-  else readInputFrames( reference, type, argnames, false, this, reference_data );
+  if( getName()=="PATH") {
+    properties.resize(1);
+  } else {
+    parseVector("PROPERTY",pnames);
+    properties.resize( pnames.size() );
+  }
+  std::string type, reference_data, reference;
+  parse("REFERENCE",reference);
+  std::vector<std::string> argnames;
+  parseVector("ARG",argnames);
+  parse("TYPE",type);
+  if( type.find("DRMSD")!=std::string::npos ) {
+    readInputLine( getShortcutLabel() + "_data: DRMSD SQUARED TYPE=" + type + " REFERENCE=" + reference );
+  } else {
+    readInputFrames( reference, type, argnames, false, this, reference_data );
+  }
   // Find the shortest distance to the frames
   readInputLine( getShortcutLabel() + "_mindist: LOWEST ARG=" + getShortcutLabel() + "_data");
   // Now create all other parts of the calculation
-  std::string lambda; parse("LAMBDA",lambda);
+  std::string lambda;
+  parse("LAMBDA",lambda);
   // Now create MATHEVAL object to compute exponential functions
   readInputLine( getShortcutLabel() + "_weights: CUSTOM ARG=" + getShortcutLabel() + "_data," + getShortcutLabel() + "_mindist FUNC=exp(-(x-y)*" + lambda + ") PERIODIC=NO" );
   // Create denominator
@@ -284,48 +308,86 @@ Path::Path( const ActionOptions& ao ):
 }
 
 std::string Path::fixArgumentName( const std::string& argin ) {
-  std::string argout = argin; std::size_t dot=argin.find(".");
-  if( dot!=std::string::npos ) argout = argin.substr(0,dot) + "_" + argin.substr(dot+1);
+  std::string argout = argin;
+  std::size_t dot=argin.find(".");
+  if( dot!=std::string::npos ) {
+    argout = argin.substr(0,dot) + "_" + argin.substr(dot+1);
+  }
   return argout;
 }
 
 void Path::readInputFrames( const std::string& reference, const std::string& type, std::vector<std::string>& argnames, const bool& displacements, ActionShortcut* action, std::string& reference_data ) {
-  FILE* fp=std::fopen(reference.c_str(),"r"); PDB pdb; if(!fp) action->error("could not open reference file " + reference );
-  bool do_read=pdb.readFromFilepointer(fp,false,0.1); if( !do_read ) action->error("missing file " + reference );
+  FILE* fp=std::fopen(reference.c_str(),"r");
+  PDB pdb;
+  if(!fp) {
+    action->error("could not open reference file " + reference );
+  }
+  bool do_read=pdb.readFromFilepointer(fp,false,0.1);
+  if( !do_read ) {
+    action->error("missing file " + reference );
+  }
   if( pdb.getPositions().size()!=0 && argnames.size()==0 ) {
     reference_data = action->getShortcutLabel() + "_data_ref";
-    if( displacements ) action->readInputLine( action->getShortcutLabel() + "_data: RMSD DISPLACEMENT SQUARED REFERENCE=" + reference + " TYPE=" + type );
-    else action->readInputLine( action->getShortcutLabel() + "_data: RMSD SQUARED REFERENCE=" + reference + " TYPE=" + type );
+    if( displacements ) {
+      action->readInputLine( action->getShortcutLabel() + "_data: RMSD DISPLACEMENT SQUARED REFERENCE=" + reference + " TYPE=" + type );
+    } else {
+      action->readInputLine( action->getShortcutLabel() + "_data: RMSD SQUARED REFERENCE=" + reference + " TYPE=" + type );
+    }
   } else if( pdb.getPositions().size()!=0 ) {
     reference_data = action->getShortcutLabel() + "_atomdata_ref";
-    if( displacements ) action->readInputLine( action->getShortcutLabel() + "_atomdata: RMSD DISPLACEMENT SQUARED REFERENCE=" + reference + " TYPE=" + type );
-    else action->readInputLine( action->getShortcutLabel() + "_atomdata: RMSD SQUARED REFERENCE=" + reference + " TYPE=" + type );
+    if( displacements ) {
+      action->readInputLine( action->getShortcutLabel() + "_atomdata: RMSD DISPLACEMENT SQUARED REFERENCE=" + reference + " TYPE=" + type );
+    } else {
+      action->readInputLine( action->getShortcutLabel() + "_atomdata: RMSD SQUARED REFERENCE=" + reference + " TYPE=" + type );
+    }
   } else if( argnames.size()==0 ) {
     argnames.resize( pdb.getArgumentNames().size() );
-    for(unsigned i=0; i<argnames.size(); ++i) argnames[i] = pdb.getArgumentNames()[i];
+    for(unsigned i=0; i<argnames.size(); ++i) {
+      argnames[i] = pdb.getArgumentNames()[i];
+    }
+  }
+  std::vector<Value*> theargs;
+  if( argnames.size()>0 ) {
+    ActionWithArguments::interpretArgumentList( argnames, action->plumed.getActionSet(), action, theargs );
   }
-  std::vector<Value*> theargs; if( argnames.size()>0 ) ActionWithArguments::interpretArgumentList( argnames, action->plumed.getActionSet(), action, theargs );
 
   if( theargs.size()>0 ) {
     std::string instargs, refargs;
     for(unsigned i=0; i<theargs.size(); ++i) {
       std::string iargn = fixArgumentName( theargs[i]->getName() );
       action->readInputLine( action->getShortcutLabel() + "_ref_" + iargn + ": PDB2CONSTANT REFERENCE=" + reference + " ARG=" + theargs[i]->getName() );
-      if( i==0 ) { instargs=" ARG1=" + theargs[i]->getName(); refargs=" ARG2=" + action->getShortcutLabel() + "_ref_" + iargn; }
-      else { instargs +="," + theargs[i]->getName(); refargs +="," + action->getShortcutLabel() + "_ref_" + iargn; }
-      if( pdb.getPositions().size()==0 && i==0 ) reference_data = action->getShortcutLabel() + "_ref_" + iargn;
-      else reference_data += "," + action->getShortcutLabel() + "_ref_" + iargn;
+      if( i==0 ) {
+        instargs=" ARG1=" + theargs[i]->getName();
+        refargs=" ARG2=" + action->getShortcutLabel() + "_ref_" + iargn;
+      } else {
+        instargs +="," + theargs[i]->getName();
+        refargs +="," + action->getShortcutLabel() + "_ref_" + iargn;
+      }
+      if( pdb.getPositions().size()==0 && i==0 ) {
+        reference_data = action->getShortcutLabel() + "_ref_" + iargn;
+      } else {
+        reference_data += "," + action->getShortcutLabel() + "_ref_" + iargn;
+      }
     }
-    std::string comname="EUCLIDEAN_DISTANCE SQUARED"; std::string coeffstr; action->parse("COEFFICIENTS",coeffstr);
+    std::string comname="EUCLIDEAN_DISTANCE SQUARED";
+    std::string coeffstr;
+    action->parse("COEFFICIENTS",coeffstr);
     if( coeffstr.length()>0 ) {
-      if( displacements ) action->error("cannot use COEFFICIENTS arguments with GEOMETRIC PATH");
+      if( displacements ) {
+        action->error("cannot use COEFFICIENTS arguments with GEOMETRIC PATH");
+      }
       action->readInputLine( action->getShortcutLabel() + "_coeff: CONSTANT VALUES=" + coeffstr );
       action->readInputLine( action->getShortcutLabel() + "_coeff2: CUSTOM ARG=" + action->getShortcutLabel() + "_coeff FUNC=x*x PERIODIC=NO");
       comname = "NORMALIZED_EUCLIDEAN_DISTANCE SQUARED METRIC=" + action->getShortcutLabel() + "_coeff2";
-    } else if( displacements ) comname = "DISPLACEMENT";
+    } else if( displacements ) {
+      comname = "DISPLACEMENT";
+    }
 
-    if( pdb.getPositions().size()==0 ) action->readInputLine( action->getShortcutLabel() + "_data: " + comname + instargs + refargs );
-    else action->readInputLine( action->getShortcutLabel() + "_argdata: " + comname + instargs + refargs );
+    if( pdb.getPositions().size()==0 ) {
+      action->readInputLine( action->getShortcutLabel() + "_data: " + comname + instargs + refargs );
+    } else {
+      action->readInputLine( action->getShortcutLabel() + "_argdata: " + comname + instargs + refargs );
+    }
   }
 }
 
@@ -337,8 +399,13 @@ void Path::readPropertyInformation( const std::vector<std::string>& pnames, cons
     }
   } else {
     ActionWithValue* av=action->plumed.getActionSet().selectWithLabel<ActionWithValue*>( lab + "_data" );
-    unsigned nfram = av->copyOutput(0)->getShape()[0]; std::string indices = "VALUES=1";
-    for(unsigned i=1; i<nfram; ++i) { std::string num; Tools::convert( i+1, num ); indices += "," + num; }
+    unsigned nfram = av->copyOutput(0)->getShape()[0];
+    std::string indices = "VALUES=1";
+    for(unsigned i=1; i<nfram; ++i) {
+      std::string num;
+      Tools::convert( i+1, num );
+      indices += "," + num;
+    }
     action->readInputLine( lab + "_ind: CONSTANT " + indices );
   }
 }
diff --git a/src/mapping/PathDisplacements.cpp b/src/mapping/PathDisplacements.cpp
index a202dd8f77..1ddaef3fcd 100644
--- a/src/mapping/PathDisplacements.cpp
+++ b/src/mapping/PathDisplacements.cpp
@@ -59,8 +59,12 @@ class PathDisplacements : public ActionWithValue, public ActionPilot, public Act
 PLUMED_REGISTER_ACTION(PathDisplacements,"AVERAGE_PATH_DISPLACEMENT")
 
 void PathDisplacements::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys ); ActionPilot::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.use("ARG"); PathProjectionCalculator::registerKeywords( keys );
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionPilot::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  keys.use("ARG");
+  PathProjectionCalculator::registerKeywords( keys );
   keys.add("compulsory","STRIDE","1","the frequency with which the average displacements should be collected and added to the average displacements");
   keys.add("compulsory","HALFLIFE","-1","the number of MD steps after which a previously measured path distance weighs only 50 percent in the average. This option may increase convergence by allowing to forget the memory of a bad initial guess path. The default is to set this to infinity");
   keys.add("compulsory","CLEAR","0","the frequency with which to clear all the accumulated data.  The default value "
@@ -74,30 +78,42 @@ PathDisplacements::PathDisplacements(const ActionOptions& ao):
   ActionPilot(ao),
   ActionWithArguments(ao),
   clearnextstep(false),
-  path_projector(this)
-{
+  path_projector(this) {
   // Read in clear instructions
   parse("CLEAR",clearstride);
   if( clearstride>0 ) {
-    if( clearstride%getStride()!=0 ) error("CLEAR parameter must be a multiple of STRIDE");
+    if( clearstride%getStride()!=0 ) {
+      error("CLEAR parameter must be a multiple of STRIDE");
+    }
     log.printf("  clearing average every %u steps \n",clearstride);
   }
-  double halflife; parse("HALFLIFE",halflife);
+  double halflife;
+  parse("HALFLIFE",halflife);
   log.printf("  weight of contribution to frame halves every %f steps \n",halflife);
-  if( halflife<0 ) fadefact=1.0;
-  else fadefact = exp( -0.693147180559945 / static_cast<double>(halflife) );
+  if( halflife<0 ) {
+    fadefact=1.0;
+  } else {
+    fadefact = exp( -0.693147180559945 / static_cast<double>(halflife) );
+  }
   // Now create the weights vector and displacements matrix
   unsigned nrows = getPntrToArgument(0)->getShape()[0];
   unsigned ncols = getPntrToArgument(0)->getShape()[1];
-  wsum.resize( nrows ); displacements.resize( nrows, ncols );
+  wsum.resize( nrows );
+  displacements.resize( nrows, ncols );
   for(unsigned i=0; i<nrows; ++i) {
-    wsum[i]=0; for(unsigned j=0; j<ncols; ++j) displacements(i,j)=0;
+    wsum[i]=0;
+    for(unsigned j=0; j<ncols; ++j) {
+      displacements(i,j)=0;
+    }
   }
   // Add bibliography
   log<<"  Bibliography "<<plumed.cite("Diaz Leines and Ensing, Phys. Rev. Lett. 109, 020601 (2012)")<<"\n";
   // And create a value to hold the displacements
-  std::vector<unsigned> shape(2); shape[0]=nrows; shape[1]=ncols;
-  addValue( shape ); setNotPeriodic();
+  std::vector<unsigned> shape(2);
+  shape[0]=nrows;
+  shape[1]=ncols;
+  addValue( shape );
+  setNotPeriodic();
   getPntrToComponent(0)->buildDataStore();
   getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
 }
@@ -113,64 +129,105 @@ void PathDisplacements::update() {
   if( clearnextstep ) {
     unsigned k=0;
     for(unsigned i=0; i<nrows; ++i) {
-      for(unsigned j=0; j<ncols; ++j) { displacements(i,j)=0; getPntrToComponent(0)->set(k,0); k++; }
+      for(unsigned j=0; j<ncols; ++j) {
+        displacements(i,j)=0;
+        getPntrToComponent(0)->set(k,0);
+        k++;
+      }
     }
     clearnextstep=false;
   }
 
-  unsigned k=0, iclose1=0, iclose2=0; double v1v1=0, v3v3=0;
+  unsigned k=0, iclose1=0, iclose2=0;
+  double v1v1=0, v3v3=0;
   for(unsigned i=0; i<nrows; ++i) {
     double dist = 0;
     for(unsigned j=0; j<ncols; ++j) {
       double tmp = getPntrToArgument(0)->get(k);
-      dist += tmp*tmp; k++;
+      dist += tmp*tmp;
+      k++;
+    }
+    if( i==0 ) {
+      v1v1 = dist;
+      iclose1 = 0;
+    } else if( dist<v1v1 ) {
+      v3v3=v1v1;
+      v1v1=dist;
+      iclose2=iclose1;
+      iclose1=i;
+    } else if( i==1 ) {
+      v3v3=dist;
+      iclose2=1;
+    } else if( dist<v3v3 ) {
+      v3v3=dist;
+      iclose2=i;
     }
-    if( i==0 ) { v1v1 = dist; iclose1 = 0; }
-    else if( dist<v1v1 ) { v3v3=v1v1; v1v1=dist; iclose2=iclose1; iclose1=i; }
-    else if( i==1 ) { v3v3=dist; iclose2=1; }
-    else if( dist<v3v3 ) { v3v3=dist; iclose2=i; }
   }
   // And find third closest point
   int isign = iclose1 - iclose2;
-  if( isign>1 ) isign=1; else if( isign<-1 ) isign=-1;
+  if( isign>1 ) {
+    isign=1;
+  } else if( isign<-1 ) {
+    isign=-1;
+  }
   int iclose3 = iclose1 + isign;
-  unsigned ifrom=iclose1, ito=iclose3; if( iclose3<0 || iclose3>=nrows ) { ifrom=iclose2; ito=iclose1; }
+  unsigned ifrom=iclose1, ito=iclose3;
+  if( iclose3<0 || iclose3>=nrows ) {
+    ifrom=iclose2;
+    ito=iclose1;
+  }
 
   // Calculate the dot product of v1 with v2
   path_projector.getDisplaceVector( ifrom, ito, displace_v );
-  double v2v2=0, v1v2=0; unsigned kclose1 = iclose1*ncols;
-  for(unsigned i=0; i<displace_v.size(); ++i) { v2v2 += displace_v[i]*displace_v[i]; v1v2 += displace_v[i]*getPntrToArgument(0)->get(kclose1+i); }
+  double v2v2=0, v1v2=0;
+  unsigned kclose1 = iclose1*ncols;
+  for(unsigned i=0; i<displace_v.size(); ++i) {
+    v2v2 += displace_v[i]*displace_v[i];
+    v1v2 += displace_v[i]*getPntrToArgument(0)->get(kclose1+i);
+  }
 
   double root = sqrt( v1v2*v1v2 - v2v2 * ( v1v1 - v3v3) );
   double dx = 0.5 * ( (root + v1v2) / v2v2 - 1.);
-  double weight2 = -1.* dx; double weight1 = 1.0 + dx;
+  double weight2 = -1.* dx;
+  double weight1 = 1.0 + dx;
   if( weight1>1.0 ) {
-    weight1=1.0; weight2=0.0;
+    weight1=1.0;
+    weight2=0.0;
   } else if( weight2>1.0 ) {
-    weight1=0.0; weight2=1.0;
+    weight1=0.0;
+    weight2=1.0;
   }
 
   // Accumulate displacements for path
   for(unsigned i=0; i<ncols; ++i) {
     double displace = getPntrToArgument(0)->get(kclose1+i) - dx*displace_v[i];
-    displacements(iclose1,i) += weight1 * displace; displacements(iclose2,i) += weight2 * displace;
+    displacements(iclose1,i) += weight1 * displace;
+    displacements(iclose2,i) += weight2 * displace;
   }
 
   // Update weight accumulators
-  wsum[iclose1] *= fadefact; wsum[iclose2] *= fadefact;
-  wsum[iclose1] += weight1; wsum[iclose2] += weight2;
+  wsum[iclose1] *= fadefact;
+  wsum[iclose2] *= fadefact;
+  wsum[iclose1] += weight1;
+  wsum[iclose2] += weight2;
 
   // Update numbers in values
   if( wsum[iclose1] > epsilon ) {
-    for(unsigned i=0; i<ncols; ++i) getPntrToComponent(0)->set( kclose1+i, displacements(iclose1,i) / wsum[iclose1] );
+    for(unsigned i=0; i<ncols; ++i) {
+      getPntrToComponent(0)->set( kclose1+i, displacements(iclose1,i) / wsum[iclose1] );
+    }
   }
   if( wsum[iclose2] > epsilon ) {
     unsigned kclose2 = iclose2*ncols;
-    for(unsigned i=0; i<ncols; ++i) getPntrToComponent(0)->set( kclose2+i, displacements(iclose2,i) / wsum[iclose2] );
+    for(unsigned i=0; i<ncols; ++i) {
+      getPntrToComponent(0)->set( kclose2+i, displacements(iclose2,i) / wsum[iclose2] );
+    }
   }
 
   // Clear if required
-  if( (getStep()>0 && clearstride>0 && getStep()%clearstride==0) ) clearnextstep=true;
+  if( (getStep()>0 && clearstride>0 && getStep()%clearstride==0) ) {
+    clearnextstep=true;
+  }
 }
 
 }
diff --git a/src/mapping/PathProjectionCalculator.cpp b/src/mapping/PathProjectionCalculator.cpp
index fe22867246..80eab7ed8a 100644
--- a/src/mapping/PathProjectionCalculator.cpp
+++ b/src/mapping/PathProjectionCalculator.cpp
@@ -36,66 +36,115 @@ void PathProjectionCalculator::registerKeywords(Keywords& keys) {
 }
 
 PathProjectionCalculator::PathProjectionCalculator( Action* act ):
-  mypath_obj(NULL)
-{
+  mypath_obj(NULL) {
   ActionWithArguments* aarg=dynamic_cast<ActionWithArguments*>( act );
   if( aarg ) {
     mypath_obj = aarg->getPntrToArgument(0);
     // Check that we have only one argument as input
-    if( aarg->getNumberOfArguments()!=1 ) act->error("should only have one argument to this function");
+    if( aarg->getNumberOfArguments()!=1 ) {
+      act->error("should only have one argument to this function");
+    }
   }
   // Ensure that values are stored in base calculation and that PLUMED doesn't try to calculate this in the stream
-  if( mypath_obj ) mypath_obj->buildDataStore();
+  if( mypath_obj ) {
+    mypath_obj->buildDataStore();
+  }
   // Check that the input is a matrix
-  if( mypath_obj ) if( mypath_obj->getRank()!=2 ) act->error("the input to this action should be a matrix");
+  if( mypath_obj )
+    if( mypath_obj->getRank()!=2 ) {
+      act->error("the input to this action should be a matrix");
+    }
   // Get the labels for the reference points
-  std::vector<std::string> reference_data; act->parseVector("REFERENCE", reference_data);
+  std::vector<std::string> reference_data;
+  act->parseVector("REFERENCE", reference_data);
   std::vector<colvar::RMSDVector*> allrmsd = act->plumed.getActionSet().select<colvar::RMSDVector*>();
   ActionWithArguments::interpretArgumentList( reference_data, act->plumed.getActionSet(), act, refargs );
   for(unsigned i=0; i<refargs.size(); ++i ) {
     Action* thisact = refargs[i]->getPntrToAction();
     for(unsigned j=0; j<allrmsd.size(); ++j) {
-      if( allrmsd[j]->checkForDependency(thisact) ) { rmsd_objects.push_back( allrmsd[j] ); break; }
+      if( allrmsd[j]->checkForDependency(thisact) ) {
+        rmsd_objects.push_back( allrmsd[j] );
+        break;
+      }
+    }
+    if( !refargs[i]->isConstant() ) {
+      act->error("input" + refargs[i]->getName() + " is not constant");
+    }
+    if( refargs[i]->getRank()==2 && reference_data.size()!=1 ) {
+      act->error("should only be one matrix in input to path projection object");
+    }
+    if( refargs[i]->getRank()>0 && refargs[i]->getShape()[0]!=refargs[0]->getShape()[0] ) {
+      act->error("mismatch in number of reference frames in input to reference_data");
     }
-    if( !refargs[i]->isConstant() ) act->error("input" + refargs[i]->getName() + " is not constant");
-    if( refargs[i]->getRank()==2 && reference_data.size()!=1 ) act->error("should only be one matrix in input to path projection object");
-    if( refargs[i]->getRank()>0 && refargs[i]->getShape()[0]!=refargs[0]->getShape()[0] ) act->error("mismatch in number of reference frames in input to reference_data");
   }
   // Create a plumed main object to compute distances between reference configurations
   int s=sizeof(double);
   metric.cmd("setRealPrecision",&s);
   metric.cmd("setMDEngine","plumed");
-  int nat=0; metric.cmd("setNatoms",&nat); metric.cmd("setNoVirial");
-  unsigned nargs=refargs.size(); if( refargs[0]->getRank()==2 ) nargs = refargs[0]->getShape()[1];
-  std::string str_nargs; Tools::convert( nargs, str_nargs ); std::string period_str=" PERIODIC=NO";
-  if( mypath_obj && mypath_obj->isPeriodic() ) { std::string min, max; mypath_obj->getDomain( min, max ); period_str=" PERIODIC=" + min + "," + max; }
+  int nat=0;
+  metric.cmd("setNatoms",&nat);
+  metric.cmd("setNoVirial");
+  unsigned nargs=refargs.size();
+  if( refargs[0]->getRank()==2 ) {
+    nargs = refargs[0]->getShape()[1];
+  }
+  std::string str_nargs;
+  Tools::convert( nargs, str_nargs );
+  std::string period_str=" PERIODIC=NO";
+  if( mypath_obj && mypath_obj->isPeriodic() ) {
+    std::string min, max;
+    mypath_obj->getDomain( min, max );
+    period_str=" PERIODIC=" + min + "," + max;
+  }
   metric.readInputLine("arg1: PUT UNIT=number SHAPE=" + str_nargs + period_str, true);
   metric.readInputLine("arg2: PUT UNIT=number SHAPE=" + str_nargs + period_str, true);
-  double tstep=1.0; metric.cmd("setTimestep",&tstep);
-  std::string inp; act->parse("METRIC",inp); inp += " ARG=arg2,arg1"; const char* cinp=inp.c_str();
+  double tstep=1.0;
+  metric.cmd("setTimestep",&tstep);
+  std::string inp;
+  act->parse("METRIC",inp);
+  inp += " ARG=arg2,arg1";
+  const char* cinp=inp.c_str();
   std::vector<std::string> input=Tools::getWords(inp);
   if( input.size()==1 && !actionRegister().check(input[0]) ) {
-    metric.cmd("setPlumedDat",cinp); metric.cmd("init");
+    metric.cmd("setPlumedDat",cinp);
+    metric.cmd("init");
   } else {
-    metric.cmd("init"); metric.cmd("readInputLine",cinp);
+    metric.cmd("init");
+    metric.cmd("readInputLine",cinp);
   }
   // Now setup stuff to retrieve the final displacement
   unsigned aind = metric.getActionSet().size()-1;
   while( true ) {
     const ActionShortcut* as=dynamic_cast<const ActionShortcut*>( metric.getActionSet()[aind].get() );
-    if( !as ) break ; aind = aind - 1; plumed_assert( aind>=0 );
+    if( !as ) {
+      break ;
+    }
+    aind = aind - 1;
+    plumed_assert( aind>=0 );
   }
   ActionWithValue* fav = dynamic_cast<ActionWithValue*>( metric.getActionSet()[aind].get() );
-  if( !fav ) act->error("final value should calculate relevant value that you want as reference");
+  if( !fav ) {
+    act->error("final value should calculate relevant value that you want as reference");
+  }
   std::string name = (fav->copyOutput(0))->getName();
   if( fav->getNumberOfComponents()>1 ) {
-    std::string comp; act->parse("METRIC_COMPONENT",comp); name = fav->getLabel() + "." + comp;
+    std::string comp;
+    act->parse("METRIC_COMPONENT",comp);
+    name = fav->getLabel() + "." + comp;
   }
-  long rank; metric.cmd("getDataRank " + name, &rank );
-  if( rank==0 ) rank=1;
-  std::vector<long> ishape( rank ); metric.cmd("getDataShape " + name, &ishape[0] );
-  unsigned nvals=1; for(unsigned i=0; i<ishape.size(); ++i) nvals *= ishape[i];
-  data.resize( nvals ); metric.cmd("setMemoryForData " + name, &data[0] );
+  long rank;
+  metric.cmd("getDataRank " + name, &rank );
+  if( rank==0 ) {
+    rank=1;
+  }
+  std::vector<long> ishape( rank );
+  metric.cmd("getDataShape " + name, &ishape[0] );
+  unsigned nvals=1;
+  for(unsigned i=0; i<ishape.size(); ++i) {
+    nvals *= ishape[i];
+  }
+  data.resize( nvals );
+  metric.cmd("setMemoryForData " + name, &data[0] );
 }
 
 unsigned PathProjectionCalculator::getNumberOfFrames() const {
@@ -103,39 +152,58 @@ unsigned PathProjectionCalculator::getNumberOfFrames() const {
 }
 
 void PathProjectionCalculator::computeVectorBetweenFrames( const unsigned& ifrom, const unsigned& ito ) {
-  int step = 1; metric.cmd("setStep",&step);
+  int step = 1;
+  metric.cmd("setStep",&step);
   std::vector<double> valdata1( data.size() ), valdata2( data.size() );
-  getReferenceConfiguration( ito, valdata2 ); getReferenceConfiguration( ifrom, valdata1 );
+  getReferenceConfiguration( ito, valdata2 );
+  getReferenceConfiguration( ifrom, valdata1 );
   metric.cmd("setValue arg1", &valdata1[0] );
   metric.cmd("setValue arg2", &valdata2[0] );
   metric.cmd("calc");
 }
 
 void PathProjectionCalculator::getDisplaceVector( const unsigned& ifrom, const unsigned& ito, std::vector<double>& displace ) {
-  if( displace.size()!=data.size() ) displace.resize( data.size() );
-  computeVectorBetweenFrames( ifrom, ito ); for(unsigned i=0; i<data.size(); ++i) displace[i] = data[i];
+  if( displace.size()!=data.size() ) {
+    displace.resize( data.size() );
+  }
+  computeVectorBetweenFrames( ifrom, ito );
+  for(unsigned i=0; i<data.size(); ++i) {
+    displace[i] = data[i];
+  }
 }
 
 void PathProjectionCalculator::getReferenceConfiguration( const unsigned& iframe, std::vector<double>& refpos ) const {
-  if( refpos.size()!=data.size() ) refpos.resize( data.size() );
+  if( refpos.size()!=data.size() ) {
+    refpos.resize( data.size() );
+  }
   if( refargs[0]->getRank()==2 ) {
-    for(unsigned i=0; i<refpos.size(); ++i) refpos[i] = refargs[0]->get( iframe*refpos.size() + i );
+    for(unsigned i=0; i<refpos.size(); ++i) {
+      refpos[i] = refargs[0]->get( iframe*refpos.size() + i );
+    }
   } else {
-    for(unsigned i=0; i<refpos.size(); ++i) refpos[i] = refargs[i]->get(iframe);
+    for(unsigned i=0; i<refpos.size(); ++i) {
+      refpos[i] = refargs[i]->get(iframe);
+    }
   }
 }
 
 void PathProjectionCalculator::setReferenceConfiguration( const unsigned& iframe, std::vector<double>& refpos ) {
   plumed_dbg_assert( refpos.size()==data.size() );
   if( refargs[0]->getRank()==2 ) {
-    for(unsigned i=0; i<refpos.size(); ++i) refargs[0]->set( iframe*refpos.size() + i, refpos[i] );
+    for(unsigned i=0; i<refpos.size(); ++i) {
+      refargs[0]->set( iframe*refpos.size() + i, refpos[i] );
+    }
   } else {
-    for(unsigned i=0; i<refpos.size(); ++i) refargs[i]->set( iframe, refpos[i] );
+    for(unsigned i=0; i<refpos.size(); ++i) {
+      refargs[i]->set( iframe, refpos[i] );
+    }
   }
 }
 
 void PathProjectionCalculator::updateDepedentRMSDObjects() {
-  for(unsigned i=0; i<rmsd_objects.size(); ++i) rmsd_objects[i]->setReferenceConfigurations();
+  for(unsigned i=0; i<rmsd_objects.size(); ++i) {
+    rmsd_objects[i]->setReferenceConfigurations();
+  }
 }
 
 }
diff --git a/src/mapping/PathReparameterization.cpp b/src/mapping/PathReparameterization.cpp
index d4f46f4d91..cde590dbd9 100644
--- a/src/mapping/PathReparameterization.cpp
+++ b/src/mapping/PathReparameterization.cpp
@@ -73,7 +73,8 @@ class PathReparameterization : public ActionPilot {
 PLUMED_REGISTER_ACTION(PathReparameterization,"REPARAMETERIZE_PATH")
 
 void PathReparameterization::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionPilot::registerKeywords( keys );
+  Action::registerKeywords( keys );
+  ActionPilot::registerKeywords( keys );
   PathProjectionCalculator::registerKeywords(keys);
   keys.add("compulsory","STRIDE","1","the frequency with which to reparameterize the path");
   keys.add("compulsory","FIXED","0","the frames in the path to fix");
@@ -87,40 +88,60 @@ PathReparameterization::PathReparameterization(const ActionOptions&ao):
   Action(ao),
   ActionPilot(ao),
   displace_value(NULL),
-  path_projector(this)
-{
-  parse("MAXCYLES",maxcycles); parse("TOL",TOL);
+  path_projector(this) {
+  parse("MAXCYLES",maxcycles);
+  parse("TOL",TOL);
   log.printf("  running till change is less than %f or until there have been %d optimization cycles \n", TOL, maxcycles);
-  len.resize( path_projector.getNumberOfFrames()  ); sumlen.resize( path_projector.getNumberOfFrames() ); sfrac.resize( path_projector.getNumberOfFrames() );
-  std::vector<unsigned> fixed; parseVector("FIXED",fixed);
+  len.resize( path_projector.getNumberOfFrames()  );
+  sumlen.resize( path_projector.getNumberOfFrames() );
+  sfrac.resize( path_projector.getNumberOfFrames() );
+  std::vector<unsigned> fixed;
+  parseVector("FIXED",fixed);
   if( fixed.size()==1 ) {
-    if( fixed[0]!=0 ) error("input to FIXED should be two integers");
-    ifix1=0; ifix2=path_projector.getNumberOfFrames()-1;
+    if( fixed[0]!=0 ) {
+      error("input to FIXED should be two integers");
+    }
+    ifix1=0;
+    ifix2=path_projector.getNumberOfFrames()-1;
   } else if( fixed.size()==2 ) {
     if( fixed[0]<1 || fixed[1]<1 || fixed[0]>path_projector.getNumberOfFrames() || fixed[1]>path_projector.getNumberOfFrames() ) {
       error("input to FIXED should be two numbers between 1 and the number of frames");
     }
-    ifix1=fixed[0]-1; ifix2=fixed[1]-1;
-  } else error("input to FIXED should be two integers");
+    ifix1=fixed[0]-1;
+    ifix2=fixed[1]-1;
+  } else {
+    error("input to FIXED should be two integers");
+  }
   log.printf("  fixing frames %d and %d when reparameterizing \n", ifix1, ifix2 );
-  std::string dframe; parse("DISPLACE_FRAMES",dframe);
+  std::string dframe;
+  parse("DISPLACE_FRAMES",dframe);
   if( dframe.length()>0 ) {
     ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( dframe );
-    if( !av ) error("could not find action with label " + dframe + " specified to DISPLACE_FRAMES keyword in input file");
-    if( av->getName()!="AVERAGE_PATH_DISPLACEMENT" ) error("displace object is not of correct type");
+    if( !av ) {
+      error("could not find action with label " + dframe + " specified to DISPLACE_FRAMES keyword in input file");
+    }
+    if( av->getName()!="AVERAGE_PATH_DISPLACEMENT" ) {
+      error("displace object is not of correct type");
+    }
     displace_value = av->copyOutput(0);
   }
 }
 
 bool PathReparameterization::loopEnd( const int& index, const int& end, const int& inc ) const {
-  if( inc>0 && index<end ) return false;
-  else if( inc<0 && index>end ) return false;
+  if( inc>0 && index<end ) {
+    return false;
+  } else if( inc<0 && index>end ) {
+    return false;
+  }
   return true;
 }
 
 double PathReparameterization::computeSpacing( const unsigned& ifrom, const unsigned& ito ) {
   path_projector.getDisplaceVector( ifrom, ito, data );
-  double length=0; for(unsigned i=0; i<data.size(); ++i) length += data[i]*data[i];
+  double length=0;
+  for(unsigned i=0; i<data.size(); ++i) {
+    length += data[i]*data[i];
+  }
   return sqrt( length );
 }
 
@@ -130,39 +151,56 @@ void PathReparameterization::calcCurrentPathSpacings( const int& istart, const i
   //printf("HELLO PATH SPACINGS ARE CURRENTLY \n");
 
   // Get the spacings given we can go forward and backwards
-  int incr=1; if( istart>iend ) { incr=-1; }
+  int incr=1;
+  if( istart>iend ) {
+    incr=-1;
+  }
 
   for(int i=istart+incr; loopEnd(i,iend+incr,incr)==false; i+=incr) {
-    len[i] = computeSpacing( i-incr, i ); sumlen[i] = sumlen[i-incr] + len[i];
+    len[i] = computeSpacing( i-incr, i );
+    sumlen[i] = sumlen[i-incr] + len[i];
     //printf("FRAME %d TO FRAME %d EQUALS %f : %f \n",i-incr,i,len[i],sumlen[i] );
   }
 }
 
 void PathReparameterization::reparameterizePart( const int& istart, const int& iend, const double& target ) {
-  calcCurrentPathSpacings( istart, iend ); unsigned cfin;
+  calcCurrentPathSpacings( istart, iend );
+  unsigned cfin;
   // If a target separation is set we fix where we want the nodes
-  int incr=1; if( istart>iend ) { incr=-1; }
+  int incr=1;
+  if( istart>iend ) {
+    incr=-1;
+  }
 
   if( target>0 ) {
     if( iend>istart ) {
-      for(unsigned i=istart; i<iend+1; ++i) sfrac[i] = target*(i-istart);
+      for(unsigned i=istart; i<iend+1; ++i) {
+        sfrac[i] = target*(i-istart);
+      }
     } else {
-      for(int i=istart-1; i>iend-1; --i) sfrac[i]=target*(istart-i);
+      for(int i=istart-1; i>iend-1; --i) {
+        sfrac[i]=target*(istart-i);
+      }
     }
     cfin = iend+incr;
   } else {
     cfin = iend;
   }
 
-  double prevsum=0.; Matrix<double> newmatrix( path_projector.getNumberOfFrames(), data.size() );
+  double prevsum=0.;
+  Matrix<double> newmatrix( path_projector.getNumberOfFrames(), data.size() );
   for(unsigned iter=0; iter<maxcycles; ++iter) {
-    if( fabs(sumlen[iend] - prevsum)<=TOL ) break ;
+    if( fabs(sumlen[iend] - prevsum)<=TOL ) {
+      break ;
+    }
     prevsum = sumlen[iend];
     // If no target is set we redistribute length
     if( target<0 ) {
       plumed_assert( istart<iend );
       double dr = sumlen[iend] / static_cast<double>( iend - istart );
-      for(unsigned i=istart; i<iend; ++i) sfrac[i] = dr*(i-istart);
+      for(unsigned i=istart; i<iend; ++i) {
+        sfrac[i] = dr*(i-istart);
+      }
     }
 
     // Now compute positions of new nodes in path
@@ -170,22 +208,34 @@ void PathReparameterization::reparameterizePart( const int& istart, const int& i
       int k = istart;
       while( !((sumlen[k] < sfrac[i]) && (sumlen[k+incr]>=sfrac[i])) ) {
         k+=incr;
-        if( cfin==iend && k>= iend+1 ) plumed_merror("path reparameterization error");
-        else if( cfin==(iend+1) && k>=iend ) { k=iend-1; break; }
-        else if( cfin==(iend-1) && k<=iend ) { k=iend+1; break; }
+        if( cfin==iend && k>= iend+1 ) {
+          plumed_merror("path reparameterization error");
+        } else if( cfin==(iend+1) && k>=iend ) {
+          k=iend-1;
+          break;
+        } else if( cfin==(iend-1) && k<=iend ) {
+          k=iend+1;
+          break;
+        }
       }
       double dr = (sfrac[i]-sumlen[k])/len[k+incr];
       // Copy the reference configuration to the row of a matrix
       path_projector.getReferenceConfiguration( k, data );
-      for(unsigned j=0; j<data.size(); ++j) newmatrix(i,j) = data[j];
+      for(unsigned j=0; j<data.size(); ++j) {
+        newmatrix(i,j) = data[j];
+      }
       path_projector.getDisplaceVector( k, k+incr, data );
       // Shift the reference configuration by this ammount
-      for(unsigned j=0; j<data.size(); ++j) newmatrix(i,j) += dr*data[j];
+      for(unsigned j=0; j<data.size(); ++j) {
+        newmatrix(i,j) += dr*data[j];
+      }
     }
 
     // Copy the positions of the new path to the new paths
     for(int i=istart+incr; loopEnd(i,cfin,incr)==false; i+=incr) {
-      for(unsigned j=0; j<data.size(); ++j) data[j] = newmatrix(i,j);
+      for(unsigned j=0; j<data.size(); ++j) {
+        data[j] = newmatrix(i,j);
+      }
       path_projector.setReferenceConfiguration( i, data );
     }
 
@@ -196,17 +246,23 @@ void PathReparameterization::reparameterizePart( const int& istart, const int& i
 
 void PathReparameterization::update() {
   // We never run this on the first step
-  if( getStep()==0 ) return ;
+  if( getStep()==0 ) {
+    return ;
+  }
 
   // Shift the frames using the displacements
   if( displace_value ) {
     for(unsigned i=0; i<path_projector.getNumberOfFrames(); ++i) {
-      if( i==ifix1 || i==ifix2 ) continue ;
+      if( i==ifix1 || i==ifix2 ) {
+        continue ;
+      }
       // Retrieve the current position of the frame
       path_projector.getReferenceConfiguration( i, data );
       // Shift using the averages accumulated in the action that accumulates the displacements
       unsigned kstart = i*data.size();
-      for(unsigned j=0; j<data.size(); ++j) data[j] += displace_value->get( kstart + j );
+      for(unsigned j=0; j<data.size(); ++j) {
+        data[j] += displace_value->get( kstart + j );
+      }
       // And now set the new position of the refernce frame
       path_projector.setReferenceConfiguration( i, data );
     }
@@ -219,8 +275,12 @@ void PathReparameterization::update() {
   double target = sumlen[ifix2] / ( ifix2 - ifix1 );
 
   // And reparameterize the begining and end of the path
-  if( ifix1>0 ) reparameterizePart( ifix1, 0, target );
-  if( ifix2<(path_projector.getNumberOfFrames()-1) ) reparameterizePart( ifix2, path_projector.getNumberOfFrames()-1, target );
+  if( ifix1>0 ) {
+    reparameterizePart( ifix1, 0, target );
+  }
+  if( ifix2<(path_projector.getNumberOfFrames()-1) ) {
+    reparameterizePart( ifix2, path_projector.getNumberOfFrames()-1, target );
+  }
   // And update any RMSD objects that depend on input values
   path_projector.updateDepedentRMSDObjects();
 }
diff --git a/src/mapping/PathTools.cpp b/src/mapping/PathTools.cpp
index 9c85b98d2c..a5e07d60ef 100644
--- a/src/mapping/PathTools.cpp
+++ b/src/mapping/PathTools.cpp
@@ -105,8 +105,7 @@ plumed pathtools --path inpath.pdb --metric EUCLIDEAN --out outpath.pdb --fixed
 //+ENDPLUMEDOC
 
 class PathTools :
-  public CLTool
-{
+  public CLTool {
 public:
   static void registerKeywords( Keywords& keys );
   explicit PathTools(const CLToolOptions& co );
@@ -136,66 +135,115 @@ void PathTools::registerKeywords( Keywords& keys ) {
 }
 
 PathTools::PathTools(const CLToolOptions& co ):
-  CLTool(co)
-{
+  CLTool(co) {
   inputdata=commandline;
 }
 
 int PathTools::main(FILE* in, FILE*out,Communicator& pc) {
   // Create a PLUMED object
-  PlumedMain plmd; int s=sizeof(double);
+  PlumedMain plmd;
+  int s=sizeof(double);
   plmd.cmd("setRealPrecision",&s);
   plmd.cmd("setMDEngine","pathtools");
   // plmd.cmd("setNoVirial");
-  double tstep=1.0; plmd.cmd("setTimestep",&tstep);
+  double tstep=1.0;
+  plmd.cmd("setTimestep",&tstep);
   plmd.cmd("init");
-  int step=1; plmd.cmd("setStep",&step);
-
-  std::string mtype; parse("--metric",mtype);
-  std::string ifilename; parse("--path",ifilename);
-  std::string ofmt; parse("--arg-fmt",ofmt);
-  std::string ofilename; parse("--out",ofilename);
-  std::vector<std::string> argstr; parseVector("--arg",argstr);
+  int step=1;
+  plmd.cmd("setStep",&step);
+
+  std::string mtype;
+  parse("--metric",mtype);
+  std::string ifilename;
+  parse("--path",ifilename);
+  std::string ofmt;
+  parse("--arg-fmt",ofmt);
+  std::string ofilename;
+  parse("--out",ofilename);
+  std::vector<std::string> argstr;
+  parseVector("--arg",argstr);
   if( ifilename.length()>0 ) {
     fprintf(out,"Reparameterising path in file named %s so that all frames are equally spaced \n",ifilename.c_str() );
-    FILE* fp=fopen(ifilename.c_str(),"r"); PDB mypdb; bool do_read=mypdb.readFromFilepointer(fp,false,0.1);
-    std::vector<double> alig( mypdb.getOccupancy() ), disp( mypdb.getBeta() ); std::vector<AtomNumber> indices( mypdb.getAtomNumbers() );
-    std::vector<unsigned> residue_indices( indices.size() ); for(unsigned i=0; i<residue_indices.size(); ++i) residue_indices[i] = mypdb.getResidueNumber( indices[i] );
+    FILE* fp=fopen(ifilename.c_str(),"r");
+    PDB mypdb;
+    bool do_read=mypdb.readFromFilepointer(fp,false,0.1);
+    std::vector<double> alig( mypdb.getOccupancy() ), disp( mypdb.getBeta() );
+    std::vector<AtomNumber> indices( mypdb.getAtomNumbers() );
+    std::vector<unsigned> residue_indices( indices.size() );
+    for(unsigned i=0; i<residue_indices.size(); ++i) {
+      residue_indices[i] = mypdb.getResidueNumber( indices[i] );
+    }
     // Count the number of frames in the input file
-    unsigned nfram=1; while ( do_read ) { if( !mypdb.readFromFilepointer(fp,false,0.1) ) break; nfram++; }
+    unsigned nfram=1;
+    while ( do_read ) {
+      if( !mypdb.readFromFilepointer(fp,false,0.1) ) {
+        break;
+      }
+      nfram++;
+    }
     if( argstr.size()>0 ) {
       for(unsigned i=0; i<argstr.size(); ++i ) {
         std::string input = argstr[i] + ": PDB2CONSTANT NOARGS REFERENCE=" + ifilename + " ARG=" + argstr[i];
-        const char* inpt = input.c_str(); plmd.cmd("readInputLine", inpt);
+        const char* inpt = input.c_str();
+        plmd.cmd("readInputLine", inpt);
       }
     } else {
       std::string input = "data: PDB2CONSTANT REFERENCE=" + ifilename;
-      const char* inpt = input.c_str(); plmd.cmd("readInputLine", inpt );
+      const char* inpt = input.c_str();
+      plmd.cmd("readInputLine", inpt );
     }
     std::string reparam_str = "REPARAMETERIZE_PATH REFERENCE=";
-    if( argstr.size()>0 ) { reparam_str += argstr[0]; for(unsigned i=0; i<argstr.size(); ++i ) reparam_str += "," + argstr[i]; }
-    else { reparam_str += "data"; } std::vector<unsigned> fixed; parseVector("--fixed",fixed);
+    if( argstr.size()>0 ) {
+      reparam_str += argstr[0];
+      for(unsigned i=0; i<argstr.size(); ++i ) {
+        reparam_str += "," + argstr[i];
+      }
+    } else {
+      reparam_str += "data";
+    }
+    std::vector<unsigned> fixed;
+    parseVector("--fixed",fixed);
     if( fixed.size()==1 ) {
-      if( fixed[0]!=0 ) error("input to --fixed should be two integers");
-      fixed.resize(2); fixed[0]=1; fixed[1]=nfram;
+      if( fixed[0]!=0 ) {
+        error("input to --fixed should be two integers");
+      }
+      fixed.resize(2);
+      fixed[0]=1;
+      fixed[1]=nfram;
     } else if( fixed.size()==2 ) {
       if( fixed[0]<1 || fixed[1]<1 || fixed[0]>nfram || fixed[1]>nfram ) {
         error("input to --fixed should be two numbers between 0 and the number of frames-1");
       }
-    } else error("input to --fixed should be two integers");
-    std::string fix1, fix2; Tools::convert( fixed[0], fix1 ); Tools::convert( fixed[1], fix2 );
+    } else {
+      error("input to --fixed should be two integers");
+    }
+    std::string fix1, fix2;
+    Tools::convert( fixed[0], fix1 );
+    Tools::convert( fixed[1], fix2 );
     reparam_str += " FIXED=" + fix1 + "," + fix2;
-    std::string tol; parse("--tolerance",tol); reparam_str += " TOL=" + tol;
+    std::string tol;
+    parse("--tolerance",tol);
+    reparam_str += " TOL=" + tol;
 // Now create the metric object
     reparam_str += " METRIC=";
     if( mtype=="OPTIMAL-FAST" || mtype=="OPTIMAL" || mtype=="SIMPLE" ) {
       reparam_str += "{RMSD_VECTOR DISPLACEMENT SQUARED UNORMALIZED TYPE=" + mtype;
       // Get the align values
-      std::string anum; Tools::convert( alig[0], anum ); reparam_str += " ALIGN=" + anum;
-      for(unsigned i=1; i<alig.size(); ++i) { Tools::convert( alig[i], anum ); reparam_str += "," + anum; }
+      std::string anum;
+      Tools::convert( alig[0], anum );
+      reparam_str += " ALIGN=" + anum;
+      for(unsigned i=1; i<alig.size(); ++i) {
+        Tools::convert( alig[i], anum );
+        reparam_str += "," + anum;
+      }
       // Get the displace values
-      std::string dnum; Tools::convert( disp[0], dnum ); reparam_str += " DISPLACE=" + dnum;
-      for(unsigned i=1; i<disp.size(); ++i) { Tools::convert( disp[i], dnum ); reparam_str += "," + dnum; }
+      std::string dnum;
+      Tools::convert( disp[0], dnum );
+      reparam_str += " DISPLACE=" + dnum;
+      for(unsigned i=1; i<disp.size(); ++i) {
+        Tools::convert( disp[i], dnum );
+        reparam_str += "," + dnum;
+      }
       reparam_str += "} METRIC_COMPONENT=disp";
     } else if( mtype=="EUCLIDEAN" ) {
       reparam_str += "DIFFERENCE";
@@ -205,22 +253,48 @@ int PathTools::main(FILE* in, FILE*out,Communicator& pc) {
     }
 
     // Now do the reparameterization
-    const char* icinp= reparam_str.c_str(); plmd.cmd("readInputLine",icinp);
+    const char* icinp= reparam_str.c_str();
+    plmd.cmd("readInputLine",icinp);
     Action* raction = plmd.getActionSet()[plmd.getActionSet().size()-1].get();
     raction->update();
 
     // And print the final reference configurations
     std::string pinput="DUMPPDB STRIDE=1 DESCRIPTION=PATH FILE=" + ofilename + " FMT=" + ofmt;
     if( argstr.size()>0 ) {
-      pinput += " ARG=" + argstr[0]; for(unsigned i=1; i<argstr.size(); ++i ) pinput += "," + argstr[i];
+      pinput += " ARG=" + argstr[0];
+      for(unsigned i=1; i<argstr.size(); ++i ) {
+        pinput += "," + argstr[i];
+      }
     } else {
-      std::string num; Tools::convert( indices[0].serial(), num ); pinput += " ATOMS=data ATOM_INDICES=" + num; for(unsigned i=1; i<indices.size(); ++i ) { Tools::convert( indices[i].serial(), num ); pinput += "," + num; }
-      Tools::convert( residue_indices[0], num ); pinput += " RESIDUE_INDICES=" + num; for(unsigned i=1; i<residue_indices.size(); ++i ) { Tools::convert( residue_indices[i], num ); pinput += "," + num; }
-      std::string anum, dnum; Tools::convert( alig[0], anum ); Tools::convert( disp[0], dnum );
-      pinput += " OCCUPANCY=" + anum; for(unsigned i=1; i<alig.size(); ++i) { Tools::convert( alig[i], anum ); pinput += "," + anum; }
-      pinput += " BETA=" + dnum; for(unsigned i=1; i<disp.size(); ++i) { Tools::convert( disp[i], dnum ); pinput += "," + dnum; }
+      std::string num;
+      Tools::convert( indices[0].serial(), num );
+      pinput += " ATOMS=data ATOM_INDICES=" + num;
+      for(unsigned i=1; i<indices.size(); ++i ) {
+        Tools::convert( indices[i].serial(), num );
+        pinput += "," + num;
+      }
+      Tools::convert( residue_indices[0], num );
+      pinput += " RESIDUE_INDICES=" + num;
+      for(unsigned i=1; i<residue_indices.size(); ++i ) {
+        Tools::convert( residue_indices[i], num );
+        pinput += "," + num;
+      }
+      std::string anum, dnum;
+      Tools::convert( alig[0], anum );
+      Tools::convert( disp[0], dnum );
+      pinput += " OCCUPANCY=" + anum;
+      for(unsigned i=1; i<alig.size(); ++i) {
+        Tools::convert( alig[i], anum );
+        pinput += "," + anum;
+      }
+      pinput += " BETA=" + dnum;
+      for(unsigned i=1; i<disp.size(); ++i) {
+        Tools::convert( disp[i], dnum );
+        pinput += "," + dnum;
+      }
     }
-    const char* pcinp=pinput.c_str(); plmd.cmd("readInputLine",pcinp);
+    const char* pcinp=pinput.c_str();
+    plmd.cmd("readInputLine",pcinp);
     Action* paction = plmd.getActionSet()[plmd.getActionSet().size()-1].get();
     paction->update();
 
@@ -230,78 +304,151 @@ int PathTools::main(FILE* in, FILE*out,Communicator& pc) {
   }
   for(unsigned i=0; i<argstr.size(); ++i) {
     std::string input = argstr[i] + ": CONSTANT VALUE=1";
-    const char* inpt = input.c_str(); plmd.cmd("readInputLine", inpt);
+    const char* inpt = input.c_str();
+    plmd.cmd("readInputLine", inpt);
   }
 
 // Read in the instructions
   unsigned nbefore, nbetween, nafter;
-  std::string istart; parse("--start",istart); std::string iend; parse("--end",iend);
-  parse("--nframes-before-start",nbefore); parse("--nframes",nbetween); parse("--nframes-after-end",nafter);
+  std::string istart;
+  parse("--start",istart);
+  std::string iend;
+  parse("--end",iend);
+  parse("--nframes-before-start",nbefore);
+  parse("--nframes",nbetween);
+  parse("--nframes-after-end",nafter);
   nbetween++;
   fprintf(out,"Generating linear path connecting structure in file named %s to structure in file named %s \n",istart.c_str(),iend.c_str() );
   fprintf(out,"A path consisting of %u equally-spaced frames before the initial structure, %u frames between the initial and final structures "
           "and %u frames after the final structure will be created \n",nbefore,nbetween,nafter);
 
-  std::vector<double> start_pos( argstr.size() ), end_pos( argstr.size() ); std::vector<AtomNumber> indices;
+  std::vector<double> start_pos( argstr.size() ), end_pos( argstr.size() );
+  std::vector<AtomNumber> indices;
   if( argstr.size()>0 ) {
     for(unsigned i=0; i<argstr.size(); ++i ) {
       std::string input = argstr[i] + "_start: PDB2CONSTANT REFERENCE=" + istart + " ARG=" + argstr[i];
-      const char* inpt = input.c_str(); plmd.cmd("readInputLine", inpt );
-      long srank; plmd.cmd("getDataRank " + argstr[i] + "_start", &srank );
-      if( srank!=1 ) error("should only be one frame in input pdb");
-      std::vector<long> sshape( 1 ); plmd.cmd("getDataShape " + argstr[i] + "_start", &sshape[0] );
-      if( sshape[0]!=1 ) error("should only be one frame in input pdb");
+      const char* inpt = input.c_str();
+      plmd.cmd("readInputLine", inpt );
+      long srank;
+      plmd.cmd("getDataRank " + argstr[i] + "_start", &srank );
+      if( srank!=1 ) {
+        error("should only be one frame in input pdb");
+      }
+      std::vector<long> sshape( 1 );
+      plmd.cmd("getDataShape " + argstr[i] + "_start", &sshape[0] );
+      if( sshape[0]!=1 ) {
+        error("should only be one frame in input pdb");
+      }
       plmd.cmd("setMemoryForData " + argstr[i] + "_start", &start_pos[i] );
       std::string input2 = argstr[i] + "_end: PDB2CONSTANT REFERENCE=" + iend + " ARG=" + argstr[i];
-      const char* inpt2 = input2.c_str(); plmd.cmd("readInputLine", inpt2 );
-      long erank; plmd.cmd("getDataRank " + argstr[i] + "_end", &erank );
-      if( erank!=1 ) error("should only be one frame in input pdb");
-      std::vector<long> eshape( 1 ); plmd.cmd("getDataShape " + argstr[i] + "_end", &eshape[0] );
-      if( eshape[0]!=1 ) error("should only be one frame in input pdb");
+      const char* inpt2 = input2.c_str();
+      plmd.cmd("readInputLine", inpt2 );
+      long erank;
+      plmd.cmd("getDataRank " + argstr[i] + "_end", &erank );
+      if( erank!=1 ) {
+        error("should only be one frame in input pdb");
+      }
+      std::vector<long> eshape( 1 );
+      plmd.cmd("getDataShape " + argstr[i] + "_end", &eshape[0] );
+      if( eshape[0]!=1 ) {
+        error("should only be one frame in input pdb");
+      }
       plmd.cmd("setMemoryForData " + argstr[i] + "_end", &end_pos[i] );
     }
   } else {
     std::string input = "start: PDB2CONSTANT REFERENCE=" + istart;
-    const char* inpt = input.c_str(); plmd.cmd("readInputLine", inpt );
-    FILE* fp=fopen(istart.c_str(),"r"); PDB mypdb; bool do_read=mypdb.readFromFilepointer(fp,false,0.1);
-    indices.resize( mypdb.getAtomNumbers().size() ); for(unsigned i=0; i<indices.size(); ++i) indices[i] = mypdb.getAtomNumbers()[i];
-    long srank; plmd.cmd("getDataRank start", &srank ); if( srank!=2 ) error("should only be one frame in input pdb:" + istart);
-    std::vector<long> sshape( srank ); plmd.cmd("getDataShape start", &sshape[0] ); start_pos.resize( sshape[0]*sshape[1] );
-    if( sshape[0]!=1 ) error("should only be one frame in input pdb: " + istart);
+    const char* inpt = input.c_str();
+    plmd.cmd("readInputLine", inpt );
+    FILE* fp=fopen(istart.c_str(),"r");
+    PDB mypdb;
+    bool do_read=mypdb.readFromFilepointer(fp,false,0.1);
+    indices.resize( mypdb.getAtomNumbers().size() );
+    for(unsigned i=0; i<indices.size(); ++i) {
+      indices[i] = mypdb.getAtomNumbers()[i];
+    }
+    long srank;
+    plmd.cmd("getDataRank start", &srank );
+    if( srank!=2 ) {
+      error("should only be one frame in input pdb:" + istart);
+    }
+    std::vector<long> sshape( srank );
+    plmd.cmd("getDataShape start", &sshape[0] );
+    start_pos.resize( sshape[0]*sshape[1] );
+    if( sshape[0]!=1 ) {
+      error("should only be one frame in input pdb: " + istart);
+    }
     plmd.cmd("setMemoryForData start", &start_pos[0] );
     std::string input2 = "end: PDB2CONSTANT REFERENCE=" + iend;
-    const char* inpt2 = input2.c_str(); plmd.cmd("readInputLine", inpt2 );
-    long erank; plmd.cmd("getDataRank end", &erank ); if( erank!=2 ) error("should only be one frame in input pdb: " + iend);
-    std::vector<long> eshape( erank ); plmd.cmd("getDataShape end", &eshape[0] ); end_pos.resize( eshape[0]*eshape[1] );
-    if( eshape[0]!=1 ) error("should only be one frame in input pdb: " + iend );
+    const char* inpt2 = input2.c_str();
+    plmd.cmd("readInputLine", inpt2 );
+    long erank;
+    plmd.cmd("getDataRank end", &erank );
+    if( erank!=2 ) {
+      error("should only be one frame in input pdb: " + iend);
+    }
+    std::vector<long> eshape( erank );
+    plmd.cmd("getDataShape end", &eshape[0] );
+    end_pos.resize( eshape[0]*eshape[1] );
+    if( eshape[0]!=1 ) {
+      error("should only be one frame in input pdb: " + iend );
+    }
     plmd.cmd("setMemoryForData end", &end_pos[0] );
   }
 
 // Now create the metric object
-  std::vector<double> alig, disp; std::vector<unsigned> residue_indices;
+  std::vector<double> alig, disp;
+  std::vector<unsigned> residue_indices;
   if( mtype=="OPTIMAL-FAST" || mtype=="OPTIMAL" || mtype=="SIMPLE" ) {
     std::string trinput = "endT: TRANSPOSE ARG=end";
-    const char* tinp=trinput.c_str(); plmd.cmd("readInputLine",tinp);
-    PDB pdb; pdb.read(istart,false,0.1);
-    alig.resize( pdb.getOccupancy().size() ); disp.resize( pdb.getBeta().size() );
-    for(unsigned i=0; i<alig.size(); ++i) { alig[i] = pdb.getOccupancy()[i]; disp[i]= pdb.getBeta()[i]; }
+    const char* tinp=trinput.c_str();
+    plmd.cmd("readInputLine",tinp);
+    PDB pdb;
+    pdb.read(istart,false,0.1);
+    alig.resize( pdb.getOccupancy().size() );
+    disp.resize( pdb.getBeta().size() );
+    for(unsigned i=0; i<alig.size(); ++i) {
+      alig[i] = pdb.getOccupancy()[i];
+      disp[i]= pdb.getBeta()[i];
+    }
     std::string minput = "d: RMSD_VECTOR DISPLACEMENT SQUARED UNORMALIZED TYPE=" + mtype + " ARG=endT,start";
     // Get the align values
-    std::string anum; Tools::convert( alig[0], anum ); minput += " ALIGN=" + anum;
-    for(unsigned i=1; i<alig.size(); ++i) { Tools::convert( alig[i], anum ); minput += "," + anum; }
+    std::string anum;
+    Tools::convert( alig[0], anum );
+    minput += " ALIGN=" + anum;
+    for(unsigned i=1; i<alig.size(); ++i) {
+      Tools::convert( alig[i], anum );
+      minput += "," + anum;
+    }
     // Get the displace values
-    std::string dnum; Tools::convert( disp[0], dnum ); minput += " DISPLACE=" + dnum;
-    for(unsigned i=1; i<disp.size(); ++i) { Tools::convert( disp[i], dnum ); minput += "," + dnum; }
-    const char* mcinp=minput.c_str(); plmd.cmd("readInputLine",mcinp);
-    std::string tinput = "CUSTOM ARG=d.disp FUNC=x PERIODIC=NO"; const char* tcinp=tinput.c_str(); plmd.cmd("readInputLine",tcinp);
+    std::string dnum;
+    Tools::convert( disp[0], dnum );
+    minput += " DISPLACE=" + dnum;
+    for(unsigned i=1; i<disp.size(); ++i) {
+      Tools::convert( disp[i], dnum );
+      minput += "," + dnum;
+    }
+    const char* mcinp=minput.c_str();
+    plmd.cmd("readInputLine",mcinp);
+    std::string tinput = "CUSTOM ARG=d.disp FUNC=x PERIODIC=NO";
+    const char* tcinp=tinput.c_str();
+    plmd.cmd("readInputLine",tcinp);
     // Get the residue numbers
     residue_indices.resize( pdb.size() );
-    for(unsigned i=0; i<residue_indices.size(); ++i) residue_indices[i] = pdb.getResidueNumber( indices[i] );
+    for(unsigned i=0; i<residue_indices.size(); ++i) {
+      residue_indices[i] = pdb.getResidueNumber( indices[i] );
+    }
   } else if( mtype=="EUCLIDEAN" ) {
     std::string end_args="ARG1=" + argstr[0] + "_end", start_args="ARG2=" + argstr[0] + "_start";
-    for(unsigned i=1; i<argstr.size(); ++i ) { end_args += "," + argstr[i] + "_end"; start_args += "," + argstr[i] + "_start"; }
-    std::string minput = "d: DISPLACEMENT " + end_args + " " + start_args; const char* mcinp=minput.c_str(); plmd.cmd("readInputLine",mcinp);
-    std::string tinput = "TRANSPOSE ARG=d"; const char* tcinp=tinput.c_str(); plmd.cmd("readInputLine",tcinp);
+    for(unsigned i=1; i<argstr.size(); ++i ) {
+      end_args += "," + argstr[i] + "_end";
+      start_args += "," + argstr[i] + "_start";
+    }
+    std::string minput = "d: DISPLACEMENT " + end_args + " " + start_args;
+    const char* mcinp=minput.c_str();
+    plmd.cmd("readInputLine",mcinp);
+    std::string tinput = "TRANSPOSE ARG=d";
+    const char* tcinp=tinput.c_str();
+    plmd.cmd("readInputLine",tcinp);
   } else {
     // Add functionality to read plumed input here
     plumed_merror("metric type " + mtype + " has not been implemented");
@@ -311,67 +458,128 @@ int PathTools::main(FILE* in, FILE*out,Communicator& pc) {
   unsigned aind = plmd.getActionSet().size()-1;
   while( true ) {
     const ActionShortcut* as=dynamic_cast<const ActionShortcut*>( plmd.getActionSet()[aind].get() );
-    if( !as ) break ; aind = aind - 1; plumed_assert( aind>=0 );
+    if( !as ) {
+      break ;
+    }
+    aind = aind - 1;
+    plumed_assert( aind>=0 );
   }
   ActionWithValue* av = dynamic_cast<ActionWithValue*>( plmd.getActionSet()[aind].get() );
-  if( !av ) error("invalid input for metric" );
-  if( av->getNumberOfComponents()!=1 && av->getName()!="RMSD_VECTOR" ) error("cannot use multi component actions as metric");
+  if( !av ) {
+    error("invalid input for metric" );
+  }
+  if( av->getNumberOfComponents()!=1 && av->getName()!="RMSD_VECTOR" ) {
+    error("cannot use multi component actions as metric");
+  }
   std::string mydisp = av->copyOutput(0)->getName();
 // Now add calls so we can grab the data from plumed
-  long rank; plmd.cmd("getDataRank " + mydisp, &rank );
-  if( rank!=1 ) error("displacement must be a vector quantity");
-  std::vector<long> ishape( rank ); plmd.cmd("getDataShape " + mydisp, &ishape[0] );
-  std::vector<double> displacement( ishape[0] ); plmd.cmd("setMemoryForData " + mydisp, &displacement[0] );
+  long rank;
+  plmd.cmd("getDataRank " + mydisp, &rank );
+  if( rank!=1 ) {
+    error("displacement must be a vector quantity");
+  }
+  std::vector<long> ishape( rank );
+  plmd.cmd("getDataShape " + mydisp, &ishape[0] );
+  std::vector<double> displacement( ishape[0] );
+  plmd.cmd("setMemoryForData " + mydisp, &displacement[0] );
 // And calculate the displacement
   plmd.cmd("calc");
 
   // Now read in the initial frame
 
   // Now create frames
-  double delr = 1.0 / static_cast<double>( nbetween ); std::vector<std::vector<double> > allframes; std::vector<double> frame( displacement.size() );
+  double delr = 1.0 / static_cast<double>( nbetween );
+  std::vector<std::vector<double> > allframes;
+  std::vector<double> frame( displacement.size() );
   for(int i=0; i<nbefore; ++i) {
-    for(unsigned j=0; j<frame.size(); ++j) frame[j] = start_pos[j] - i*delr*displacement[j];
+    for(unsigned j=0; j<frame.size(); ++j) {
+      frame[j] = start_pos[j] - i*delr*displacement[j];
+    }
     allframes.push_back( frame );
   }
   for(unsigned i=1; i<nbetween; ++i) {
-    for(unsigned j=0; j<frame.size(); ++j) frame[j] = start_pos[j] + i*delr*displacement[j];
+    for(unsigned j=0; j<frame.size(); ++j) {
+      frame[j] = start_pos[j] + i*delr*displacement[j];
+    }
     allframes.push_back( frame );
   }
   for(unsigned i=0; i<nafter; ++i) {
-    for(unsigned j=0; j<frame.size(); ++j) frame[j] = end_pos[j] + i*delr*displacement[j];
+    for(unsigned j=0; j<frame.size(); ++j) {
+      frame[j] = end_pos[j] + i*delr*displacement[j];
+    }
     allframes.push_back( frame );
   }
   // This prints out our final reference configurations
-  plmd.cmd("clear"); plmd.readInputLine("timestep: PUT UNIT=time PERIODIC=NO CONSTANT");
+  plmd.cmd("clear");
+  plmd.readInputLine("timestep: PUT UNIT=time PERIODIC=NO CONSTANT");
   ActionToPutData* ts = plmd.getActionSet().selectWithLabel<ActionToPutData*>("timestep");
   ts->setValuePointer("timestep", &tstep );
   std::string pinput="DUMPPDB STRIDE=1 DESCRIPTION=PATH FILE=" + ofilename + " FMT=" + ofmt;
   if( argstr.size()>0 ) {
     for(unsigned i=0; i<argstr.size(); ++i) {
-      std::string rnum; Tools::convert( allframes[0][i], rnum );
+      std::string rnum;
+      Tools::convert( allframes[0][i], rnum );
       std::string inpt = argstr[i] + ": CONSTANT VALUES=" + rnum;
-      for(unsigned j=1; j<allframes.size(); ++j) { Tools::convert( allframes[j][i], rnum ); inpt += "," + rnum; }
-      const char* icinp=inpt.c_str(); plmd.cmd("readInputLine",icinp);
-      if( i==0 ) pinput += " ARG=" + argstr[i]; else pinput += "," + argstr[i];
+      for(unsigned j=1; j<allframes.size(); ++j) {
+        Tools::convert( allframes[j][i], rnum );
+        inpt += "," + rnum;
+      }
+      const char* icinp=inpt.c_str();
+      plmd.cmd("readInputLine",icinp);
+      if( i==0 ) {
+        pinput += " ARG=" + argstr[i];
+      } else {
+        pinput += "," + argstr[i];
+      }
     }
   } else {
-    std::string nc; Tools::convert( frame.size(), nc );
-    std::string nr; Tools::convert( allframes.size(), nr );
-    std::string rnum; Tools::convert( allframes[0][0], rnum );
+    std::string nc;
+    Tools::convert( frame.size(), nc );
+    std::string nr;
+    Tools::convert( allframes.size(), nr );
+    std::string rnum;
+    Tools::convert( allframes[0][0], rnum );
     std::string inpt = "atom_data: CONSTANT NROWS=" + nr + " NCOLS=" + nc + " VALUES=" + rnum;
     for(unsigned i=0; i<allframes.size(); ++i) {
       for(unsigned j=0; j<allframes[i].size(); ++j) {
-        if( i==0 && j==0 ) continue; Tools::convert( allframes[i][j], rnum ); inpt += "," + rnum;
+        if( i==0 && j==0 ) {
+          continue;
+        }
+        Tools::convert( allframes[i][j], rnum );
+        inpt += "," + rnum;
       }
     }
-    const char* icinp=inpt.c_str(); plmd.cmd("readInputLine",icinp); std::string num; Tools::convert( indices[0].serial(), num );
-    pinput += " ATOMS=atom_data ATOM_INDICES=" + num; for(unsigned i=1; i<indices.size(); ++i ) { Tools::convert( indices[i].serial(), num ); pinput += "," + num; }
-    Tools::convert( residue_indices[0], num ); pinput += " RESIDUE_INDICES=" + num; for(unsigned i=1; i<residue_indices.size(); ++i ) { Tools::convert( residue_indices[i], num ); pinput += "," + num; }
-    std::string anum, dnum; Tools::convert( alig[0], anum ); Tools::convert( disp[0], dnum );
-    pinput += " OCCUPANCY=" + anum; for(unsigned i=1; i<alig.size(); ++i) { Tools::convert( alig[i], anum ); pinput += "," + anum; }
-    pinput += " BETA=" + dnum; for(unsigned i=1; i<disp.size(); ++i) { Tools::convert( disp[i], dnum ); pinput += "," + dnum; }
+    const char* icinp=inpt.c_str();
+    plmd.cmd("readInputLine",icinp);
+    std::string num;
+    Tools::convert( indices[0].serial(), num );
+    pinput += " ATOMS=atom_data ATOM_INDICES=" + num;
+    for(unsigned i=1; i<indices.size(); ++i ) {
+      Tools::convert( indices[i].serial(), num );
+      pinput += "," + num;
+    }
+    Tools::convert( residue_indices[0], num );
+    pinput += " RESIDUE_INDICES=" + num;
+    for(unsigned i=1; i<residue_indices.size(); ++i ) {
+      Tools::convert( residue_indices[i], num );
+      pinput += "," + num;
+    }
+    std::string anum, dnum;
+    Tools::convert( alig[0], anum );
+    Tools::convert( disp[0], dnum );
+    pinput += " OCCUPANCY=" + anum;
+    for(unsigned i=1; i<alig.size(); ++i) {
+      Tools::convert( alig[i], anum );
+      pinput += "," + anum;
+    }
+    pinput += " BETA=" + dnum;
+    for(unsigned i=1; i<disp.size(); ++i) {
+      Tools::convert( disp[i], dnum );
+      pinput += "," + dnum;
+    }
   }
-  const char* pcinp=pinput.c_str(); plmd.cmd("readInputLine",pcinp);
+  const char* pcinp=pinput.c_str();
+  plmd.cmd("readInputLine",pcinp);
   Action* paction = plmd.getActionSet()[plmd.getActionSet().size()-1].get();
   paction->update();
   // And output suggestions on the value of Lambda
@@ -381,77 +589,120 @@ int PathTools::main(FILE* in, FILE*out,Communicator& pc) {
 
 void PathTools::printLambda( const std::string& mtype, const std::vector<std::string>& argstr, const std::string& ofile ) {
   // Create a PLUMED object
-  PlumedMain plmd; int s=sizeof(double);
+  PlumedMain plmd;
+  int s=sizeof(double);
   plmd.cmd("setRealPrecision",&s);
   plmd.cmd("setMDEngine","pathtools");
-  double tstep=1.0; plmd.cmd("setTimestep",&tstep);
+  double tstep=1.0;
+  plmd.cmd("setTimestep",&tstep);
   plmd.cmd("init");
-  int step=1; plmd.cmd("setStep",&step);
+  int step=1;
+  plmd.cmd("setStep",&step);
 
   FILE* fp=fopen(ofile.c_str(),"r");
-  bool do_read=true; unsigned nfram=0;
+  bool do_read=true;
+  unsigned nfram=0;
   std::vector<double> alig, disp;
   // Read in the argument names
   for(unsigned i=0; i<argstr.size(); ++i ) {
     std::string input2 = argstr[i] + ": CONSTANT VALUE=1";
-    const char* inpt2 = input2.c_str(); plmd.cmd("readInputLine", inpt2);
+    const char* inpt2 = input2.c_str();
+    plmd.cmd("readInputLine", inpt2);
   }
   while (do_read ) {
     PDB mypdb;
     // Read the pdb file
-    do_read=mypdb.readFromFilepointer(fp,false,0.1); if( !do_read ) break;
-    std::string num; Tools::convert( nfram+1, num ); nfram++; std::string iinput;
+    do_read=mypdb.readFromFilepointer(fp,false,0.1);
+    if( !do_read ) {
+      break;
+    }
+    std::string num;
+    Tools::convert( nfram+1, num );
+    nfram++;
+    std::string iinput;
     if( argstr.size()>0 ) {
       for(unsigned i=0; i<argstr.size(); ++i ) {
         std::string input = "ref_" + num + "_" + argstr[i] + ": PDB2CONSTANT REFERENCE=" + ofile + " ARG=" + argstr[i] + " NUMBER=" + num;
-        const char* inpt = input.c_str(); plmd.cmd("readInputLine", inpt );
+        const char* inpt = input.c_str();
+        plmd.cmd("readInputLine", inpt );
       }
     } else {
       std::string input = "ref_" + num + ": PDB2CONSTANT REFERENCE=" + ofile + " NUMBER=" + num;
-      const char* inpt = input.c_str(); plmd.cmd("readInputLine", inpt );
+      const char* inpt = input.c_str();
+      plmd.cmd("readInputLine", inpt );
     }
 
     if( nfram==1 ) {
       alig.resize( mypdb.getOccupancy().size() );
-      for(unsigned i=0; i<alig.size(); ++i) alig[i]=mypdb.getOccupancy()[i];
+      for(unsigned i=0; i<alig.size(); ++i) {
+        alig[i]=mypdb.getOccupancy()[i];
+      }
       disp.resize( mypdb.getBeta().size() );
-      for(unsigned i=0; i<disp.size(); ++i) disp[i]=mypdb.getBeta()[i];
+      for(unsigned i=0; i<disp.size(); ++i) {
+        disp[i]=mypdb.getBeta()[i];
+      }
     }
   }
   // Now create the objects to measure the distances between the frames
   std::vector<double> data( nfram );
   for(unsigned j=1; j<nfram; ++j) {
-    std::string istr, jstr; Tools::convert( j, istr); Tools::convert( j+1, jstr );
+    std::string istr, jstr;
+    Tools::convert( j, istr);
+    Tools::convert( j+1, jstr );
     if( mtype=="OPTIMAL-FAST" || mtype=="OPTIMAL" || mtype=="SIMPLE" ) {
       std::string strv = "ref_" + jstr + "T: TRANSPOSE ARG=ref_" + jstr;
-      const char* cstrv = strv.c_str(); plmd.cmd("readInputLine",cstrv);
+      const char* cstrv = strv.c_str();
+      plmd.cmd("readInputLine",cstrv);
       std::string dstring = "d" + istr + ": RMSD_VECTOR TYPE=" + mtype + " ARG=ref_" + jstr + "T,ref_" + istr;
       // Get the align values
-      std::string anum; Tools::convert( alig[0], anum ); dstring += " ALIGN=" + anum;
-      for(unsigned i=1; i<alig.size(); ++i) { Tools::convert( alig[i], anum ); dstring += "," + anum; }
+      std::string anum;
+      Tools::convert( alig[0], anum );
+      dstring += " ALIGN=" + anum;
+      for(unsigned i=1; i<alig.size(); ++i) {
+        Tools::convert( alig[i], anum );
+        dstring += "," + anum;
+      }
       // Get the displace values
-      std::string dnum; Tools::convert( disp[0], dnum ); dstring += " DISPLACE=" + dnum;
-      for(unsigned i=1; i<disp.size(); ++i) { Tools::convert( disp[i], dnum ); dstring += "," + dnum; }
-      const char* icinp=dstring.c_str(); plmd.cmd("readInputLine",icinp);
+      std::string dnum;
+      Tools::convert( disp[0], dnum );
+      dstring += " DISPLACE=" + dnum;
+      for(unsigned i=1; i<disp.size(); ++i) {
+        Tools::convert( disp[i], dnum );
+        dstring += "," + dnum;
+      }
+      const char* icinp=dstring.c_str();
+      plmd.cmd("readInputLine",icinp);
     } else if( mtype=="EUCLIDEAN" ) {
       std::string end_args="ARG1=ref_" + istr + "_" + argstr[0], start_args="ARG2=ref_" + jstr + "_" + argstr[0];
-      for(unsigned i=1; i<argstr.size(); ++i ) { end_args += ",ref_" + istr + "_" + argstr[i]; start_args += ",ref_" + jstr + "_" + argstr[i]; }
+      for(unsigned i=1; i<argstr.size(); ++i ) {
+        end_args += ",ref_" + istr + "_" + argstr[i];
+        start_args += ",ref_" + jstr + "_" + argstr[i];
+      }
       std::string fstr = "d" + istr + ": EUCLIDEAN_DISTANCE " + end_args + " " + start_args;
-      const char* icinp=fstr.c_str(); plmd.cmd("readInputLine",icinp);
+      const char* icinp=fstr.c_str();
+      plmd.cmd("readInputLine",icinp);
     } else {
       plumed_merror("metric type " + mtype + " has not been implemented");
     }
-    long rank; plmd.cmd("getDataRank d" + istr, &rank );
-    if( rank!=1 ) error("distance should be of rank 1");
-    std::vector<long> ishape(1); plmd.cmd("getDataShape d" + istr, &ishape[0] );
-    if( ishape[0]!=1 ) error("distance should be of rank 1");
+    long rank;
+    plmd.cmd("getDataRank d" + istr, &rank );
+    if( rank!=1 ) {
+      error("distance should be of rank 1");
+    }
+    std::vector<long> ishape(1);
+    plmd.cmd("getDataShape d" + istr, &ishape[0] );
+    if( ishape[0]!=1 ) {
+      error("distance should be of rank 1");
+    }
     plmd.cmd("setMemoryForData d" + istr, &data[j-1] );
   }
-  plmd.cmd("calc"); double mean=0;
+  plmd.cmd("calc");
+  double mean=0;
   printf("N.B. THIS CODE ALWAYS AIMS TO CREATE EQUALLY SPACED FRAMES \n");
   printf("THERE MAY BE SMALL DESCREPENCIES IN THE NUMBERS BELOW, HOWEVER, BECAUSE OF ROUNDING ERRORS \n");
   for(unsigned i=1; i<nfram; ++i) {
-    printf("FINAL DISTANCE BETWEEN FRAME %u AND %u IS %f \n",i-1,i,data[i-1]); mean += data[i-1];
+    printf("FINAL DISTANCE BETWEEN FRAME %u AND %u IS %f \n",i-1,i,data[i-1]);
+    mean += data[i-1];
   }
   printf("SUGGESTED LAMBDA PARAMETER IS THUS %f \n",2.3/mean/static_cast<double>( nfram-1 ) );
 }
diff --git a/src/matrixtools/CovarianceMatrix.cpp b/src/matrixtools/CovarianceMatrix.cpp
index 77bfc24a0a..2ba5482d19 100644
--- a/src/matrixtools/CovarianceMatrix.cpp
+++ b/src/matrixtools/CovarianceMatrix.cpp
@@ -49,19 +49,30 @@ void CovarianceMatrix::registerKeywords(Keywords& keys ) {
            "are used as weights for the input data points.");
   keys.addFlag("UNORMALIZED",false,"do not divide by the sum of the weights");
   keys.setValueDescription("the covariance matrix");
-  keys.needsAction("SUM"); keys.needsAction("CUSTOM"); keys.needsAction("VSTACK"); keys.needsAction("TRANSPOSE");
-  keys.needsAction("ONES"); keys.needsAction("OUTER_PRODUCT"); keys.needsAction("MATRIX_PRODUCT");
+  keys.needsAction("SUM");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("VSTACK");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("ONES");
+  keys.needsAction("OUTER_PRODUCT");
+  keys.needsAction("MATRIX_PRODUCT");
 }
 
 CovarianceMatrix::CovarianceMatrix(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::vector<std::string> args; parseVector("ARG",args);
-  unsigned nargs=args.size(); std::string argstr="ARG=" + args[0];
-  for(unsigned i=1; i<args.size(); ++i) argstr += "," + args[i];
+  ActionShortcut(ao) {
+  std::vector<std::string> args;
+  parseVector("ARG",args);
+  unsigned nargs=args.size();
+  std::string argstr="ARG=" + args[0];
+  for(unsigned i=1; i<args.size(); ++i) {
+    argstr += "," + args[i];
+  }
 
-  bool unorm; parseFlag("UNORMALIZED",unorm); std::string wstr; parse("WEIGHTS",wstr);
+  bool unorm;
+  parseFlag("UNORMALIZED",unorm);
+  std::string wstr;
+  parse("WEIGHTS",wstr);
   if( !unorm ) {
     // Normalize the weights
     readInputLine( getShortcutLabel() + "_wsum: SUM ARG=" + wstr + " PERIODIC=NO");
@@ -73,7 +84,8 @@ CovarianceMatrix::CovarianceMatrix(const ActionOptions&ao):
   // And calculate the covariance matrix by first transposing the stack
   readInputLine( getShortcutLabel() + "_stackT: TRANSPOSE ARG=" + getShortcutLabel() + "_stack");
   // Create a matrix that holds all the weights
-  std::string str_nargs; Tools::convert( nargs, str_nargs );
+  std::string str_nargs;
+  Tools::convert( nargs, str_nargs );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + str_nargs );
   // Now create a matrix that holds all the weights
   readInputLine( getShortcutLabel() + "_matweights: OUTER_PRODUCT ARG=" + getShortcutLabel() + "_ones," + wstr );
diff --git a/src/matrixtools/Determinent.cpp b/src/matrixtools/Determinent.cpp
index ccea1860ab..8e0c3250a4 100644
--- a/src/matrixtools/Determinent.cpp
+++ b/src/matrixtools/Determinent.cpp
@@ -50,9 +50,9 @@ void Determinant::registerKeywords( Keywords& keys ) {
 
 Determinant::Determinant( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string arg; parse("ARG",arg);
+  ActionShortcut(ao) {
+  std::string arg;
+  parse("ARG",arg);
   // Compose a vector from the args
   readInputLine( getShortcutLabel() + "_diag: DIAGONALIZE ARG=" + arg + " VECTORS=all");
   // Not sure about the regexp here - check with matrix with more than 10 rows
diff --git a/src/matrixtools/DiagonalizeMatrix.cpp b/src/matrixtools/DiagonalizeMatrix.cpp
index 7a8cda7fef..0fdadf8667 100644
--- a/src/matrixtools/DiagonalizeMatrix.cpp
+++ b/src/matrixtools/DiagonalizeMatrix.cpp
@@ -45,7 +45,9 @@ class DiagonalizeMatrix : public MatrixOperationBase {
 /// Constructor
   explicit DiagonalizeMatrix(const ActionOptions&);
 /// This is required to set the number of derivatives for the eigenvalues
-  unsigned getNumberOfDerivatives() override { return getPntrToArgument(0)->getNumberOfValues(); }
+  unsigned getNumberOfDerivatives() override {
+    return getPntrToArgument(0)->getNumberOfValues();
+  }
 ///
   void prepare() override ;
 ///
@@ -65,53 +67,79 @@ void DiagonalizeMatrix::registerKeywords( Keywords& keys ) {
 
 DiagonalizeMatrix::DiagonalizeMatrix(const ActionOptions& ao):
   Action(ao),
-  MatrixOperationBase(ao)
-{
-  if( getPntrToArgument(0)->getShape()[0]!=getPntrToArgument(0)->getShape()[1] ) error("input matrix should be square");
+  MatrixOperationBase(ao) {
+  if( getPntrToArgument(0)->getShape()[0]!=getPntrToArgument(0)->getShape()[1] ) {
+    error("input matrix should be square");
+  }
 
-  std::vector<std::string> eigv; parseVector("VECTORS",eigv);
+  std::vector<std::string> eigv;
+  parseVector("VECTORS",eigv);
   if( eigv.size()>1 ) {
-    Tools::interpretRanges(eigv); desired_vectors.resize( eigv.size() );
-    for(unsigned i=0; i<eigv.size(); ++i) Tools::convert( eigv[i], desired_vectors[i] );
+    Tools::interpretRanges(eigv);
+    desired_vectors.resize( eigv.size() );
+    for(unsigned i=0; i<eigv.size(); ++i) {
+      Tools::convert( eigv[i], desired_vectors[i] );
+    }
   } else  {
-    if( eigv.size()==0 ) error("missing input to VECTORS keyword");
+    if( eigv.size()==0 ) {
+      error("missing input to VECTORS keyword");
+    }
     unsigned ivec;
     if( eigv[0]=="all" ) {
       desired_vectors.resize( getPntrToArgument(0)->getShape()[0] );
-      for(unsigned i=0; i<desired_vectors.size(); ++i) desired_vectors[i] = i + 1;
+      for(unsigned i=0; i<desired_vectors.size(); ++i) {
+        desired_vectors[i] = i + 1;
+      }
     } else {
       Tools::convert( eigv[0], ivec );
-      desired_vectors.resize(1); desired_vectors[0]=ivec;
+      desired_vectors.resize(1);
+      desired_vectors[0]=ivec;
     }
   }
 
-  std::string num; std::vector<unsigned> eval_shape(0);
-  std::vector<unsigned> evec_shape(1); evec_shape[0] = getPntrToArgument(0)->getShape()[0];
+  std::string num;
+  std::vector<unsigned> eval_shape(0);
+  std::vector<unsigned> evec_shape(1);
+  evec_shape[0] = getPntrToArgument(0)->getShape()[0];
   for(unsigned i=0; i<desired_vectors.size(); ++i) {
     Tools::convert( desired_vectors[i], num );
-    addComponent( "vals-" + num, eval_shape ); componentIsNotPeriodic( "vals-" + num );
-    addComponent( "vecs-" + num, evec_shape ); componentIsNotPeriodic( "vecs-" + num );
+    addComponent( "vals-" + num, eval_shape );
+    componentIsNotPeriodic( "vals-" + num );
+    addComponent( "vecs-" + num, evec_shape );
+    componentIsNotPeriodic( "vecs-" + num );
     // Make sure eigenvalues are always stored
     getPntrToComponent( 2*i+1 )->buildDataStore();
   }
 
-  std::vector<unsigned> eigvecs_shape(2); eigvecs_shape[0]=eigvecs_shape[1]=getPntrToArgument(0)->getShape()[0];
-  mymatrix.resize( eigvecs_shape[0], eigvecs_shape[1] ); eigvals.resize( eigvecs_shape[0] ); eigvecs.resize( eigvecs_shape[0], eigvecs_shape[1] );
+  std::vector<unsigned> eigvecs_shape(2);
+  eigvecs_shape[0]=eigvecs_shape[1]=getPntrToArgument(0)->getShape()[0];
+  mymatrix.resize( eigvecs_shape[0], eigvecs_shape[1] );
+  eigvals.resize( eigvecs_shape[0] );
+  eigvecs.resize( eigvecs_shape[0], eigvecs_shape[1] );
 }
 
 void DiagonalizeMatrix::prepare() {
-  std::vector<unsigned> shape(1); shape[0]=getPntrToArgument(0)->getShape()[0];
+  std::vector<unsigned> shape(1);
+  shape[0]=getPntrToArgument(0)->getShape()[0];
   for(unsigned i=0; i<desired_vectors.size(); ++i) {
-    if( getPntrToComponent( 2*i+1 )->getShape()[0]!=shape[0] ) getPntrToComponent( 2*i+1 )->setShape( shape );
+    if( getPntrToComponent( 2*i+1 )->getShape()[0]!=shape[0] ) {
+      getPntrToComponent( 2*i+1 )->setShape( shape );
+    }
   }
 
 }
 
 void DiagonalizeMatrix::calculate() {
-  if( getPntrToArgument(0)->getShape()[0]==0 ) return ;
+  if( getPntrToArgument(0)->getShape()[0]==0 ) {
+    return ;
+  }
   // Resize stuff that might need resizing
   unsigned nvals=getPntrToArgument(0)->getShape()[0];
-  if( eigvals.size()!=nvals ) { mymatrix.resize( nvals, nvals ); eigvals.resize( nvals ); eigvecs.resize( nvals, nvals ); }
+  if( eigvals.size()!=nvals ) {
+    mymatrix.resize( nvals, nvals );
+    eigvals.resize( nvals );
+    eigvecs.resize( nvals, nvals );
+  }
 
   // Retrieve the matrix from input
   retrieveFullMatrix( mymatrix );
@@ -120,8 +148,11 @@ void DiagonalizeMatrix::calculate() {
   // And set the eigenvalues and eigenvectors
   for(unsigned i=0; i<desired_vectors.size(); ++i) {
     getPntrToComponent(2*i)->set( eigvals[ mymatrix.ncols()-desired_vectors[i]] );
-    Value* evec_out = getPntrToComponent(2*i+1); unsigned vreq = mymatrix.ncols()-desired_vectors[i];
-    for(unsigned j=0; j<mymatrix.ncols(); ++j) evec_out->set( j, eigvecs( vreq, j ) );
+    Value* evec_out = getPntrToComponent(2*i+1);
+    unsigned vreq = mymatrix.ncols()-desired_vectors[i];
+    for(unsigned j=0; j<mymatrix.ncols(); ++j) {
+      evec_out->set( j, eigvecs( vreq, j ) );
+    }
   }
 }
 
@@ -134,13 +165,17 @@ double DiagonalizeMatrix::getForceOnMatrixElement( const unsigned& jrow, const u
       ff += getConstPntrToComponent(2*i)->getForce(0)*eigvecs(ncol,jrow)*eigvecs(ncol,kcol);
     }
     // And forces on eigenvectors
-    if( !getConstPntrToComponent(2*i+1)->forcesWereAdded() ) continue;
+    if( !getConstPntrToComponent(2*i+1)->forcesWereAdded() ) {
+      continue;
+    }
 
     unsigned ncol = mymatrix.ncols()-desired_vectors[i];
     for(unsigned n=0; n<mymatrix.nrows(); ++n) {
       double tmp2 = 0;
       for(unsigned m=0; m<mymatrix.nrows(); ++m) {
-        if( m==ncol ) continue;
+        if( m==ncol ) {
+          continue;
+        }
         tmp2 += eigvecs(m,n)*eigvecs(m,jrow)*eigvecs(ncol,kcol) / (eigvals[ncol]-eigvals[m]);
       }
       ff += getConstPntrToComponent(2*i+1)->getForce(n) * tmp2;
diff --git a/src/matrixtools/InvertMatrix.cpp b/src/matrixtools/InvertMatrix.cpp
index 72633d261a..acec86f776 100644
--- a/src/matrixtools/InvertMatrix.cpp
+++ b/src/matrixtools/InvertMatrix.cpp
@@ -45,12 +45,16 @@ class InvertMatrix : public MatrixOperationBase {
 /// Constructor
   explicit InvertMatrix(const ActionOptions&);
 ///
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
 /// Do the calculation
   void calculate() override;
 ///
   void apply() override;
-  double getForceOnMatrixElement( const unsigned& jrow, const unsigned& krow ) const override { plumed_error(); }
+  double getForceOnMatrixElement( const unsigned& jrow, const unsigned& krow ) const override {
+    plumed_error();
+  }
 };
 
 PLUMED_REGISTER_ACTION(InvertMatrix,"INVERT_MATRIX")
@@ -63,16 +67,24 @@ void InvertMatrix::registerKeywords( Keywords& keys ) {
 InvertMatrix::InvertMatrix(const ActionOptions& ao):
   Action(ao),
   MatrixOperationBase(ao),
-  input_is_constant(false)
-{
-  if( getPntrToArgument(0)->getShape()[0]!=getPntrToArgument(0)->getShape()[1] ) error("input matrix should be square");
+  input_is_constant(false) {
+  if( getPntrToArgument(0)->getShape()[0]!=getPntrToArgument(0)->getShape()[1] ) {
+    error("input matrix should be square");
+  }
 
   ActionSetup* as = dynamic_cast<ActionSetup*>( getPntrToArgument(0)->getPntrToAction() );
-  if(as) input_is_constant=true;
+  if(as) {
+    input_is_constant=true;
+  }
 
-  std::vector<unsigned> shape(2); shape[0]=shape[1]=getPntrToArgument(0)->getShape()[0]; addValue( shape );
-  setNotPeriodic(); getPntrToComponent(0)->buildDataStore(); getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
-  mymatrix.resize( shape[0], shape[1] ); inverse.resize( shape[0], shape[1] );
+  std::vector<unsigned> shape(2);
+  shape[0]=shape[1]=getPntrToArgument(0)->getShape()[0];
+  addValue( shape );
+  setNotPeriodic();
+  getPntrToComponent(0)->buildDataStore();
+  getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+  mymatrix.resize( shape[0], shape[1] );
+  inverse.resize( shape[0], shape[1] );
 }
 
 void InvertMatrix::calculate() {
@@ -81,18 +93,24 @@ void InvertMatrix::calculate() {
   // Now invert the matrix
   Invert( mymatrix, inverse );
   // And set the inverse
-  unsigned k = 0; Value* myval=getPntrToComponent(0);
+  unsigned k = 0;
+  Value* myval=getPntrToComponent(0);
   for(unsigned i=0; i<mymatrix.nrows(); ++i) {
     for(unsigned j=0; j<mymatrix.ncols(); ++j) {
-      myval->set( k, inverse(i,j) ); k++;
+      myval->set( k, inverse(i,j) );
+      k++;
     }
   }
 
-  if( !doNotCalculateDerivatives() && !input_is_constant ) error("derivatives of inverse matrix have not been implemented");
+  if( !doNotCalculateDerivatives() && !input_is_constant ) {
+    error("derivatives of inverse matrix have not been implemented");
+  }
 }
 
 void InvertMatrix::apply() {
-  if( doNotCalculateDerivatives() || input_is_constant ) return;
+  if( doNotCalculateDerivatives() || input_is_constant ) {
+    return;
+  }
   error("derivatives of inverse matrix have not been implemented");
 }
 
diff --git a/src/matrixtools/MatrixOperationBase.cpp b/src/matrixtools/MatrixOperationBase.cpp
index e2b2a4d7b0..0636d2807a 100644
--- a/src/matrixtools/MatrixOperationBase.cpp
+++ b/src/matrixtools/MatrixOperationBase.cpp
@@ -25,24 +25,34 @@ namespace PLMD {
 namespace matrixtools {
 
 void MatrixOperationBase::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithArguments::registerKeywords( keys ); ActionWithValue::registerKeywords( keys );
-  keys.use("ARG"); keys.remove("NUMERICAL_DERIVATIVES");
+  Action::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  keys.use("ARG");
+  keys.remove("NUMERICAL_DERIVATIVES");
   keys.add("optional","MATRIX","the input matrix (can use ARG instead)");
 }
 
 MatrixOperationBase::MatrixOperationBase(const ActionOptions&ao):
   Action(ao),
   ActionWithArguments(ao),
-  ActionWithValue(ao)
-{
+  ActionWithValue(ao) {
   if( getNumberOfArguments()==0 ) {
-    std::vector<Value*> args; parseArgumentList("MATRIX",args); requestArguments(args);
+    std::vector<Value*> args;
+    parseArgumentList("MATRIX",args);
+    requestArguments(args);
+  }
+  if( getNumberOfArguments()!=1 ) {
+    error("should only be one argument to this action");
   }
-  if( getNumberOfArguments()!=1 ) error("should only be one argument to this action");
   if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) {
     if( getName()=="TRANSPOSE" ) {
-      if (getPntrToArgument(0)->getRank()!=1 || getPntrToArgument(0)->hasDerivatives() ) error("input to this argument should be a matrix or vector");
-    } else error("input to this argument should be a matrix");
+      if (getPntrToArgument(0)->getRank()!=1 || getPntrToArgument(0)->hasDerivatives() ) {
+        error("input to this argument should be a matrix or vector");
+      }
+    } else {
+      error("input to this argument should be a matrix");
+    }
   }
   getPntrToArgument(0)->buildDataStore();
 }
@@ -51,29 +61,42 @@ void MatrixOperationBase::retrieveFullMatrix( Matrix<double>& mymatrix ) {
   if( mymatrix.nrows()!=getPntrToArgument(0)->getShape()[0] || mymatrix.nrows()!=getPntrToArgument(0)->getShape()[1] ) {
     mymatrix.resize( getPntrToArgument(0)->getShape()[0], getPntrToArgument(0)->getShape()[1] );
   }
-  unsigned nedge; getPntrToArgument(0)->retrieveEdgeList( nedge, pairs, vals  ); mymatrix=0;
+  unsigned nedge;
+  getPntrToArgument(0)->retrieveEdgeList( nedge, pairs, vals  );
+  mymatrix=0;
   bool symmetric = getPntrToArgument(0)->isSymmetric();
   for(unsigned i=0; i<nedge; ++i ) {
     mymatrix( pairs[i].first, pairs[i].second ) = vals[i];
-    if( symmetric ) mymatrix( pairs[i].second, pairs[i].first ) = vals[i];
+    if( symmetric ) {
+      mymatrix( pairs[i].second, pairs[i].first ) = vals[i];
+    }
   }
 }
 
 
 void MatrixOperationBase::apply() {
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
 
   bool forces=false;
   for(int i=0; i<getNumberOfComponents(); ++i) {
-    if( getPntrToComponent(i)->forcesWereAdded() ) { forces=true; break; }
+    if( getPntrToComponent(i)->forcesWereAdded() ) {
+      forces=true;
+      break;
+    }
+  }
+  if( !forces ) {
+    return;
   }
-  if( !forces ) return;
 
   Value* mat = getPntrToArgument(0);
   unsigned ncols=mat->getNumberOfColumns();
   for(unsigned i=0; i<mat->getShape()[0]; ++i) {
     unsigned ncol = mat->getRowLength(i);
-    for(unsigned j=0; j<ncol; ++j) mat->addForce( i*ncols+j, getForceOnMatrixElement( i, mat->getRowIndex(i,j) ), false );
+    for(unsigned j=0; j<ncol; ++j) {
+      mat->addForce( i*ncols+j, getForceOnMatrixElement( i, mat->getRowIndex(i,j) ), false );
+    }
   }
 }
 
diff --git a/src/matrixtools/MatrixOperationBase.h b/src/matrixtools/MatrixOperationBase.h
index e3d279c0f7..1aa5525308 100644
--- a/src/matrixtools/MatrixOperationBase.h
+++ b/src/matrixtools/MatrixOperationBase.h
@@ -31,8 +31,7 @@ namespace matrixtools {
 
 class MatrixOperationBase :
   public ActionWithArguments,
-  public ActionWithValue
-{
+  public ActionWithValue {
 private:
 /// These are used to hold the matrix
   std::vector<double> vals;
diff --git a/src/matrixtools/MatrixTimesMatrix.cpp b/src/matrixtools/MatrixTimesMatrix.cpp
index 34dc2f0b5a..498e282cb4 100644
--- a/src/matrixtools/MatrixTimesMatrix.cpp
+++ b/src/matrixtools/MatrixTimesMatrix.cpp
@@ -53,7 +53,9 @@ class MatrixTimesMatrix : public ActionWithMatrix {
   explicit MatrixTimesMatrix(const ActionOptions&);
   void prepare() override ;
   unsigned getNumberOfDerivatives();
-  unsigned getNumberOfColumns() const override { return getConstPntrToComponent(0)->getShape()[1]; }
+  unsigned getNumberOfColumns() const override {
+    return getConstPntrToComponent(0)->getShape()[1];
+  }
   void getAdditionalTasksRequired( ActionWithVector* action, std::vector<unsigned>& atasks ) override ;
   void setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const ;
   void performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const override;
@@ -64,28 +66,44 @@ PLUMED_REGISTER_ACTION(MatrixTimesMatrix,"MATRIX_PRODUCT")
 PLUMED_REGISTER_ACTION(MatrixTimesMatrix,"DISSIMILARITIES")
 
 void MatrixTimesMatrix::registerKeywords( Keywords& keys ) {
-  ActionWithMatrix::registerKeywords(keys); keys.use("ARG");
+  ActionWithMatrix::registerKeywords(keys);
+  keys.use("ARG");
   keys.addFlag("SQUARED",false,"calculate the squares of the dissimilarities (this option cannot be used with MATRIX_PRODUCT)");
   keys.setValueDescription("the product of the two input matrices");
 }
 
 MatrixTimesMatrix::MatrixTimesMatrix(const ActionOptions&ao):
   Action(ao),
-  ActionWithMatrix(ao)
-{
-  if( getNumberOfArguments()!=2 ) error("should be two arguments to this action, a matrix and a vector");
-  if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) error("first argument to this action should be a matrix");
-  if( getPntrToArgument(1)->getRank()!=2 || getPntrToArgument(1)->hasDerivatives() ) error("second argument to this action should be a matrix");
-  if( getPntrToArgument(0)->getShape()[1]!=getPntrToArgument(1)->getShape()[0] ) error("number of columns in first matrix does not equal number of rows in second matrix");
-  std::vector<unsigned> shape(2); shape[0]=getPntrToArgument(0)->getShape()[0]; shape[1]=getPntrToArgument(1)->getShape()[1];
-  addValue( shape ); setNotPeriodic(); nderivatives = buildArgumentStore(0);
+  ActionWithMatrix(ao) {
+  if( getNumberOfArguments()!=2 ) {
+    error("should be two arguments to this action, a matrix and a vector");
+  }
+  if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) {
+    error("first argument to this action should be a matrix");
+  }
+  if( getPntrToArgument(1)->getRank()!=2 || getPntrToArgument(1)->hasDerivatives() ) {
+    error("second argument to this action should be a matrix");
+  }
+  if( getPntrToArgument(0)->getShape()[1]!=getPntrToArgument(1)->getShape()[0] ) {
+    error("number of columns in first matrix does not equal number of rows in second matrix");
+  }
+  std::vector<unsigned> shape(2);
+  shape[0]=getPntrToArgument(0)->getShape()[0];
+  shape[1]=getPntrToArgument(1)->getShape()[1];
+  addValue( shape );
+  setNotPeriodic();
+  nderivatives = buildArgumentStore(0);
   std::string headstr=getFirstActionInChain()->getLabel();
   stored_matrix1 = getPntrToArgument(0)->ignoreStoredValue( headstr );
   stored_matrix2 = getPntrToArgument(1)->ignoreStoredValue( headstr );
   if( getName()=="DISSIMILARITIES" ) {
     parseFlag("SQUARED",squared);
-    if( squared ) log.printf("  calculating the squares of the dissimilarities \n");
-  } else squared=true;
+    if( squared ) {
+      log.printf("  calculating the squares of the dissimilarities \n");
+    }
+  } else {
+    squared=true;
+  }
 }
 
 unsigned MatrixTimesMatrix::getNumberOfDerivatives() {
@@ -94,52 +112,83 @@ unsigned MatrixTimesMatrix::getNumberOfDerivatives() {
 
 void MatrixTimesMatrix::prepare() {
   Value* myval = getPntrToComponent(0);
-  if( myval->getShape()[0]==getPntrToArgument(0)->getShape()[0] && myval->getShape()[1]==getPntrToArgument(1)->getShape()[1] ) return;
-  std::vector<unsigned> shape(2); shape[0]=getPntrToArgument(0)->getShape()[0]; shape[1]=getPntrToArgument(1)->getShape()[1];
-  myval->setShape(shape); if( myval->valueIsStored() ) myval->reshapeMatrixStore( shape[1] );
+  if( myval->getShape()[0]==getPntrToArgument(0)->getShape()[0] && myval->getShape()[1]==getPntrToArgument(1)->getShape()[1] ) {
+    return;
+  }
+  std::vector<unsigned> shape(2);
+  shape[0]=getPntrToArgument(0)->getShape()[0];
+  shape[1]=getPntrToArgument(1)->getShape()[1];
+  myval->setShape(shape);
+  if( myval->valueIsStored() ) {
+    myval->reshapeMatrixStore( shape[1] );
+  }
 }
 
 void MatrixTimesMatrix::getAdditionalTasksRequired( ActionWithVector* action, std::vector<unsigned>& atasks ) {
 
   ActionWithMatrix* adj=dynamic_cast<ActionWithMatrix*>( getPntrToArgument(0)->getPntrToAction() );
-  if( !adj->isAdjacencyMatrix() ) return;
-  adj->retrieveAtoms(); adj->getAdditionalTasksRequired( action, atasks );
+  if( !adj->isAdjacencyMatrix() ) {
+    return;
+  }
+  adj->retrieveAtoms();
+  adj->getAdditionalTasksRequired( action, atasks );
 }
 
 void MatrixTimesMatrix::setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const {
   unsigned start_n = getPntrToArgument(0)->getShape()[0], size_v = getPntrToArgument(1)->getShape()[1];
-  if( indices.size()!=size_v+1 ) indices.resize( size_v+1 );
-  for(unsigned i=0; i<size_v; ++i) indices[i+1] = start_n + i;
+  if( indices.size()!=size_v+1 ) {
+    indices.resize( size_v+1 );
+  }
+  for(unsigned i=0; i<size_v; ++i) {
+    indices[i+1] = start_n + i;
+  }
   myvals.setSplitIndex( size_v + 1 );
 }
 
 void MatrixTimesMatrix::performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const {
   unsigned ostrn = getConstPntrToComponent(0)->getPositionInStream(), ind2=index2;
-  if( index2>=getPntrToArgument(0)->getShape()[0] ) ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  if( index2>=getPntrToArgument(0)->getShape()[0] ) {
+    ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  }
 
   Value* myarg = getPntrToArgument(0);
-  unsigned nmult=myarg->getRowLength(index1); double matval=0;
+  unsigned nmult=myarg->getRowLength(index1);
+  double matval=0;
   std::vector<double>  dvec1(nmult), dvec2(nmult);
   for(unsigned i=0; i<nmult; ++i) {
     unsigned kind = myarg->getRowIndex( index1, i );
     double val1 = getElementOfMatrixArgument( 0, index1, kind, myvals );
     double val2 = getElementOfMatrixArgument( 1, kind, ind2, myvals );
     if( getName()=="DISSIMILARITIES" ) {
-      double tmp = getPntrToArgument(0)->difference(val2, val1); matval += tmp*tmp;
+      double tmp = getPntrToArgument(0)->difference(val2, val1);
+      matval += tmp*tmp;
       if( !squared ) {
-        dvec1[i] = 2*tmp; dvec2[i] = -2*tmp; continue;
-      } else { val2 = -2*tmp; val1 = 2*tmp; }
-    } else matval+= val1*val2;
+        dvec1[i] = 2*tmp;
+        dvec2[i] = -2*tmp;
+        continue;
+      } else {
+        val2 = -2*tmp;
+        val1 = 2*tmp;
+      }
+    } else {
+      matval+= val1*val2;
+    }
 
-    if( doNotCalculateDerivatives() ) continue;
+    if( doNotCalculateDerivatives() ) {
+      continue;
+    }
 
     addDerivativeOnMatrixArgument( stored_matrix1, 0, 0, index1, kind, val2, myvals );
     addDerivativeOnMatrixArgument( stored_matrix2, 0, 1, kind, ind2, val1, myvals );
   }
   // And add this part of the product
-  if( !squared ) matval = sqrt(matval);
+  if( !squared ) {
+    matval = sqrt(matval);
+  }
   myvals.addValue( ostrn, matval );
-  if( squared || doNotCalculateDerivatives() ) return;
+  if( squared || doNotCalculateDerivatives() ) {
+    return;
+  }
 
   for(unsigned i=0; i<nmult; ++i) {
     unsigned kind = myarg->getRowIndex( index1, i );
@@ -149,17 +198,25 @@ void MatrixTimesMatrix::performTask( const std::string& controller, const unsign
 }
 
 void MatrixTimesMatrix::runEndOfRowJobs( const unsigned& ival, const std::vector<unsigned> & indices, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() || !matrixChainContinues() ) return ;
+  if( doNotCalculateDerivatives() || !matrixChainContinues() ) {
+    return ;
+  }
 
   unsigned mat1s = ival*getPntrToArgument(0)->getShape()[1];
   unsigned nmult = getPntrToArgument(0)->getShape()[1], ss = getPntrToArgument(1)->getShape()[1];
   unsigned nmat = getConstPntrToComponent(0)->getPositionInMatrixStash(), nmat_ind = myvals.getNumberOfMatrixRowDerivatives( nmat );
-  std::vector<unsigned>& matrix_indices( myvals.getMatrixRowDerivativeIndices( nmat ) ); unsigned ntwo_atoms = myvals.getSplitIndex();
+  std::vector<unsigned>& matrix_indices( myvals.getMatrixRowDerivativeIndices( nmat ) );
+  unsigned ntwo_atoms = myvals.getSplitIndex();
   for(unsigned j=0; j<nmult; ++j) {
-    matrix_indices[nmat_ind] = mat1s + j; nmat_ind++;
+    matrix_indices[nmat_ind] = mat1s + j;
+    nmat_ind++;
     for(unsigned i=1; i<ntwo_atoms; ++i) {
-      unsigned ind2 = indices[i]; if( ind2>=getPntrToArgument(0)->getShape()[0] ) ind2 = indices[i] - getPntrToArgument(0)->getShape()[0];
-      matrix_indices[nmat_ind] = arg_deriv_starts[1] + j*ss + ind2; nmat_ind++;
+      unsigned ind2 = indices[i];
+      if( ind2>=getPntrToArgument(0)->getShape()[0] ) {
+        ind2 = indices[i] - getPntrToArgument(0)->getShape()[0];
+      }
+      matrix_indices[nmat_ind] = arg_deriv_starts[1] + j*ss + ind2;
+      nmat_ind++;
     }
   }
   myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind );
diff --git a/src/matrixtools/MatrixTimesVector.cpp b/src/matrixtools/MatrixTimesVector.cpp
index 4725b5131c..fad3f53838 100644
--- a/src/matrixtools/MatrixTimesVector.cpp
+++ b/src/matrixtools/MatrixTimesVector.cpp
@@ -43,10 +43,15 @@ class MatrixTimesVector : public ActionWithMatrix {
   static void registerKeywords( Keywords& keys );
   explicit MatrixTimesVector(const ActionOptions&);
   std::string getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const override ;
-  unsigned getNumberOfColumns() const override { plumed_error(); }
+  unsigned getNumberOfColumns() const override {
+    plumed_error();
+  }
   unsigned getNumberOfDerivatives();
   void prepare() override ;
-  bool isInSubChain( unsigned& nder ) override { nder = arg_deriv_starts[0]; return true; }
+  bool isInSubChain( unsigned& nder ) override {
+    nder = arg_deriv_starts[0];
+    return true;
+  }
   void setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const ;
   void performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const override;
   void runEndOfRowJobs( const unsigned& ind, const std::vector<unsigned> & indices, MultiValue& myvals ) const override ;
@@ -56,7 +61,8 @@ class MatrixTimesVector : public ActionWithMatrix {
 PLUMED_REGISTER_ACTION(MatrixTimesVector,"MATRIX_VECTOR_PRODUCT")
 
 void MatrixTimesVector::registerKeywords( Keywords& keys ) {
-  ActionWithMatrix::registerKeywords(keys); keys.use("ARG");
+  ActionWithMatrix::registerKeywords(keys);
+  keys.use("ARG");
   keys.setValueDescription("the vector that is obtained by taking the product between the matrix and the vector that were input");
   ActionWithValue::useCustomisableComponents(keys);
 }
@@ -74,81 +80,129 @@ std::string MatrixTimesVector::getOutputComponentDescription( const std::string&
       return "the product of the matrix " + getPntrToArgument(i)->getName() + " and the vector " + getPntrToArgument(getNumberOfArguments()-1)->getName();
     }
   }
-  plumed_merror( "could not understand request for component " + cname ); return "";
+  plumed_merror( "could not understand request for component " + cname );
+  return "";
 }
 
 MatrixTimesVector::MatrixTimesVector(const ActionOptions&ao):
   Action(ao),
   ActionWithMatrix(ao),
-  sumrows(false)
-{
-  if( getNumberOfArguments()<2 ) error("Not enough arguments specified");
+  sumrows(false) {
+  if( getNumberOfArguments()<2 ) {
+    error("Not enough arguments specified");
+  }
   unsigned nvectors=0, nmatrices=0;
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->hasDerivatives() ) error("arguments should be vectors or matrices");
-    if( getPntrToArgument(i)->getRank()<=1 ) nvectors++;
-    if( getPntrToArgument(i)->getRank()==2 ) nmatrices++;
+    if( getPntrToArgument(i)->hasDerivatives() ) {
+      error("arguments should be vectors or matrices");
+    }
+    if( getPntrToArgument(i)->getRank()<=1 ) {
+      nvectors++;
+    }
+    if( getPntrToArgument(i)->getRank()==2 ) {
+      nmatrices++;
+    }
   }
 
-  std::vector<unsigned> shape(1); shape[0]=getPntrToArgument(0)->getShape()[0];
+  std::vector<unsigned> shape(1);
+  shape[0]=getPntrToArgument(0)->getShape()[0];
   if( nvectors==1 ) {
     unsigned n = getNumberOfArguments()-1;
     for(unsigned i=0; i<n; ++i) {
-      if( getPntrToArgument(i)->getRank()!=2 || getPntrToArgument(i)->hasDerivatives() ) error("all arguments other than last argument should be matrices");
+      if( getPntrToArgument(i)->getRank()!=2 || getPntrToArgument(i)->hasDerivatives() ) {
+        error("all arguments other than last argument should be matrices");
+      }
       if( getPntrToArgument(n)->getRank()==0 ) {
-        if( getPntrToArgument(i)->getShape()[1]!=1 ) error("number of columns in input matrix does not equal number of elements in vector");
-      } else if( getPntrToArgument(i)->getShape()[1]!=getPntrToArgument(n)->getShape()[0] ) error("number of columns in input matrix does not equal number of elements in vector");
+        if( getPntrToArgument(i)->getShape()[1]!=1 ) {
+          error("number of columns in input matrix does not equal number of elements in vector");
+        }
+      } else if( getPntrToArgument(i)->getShape()[1]!=getPntrToArgument(n)->getShape()[0] ) {
+        error("number of columns in input matrix does not equal number of elements in vector");
+      }
     }
     if( getPntrToArgument(n)->getRank()>0 ) {
-      if( getPntrToArgument(n)->getRank()!=1 || getPntrToArgument(n)->hasDerivatives() ) error("last argument to this action should be a vector");
+      if( getPntrToArgument(n)->getRank()!=1 || getPntrToArgument(n)->hasDerivatives() ) {
+        error("last argument to this action should be a vector");
+      }
     }
     getPntrToArgument(n)->buildDataStore();
 
     ActionWithVector* av=dynamic_cast<ActionWithVector*>( getPntrToArgument(0)->getPntrToAction() );
-    if( av ) done_in_chain=canBeAfterInChain( av );
+    if( av ) {
+      done_in_chain=canBeAfterInChain( av );
+    }
 
     if( getNumberOfArguments()==2 ) {
-      addValue( shape ); setNotPeriodic();
+      addValue( shape );
+      setNotPeriodic();
     } else {
       for(unsigned i=0; i<getNumberOfArguments()-1; ++i) {
         std::string name = getPntrToArgument(i)->getName();
-        if( name.find_first_of(".")!=std::string::npos ) { std::size_t dot=name.find_first_of("."); name = name.substr(dot+1); }
-        addComponent( name, shape ); componentIsNotPeriodic( name );
+        if( name.find_first_of(".")!=std::string::npos ) {
+          std::size_t dot=name.find_first_of(".");
+          name = name.substr(dot+1);
+        }
+        addComponent( name, shape );
+        componentIsNotPeriodic( name );
       }
     }
     if( (getPntrToArgument(n)->getPntrToAction())->getName()=="CONSTANT" ) {
       sumrows=true;
       if( getPntrToArgument(n)->getRank()==0 ) {
-        if( fabs( getPntrToArgument(n)->get() - 1.0 )>epsilon ) sumrows = false;
+        if( fabs( getPntrToArgument(n)->get() - 1.0 )>epsilon ) {
+          sumrows = false;
+        }
       } else {
         for(unsigned i=0; i<getPntrToArgument(n)->getShape()[0]; ++i) {
-          if( fabs( getPntrToArgument(n)->get(i) - 1.0 )>epsilon ) { sumrows=false; break; }
+          if( fabs( getPntrToArgument(n)->get(i) - 1.0 )>epsilon ) {
+            sumrows=false;
+            break;
+          }
         }
       }
     }
   } else if( nmatrices==1 ) {
-    if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) error("first argument to this action should be a matrix");
+    if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) {
+      error("first argument to this action should be a matrix");
+    }
     for(unsigned i=1; i<getNumberOfArguments(); ++i) {
-      if( getPntrToArgument(i)->getRank()>1 || getPntrToArgument(i)->hasDerivatives() ) error("all arguments other than first argument should be vectors");
+      if( getPntrToArgument(i)->getRank()>1 || getPntrToArgument(i)->hasDerivatives() ) {
+        error("all arguments other than first argument should be vectors");
+      }
       if( getPntrToArgument(i)->getRank()==0 ) {
-        if( getPntrToArgument(0)->getShape()[1]!=1 ) error("number of columns in input matrix does not equal number of elements in vector");
-      } else if( getPntrToArgument(0)->getShape()[1]!=getPntrToArgument(i)->getShape()[0] ) error("number of columns in input matrix does not equal number of elements in vector");
+        if( getPntrToArgument(0)->getShape()[1]!=1 ) {
+          error("number of columns in input matrix does not equal number of elements in vector");
+        }
+      } else if( getPntrToArgument(0)->getShape()[1]!=getPntrToArgument(i)->getShape()[0] ) {
+        error("number of columns in input matrix does not equal number of elements in vector");
+      }
       getPntrToArgument(i)->buildDataStore();
     }
 
     ActionWithVector* av=dynamic_cast<ActionWithVector*>( getPntrToArgument(0)->getPntrToAction() );
-    if( av ) done_in_chain=canBeAfterInChain( av );
+    if( av ) {
+      done_in_chain=canBeAfterInChain( av );
+    }
 
     for(unsigned i=1; i<getNumberOfArguments(); ++i) {
       std::string name = getPntrToArgument(i)->getName();
-      if( name.find_first_of(".")!=std::string::npos ) { std::size_t dot=name.find_first_of("."); name = name.substr(dot+1); }
-      addComponent( name, shape ); componentIsNotPeriodic( name );
+      if( name.find_first_of(".")!=std::string::npos ) {
+        std::size_t dot=name.find_first_of(".");
+        name = name.substr(dot+1);
+      }
+      addComponent( name, shape );
+      componentIsNotPeriodic( name );
     }
-  } else error("You should either have one vector or one matrix in input");
+  } else {
+    error("You should either have one vector or one matrix in input");
+  }
 
   nderivatives = buildArgumentStore(0);
-  std::string headstr=getFirstActionInChain()->getLabel(); stored_arg.resize( getNumberOfArguments() );
-  for(unsigned i=0; i<getNumberOfArguments(); ++i) stored_arg[i] = getPntrToArgument(i)->ignoreStoredValue( headstr );
+  std::string headstr=getFirstActionInChain()->getLabel();
+  stored_arg.resize( getNumberOfArguments() );
+  for(unsigned i=0; i<getNumberOfArguments(); ++i) {
+    stored_arg[i] = getPntrToArgument(i)->ignoreStoredValue( headstr );
+  }
 }
 
 unsigned MatrixTimesVector::getNumberOfDerivatives() {
@@ -156,35 +210,56 @@ unsigned MatrixTimesVector::getNumberOfDerivatives() {
 }
 
 void MatrixTimesVector::prepare() {
-  ActionWithVector::prepare(); Value* myval = getPntrToComponent(0);
-  if( myval->getShape()[0]==getPntrToArgument(0)->getShape()[0] ) return;
-  std::vector<unsigned> shape(1); shape[0] = getPntrToArgument(0)->getShape()[0]; myval->setShape(shape);
+  ActionWithVector::prepare();
+  Value* myval = getPntrToComponent(0);
+  if( myval->getShape()[0]==getPntrToArgument(0)->getShape()[0] ) {
+    return;
+  }
+  std::vector<unsigned> shape(1);
+  shape[0] = getPntrToArgument(0)->getShape()[0];
+  myval->setShape(shape);
 }
 
 void MatrixTimesVector::setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const {
   unsigned start_n = getPntrToArgument(0)->getShape()[0], size_v = getPntrToArgument(0)->getRowLength(task_index);
-  if( indices.size()!=size_v+1 ) indices.resize( size_v + 1 );
-  for(unsigned i=0; i<size_v; ++i) indices[i+1] = start_n + i;
+  if( indices.size()!=size_v+1 ) {
+    indices.resize( size_v + 1 );
+  }
+  for(unsigned i=0; i<size_v; ++i) {
+    indices[i+1] = start_n + i;
+  }
   myvals.setSplitIndex( size_v + 1 );
 }
 
 void MatrixTimesVector::performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const {
-  unsigned ind2 = index2; if( index2>=getPntrToArgument(0)->getShape()[0] ) ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  unsigned ind2 = index2;
+  if( index2>=getPntrToArgument(0)->getShape()[0] ) {
+    ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  }
   if( sumrows ) {
-    unsigned n=getNumberOfArguments()-1; double matval = 0;
+    unsigned n=getNumberOfArguments()-1;
+    double matval = 0;
     for(unsigned i=0; i<getNumberOfArguments()-1; ++i) {
       unsigned ostrn = getConstPntrToComponent(i)->getPositionInStream();
       Value* myarg = getPntrToArgument(i);
-      if( !myarg->valueHasBeenSet() ) myvals.addValue( ostrn, myvals.get( myarg->getPositionInStream() ) );
-      else myvals.addValue( ostrn, myarg->get( index1*myarg->getNumberOfColumns() + ind2, false ) );
+      if( !myarg->valueHasBeenSet() ) {
+        myvals.addValue( ostrn, myvals.get( myarg->getPositionInStream() ) );
+      } else {
+        myvals.addValue( ostrn, myarg->get( index1*myarg->getNumberOfColumns() + ind2, false ) );
+      }
       // Now lets work out the derivatives
-      if( doNotCalculateDerivatives() ) continue;
+      if( doNotCalculateDerivatives() ) {
+        continue;
+      }
       addDerivativeOnMatrixArgument( stored_arg[i], i, i, index1, ind2, 1.0, myvals );
     }
   } else if( getPntrToArgument(1)->getRank()==1 ) {
-    double matval = 0; Value* myarg = getPntrToArgument(0); unsigned vcol = ind2;
-    if( !myarg->valueHasBeenSet() ) matval = myvals.get( myarg->getPositionInStream() );
-    else {
+    double matval = 0;
+    Value* myarg = getPntrToArgument(0);
+    unsigned vcol = ind2;
+    if( !myarg->valueHasBeenSet() ) {
+      matval = myvals.get( myarg->getPositionInStream() );
+    } else {
       matval = myarg->get( index1*myarg->getNumberOfColumns() + ind2, false );
       vcol = getPntrToArgument(0)->getRowIndex( index1, ind2 );
     }
@@ -194,16 +269,22 @@ void MatrixTimesVector::performTask( const std::string& controller, const unsign
       // And add this part of the product
       myvals.addValue( ostrn, matval*vecval );
       // Now lets work out the derivatives
-      if( doNotCalculateDerivatives() ) continue;
-      addDerivativeOnMatrixArgument( stored_arg[0], i, 0, index1, ind2, vecval, myvals ); addDerivativeOnVectorArgument( stored_arg[i+1], i, i+1, vcol, matval, myvals );
+      if( doNotCalculateDerivatives() ) {
+        continue;
+      }
+      addDerivativeOnMatrixArgument( stored_arg[0], i, 0, index1, ind2, vecval, myvals );
+      addDerivativeOnVectorArgument( stored_arg[i+1], i, i+1, vcol, matval, myvals );
     }
   } else {
-    unsigned n=getNumberOfArguments()-1; double matval = 0; unsigned vcol = ind2;
+    unsigned n=getNumberOfArguments()-1;
+    double matval = 0;
+    unsigned vcol = ind2;
     for(unsigned i=0; i<getNumberOfArguments()-1; ++i) {
       unsigned ostrn = getConstPntrToComponent(i)->getPositionInStream();
       Value* myarg = getPntrToArgument(i);
-      if( !myarg->valueHasBeenSet() ) matval = myvals.get( myarg->getPositionInStream() );
-      else {
+      if( !myarg->valueHasBeenSet() ) {
+        matval = myvals.get( myarg->getPositionInStream() );
+      } else {
         matval = myarg->get( index1*myarg->getNumberOfColumns() + ind2, false );
         vcol = getPntrToArgument(i)->getRowIndex( index1, ind2 );
       }
@@ -211,36 +292,50 @@ void MatrixTimesVector::performTask( const std::string& controller, const unsign
       // And add this part of the product
       myvals.addValue( ostrn, matval*vecval );
       // Now lets work out the derivatives
-      if( doNotCalculateDerivatives() ) continue;
-      addDerivativeOnMatrixArgument( stored_arg[i], i, i, index1, ind2, vecval, myvals ); addDerivativeOnVectorArgument( stored_arg[n], i, n, vcol, matval, myvals );
+      if( doNotCalculateDerivatives() ) {
+        continue;
+      }
+      addDerivativeOnMatrixArgument( stored_arg[i], i, i, index1, ind2, vecval, myvals );
+      addDerivativeOnVectorArgument( stored_arg[n], i, n, vcol, matval, myvals );
     }
   }
 }
 
 void MatrixTimesVector::runEndOfRowJobs( const unsigned& ind, const std::vector<unsigned> & indices, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() || !actionInChain() ) return ;
+  if( doNotCalculateDerivatives() || !actionInChain() ) {
+    return ;
+  }
 
   if( getPntrToArgument(1)->getRank()==1 ) {
     unsigned istrn = getPntrToArgument(0)->getPositionInMatrixStash();
     std::vector<unsigned>& mat_indices( myvals.getMatrixRowDerivativeIndices( istrn ) );
     for(unsigned j=0; j<getNumberOfComponents(); ++j) {
       unsigned ostrn = getConstPntrToComponent(j)->getPositionInStream();
-      for(unsigned i=0; i<myvals.getNumberOfMatrixRowDerivatives(istrn); ++i) myvals.updateIndex( ostrn, mat_indices[i] );
+      for(unsigned i=0; i<myvals.getNumberOfMatrixRowDerivatives(istrn); ++i) {
+        myvals.updateIndex( ostrn, mat_indices[i] );
+      }
     }
   } else {
     for(unsigned j=0; j<getNumberOfComponents(); ++j) {
       unsigned istrn = getPntrToArgument(j)->getPositionInMatrixStash();
       unsigned ostrn = getConstPntrToComponent(j)->getPositionInStream();
       std::vector<unsigned>& mat_indices( myvals.getMatrixRowDerivativeIndices( istrn ) );
-      for(unsigned i=0; i<myvals.getNumberOfMatrixRowDerivatives(istrn); ++i) myvals.updateIndex( ostrn, mat_indices[i] );
+      for(unsigned i=0; i<myvals.getNumberOfMatrixRowDerivatives(istrn); ++i) {
+        myvals.updateIndex( ostrn, mat_indices[i] );
+      }
     }
   }
 }
 
 void MatrixTimesVector::updateAdditionalIndices( const unsigned& ostrn, MultiValue& myvals ) const {
-  unsigned n = getNumberOfArguments()-1; if( getPntrToArgument(1)->getRank()==1 ) n = 1;
+  unsigned n = getNumberOfArguments()-1;
+  if( getPntrToArgument(1)->getRank()==1 ) {
+    n = 1;
+  }
   unsigned nvals = getPntrToArgument(n)->getNumberOfValues();
-  for(unsigned i=0; i<nvals; ++i) myvals.updateIndex( ostrn, arg_deriv_starts[n] + i );
+  for(unsigned i=0; i<nvals; ++i) {
+    myvals.updateIndex( ostrn, arg_deriv_starts[n] + i );
+  }
 }
 
 }
diff --git a/src/matrixtools/OuterProduct.cpp b/src/matrixtools/OuterProduct.cpp
index 881617ae02..714436338a 100644
--- a/src/matrixtools/OuterProduct.cpp
+++ b/src/matrixtools/OuterProduct.cpp
@@ -46,7 +46,9 @@ class OuterProduct : public ActionWithMatrix {
   explicit OuterProduct(const ActionOptions&);
   unsigned getNumberOfDerivatives();
   void prepare() override ;
-  unsigned getNumberOfColumns() const override { return getConstPntrToComponent(0)->getShape()[1]; }
+  unsigned getNumberOfColumns() const override {
+    return getConstPntrToComponent(0)->getShape()[1];
+  }
   void setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const ;
   void performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const override;
   void runEndOfRowJobs( const unsigned& ival, const std::vector<unsigned> & indices, MultiValue& myvals ) const override ;
@@ -55,7 +57,8 @@ class OuterProduct : public ActionWithMatrix {
 PLUMED_REGISTER_ACTION(OuterProduct,"OUTER_PRODUCT")
 
 void OuterProduct::registerKeywords( Keywords& keys ) {
-  ActionWithMatrix::registerKeywords(keys); keys.use("ARG");
+  ActionWithMatrix::registerKeywords(keys);
+  keys.use("ARG");
   keys.add("compulsory","FUNC","x*y","the function of the input vectors that should be put in the elements of the outer product");
   keys.addFlag("ELEMENTS_ON_DIAGONAL_ARE_ZERO",false,"set all diagonal elements to zero");
   keys.setValueDescription("a matrix containing the outer product of the two input vectors that was obtained using the function that was input");
@@ -65,13 +68,19 @@ OuterProduct::OuterProduct(const ActionOptions&ao):
   Action(ao),
   ActionWithMatrix(ao),
   domin(false),
-  domax(false)
-{
-  if( getNumberOfArguments()!=2 ) error("should be two arguments to this action, a matrix and a vector");
-  if( getPntrToArgument(0)->getRank()!=1 || getPntrToArgument(0)->hasDerivatives() ) error("first argument to this action should be a vector");
-  if( getPntrToArgument(1)->getRank()!=1 || getPntrToArgument(1)->hasDerivatives() ) error("first argument to this action should be a vector");
+  domax(false) {
+  if( getNumberOfArguments()!=2 ) {
+    error("should be two arguments to this action, a matrix and a vector");
+  }
+  if( getPntrToArgument(0)->getRank()!=1 || getPntrToArgument(0)->hasDerivatives() ) {
+    error("first argument to this action should be a vector");
+  }
+  if( getPntrToArgument(1)->getRank()!=1 || getPntrToArgument(1)->hasDerivatives() ) {
+    error("first argument to this action should be a vector");
+  }
 
-  std::string func; parse("FUNC",func);
+  std::string func;
+  parse("FUNC",func);
   if( func=="min") {
     domin=true;
     log.printf("  taking minimum of two input vectors \n");
@@ -80,18 +89,28 @@ OuterProduct::OuterProduct(const ActionOptions&ao):
     log.printf("  taking maximum of two input vectors \n");
   } else {
     log.printf("  with function : %s \n", func.c_str() );
-    std::vector<std::string> var(2); var[0]="x"; var[1]="y";
+    std::vector<std::string> var(2);
+    var[0]="x";
+    var[1]="y";
     function.set( func, var, this );
   }
   parseFlag("ELEMENTS_ON_DIAGONAL_ARE_ZERO",diagzero);
-  if( diagzero ) log.printf("  setting diagonal elements equal to zero\n");
+  if( diagzero ) {
+    log.printf("  setting diagonal elements equal to zero\n");
+  }
 
-  std::vector<unsigned> shape(2); shape[0]=getPntrToArgument(0)->getShape()[0]; shape[1]=getPntrToArgument(1)->getShape()[0];
-  addValue( shape ); setNotPeriodic(); nderivatives = buildArgumentStore(0);
+  std::vector<unsigned> shape(2);
+  shape[0]=getPntrToArgument(0)->getShape()[0];
+  shape[1]=getPntrToArgument(1)->getShape()[0];
+  addValue( shape );
+  setNotPeriodic();
+  nderivatives = buildArgumentStore(0);
   std::string headstr=getFirstActionInChain()->getLabel();
   stored_vector1 = getPntrToArgument(0)->ignoreStoredValue( headstr );
   stored_vector2 = getPntrToArgument(1)->ignoreStoredValue( headstr );
-  if( getPntrToArgument(0)->isDerivativeZeroWhenValueIsZero() || getPntrToArgument(1)->isDerivativeZeroWhenValueIsZero() ) getPntrToComponent(0)->setDerivativeIsZeroWhenValueIsZero();
+  if( getPntrToArgument(0)->isDerivativeZeroWhenValueIsZero() || getPntrToArgument(1)->isDerivativeZeroWhenValueIsZero() ) {
+    getPntrToComponent(0)->setDerivativeIsZeroWhenValueIsZero();
+  }
 }
 
 unsigned OuterProduct::getNumberOfDerivatives() {
@@ -99,46 +118,82 @@ unsigned OuterProduct::getNumberOfDerivatives() {
 }
 
 void OuterProduct::prepare() {
-  ActionWithVector::prepare(); Value* myval=getPntrToComponent(0);
-  if( myval->getShape()[0]==getPntrToArgument(0)->getShape()[0] && myval->getShape()[1]==getPntrToArgument(1)->getShape()[0] ) return;
-  std::vector<unsigned> shape(2); shape[0] = getPntrToArgument(0)->getShape()[0]; shape[1] = getPntrToArgument(1)->getShape()[0];
+  ActionWithVector::prepare();
+  Value* myval=getPntrToComponent(0);
+  if( myval->getShape()[0]==getPntrToArgument(0)->getShape()[0] && myval->getShape()[1]==getPntrToArgument(1)->getShape()[0] ) {
+    return;
+  }
+  std::vector<unsigned> shape(2);
+  shape[0] = getPntrToArgument(0)->getShape()[0];
+  shape[1] = getPntrToArgument(1)->getShape()[0];
   myval->setShape( shape );
 }
 
 void OuterProduct::setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const {
   unsigned start_n = getPntrToArgument(0)->getShape()[0], size_v = getPntrToArgument(1)->getShape()[0];
   if( diagzero ) {
-    if( indices.size()!=size_v ) indices.resize( size_v );
+    if( indices.size()!=size_v ) {
+      indices.resize( size_v );
+    }
     unsigned k=1;
     for(unsigned i=0; i<size_v; ++i) {
-      if( task_index==i ) continue ;
-      indices[k] = size_v + i; k++;
+      if( task_index==i ) {
+        continue ;
+      }
+      indices[k] = size_v + i;
+      k++;
     }
     myvals.setSplitIndex( size_v );
   } else {
-    if( indices.size()!=size_v+1 ) indices.resize( size_v+1 );
-    for(unsigned i=0; i<size_v; ++i) indices[i+1] = start_n + i;
+    if( indices.size()!=size_v+1 ) {
+      indices.resize( size_v+1 );
+    }
+    for(unsigned i=0; i<size_v; ++i) {
+      indices[i+1] = start_n + i;
+    }
     myvals.setSplitIndex( size_v + 1 );
   }
 }
 
 void OuterProduct::performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const {
   unsigned ostrn = getConstPntrToComponent(0)->getPositionInStream(), ind2=index2;
-  if( index2>=getPntrToArgument(0)->getShape()[0] ) ind2 = index2 - getPntrToArgument(0)->getShape()[0];
-  if( diagzero && index1==ind2 ) return;
+  if( index2>=getPntrToArgument(0)->getShape()[0] ) {
+    ind2 = index2 - getPntrToArgument(0)->getShape()[0];
+  }
+  if( diagzero && index1==ind2 ) {
+    return;
+  }
 
-  double fval; unsigned jarg = 0, kelem = index1; bool jstore=stored_vector1;
+  double fval;
+  unsigned jarg = 0, kelem = index1;
+  bool jstore=stored_vector1;
   std::vector<double> args(2);
   args[0] = getArgumentElement( 0, index1, myvals );
   args[1] = getArgumentElement( 1, ind2, myvals );
   if( domin ) {
-    fval=args[0]; if( args[1]<args[0] ) { fval=args[1]; jarg=1; kelem=ind2; jstore=stored_vector2; }
+    fval=args[0];
+    if( args[1]<args[0] ) {
+      fval=args[1];
+      jarg=1;
+      kelem=ind2;
+      jstore=stored_vector2;
+    }
   } else if( domax ) {
-    fval=args[0]; if( args[1]>args[0] ) { fval=args[1]; jarg=1; kelem=ind2; jstore=stored_vector2; }
-  } else { fval=function.evaluate( args ); }
+    fval=args[0];
+    if( args[1]>args[0] ) {
+      fval=args[1];
+      jarg=1;
+      kelem=ind2;
+      jstore=stored_vector2;
+    }
+  } else {
+    fval=function.evaluate( args );
+  }
 
   myvals.addValue( ostrn, fval );
-  if( doNotCalculateDerivatives() ) return ;
+  if( doNotCalculateDerivatives() ) {
+    return ;
+  }
 
   if( domin || domax ) {
     addDerivativeOnVectorArgument( jstore, 0, jarg, kelem, 1.0, myvals );
@@ -146,15 +201,21 @@ void OuterProduct::performTask( const std::string& controller, const unsigned& i
     addDerivativeOnVectorArgument( stored_vector1, 0, 0, index1, function.evaluateDeriv( 0, args ), myvals );
     addDerivativeOnVectorArgument( stored_vector2, 0, 1, ind2, function.evaluateDeriv( 1, args ), myvals );
   }
-  if( doNotCalculateDerivatives() || !matrixChainContinues() ) return ;
+  if( doNotCalculateDerivatives() || !matrixChainContinues() ) {
+    return ;
+  }
   unsigned nmat = getConstPntrToComponent(0)->getPositionInMatrixStash(), nmat_ind = myvals.getNumberOfMatrixRowDerivatives( nmat );
-  myvals.getMatrixRowDerivativeIndices( nmat )[nmat_ind] = arg_deriv_starts[1] + ind2; myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind+1 );
+  myvals.getMatrixRowDerivativeIndices( nmat )[nmat_ind] = arg_deriv_starts[1] + ind2;
+  myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind+1 );
 }
 
 void OuterProduct::runEndOfRowJobs( const unsigned& ival, const std::vector<unsigned> & indices, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() || !matrixChainContinues() ) return ;
+  if( doNotCalculateDerivatives() || !matrixChainContinues() ) {
+    return ;
+  }
   unsigned nmat = getConstPntrToComponent(0)->getPositionInMatrixStash(), nmat_ind = myvals.getNumberOfMatrixRowDerivatives( nmat );
-  myvals.getMatrixRowDerivativeIndices( nmat )[nmat_ind] = ival; myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind+1 );
+  myvals.getMatrixRowDerivativeIndices( nmat )[nmat_ind] = ival;
+  myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind+1 );
 }
 
 }
diff --git a/src/matrixtools/TransposeMatrix.cpp b/src/matrixtools/TransposeMatrix.cpp
index 125bd43b31..932a9d251e 100644
--- a/src/matrixtools/TransposeMatrix.cpp
+++ b/src/matrixtools/TransposeMatrix.cpp
@@ -40,7 +40,9 @@ class TransposeMatrix : public MatrixOperationBase {
 /// Constructor
   explicit TransposeMatrix(const ActionOptions&);
 ///
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
 ///
   void prepare() override ;
 ///
@@ -60,67 +62,115 @@ void TransposeMatrix::registerKeywords( Keywords& keys ) {
 
 TransposeMatrix::TransposeMatrix(const ActionOptions& ao):
   Action(ao),
-  MatrixOperationBase(ao)
-{
-  if( getPntrToArgument(0)->isSymmetric() ) error("input matrix is symmetric.  Transposing will achieve nothing!");
+  MatrixOperationBase(ao) {
+  if( getPntrToArgument(0)->isSymmetric() ) {
+    error("input matrix is symmetric.  Transposing will achieve nothing!");
+  }
   std::vector<unsigned> shape;
-  if( getPntrToArgument(0)->getRank()==0 ) error("transposing a scalar?");
-  else if( getPntrToArgument(0)->getRank()==1 ) { shape.resize(2); shape[0]=1; shape[1]=getPntrToArgument(0)->getShape()[0]; }
-  else if( getPntrToArgument(0)->getShape()[0]==1 ) { shape.resize(1); shape[0] = getPntrToArgument(0)->getShape()[1]; }
-  else { shape.resize(2); shape[0]=getPntrToArgument(0)->getShape()[1]; shape[1]=getPntrToArgument(0)->getShape()[0]; }
-  addValue( shape ); setNotPeriodic(); getPntrToComponent(0)->buildDataStore();
-  if( shape.size()==2 ) getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+  if( getPntrToArgument(0)->getRank()==0 ) {
+    error("transposing a scalar?");
+  } else if( getPntrToArgument(0)->getRank()==1 ) {
+    shape.resize(2);
+    shape[0]=1;
+    shape[1]=getPntrToArgument(0)->getShape()[0];
+  } else if( getPntrToArgument(0)->getShape()[0]==1 ) {
+    shape.resize(1);
+    shape[0] = getPntrToArgument(0)->getShape()[1];
+  } else {
+    shape.resize(2);
+    shape[0]=getPntrToArgument(0)->getShape()[1];
+    shape[1]=getPntrToArgument(0)->getShape()[0];
+  }
+  addValue( shape );
+  setNotPeriodic();
+  getPntrToComponent(0)->buildDataStore();
+  if( shape.size()==2 ) {
+    getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+  }
 }
 
 void TransposeMatrix::prepare() {
-  Value* myval = getPntrToComponent(0); Value* myarg = getPntrToArgument(0);
+  Value* myval = getPntrToComponent(0);
+  Value* myarg = getPntrToArgument(0);
   if( myarg->getRank()==1 ) {
     if( myval->getShape()[0]!=1 || myval->getShape()[1]!=myarg->getShape()[0] ) {
-      std::vector<unsigned> shape(2); shape[0] = 1; shape[1] = myarg->getShape()[0];
-      myval->setShape( shape ); myval->reshapeMatrixStore( shape[1] );
+      std::vector<unsigned> shape(2);
+      shape[0] = 1;
+      shape[1] = myarg->getShape()[0];
+      myval->setShape( shape );
+      myval->reshapeMatrixStore( shape[1] );
     }
   } else if( myarg->getShape()[0]==1 ) {
-    if( myval->getShape()[0]!=myarg->getShape()[1] ) { std::vector<unsigned> shape(1); shape[0] = myarg->getShape()[1]; myval->setShape( shape ); }
+    if( myval->getShape()[0]!=myarg->getShape()[1] ) {
+      std::vector<unsigned> shape(1);
+      shape[0] = myarg->getShape()[1];
+      myval->setShape( shape );
+    }
   } else if( myarg->getShape()[0]!=myval->getShape()[1] || myarg->getShape()[1]!=myval->getShape()[0] ) {
-    std::vector<unsigned> shape(2); shape[0] = myarg->getShape()[1]; shape[1] = myarg->getShape()[0];
-    myval->setShape( shape ); myval->reshapeMatrixStore( shape[1] );
+    std::vector<unsigned> shape(2);
+    shape[0] = myarg->getShape()[1];
+    shape[1] = myarg->getShape()[0];
+    myval->setShape( shape );
+    myval->reshapeMatrixStore( shape[1] );
   }
 }
 
 void TransposeMatrix::calculate() {
   // Retrieve the non-zero pairs
-  Value* myarg=getPntrToArgument(0); Value* myval=getPntrToComponent(0);
+  Value* myarg=getPntrToArgument(0);
+  Value* myval=getPntrToComponent(0);
   if( myarg->getRank()<=1 || myval->getRank()==1 ) {
     if( myarg->getRank()<=1 && myval->getShape()[1]!=myarg->getShape()[0] ) {
-      std::vector<unsigned> shape( 2 ); shape[0] = 1; shape[1] = myarg->getShape()[0];
-      myval->setShape( shape ); myval->reshapeMatrixStore( shape[1] );
+      std::vector<unsigned> shape( 2 );
+      shape[0] = 1;
+      shape[1] = myarg->getShape()[0];
+      myval->setShape( shape );
+      myval->reshapeMatrixStore( shape[1] );
     } else if( myval->getRank()==1 && myval->getShape()[0]!=myarg->getShape()[1] ) {
-      std::vector<unsigned> shape( 1 ); shape[0] = myarg->getShape()[1];
+      std::vector<unsigned> shape( 1 );
+      shape[0] = myarg->getShape()[1];
       myval->setShape( shape );
     }
     unsigned nv=myarg->getNumberOfValues();
-    for(unsigned i=0; i<nv; ++i) myval->set( i, myarg->get(i) );
+    for(unsigned i=0; i<nv; ++i) {
+      myval->set( i, myarg->get(i) );
+    }
   } else {
     if( myarg->getShape()[0]!=myval->getShape()[1] || myarg->getShape()[1]!=myval->getShape()[0] ) {
-      std::vector<unsigned> shape( 2 ); shape[0] = myarg->getShape()[1]; shape[1] = myarg->getShape()[0];
-      myval->setShape( shape ); myval->reshapeMatrixStore( shape[1] );
+      std::vector<unsigned> shape( 2 );
+      shape[0] = myarg->getShape()[1];
+      shape[1] = myarg->getShape()[0];
+      myval->setShape( shape );
+      myval->reshapeMatrixStore( shape[1] );
+    }
+    std::vector<double> vals;
+    std::vector<std::pair<unsigned,unsigned> > pairs;
+    std::vector<unsigned> shape( myval->getShape() );
+    unsigned nedge=0;
+    myarg->retrieveEdgeList( nedge, pairs, vals );
+    for(unsigned i=0; i<nedge; ++i) {
+      myval->set( pairs[i].second*shape[1] + pairs[i].first, vals[i] );
     }
-    std::vector<double> vals; std::vector<std::pair<unsigned,unsigned> > pairs;
-    std::vector<unsigned> shape( myval->getShape() ); unsigned nedge=0; myarg->retrieveEdgeList( nedge, pairs, vals );
-    for(unsigned i=0; i<nedge; ++i) myval->set( pairs[i].second*shape[1] + pairs[i].first, vals[i] );
   }
 }
 
 void TransposeMatrix::apply() {
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
 
   // Apply force on the matrix
   if( getPntrToComponent(0)->forcesWereAdded() ) {
-    Value* myarg=getPntrToArgument(0); Value* myval=getPntrToComponent(0);
+    Value* myarg=getPntrToArgument(0);
+    Value* myval=getPntrToComponent(0);
     if( myarg->getRank()<=1 || myval->getRank()==1 ) {
       unsigned nv=myarg->getNumberOfValues();
-      for(unsigned i=0; i<nv; ++i) myarg->addForce( i, myval->getForce(i) );
-    } else MatrixOperationBase::apply();
+      for(unsigned i=0; i<nv; ++i) {
+        myarg->addForce( i, myval->getForce(i) );
+      }
+    } else {
+      MatrixOperationBase::apply();
+    }
   }
 }
 
diff --git a/src/matrixtools/Voronoi.cpp b/src/matrixtools/Voronoi.cpp
index a5ab13090b..df91ba6f2e 100644
--- a/src/matrixtools/Voronoi.cpp
+++ b/src/matrixtools/Voronoi.cpp
@@ -39,8 +39,12 @@ class Voronoi : public ActionWithMatrix {
   static void registerKeywords( Keywords& keys );
   explicit Voronoi(const ActionOptions&);
   void prepare() override ;
-  unsigned getNumberOfDerivatives() override { return 0; }
-  unsigned getNumberOfColumns() const override { return getConstPntrToComponent(0)->getShape()[1]; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
+  unsigned getNumberOfColumns() const override {
+    return getConstPntrToComponent(0)->getShape()[1];
+  }
   void setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const override {}
   void performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const override {}
   void runEndOfRowJobs( const unsigned& ival, const std::vector<unsigned> & indices, MultiValue& myvals ) const override {}
@@ -51,33 +55,51 @@ class Voronoi : public ActionWithMatrix {
 PLUMED_REGISTER_ACTION(Voronoi,"VORONOI")
 
 void Voronoi::registerKeywords( Keywords& keys ) {
-  ActionWithMatrix::registerKeywords(keys); keys.use("ARG");
+  ActionWithMatrix::registerKeywords(keys);
+  keys.use("ARG");
   keys.setValueDescription("a matrix in which element ij is equal to one if the ij component of the input matrix is lower than all the ik elements of the matrix where k is not j and zero otherwise");
 }
 
 Voronoi::Voronoi(const ActionOptions&ao):
   Action(ao),
-  ActionWithMatrix(ao)
-{
-  if( getNumberOfArguments()!=1 ) error("should be one arguments to this action, a matrix");
-  if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) error("argument to this action should be a matrix");
-  if( getPntrToArgument(0)->getShape()[1]>getPntrToArgument(0)->getShape()[0] ) warning("would expect number of columns in matrix to exceed number of rows");
-  getPntrToArgument(0)->buildDataStore(); std::vector<unsigned> shape( getPntrToArgument(0)->getShape() );
-  addValue( shape ); setNotPeriodic(); getPntrToComponent(0)->buildDataStore();
+  ActionWithMatrix(ao) {
+  if( getNumberOfArguments()!=1 ) {
+    error("should be one arguments to this action, a matrix");
+  }
+  if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) {
+    error("argument to this action should be a matrix");
+  }
+  if( getPntrToArgument(0)->getShape()[1]>getPntrToArgument(0)->getShape()[0] ) {
+    warning("would expect number of columns in matrix to exceed number of rows");
+  }
+  getPntrToArgument(0)->buildDataStore();
+  std::vector<unsigned> shape( getPntrToArgument(0)->getShape() );
+  addValue( shape );
+  setNotPeriodic();
+  getPntrToComponent(0)->buildDataStore();
 }
 
 void Voronoi::prepare() {
   Value* myval = getPntrToComponent(0);
-  if( myval->getShape()[0]==getPntrToArgument(0)->getShape()[0] && myval->getShape()[1]==getPntrToArgument(0)->getShape()[1] ) return;
-  std::vector<unsigned> shape( getPntrToArgument(0)->getShape() ); myval->setShape(shape);
+  if( myval->getShape()[0]==getPntrToArgument(0)->getShape()[0] && myval->getShape()[1]==getPntrToArgument(0)->getShape()[1] ) {
+    return;
+  }
+  std::vector<unsigned> shape( getPntrToArgument(0)->getShape() );
+  myval->setShape(shape);
 }
 
 void Voronoi::gatherStoredValue( const unsigned& valindex, const unsigned& code, const MultiValue& myvals,
                                  const unsigned& bufstart, std::vector<double>& buffer ) const {
-  Value* arg0 = getPntrToArgument(0); unsigned nv = 0; std::size_t cc=code; double minmax = arg0->get( cc*arg0->getShape()[1] );
+  Value* arg0 = getPntrToArgument(0);
+  unsigned nv = 0;
+  std::size_t cc=code;
+  double minmax = arg0->get( cc*arg0->getShape()[1] );
   for(unsigned i=0; i<arg0->getShape()[1]; ++i) {
     double value = arg0->get( code*arg0->getShape()[1] + i );
-    if( value<minmax ) { minmax = value; nv = i; }
+    if( value<minmax ) {
+      minmax = value;
+      nv = i;
+    }
   }
   buffer[bufstart + code*arg0->getShape()[1] + nv] = 1;
 }
diff --git a/src/maze/Loss.cpp b/src/maze/Loss.cpp
index 76a4a16e9b..2e2d0280dd 100644
--- a/src/maze/Loss.cpp
+++ b/src/maze/Loss.cpp
@@ -74,8 +74,7 @@ void Loss::registerKeywords(Keywords& keys) {
 }
 
 Loss::Loss(const ActionOptions& ao)
-  : PLUMED_COLVAR_INIT(ao)
-{
+  : PLUMED_COLVAR_INIT(ao) {
   if (keywords.exists("PARAMS")) {
     parseVector("PARAMS", params_);
 
diff --git a/src/maze/Memetic.cpp b/src/maze/Memetic.cpp
index 36774e55e7..7cc61c6534 100644
--- a/src/maze/Memetic.cpp
+++ b/src/maze/Memetic.cpp
@@ -147,8 +147,7 @@ Memetic::Memetic(const ActionOptions& ao)
     score_best_(0),
     adaptation_(true),
     coding_len_(3),
-    local_search_on_(false)
-{
+    local_search_on_(false) {
   log.printf("maze> Memetic sampling.\n");
 
   if (keywords.exists("CAPACITY")) {
diff --git a/src/maze/Memetic.h b/src/maze/Memetic.h
index 439f72cb3b..695584d07b 100644
--- a/src/maze/Memetic.h
+++ b/src/maze/Memetic.h
@@ -357,7 +357,9 @@ void Memetic::sort_members() {
 }
 
 double Memetic::score_mean() {
-  auto acc = [](double s, const Member& m) { return s + m.score; };
+  auto acc = [](double s, const Member& m) {
+    return s + m.score;
+  };
 
   return std::accumulate(
            members_.begin(),
@@ -440,8 +442,7 @@ void Memetic::mutation(std::vector<Member>& m) {
 
 void Memetic::stochastic_hill_climbing(
   Member& m,
-  const std::vector<double>& params)
-{
+  const std::vector<double>& params) {
   for (std::size_t i = 0; i < n_local_iterations_; ++i) {
     Member n;
     n.translation = m.translation;
@@ -456,8 +457,7 @@ void Memetic::stochastic_hill_climbing(
 
 void Memetic::random_restart_hill_climbing(
   Member& m,
-  const std::vector<double>& params)
-{
+  const std::vector<double>& params) {
   unsigned int n_restarts = static_cast<int>(params[0]);
   std::vector<Member> s(n_restarts);
   unsigned int ndx = 0;
@@ -479,8 +479,7 @@ void Memetic::random_restart_hill_climbing(
 
 void Memetic::annealing(
   Member& m,
-  const std::vector<double>& params)
-{
+  const std::vector<double>& params) {
   double T = params[0];
   double alpha = params[1];
 
@@ -506,15 +505,13 @@ void Memetic::annealing(
 
 void Memetic::luus_jaakola(
   Member& m,
-  const std::vector<double>& params)
-{
+  const std::vector<double>& params) {
   /* TODO */
 }
 
 void Memetic::adaptive_random_search(
   Member& m,
-  const std::vector<double>& params)
-{
+  const std::vector<double>& params) {
   double rho_start = params[0];
   double rho_lower_bound = params[1];
   double ex = params[2];
@@ -533,8 +530,7 @@ void Memetic::adaptive_random_search(
   while (rho_k > rho_lower_bound && k < n_local_iterations_) {
     if (ns >= s_ex) {
       rho_k *= ex;
-    }
-    else if (nf >= f_ct) {
+    } else if (nf >= f_ct) {
       rho_k *= ct;
     }
 
@@ -558,8 +554,7 @@ void Memetic::adaptive_random_search(
         bk[i] = 0.2 * bk[i] + 0.4 * (chi[i] - xk[i]);
         xk[i] = chi[i];
       }
-    }
-    else if (score_tmp < score_xk && score_xk <= score_chi) {
+    } else if (score_tmp < score_xk && score_xk <= score_chi) {
       ns++;
       nf = 0;
 
@@ -567,8 +562,7 @@ void Memetic::adaptive_random_search(
         bk[i] = bk[i] - 0.4 * (chi[i] - xk[i]);
         xk[i] = 2.0 * xk[i] - chi[i];
       }
-    }
-    else {
+    } else {
       ns = 0;
       nf++;
 
@@ -591,12 +585,13 @@ void Memetic::local_search(std::vector<Member>& m) {
       double probability = rnd::next_double();
 
       if (probability < local_search_rate_) {
-        if (local_search_type_ == "stochastic_hill_climbing")
+        if (local_search_type_ == "stochastic_hill_climbing") {
           stochastic_hill_climbing(m[i]);
-        else if (local_search_type_ == "adaptive_random_search")
+        } else if (local_search_type_ == "adaptive_random_search") {
           adaptive_random_search(m[i]);
-        else if (local_search_type_ == "random_restart_hill_climbing")
+        } else if (local_search_type_ == "random_restart_hill_climbing") {
           random_restart_hill_climbing(m[i]);
+        }
       }
     }
   }
@@ -621,8 +616,7 @@ void Memetic::mating(std::vector<Member>& m) {
     if (i > j) {
       m.erase(m.begin() + i);
       m.erase(m.begin() + j);
-    }
-    else if (j > i) {
+    } else if (j > i) {
       m.erase(m.begin() + j);
       m.erase(m.begin() + i);
     }
@@ -672,8 +666,7 @@ double Memetic::score_member(const Vector& coding) {
 
       if (pbc_) {
         distance = pbcDistance(getPosition(i0) + dev, getPosition(i1));
-      }
-      else {
+      } else {
         distance = delta(getPosition(i0) + dev, getPosition(i1));
       }
 
diff --git a/src/maze/Optimizer.cpp b/src/maze/Optimizer.cpp
index 73dc38ca2d..fbf2a0a56c 100644
--- a/src/maze/Optimizer.cpp
+++ b/src/maze/Optimizer.cpp
@@ -143,8 +143,7 @@ Optimizer::Optimizer(const ActionOptions& ao)
     sampling_r_(0.0),
     serial_(false),
     validate_list_(true),
-    first_time_(true)
-{
+    first_time_(true) {
   parseFlag("SERIAL", serial_);
 
   if (keywords.exists("LOSS")) {
@@ -234,8 +233,7 @@ Optimizer::Optimizer(const ActionOptions& ao)
                          nl_cutoff_,
                          nl_stride_
                        );
-    }
-    else {
+    } else {
       neighbor_list_=Tools::make_unique<NeighborList>(
                        ga_list,
                        gb_list,
@@ -246,8 +244,7 @@ Optimizer::Optimizer(const ActionOptions& ao)
                        comm
                      );
     }
-  }
-  else {
+  } else {
     if (do_neigh) {
       neighbor_list_ = Tools::make_unique<NeighborList>(
                          ga_list,
@@ -258,8 +255,7 @@ Optimizer::Optimizer(const ActionOptions& ao)
                          nl_cutoff_,
                          nl_stride_
                        );
-    }
-    else {
+    } else {
       neighbor_list_=Tools::make_unique<NeighborList>(
                        ga_list,
                        serial_,
@@ -294,8 +290,7 @@ Optimizer::Optimizer(const ActionOptions& ao)
 
   if (pbc_) {
     log.printf("maze> Using periodic boundary conditions.\n");
-  }
-  else {
+  } else {
     log.printf("maze> Without periodic boundary conditions.\n");
   }
 
@@ -393,8 +388,7 @@ void Optimizer::prepare() {
 
       validate_list_ = true;
       first_time_ = false;
-    }
-    else {
+    } else {
       requestAtoms(neighbor_list_->getReducedAtomList());
 
       validate_list_ = false;
@@ -430,8 +424,7 @@ double Optimizer::score() {
 
       if (pbc_) {
         distance = pbcDistance(getPosition(i0), getPosition(i1));
-      }
-      else {
+      } else {
         distance = delta(getPosition(i0), getPosition(i1));
       }
 
@@ -448,8 +441,7 @@ void Optimizer::update_nl() {
   }
 }
 
-double Optimizer::sampling_radius()
-{
+double Optimizer::sampling_radius() {
   const unsigned nl_size=neighbor_list_->size();
   Vector d;
   double min=std::numeric_limits<int>::max();
@@ -464,8 +456,7 @@ double Optimizer::sampling_radius()
 
     if (pbc_) {
       d = pbcDistance(getPosition(i0), getPosition(i1));
-    }
-    else {
+    } else {
       d = delta(getPosition(i0), getPosition(i1));
     }
 
@@ -491,8 +482,7 @@ void Optimizer::calculate() {
 
     value_action_->set(score());
     value_sampling_radius_->set(sampling_radius());
-  }
-  else {
+  } else {
     first_step_=false;
 
     value_x_->set(opt_[0]);
diff --git a/src/maze/Optimizer_Bias.cpp b/src/maze/Optimizer_Bias.cpp
index 7b420fd493..af17fed790 100644
--- a/src/maze/Optimizer_Bias.cpp
+++ b/src/maze/Optimizer_Bias.cpp
@@ -260,8 +260,7 @@ OptimizerBias::OptimizerBias(const ActionOptions& ao)
   : PLUMED_BIAS_INIT(ao),
     bias_(0.0),
     force_(0.0),
-    total_distance_(0.0)
-{
+    total_distance_(0.0) {
   log.printf(
     "maze> You are using the maze module of PLUMED2,\
     please read and cite "
diff --git a/src/maze/Random_Acceleration_MD.cpp b/src/maze/Random_Acceleration_MD.cpp
index 741fda6e95..7eae952b48 100644
--- a/src/maze/Random_Acceleration_MD.cpp
+++ b/src/maze/Random_Acceleration_MD.cpp
@@ -180,8 +180,7 @@ void Random_Acceleration_MD::optimize() {
 
   if (pbc_) {
     d = pbcDistance(c, com_);
-  }
-  else {
+  } else {
     d = delta(c, com_);
   }
 
diff --git a/src/maze/Random_Walk.cpp b/src/maze/Random_Walk.cpp
index 5d82c456e4..6d4e2ab6f2 100644
--- a/src/maze/Random_Walk.cpp
+++ b/src/maze/Random_Walk.cpp
@@ -103,8 +103,7 @@ void Random_Walk::registerKeywords(Keywords& keys) {
 }
 
 Random_Walk::Random_Walk(const ActionOptions& ao)
-  : PLUMED_OPT_INIT(ao)
-{
+  : PLUMED_OPT_INIT(ao) {
   log.printf("maze> Fake optimizer that returns a next step as random,\
     can be used to monitor loss, and for debugging and regtests purposes.\n");
 
diff --git a/src/maze/Simulated_Annealing.cpp b/src/maze/Simulated_Annealing.cpp
index 4edf3003cc..48090e536b 100644
--- a/src/maze/Simulated_Annealing.cpp
+++ b/src/maze/Simulated_Annealing.cpp
@@ -143,8 +143,7 @@ void Simulated_Annealing::registerKeywords(Keywords& keys) {
 }
 
 Simulated_Annealing::Simulated_Annealing(const ActionOptions& ao)
-  : PLUMED_OPT_INIT(ao)
-{
+  : PLUMED_OPT_INIT(ao) {
   log.printf("maze> Simulated annealing optimizer.\n");
 
   if(keywords.exists("COOLING")) {
@@ -184,17 +183,13 @@ Simulated_Annealing::Simulated_Annealing(const ActionOptions& ao)
 void Simulated_Annealing::decrease_probability(unsigned int time) {
   if (cooling_scheme_ == "linear") {
     probability_decreaser_ -= time * cooling_factor_;
-  }
-  else if (cooling_scheme_ == "exponential") {
+  } else if (cooling_scheme_ == "exponential") {
     probability_decreaser_ *= pow(cooling_factor_, time);
-  }
-  else if (cooling_scheme_ == "geometric") {
+  } else if (cooling_scheme_ == "geometric") {
     probability_decreaser_ *= cooling_factor_;
-  }
-  else if (cooling_scheme_ == "logarithmic") {
+  } else if (cooling_scheme_ == "logarithmic") {
     probability_decreaser_ = cooling_factor_ / std::log(time + 1);
-  }
-  else if (cooling_scheme_ == "hoffman") {
+  } else if (cooling_scheme_ == "hoffman") {
     probability_decreaser_ = (cooling_factor_ - 1) / std::log(time);
   }
 }
@@ -234,8 +229,7 @@ void Simulated_Annealing::optimize() {
                             getPosition(i0) + dev,
                             getPosition(i1)
                           );
-        }
-        else {
+        } else {
           distance = delta(
                        getPosition(i0) + get_opt(),
                        getPosition(i1)
diff --git a/src/maze/Steered_MD.cpp b/src/maze/Steered_MD.cpp
index 867c354f2c..74854ab181 100644
--- a/src/maze/Steered_MD.cpp
+++ b/src/maze/Steered_MD.cpp
@@ -124,8 +124,7 @@ void Steered_MD::registerKeywords(Keywords& keys) {
 
 Steered_MD::Steered_MD(const ActionOptions& ao)
   : PLUMED_OPT_INIT(ao),
-    total_dist_(0.0)
-{
+    total_dist_(0.0) {
   log.printf("maze> Steered MD.\n");
 
   if (keywords.exists("PULLING")) {
@@ -157,8 +156,7 @@ void Steered_MD::optimize() {
 
   if (pbc_) {
     d = pbcDistance(c, com_);
-  }
-  else {
+  } else {
     d = delta(c, com_);
   }
 
diff --git a/src/maze/Tools.h b/src/maze/Tools.h
index d20694cd4e..b09bf141d6 100644
--- a/src/maze/Tools.h
+++ b/src/maze/Tools.h
@@ -106,8 +106,9 @@ template<typename T>
 std::vector<T> tls::vector_n(const std::vector<T>& v) {
   double l=vector_l(v);
   std::vector<double> n;
-  for(std::size_t i=0; i<v.size(); ++i)
+  for(std::size_t i=0; i<v.size(); ++i) {
     n.push_back(v[i]/l);
+  }
 
   return n;
 }
@@ -136,8 +137,9 @@ std::vector<std::string> tls::get_labels_actions(const ActionSet& actionset) {
   std::vector<std::string> action_str(0);
   std::vector<T> action_pntrs=actionset.select<T>();
 
-  for(unsigned int i=0; i<action_pntrs.size(); i++)
+  for(unsigned int i=0; i<action_pntrs.size(); i++) {
     action_str.push_back(action_pntrs[i]->getLabel());
+  }
 
   return action_str;
 }
@@ -167,8 +169,9 @@ std::vector<T> tls::get_pointers_labels(
 
   for(unsigned int i=0; i<action_labels.size(); i++) {
     action_pntrs[i]=actionset.selectWithLabel<T>(action_labels[i]);
-    if(action_pntrs[i]==NULL)
+    if(action_pntrs[i]==NULL) {
       missing.push_back(action_labels[i]);
+    }
   }
 
   return action_pntrs;
diff --git a/src/membranefusion/FusionPoreExpansionP.cpp b/src/membranefusion/FusionPoreExpansionP.cpp
index 303a40e356..45ec5bbfd9 100644
--- a/src/membranefusion/FusionPoreExpansionP.cpp
+++ b/src/membranefusion/FusionPoreExpansionP.cpp
@@ -27,10 +27,8 @@ along with plumed.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 #endif
 
-namespace PLMD
-{
-namespace membranefusion
-{
+namespace PLMD {
+namespace membranefusion {
 //+PLUMEDOC MEMBRANEFUSIONMOD_COLVAR FUSIONPOREEXPANSIONP
 /*
 A CV for inducing the expansion of a fusion pore from a nucleated fusion pore.
@@ -71,8 +69,7 @@ PRINT ARG=fusionPoreExpansion FILE=COLVAR STRIDE=1
 
 */
 //+ENDPLUMEDOC
-class fusionPoreExpansionP : public Colvar
-{
+class fusionPoreExpansionP : public Colvar {
   std::vector<AtomNumber> UMEM, LMEM, TAILS, WATERS, POXYGENS;
   std::vector<double> NSMEM, DSMEM, HMEM, VO, D, H, RMAX, R0, XCYL, YCYL;
 
@@ -84,8 +81,7 @@ class fusionPoreExpansionP : public Colvar
 
 PLUMED_REGISTER_ACTION(fusionPoreExpansionP, "FUSIONPOREEXPANSIONP")
 
-void fusionPoreExpansionP::registerKeywords(Keywords &keys)
-{
+void fusionPoreExpansionP::registerKeywords(Keywords &keys) {
   Colvar::registerKeywords(keys);
   keys.add("atoms", "UMEMBRANE", "all the beads of the upper membrane.");
   keys.add("atoms", "LMEMBRANE", "all the beads of the lower membrane.");
@@ -105,103 +101,119 @@ void fusionPoreExpansionP::registerKeywords(Keywords &keys)
   keys.setValueDescription("the value of the CV");
 }
 
-fusionPoreExpansionP::fusionPoreExpansionP(const ActionOptions &ao) : PLUMED_COLVAR_INIT(ao)
-{
+fusionPoreExpansionP::fusionPoreExpansionP(const ActionOptions &ao) : PLUMED_COLVAR_INIT(ao) {
   parseAtomList("UMEMBRANE", UMEM);
-  if (UMEM.size() == 0)
+  if (UMEM.size() == 0) {
     error("UMEMBRANE has not any atom specified.");
+  }
 
   parseAtomList("LMEMBRANE", LMEM);
-  if (LMEM.size() == 0)
+  if (LMEM.size() == 0) {
     error("LMEMBRANE has not any atom specified.");
+  }
 
   parseAtomList("TAILS", TAILS);
-  if (TAILS.size() == 0)
+  if (TAILS.size() == 0) {
     error("TAILS has not any atom specified.");
+  }
 
   parseAtomList("WATERS", WATERS);
-  if (WATERS.size() == 0)
+  if (WATERS.size() == 0) {
     error("WATERS has not any atom specified.");
+  }
 
   parseAtomList("PHOSPHATEOXYGENS", POXYGENS);
-  if (POXYGENS.size() == 0)
+  if (POXYGENS.size() == 0) {
     error("PHOSPHATEOXYGENS has not any atom specified.");
+  }
 
   parseVector("NSMEM", NSMEM);
-  if (NSMEM.size() > 1)
+  if (NSMEM.size() > 1) {
     error("NSMEM cannot take more than one value.");
+  }
 
   parseVector("DSMEM", DSMEM);
-  if (DSMEM.size() > 1)
+  if (DSMEM.size() > 1) {
     error("DSMEM cannot take more than one value.");
-  if (DSMEM.size() == 0)
+  }
+  if (DSMEM.size() == 0) {
     DSMEM.push_back(0.1);
+  }
 
   parseVector("HMEM", HMEM);
-  if (HMEM.size() > 1)
+  if (HMEM.size() > 1) {
     error("HMEM cannot take more than one value.");
-  if (HMEM.size() == 0)
+  }
+  if (HMEM.size() == 0) {
     HMEM.push_back(0.25);
+  }
 
   parseVector("VO", VO);
-  if (VO.size() > 1)
+  if (VO.size() > 1) {
     error("VO cannot take more than one value.");
-  if (VO.size() == 0)
+  }
+  if (VO.size() == 0) {
     VO.push_back(0.076879);
+  }
 
   parseVector("D", D);
-  if (D.size() > 1)
+  if (D.size() > 1) {
     error("D cannot take more than one value.");
+  }
 
   parseVector("H", H);
-  if (H.size() > 1)
+  if (H.size() > 1) {
     error("H cannot take more than one value.");
-  if (H.size() == 0)
+  }
+  if (H.size() == 0) {
     H.push_back(0.1);
+  }
 
   parseVector("RMAX", RMAX);
-  if (RMAX.size() > 1)
+  if (RMAX.size() > 1) {
     error("RMAX cannot take more than one value.");
-  if (RMAX.size() == 0)
+  }
+  if (RMAX.size() == 0) {
     RMAX.push_back(2.5);
+  }
 
   parseVector("R0", R0);
-  if (R0.size() > 1)
+  if (R0.size() > 1) {
     error("R0 cannot take more than one value.");
+  }
 
   parseVector("XCYL", XCYL);
-  if (XCYL.size() > 1)
+  if (XCYL.size() > 1) {
     error("XCYL cannot take more than one value.");
-  if (XCYL.size() == 0)
+  }
+  if (XCYL.size() == 0) {
     XCYL.push_back(-1.0);
+  }
 
   parseVector("YCYL", YCYL);
-  if (YCYL.size() > 1)
+  if (YCYL.size() > 1) {
     error("YCYL cannot take more than one value.");
-  if (YCYL.size() == 0)
+  }
+  if (YCYL.size() == 0) {
     YCYL.push_back(-1.0);
+  }
 
   checkRead();
 
   std::vector<AtomNumber> atoms;
-  for (unsigned i = 0; i < UMEM.size(); i++)
-  {
+  for (unsigned i = 0; i < UMEM.size(); i++) {
     atoms.push_back(UMEM[i]);
   }
-  for (unsigned i = 0; i < LMEM.size(); i++)
-  {
+  for (unsigned i = 0; i < LMEM.size(); i++) {
     atoms.push_back(LMEM[i]);
   }
-  for (unsigned i = 0; i < TAILS.size(); i++)
-  {
+  for (unsigned i = 0; i < TAILS.size(); i++) {
     atoms.push_back(TAILS[i]);
   }
-  for (unsigned i = 0; i < WATERS.size(); i++)
-  {
+  for (unsigned i = 0; i < WATERS.size(); i++) {
     atoms.push_back(WATERS[i]);
   }
-  for (unsigned i = 0; i < POXYGENS.size(); i++)
-  {
+  for (unsigned i = 0; i < POXYGENS.size(); i++) {
     atoms.push_back(POXYGENS[i]);
   }
 
@@ -209,8 +221,7 @@ fusionPoreExpansionP::fusionPoreExpansionP(const ActionOptions &ao) : PLUMED_COL
   setNotPeriodic();
   requestAtoms(atoms);
 }
-void fusionPoreExpansionP::calculate()
-{
+void fusionPoreExpansionP::calculate() {
   /*************************
   *                        *
   *         System         *
@@ -228,8 +239,7 @@ void fusionPoreExpansionP::calculate()
   #pragma omp parallel for private(uMemAngle, lMemAngle) reduction(+:ZuMemcos, ZuMemsin, ZlMemcos, ZlMemsin)
 #endif
 #endif
-  for (unsigned i = 0; i < UMEM.size(); i++)
-  {
+  for (unsigned i = 0; i < UMEM.size(); i++) {
     uMemAngle = 2.0 * M_PI * getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i)))[2];
     lMemAngle = 2.0 * M_PI * getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + UMEM.size())))[2];
     ZuMemcos += cos(uMemAngle);
@@ -308,48 +318,36 @@ void fusionPoreExpansionP::calculate()
   #pragma omp parallel for private(ZTailDistance, PositionS_Mem, TailPosition, x, aux, s1_Mem, s2_Mem) reduction(vec_double_plus:Fs_Mem, sx_Mem, sy_Mem, cx_Mem, cy_Mem)
 #endif
 #endif
-  for (unsigned i = 0; i < TAILS.size(); i++)
-  {
+  for (unsigned i = 0; i < TAILS.size(); i++) {
     ZTailDistance = pbcDistance(Vector(0.0, 0.0, ZMems), getPosition(i + membraneBeads))[2];
     PositionS_Mem = (ZTailDistance + firstSliceZDist_Mem) / DSMEM[0];
     // If the following condition is met the particle is in the Z space of the cylinder.
-    if ((PositionS_Mem >= (-0.5 - HMEM[0])) && (PositionS_Mem <= (NSMEM[0] + 0.5 - 1.0 + HMEM[0])))
-    {
+    if ((PositionS_Mem >= (-0.5 - HMEM[0])) && (PositionS_Mem <= (NSMEM[0] + 0.5 - 1.0 + HMEM[0]))) {
       //Defining the slices to analyze each particle.
-      if (PositionS_Mem < 1)
-      {
+      if (PositionS_Mem < 1) {
         s1_Mem = 0;
         s2_Mem = 2;
-      }
-      else if (PositionS_Mem <= (NSMEM[0] - 2.0))
-      {
+      } else if (PositionS_Mem <= (NSMEM[0] - 2.0)) {
         s1_Mem = floor(PositionS_Mem) - 1;
         s2_Mem = floor(PositionS_Mem) + 1;
-      }
-      else
-      {
+      } else {
         s1_Mem = NSMEM[0] - 3;
         s2_Mem = NSMEM[0] - 1;
       }
 
       TailPosition = getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + membraneBeads)));
 
-      for (unsigned s = s1_Mem; s <= s2_Mem; s++)
-      {
+      for (unsigned s = s1_Mem; s <= s2_Mem; s++) {
         x = (ZTailDistance - (s + 0.5 - NSMEM[0] / 2.0) * DSMEM[0]) * 2.0 / DSMEM[0];
-        if (!((x <= -1.0 - HMEM[0]) || (x >= 1.0 + HMEM[0])))
-        {
-          if (((-1.0 + HMEM[0]) <= x) && (x <= (1.0 - HMEM[0])))
-          {
+        if (!((x <= -1.0 - HMEM[0]) || (x >= 1.0 + HMEM[0]))) {
+          if (((-1.0 + HMEM[0]) <= x) && (x <= (1.0 - HMEM[0]))) {
             faxial_Mem[i + TAILS.size() * s] = 1.0;
             Fs_Mem[s] += 1.0;
             sx_Mem[s] += sin(2.0 * M_PI * TailPosition[0]);
             sy_Mem[s] += sin(2.0 * M_PI * TailPosition[1]);
             cx_Mem[s] += cos(2.0 * M_PI * TailPosition[0]);
             cy_Mem[s] += cos(2.0 * M_PI * TailPosition[1]);
-          }
-          else if (((1.0 - HMEM[0]) < x) && (x < (1.0 + HMEM[0])))
-          {
+          } else if (((1.0 - HMEM[0]) < x) && (x < (1.0 + HMEM[0]))) {
             aux = 0.5 - ((3.0 * x - 3.0) / (4.0 * HMEM[0])) + (pow((x - 1.0), 3) / (4.0 * pow(HMEM[0], 3)));
             faxial_Mem[i + TAILS.size() * s] = aux;
             Fs_Mem[s] += aux;
@@ -357,9 +355,7 @@ void fusionPoreExpansionP::calculate()
             sy_Mem[s] += aux * sin(2.0 * M_PI * TailPosition[1]);
             cx_Mem[s] += aux * cos(2.0 * M_PI * TailPosition[0]);
             cy_Mem[s] += aux * cos(2.0 * M_PI * TailPosition[1]);
-          }
-          else if (((-1.0 - HMEM[0]) < x) && (x < (-1.0 + HMEM[0])))
-          {
+          } else if (((-1.0 - HMEM[0]) < x) && (x < (-1.0 + HMEM[0]))) {
             aux = 0.5 + ((3.0 * x + 3.0) / (4.0 * HMEM[0])) - (pow((x + 1.0), 3) / (4.0 * pow(HMEM[0], 3)));
             faxial_Mem[i + TAILS.size() * s] = aux;
             Fs_Mem[s] += aux;
@@ -373,10 +369,8 @@ void fusionPoreExpansionP::calculate()
     }
   }
 
-  for (unsigned s = 0; s < NSMEM[0]; s++)
-  {
-    if (Fs_Mem[s] != 0.0)
-    {
+  for (unsigned s = 0; s < NSMEM[0]; s++) {
+    if (Fs_Mem[s] != 0.0) {
       ws_Mem[s] = tanh(Fs_Mem[s]);
       W_Mem += ws_Mem[s];
       sx_Mem[s] = sx_Mem[s] / Fs_Mem[s];
@@ -398,13 +392,10 @@ void fusionPoreExpansionP::calculate()
   // Eq. 12 Hub & Awasthi JCTC 2017.
   double Xcyl_Mem, Ycyl_Mem;
 
-  if ((XCYL[0] > 0.0) && (YCYL[0] > 0.0))
-  {
+  if ((XCYL[0] > 0.0) && (YCYL[0] > 0.0)) {
     Xcyl_Mem = XCYL[0];
     Ycyl_Mem = YCYL[0];
-  }
-  else
-  {
+  } else {
     Xcyl_Mem = (atan2(-Xsc_Mem, -Xcc_Mem) + M_PI) * Lx / (2 * M_PI);
     Ycyl_Mem = (atan2(-Ysc_Mem, -Ycc_Mem) + M_PI) * Ly / (2 * M_PI);
   }
@@ -467,29 +458,22 @@ void fusionPoreExpansionP::calculate()
   #pragma omp parallel for private(MemCylDistances, x, angle, auxcos, auxsin) reduction(+:ZMemRMAXcos, ZMemRMAXsin, countAux)
 #endif
 #endif
-  for (unsigned i = 0; i < membraneBeads; i++)
-{
+  for (unsigned i = 0; i < membraneBeads; i++) {
   MemCylDistances = pbcDistance(xyzCyl, pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i)));
     x = sqrt(pow(MemCylDistances[0], 2) + pow(MemCylDistances[1], 2)) / RMAX[0];
-    if (!((x <= -1.0 - H[0]) || (x >= 1.0 + H[0])))
-    {
+    if (!((x <= -1.0 - H[0]) || (x >= 1.0 + H[0]))) {
       angle = 2.0 * M_PI * getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i)))[2];
       auxcos = cos(angle);
       auxsin = sin(angle);
-      if (((-1.0 + H[0]) <= x) && (x <= (1.0 - H[0])))
-      {
+      if (((-1.0 + H[0]) <= x) && (x <= (1.0 - H[0]))) {
         ZMemRMAXcos += 1.0 * auxcos;
         ZMemRMAXsin += 1.0 * auxsin;
         countAux += 1.0;
-      }
-      else if (((1.0 - H[0]) < x) && (x < (1.0 + H[0])))
-      {
+      } else if (((1.0 - H[0]) < x) && (x < (1.0 + H[0]))) {
         ZMemRMAXcos += (0.5 - 0.75 * (x - 1.0) / H[0] + 0.25 * pow((x - 1.0), 3) / pow(H[0], 3)) * auxcos;
         ZMemRMAXsin += (0.5 - 0.75 * (x - 1.0) / H[0] + 0.25 * pow((x - 1.0), 3) / pow(H[0], 3)) * auxsin;
         countAux += (0.5 - 0.75 * (x - 1.0) / H[0] + 0.25 * pow((x - 1.0), 3) / pow(H[0], 3));
-      }
-      else if (((-1.0 - H[0]) < x) && (x < (-1.0 + H[0])))
-      {
+      } else if (((-1.0 - H[0]) < x) && (x < (-1.0 + H[0]))) {
         ZMemRMAXcos += (0.5 + 0.75 * (x + 1.0) / H[0] - 0.25 * pow((x + 1.0), 3) / pow(H[0], 3)) * auxcos;
         ZMemRMAXsin += (0.5 + 0.75 * (x + 1.0) / H[0] - 0.25 * pow((x + 1.0), 3) / pow(H[0], 3)) * auxsin;
         countAux += (0.5 + 0.75 * (x + 1.0) / H[0] - 0.25 * pow((x + 1.0), 3) / pow(H[0], 3));
@@ -508,8 +492,7 @@ void fusionPoreExpansionP::calculate()
   #pragma omp parallel for private(distCylinder, fz, fz_prime, fr, fr_prime, ri, x) reduction(+:np)
 #endif
 #endif
-  for (unsigned i = 0; i < chainBeads; i++)
-{
+  for (unsigned i = 0; i < chainBeads; i++) {
   distCylinder = pbcDistance(xyzCyl, pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + noChainBeads)));
     fz = 0.0;
     fz_prime = 0.0;
@@ -518,37 +501,25 @@ void fusionPoreExpansionP::calculate()
 
     ri = sqrt(pow(distCylinder[0], 2) + pow(distCylinder[1], 2));
     x = ri / RMAX[0];
-    if (!((x <= -1.0 - H[0]) || (x >= 1.0 + H[0])))
-    {
-      if (((-1.0 + H[0]) <= x) && (x <= (1.0 - H[0])))
-      {
+    if (!((x <= -1.0 - H[0]) || (x >= 1.0 + H[0]))) {
+      if (((-1.0 + H[0]) <= x) && (x <= (1.0 - H[0]))) {
         fr = 1.0;
-      }
-      else if (((1.0 - H[0]) < x) && (x < (1.0 + H[0])))
-      {
+      } else if (((1.0 - H[0]) < x) && (x < (1.0 + H[0]))) {
         fr = 0.5 - 0.75 * (x - 1.0) / H[0] + 0.25 * pow((x - 1.0), 3) / pow(H[0], 3);
         fr_prime = (-0.75 / H[0] + 0.75 * pow((x - 1.0), 2) / pow(H[0], 3)) / (RMAX[0] * ri);
-      }
-      else if (((-1.0 - H[0]) < x) && (x < (-1.0 + H[0])))
-      {
+      } else if (((-1.0 - H[0]) < x) && (x < (-1.0 + H[0]))) {
         fr = 0.5 + 0.75 * (x + 1.0) / H[0] - 0.25 * pow((x + 1.0), 3) / pow(H[0], 3);
         fr_prime = (0.75 / H[0] - 0.75 * pow((x + 1), 2) / pow(H[0], 3)) / (RMAX[0] * ri);
       }
 
       x = distCylinder[2] * 2.0 / D[0];
-      if (!((x <= -1.0 - H[0]) || (x >= 1.0 + H[0])))
-      {
-        if (((-1.0 + H[0]) <= x) && (x <= (1.0 - H[0])))
-        {
+      if (!((x <= -1.0 - H[0]) || (x >= 1.0 + H[0]))) {
+        if (((-1.0 + H[0]) <= x) && (x <= (1.0 - H[0]))) {
           fz = 1.0;
-        }
-        else if (((1.0 - H[0]) < x) && (x < (1.0 + H[0])))
-        {
+        } else if (((1.0 - H[0]) < x) && (x < (1.0 + H[0]))) {
           fz = 0.5 - 0.75 * (x - 1.0) / H[0] + 0.25 * pow((x - 1.0), 3) / pow(H[0], 3);
           fz_prime = (-0.75 / H[0] + 0.75 * pow((x - 1.0), 2) / pow(H[0], 3)) * 2.0 / D[0];
-        }
-        else if (((-1.0 - H[0]) < x) && (x < (-1.0 + H[0])))
-        {
+        } else if (((-1.0 - H[0]) < x) && (x < (-1.0 + H[0]))) {
           fz = 0.5 + 0.75 * (x + 1.0) / H[0] - 0.25 * pow((x + 1.0), 3) / pow(H[0], 3);
           fz_prime = (0.75 / H[0] - 0.75 * pow((x + 1), 2) / pow(H[0], 3)) * 2.0 / D[0];
         }
@@ -571,8 +542,7 @@ void fusionPoreExpansionP::calculate()
   // Aux for the derivatives calculations. Eq. 7 Hub 2021 JCTC.
   double fact2 = 0.0;
 
-  if (poreR != 0.0)
-{
+  if (poreR != 0.0) {
   fact2 = VO[0] / (2.0 * M_PI * RO * D[0] * poreR);
   }
 
@@ -584,8 +554,7 @@ void fusionPoreExpansionP::calculate()
   #pragma omp parallel for
 #endif
 #endif
-  for (unsigned i = 0; i < chainBeads; i++)
-{
+  for (unsigned i = 0; i < chainBeads; i++) {
   derivatives[i][0] = fact2 * d_np_dx[i];
     derivatives[i][1] = fact2 * d_np_dy[i];
     derivatives[i][2] = fact2 * d_np_dz[i];
@@ -593,8 +562,7 @@ void fusionPoreExpansionP::calculate()
   }
 
   Tensor virial;
-  for (unsigned i = 0; i < chainBeads; i++)
-{
+  for (unsigned i = 0; i < chainBeads; i++) {
   setAtomsDerivatives((i + noChainBeads), derivatives[i]);
     virial -= Tensor(CylDistances[i], derivatives[i]);
   }
diff --git a/src/membranefusion/FusionPoreNucleationP.cpp b/src/membranefusion/FusionPoreNucleationP.cpp
index a68ea0f47c..53d8c6f666 100644
--- a/src/membranefusion/FusionPoreNucleationP.cpp
+++ b/src/membranefusion/FusionPoreNucleationP.cpp
@@ -27,10 +27,8 @@ along with plumed.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 #endif
 
-namespace PLMD
-{
-namespace membranefusion
-{
+namespace PLMD {
+namespace membranefusion {
 //+PLUMEDOC MEMBRANEFUSIONMOD_COLVAR FUSIONPORENUCLEATIONP
 /*
 A CV for inducing the nucleation of the fusion pore from a hemifusion stalk.
@@ -74,8 +72,7 @@ PRINT ARG=fusionPoreNucleation FILE=COLVAR STRIDE=1
 
 */
 //+ENDPLUMEDOC
-class fusionPoreNucleationP : public Colvar
-{
+class fusionPoreNucleationP : public Colvar {
   std::vector<AtomNumber> UMEM, LMEM, TAILS, WATERS, POXYGENS;
   std::vector<double> NSMEM, DSMEM, HMEM, NS, DS, HCH, RCYL, ZETA, ONEOVERS2C2CUTOFF, XCYL, YCYL;
 
@@ -87,8 +84,7 @@ class fusionPoreNucleationP : public Colvar
 
 PLUMED_REGISTER_ACTION(fusionPoreNucleationP, "FUSIONPORENUCLEATIONP")
 
-void fusionPoreNucleationP::registerKeywords(Keywords &keys)
-{
+void fusionPoreNucleationP::registerKeywords(Keywords &keys) {
   Colvar::registerKeywords(keys);
   keys.add("atoms", "UMEMBRANE", "all the beads of the upper membrane.");
   keys.add("atoms", "LMEMBRANE", "all the beads of the lower membrane.");
@@ -109,111 +105,130 @@ void fusionPoreNucleationP::registerKeywords(Keywords &keys)
   keys.setValueDescription("the value of the CV");
 }
 
-fusionPoreNucleationP::fusionPoreNucleationP(const ActionOptions &ao) : PLUMED_COLVAR_INIT(ao)
-{
+fusionPoreNucleationP::fusionPoreNucleationP(const ActionOptions &ao) : PLUMED_COLVAR_INIT(ao) {
   parseAtomList("UMEMBRANE", UMEM);
-  if (UMEM.size() == 0)
+  if (UMEM.size() == 0) {
     error("UMEMBRANE has not any atom specified.");
+  }
 
   parseAtomList("LMEMBRANE", LMEM);
-  if (LMEM.size() == 0)
+  if (LMEM.size() == 0) {
     error("LMEMBRANE has not any atom specified.");
+  }
 
   parseAtomList("TAILS", TAILS);
-  if (TAILS.size() == 0)
+  if (TAILS.size() == 0) {
     error("TAILS has not any atom specified.");
+  }
 
   parseAtomList("WATERS", WATERS);
-  if (WATERS.size() == 0)
+  if (WATERS.size() == 0) {
     error("WATERS has not any atom specified.");
+  }
 
   parseAtomList("PHOSPHATEOXYGENS", POXYGENS);
-  if (POXYGENS.size() == 0)
+  if (POXYGENS.size() == 0) {
     error("PHOSPHATEOXYGENS has not any atom specified.");
+  }
 
   parseVector("NSMEM", NSMEM);
-  if (NSMEM.size() > 1)
+  if (NSMEM.size() > 1) {
     error("NSMEM cannot take more than one value.");
+  }
 
   parseVector("DSMEM", DSMEM);
-  if (DSMEM.size() > 1)
+  if (DSMEM.size() > 1) {
     error("DSMEM cannot take more than one value.");
-  if (DSMEM.size() == 0)
+  }
+  if (DSMEM.size() == 0) {
     DSMEM.push_back(0.1);
+  }
 
   parseVector("HMEM", HMEM);
-  if (HMEM.size() > 1)
+  if (HMEM.size() > 1) {
     error("HMEM cannot take more than one value.");
-  if (HMEM.size() == 0)
+  }
+  if (HMEM.size() == 0) {
     HMEM.push_back(0.25);
+  }
 
   parseVector("NS", NS);
-  if (NS.size() > 1)
+  if (NS.size() > 1) {
     error("NS cannot take more than one value.");
+  }
 
   parseVector("DS", DS);
-  if (DS.size() > 1)
+  if (DS.size() > 1) {
     error("DS cannot take more than one value.");
-  if (DS.size() == 0)
+  }
+  if (DS.size() == 0) {
     DS.push_back(0.25);
+  }
 
   parseVector("HCH", HCH);
-  if (HCH.size() > 1)
+  if (HCH.size() > 1) {
     error("H cannot take more than one value.");
-  if (HCH.size() == 0)
+  }
+  if (HCH.size() == 0) {
     HCH.push_back(0.25);
+  }
 
   parseVector("RCYL", RCYL);
-  if (RCYL.size() > 1)
+  if (RCYL.size() > 1) {
     error("RCYL cannot take more than one value.");
-  if (RCYL.size() == 0)
+  }
+  if (RCYL.size() == 0) {
     RCYL.push_back(0.8);
+  }
 
   parseVector("ZETA", ZETA);
-  if (ZETA.size() > 1)
+  if (ZETA.size() > 1) {
     error("ZETA cannot take more than one value.");
-  if (ZETA.size() == 0)
+  }
+  if (ZETA.size() == 0) {
     ZETA.push_back(0.75);
+  }
 
   parseVector("ONEOVERS2C2CUTOFF", ONEOVERS2C2CUTOFF);
-  if (ONEOVERS2C2CUTOFF.size() > 1)
+  if (ONEOVERS2C2CUTOFF.size() > 1) {
     error("ONEOVERS2C2CUTOFF cannot take more than one value.");
-  if (ONEOVERS2C2CUTOFF.size() == 0)
+  }
+  if (ONEOVERS2C2CUTOFF.size() == 0) {
     ONEOVERS2C2CUTOFF.push_back(500);
+  }
 
   parseVector("XCYL", XCYL);
-  if (XCYL.size() > 1)
+  if (XCYL.size() > 1) {
     error("XCYL cannot take more than one value.");
-  if (XCYL.size() == 0)
+  }
+  if (XCYL.size() == 0) {
     XCYL.push_back(-1.0);
+  }
 
   parseVector("YCYL", YCYL);
-  if (YCYL.size() > 1)
+  if (YCYL.size() > 1) {
     error("YCYL cannot take more than one value.");
-  if (YCYL.size() == 0)
+  }
+  if (YCYL.size() == 0) {
     YCYL.push_back(-1.0);
+  }
 
   checkRead();
 
   std::vector<AtomNumber> atoms;
-  for (unsigned i = 0; i < UMEM.size(); i++)
-  {
+  for (unsigned i = 0; i < UMEM.size(); i++) {
     atoms.push_back(UMEM[i]);
   }
-  for (unsigned i = 0; i < LMEM.size(); i++)
-  {
+  for (unsigned i = 0; i < LMEM.size(); i++) {
     atoms.push_back(LMEM[i]);
   }
-  for (unsigned i = 0; i < TAILS.size(); i++)
-  {
+  for (unsigned i = 0; i < TAILS.size(); i++) {
     atoms.push_back(TAILS[i]);
   }
-  for (unsigned i = 0; i < WATERS.size(); i++)
-  {
+  for (unsigned i = 0; i < WATERS.size(); i++) {
     atoms.push_back(WATERS[i]);
   }
-  for (unsigned i = 0; i < POXYGENS.size(); i++)
-  {
+  for (unsigned i = 0; i < POXYGENS.size(); i++) {
     atoms.push_back(POXYGENS[i]);
   }
 
@@ -222,8 +237,7 @@ fusionPoreNucleationP::fusionPoreNucleationP(const ActionOptions &ao) : PLUMED_C
   requestAtoms(atoms);
 }
 
-void fusionPoreNucleationP::calculate()
-{
+void fusionPoreNucleationP::calculate() {
   /*************************
   *                        *
   *         System         *
@@ -241,8 +255,7 @@ void fusionPoreNucleationP::calculate()
   #pragma omp parallel for private(uMemAngle, lMemAngle) reduction(+:ZuMemcos, ZuMemsin, ZlMemcos, ZlMemsin)
 #endif
 #endif
-  for (unsigned i = 0; i < UMEM.size(); i++)
-  {
+  for (unsigned i = 0; i < UMEM.size(); i++) {
     uMemAngle = 2.0 * M_PI * getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i)))[2];
     lMemAngle = 2.0 * M_PI * getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + UMEM.size())))[2];
     ZuMemcos += cos(uMemAngle);
@@ -321,48 +334,36 @@ void fusionPoreNucleationP::calculate()
   #pragma omp parallel for private(ZTailDistance, PositionS_Mem, s1_Mem, s2_Mem, TailPosition, x, aux) reduction(vec_double_plus:Fs_Mem, sx_Mem, sy_Mem, cx_Mem, cy_Mem)
 #endif
 #endif
-  for (unsigned i = 0; i < TAILS.size(); i++)
-  {
+  for (unsigned i = 0; i < TAILS.size(); i++) {
     ZTailDistance = pbcDistance(Vector(0.0, 0.0, ZMems), getPosition(i + membraneBeads))[2];
     PositionS_Mem = (ZTailDistance + firstSliceZDist_Mem) / DSMEM[0];
     // If the following condition is met the particle is in the Z space of the cylinder.
-    if ((PositionS_Mem >= (-0.5 - HMEM[0])) && (PositionS_Mem <= (NSMEM[0] + 0.5 - 1.0 + HMEM[0])))
-    {
+    if ((PositionS_Mem >= (-0.5 - HMEM[0])) && (PositionS_Mem <= (NSMEM[0] + 0.5 - 1.0 + HMEM[0]))) {
       //Defining the slices to analyze each particle.
-      if (PositionS_Mem < 1)
-      {
+      if (PositionS_Mem < 1) {
         s1_Mem = 0;
         s2_Mem = 2;
-      }
-      else if (PositionS_Mem <= (NSMEM[0] - 2.0))
-      {
+      } else if (PositionS_Mem <= (NSMEM[0] - 2.0)) {
         s1_Mem = floor(PositionS_Mem) - 1;
         s2_Mem = floor(PositionS_Mem) + 1;
-      }
-      else
-      {
+      } else {
         s1_Mem = NSMEM[0] - 3;
         s2_Mem = NSMEM[0] - 1;
       }
 
       TailPosition = getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + membraneBeads)));
 
-      for (unsigned s = s1_Mem; s <= s2_Mem; s++)
-      {
+      for (unsigned s = s1_Mem; s <= s2_Mem; s++) {
         x = (ZTailDistance - (s + 0.5 - NSMEM[0] / 2.0) * DSMEM[0]) * 2.0 / DSMEM[0];
-        if (!((x <= -1.0 - HMEM[0]) || (x >= 1.0 + HMEM[0])))
-        {
-          if (((-1.0 + HMEM[0]) <= x) && (x <= (1.0 - HMEM[0])))
-          {
+        if (!((x <= -1.0 - HMEM[0]) || (x >= 1.0 + HMEM[0]))) {
+          if (((-1.0 + HMEM[0]) <= x) && (x <= (1.0 - HMEM[0]))) {
             faxial_Mem[i + TAILS.size() * s] = 1.0;
             Fs_Mem[s] += 1.0;
             sx_Mem[s] += sin(2.0 * M_PI * TailPosition[0]);
             sy_Mem[s] += sin(2.0 * M_PI * TailPosition[1]);
             cx_Mem[s] += cos(2.0 * M_PI * TailPosition[0]);
             cy_Mem[s] += cos(2.0 * M_PI * TailPosition[1]);
-          }
-          else if (((1.0 - HMEM[0]) < x) && (x < (1.0 + HMEM[0])))
-          {
+          } else if (((1.0 - HMEM[0]) < x) && (x < (1.0 + HMEM[0]))) {
             aux = 0.5 - ((3.0 * x - 3.0) / (4.0 * HMEM[0])) + (pow((x - 1.0), 3) / (4.0 * pow(HMEM[0], 3)));
             faxial_Mem[i + TAILS.size() * s] = aux;
             Fs_Mem[s] += aux;
@@ -370,9 +371,7 @@ void fusionPoreNucleationP::calculate()
             sy_Mem[s] += aux * sin(2.0 * M_PI * TailPosition[1]);
             cx_Mem[s] += aux * cos(2.0 * M_PI * TailPosition[0]);
             cy_Mem[s] += aux * cos(2.0 * M_PI * TailPosition[1]);
-          }
-          else if (((-1.0 - HMEM[0]) < x) && (x < (-1.0 + HMEM[0])))
-          {
+          } else if (((-1.0 - HMEM[0]) < x) && (x < (-1.0 + HMEM[0]))) {
             aux = 0.5 + ((3.0 * x + 3.0) / (4.0 * HMEM[0])) - (pow((x + 1.0), 3) / (4.0 * pow(HMEM[0], 3)));
             faxial_Mem[i + TAILS.size() * s] = aux;
             Fs_Mem[s] += aux;
@@ -386,10 +385,8 @@ void fusionPoreNucleationP::calculate()
     }
   }
 
-  for (unsigned s = 0; s < NSMEM[0]; s++)
-  {
-    if (Fs_Mem[s] != 0.0)
-    {
+  for (unsigned s = 0; s < NSMEM[0]; s++) {
+    if (Fs_Mem[s] != 0.0) {
       ws_Mem[s] = tanh(Fs_Mem[s]);
       W_Mem += ws_Mem[s];
       sx_Mem[s] = sx_Mem[s] / Fs_Mem[s];
@@ -411,13 +408,10 @@ void fusionPoreNucleationP::calculate()
   // Eq. 12 Hub & Awasthi JCTC 2017.
   double Xcyl_Mem, Ycyl_Mem;
 
-  if ((XCYL[0] > 0.0) && (YCYL[0] > 0.0))
-  {
+  if ((XCYL[0] > 0.0) && (YCYL[0] > 0.0)) {
     Xcyl_Mem = XCYL[0];
     Ycyl_Mem = YCYL[0];
-  }
-  else
-  {
+  } else {
     Xcyl_Mem = (atan2(-Xsc_Mem, -Xcc_Mem) + M_PI) * Lx / (2 * M_PI);
     Ycyl_Mem = (atan2(-Ysc_Mem, -Ycc_Mem) + M_PI) * Ly / (2 * M_PI);
   }
@@ -496,57 +490,44 @@ void fusionPoreNucleationP::calculate()
   #pragma omp parallel for private(distCylinder, aux, condition1, condition2, condition3, ZMemDistance, PositionS, Position, x) reduction(vec_double_plus:Fs, sx, sy, cx, cy)
 #endif
 #endif
-  for (unsigned i = 0; i < chainBeads; i++)
-{
+  for (unsigned i = 0; i < chainBeads; i++) {
   distCylinder = pbcDistance(xyzCyl_Mem, pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + noChainBeads)));
     aux = sqrt(pow(distCylinder[0], 2) + pow(distCylinder[1], 2));
     condition1 = ((aux / RCYLAVERAGE) < 1.0);
     condition2 = ((pbcDistance(Vector(0.0, 0.0, ZuMem), getPosition(i + noChainBeads))[2] > 0) && (aux / RCYLAVERAGE) < 2.0);
     condition3 = ((pbcDistance(getPosition(i + noChainBeads), Vector(0.0, 0.0, ZlMem))[2] > 0) && (aux / RCYLAVERAGE) < 2.0);
-    if (condition1 || condition2 || condition3)
-    {
+    if (condition1 || condition2 || condition3) {
       ZMemDistance = pbcDistance(Vector(0.0, 0.0, ZMems), getPosition(i + noChainBeads))[2];
       PositionS = (ZMemDistance + firstSliceZDist) / DS[0];
       // If the following condition is met the particle is in the Z space of the cylinder.
-      if ((PositionS >= (-0.5 - HCH[0])) && (PositionS <= (NS[0] + 0.5 - 1.0 + HCH[0])))
-      {
+      if ((PositionS >= (-0.5 - HCH[0])) && (PositionS <= (NS[0] + 0.5 - 1.0 + HCH[0]))) {
         analyzeThisParticle[i] = 1.0;
 
         //Defining the slices to analyze each particle.
-        if (PositionS < 1)
-        {
+        if (PositionS < 1) {
           s1[i] = 0;
           s2[i] = 2;
-        }
-        else if (PositionS <= (NS[0] - 2.0))
-        {
+        } else if (PositionS <= (NS[0] - 2.0)) {
           s1[i] = floor(PositionS) - 1;
           s2[i] = floor(PositionS) + 1;
-        }
-        else
-        {
+        } else {
           s1[i] = NS[0] - 3;
           s2[i] = NS[0] - 1;
         }
 
         Position = getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + noChainBeads)));
 
-        for (unsigned s = s1[i]; s <= s2[i]; s++)
-        {
+        for (unsigned s = s1[i]; s <= s2[i]; s++) {
           x = (ZMemDistance - (s + 0.5 - NS[0] / 2.0) * DS[0]) * 2.0 / DS[0];
-          if (!((x <= -1.0 - HCH[0]) || (x >= 1.0 + HCH[0])))
-          {
-            if (((-1.0 + HCH[0]) <= x) && (x <= (1.0 - HCH[0])))
-            {
+          if (!((x <= -1.0 - HCH[0]) || (x >= 1.0 + HCH[0]))) {
+            if (((-1.0 + HCH[0]) <= x) && (x <= (1.0 - HCH[0]))) {
               faxial[i + chainBeads * s] = 1.0;
               Fs[s] += 1.0;
               sx[s] += sin(2.0 * M_PI * Position[0]);
               sy[s] += sin(2.0 * M_PI * Position[1]);
               cx[s] += cos(2.0 * M_PI * Position[0]);
               cy[s] += cos(2.0 * M_PI * Position[1]);
-            }
-            else if (((1.0 - HCH[0]) < x) && (x < (1.0 + HCH[0])))
-            {
+            } else if (((1.0 - HCH[0]) < x) && (x < (1.0 + HCH[0]))) {
               aux = 0.5 - ((3.0 * x - 3.0) / (4.0 * HCH[0])) + (pow((x - 1.0), 3) / (4.0 * pow(HCH[0], 3)));
               faxial[i + chainBeads * s] = aux;
               d_faxial_dz[i + chainBeads * s] = ((-3.0 / (4.0 * HCH[0])) + ((3.0 * pow((x - 1), 2)) / (4.0 * pow(HCH[0], 3)))) * 2.0 / DS[0];
@@ -555,9 +536,7 @@ void fusionPoreNucleationP::calculate()
               sy[s] += aux * sin(2.0 * M_PI * Position[1]);
               cx[s] += aux * cos(2.0 * M_PI * Position[0]);
               cy[s] += aux * cos(2.0 * M_PI * Position[1]);
-            }
-            else if (((-1.0 - HCH[0]) < x) && (x < (-1.0 + HCH[0])))
-            {
+            } else if (((-1.0 - HCH[0]) < x) && (x < (-1.0 + HCH[0]))) {
               aux = 0.5 + ((3.0 * x + 3.0) / (4.0 * HCH[0])) - (pow((x + 1.0), 3) / (4.0 * pow(HCH[0], 3)));
               faxial[i + chainBeads * s] = aux;
               d_faxial_dz[i + chainBeads * s] = ((3.0 / (4.0 * HCH[0])) - ((3.0 * pow((x + 1), 2)) / (4.0 * pow(HCH[0], 3)))) * 2.0 / DS[0];
@@ -573,10 +552,8 @@ void fusionPoreNucleationP::calculate()
     }
   }
 
-  for (unsigned s = 0; s < NS[0]; s++)
-  {
-    if (Fs[s] != 0.0)
-    {
+  for (unsigned s = 0; s < NS[0]; s++) {
+    if (Fs[s] != 0.0) {
       ws[s] = tanh(Fs[s]);
       W += ws[s];
       sx[s] = sx[s] / Fs[s];
@@ -631,21 +608,15 @@ void fusionPoreNucleationP::calculate()
   // To avoid rare instabilities auxX and auxY are truncated at a configurable value (default 500).
   double auxX = (1 / (pow(Xsc, 2) + pow(Xcc, 2))), auxY = (1 / (pow(Ysc, 2) + pow(Ycc, 2)));
 
-  if (auxX > ONEOVERS2C2CUTOFF[0])
-  {
+  if (auxX > ONEOVERS2C2CUTOFF[0]) {
     auxX = Lx * ONEOVERS2C2CUTOFF[0] / (2 * M_PI);
-  }
-  else
-  {
+  } else {
     auxX = Lx * auxX / (2 * M_PI);
   }
 
-  if (auxY > ONEOVERS2C2CUTOFF[0])
-  {
+  if (auxY > ONEOVERS2C2CUTOFF[0]) {
     auxY = Ly * ONEOVERS2C2CUTOFF[0] / (2 * M_PI);
-  }
-  else
-  {
+  } else {
     auxY = Ly * auxY / (2 * M_PI);
   }
 
@@ -666,11 +637,9 @@ void fusionPoreNucleationP::calculate()
   #pragma omp parallel for private(d_Xsc_dx,d_Xcc_dx,d_Ysc_dy,d_Ycc_dy,d_Xsc_dz,d_Xcc_dz,d_Ysc_dz,d_Ycc_dz,d_sx_dx,d_sy_dy,d_cx_dx,d_cy_dy,d_sx_dz,d_sy_dz,d_cx_dz,d_cy_dz,d_ws_dz,ri,x,fradial) reduction(vec_double_plus: Nsp, Axs, Ays)
 #endif
 #endif
-  for (unsigned i = 0; i < chainBeads; i++)
-{
+  for (unsigned i = 0; i < chainBeads; i++) {
   CylDistances[i] = pbcDistance(xyzCyl, pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + noChainBeads)));
-    if (analyzeThisParticle[i])
-    {
+    if (analyzeThisParticle[i]) {
       Position = getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + noChainBeads)));
       d_Xsc_dx = 0.0;
       d_Xcc_dx = 0.0;
@@ -680,10 +649,8 @@ void fusionPoreNucleationP::calculate()
       d_Xcc_dz = 0.0;
       d_Ysc_dz = 0.0;
       d_Ycc_dz = 0.0;
-      for (unsigned s = s1[i]; s <= s2[i]; s++)
-      {
-        if (Fs[s] != 0.0)
-        {
+      for (unsigned s = s1[i]; s <= s2[i]; s++) {
+        if (Fs[s] != 0.0) {
           d_sx_dx = faxial[i + chainBeads * s] * 2.0 * M_PI * cos(2.0 * M_PI * Position[0]) / (Lx * Fs[s]);
           d_sy_dy = faxial[i + chainBeads * s] * 2.0 * M_PI * cos(2.0 * M_PI * Position[1]) / (Ly * Fs[s]);
           d_cx_dx = -faxial[i + chainBeads * s] * 2.0 * M_PI * sin(2.0 * M_PI * Position[0]) / (Lx * Fs[s]);
@@ -711,27 +678,20 @@ void fusionPoreNucleationP::calculate()
 
       ri = sqrt(pow(CylDistances[i][0], 2) + pow(CylDistances[i][1], 2));
       x = ri / RCYL[0];
-      if (!((x <= -1.0 - HCH[0]) || (x >= 1.0 + HCH[0])))
-      {
-        if (((-1.0 + HCH[0]) <= x) && (x <= (1.0 - HCH[0])))
-        {
+      if (!((x <= -1.0 - HCH[0]) || (x >= 1.0 + HCH[0]))) {
+        if (((-1.0 + HCH[0]) <= x) && (x <= (1.0 - HCH[0]))) {
           fradial = 1.0;
-        }
-        else if (((1.0 - HCH[0]) < x) && (x < (1.0 + HCH[0])))
-        {
+        } else if (((1.0 - HCH[0]) < x) && (x < (1.0 + HCH[0]))) {
           fradial = 0.5 - ((3.0 * x - 3.0) / (4.0 * HCH[0])) + (pow((x - 1.0), 3) / (4.0 * pow(HCH[0], 3)));
           d_fradial_dx[i] = ((-3.0 / (4.0 * HCH[0])) + ((3.0 * pow((x - 1), 2)) / (4.0 * pow(HCH[0], 3)))) * CylDistances[i][0] / (RCYL[0] * ri);
           d_fradial_dy[i] = ((-3.0 / (4.0 * HCH[0])) + ((3.0 * pow((x - 1), 2)) / (4.0 * pow(HCH[0], 3)))) * CylDistances[i][1] / (RCYL[0] * ri);
-        }
-        else if (((-1.0 - HCH[0]) < x) && (x < (-1.0 + HCH[0])))
-        {
+        } else if (((-1.0 - HCH[0]) < x) && (x < (-1.0 + HCH[0]))) {
           fradial = 0.5 + ((3.0 * x + 3.0) / (4.0 * HCH[0])) - (pow((x + 1.0), 3) / (4.0 * pow(HCH[0], 3)));
           d_fradial_dx[i] = ((3.0 / (4.0 * HCH[0])) - ((3.0 * pow((x + 1), 2)) / (4.0 * pow(HCH[0], 3)))) * CylDistances[i][0] / (RCYL[0] * ri);
           d_fradial_dy[i] = ((3.0 / (4.0 * HCH[0])) - ((3.0 * pow((x + 1), 2)) / (4.0 * pow(HCH[0], 3)))) * CylDistances[i][1] / (RCYL[0] * ri);
         }
 
-        for (unsigned s = s1[i]; s <= s2[i]; s++)
-        {
+        for (unsigned s = s1[i]; s <= s2[i]; s++) {
           Nsp[s] += fradial * faxial[i + chainBeads * s];
           Axs[s] += faxial[i + chainBeads * s] * d_fradial_dx[i];
           Ays[s] += faxial[i + chainBeads * s] * d_fradial_dy[i];
@@ -741,16 +701,12 @@ void fusionPoreNucleationP::calculate()
     }
   }
 
-  for (unsigned s = 0; s < NS[0]; s++)
-  {
-    if (Nsp[s] <= 1.0)
-    {
+  for (unsigned s = 0; s < NS[0]; s++) {
+    if (Nsp[s] <= 1.0) {
       psi[s] = ZETA[0] * Nsp[s];
       d_psi[s] = ZETA[0];
       Xi_n += psi[s];
-    }
-    else
-    {
+    } else {
       psi[s] = 1.0 - c * exp(-b * Nsp[s]);
       d_psi[s] = b * c * exp(-b * Nsp[s]);
       Xi_n += psi[s];
@@ -770,22 +726,17 @@ void fusionPoreNucleationP::calculate()
   #pragma omp parallel for private(aux)
 #endif
 #endif
-  for (unsigned i = 0; i < chainBeads; i++)
-{
-  if (analyzeThisParticle[i])
-    {
-      for (unsigned s = s1[i]; s <= s2[i]; s++)
-      {
-        if (faxial[i + chainBeads * s])
-        {
+  for (unsigned i = 0; i < chainBeads; i++) {
+  if (analyzeThisParticle[i]) {
+      for (unsigned s = s1[i]; s <= s2[i]; s++) {
+        if (faxial[i + chainBeads * s]) {
           faxial_d_fradial_dx[i + chainBeads * s] = faxial[i + chainBeads * s] * d_fradial_dx[i] - d_Xcyl_dx[i] * Axs[s];
           faxial_d_fradial_dy[i + chainBeads * s] = faxial[i + chainBeads * s] * d_fradial_dy[i] - d_Ycyl_dy[i] * Ays[s];
           faxial_d_fradial_dz[i + chainBeads * s] = -d_Xcyl_dz[i] * Axs[s] - d_Ycyl_dz[i] * Ays[s];
         }
       }
 
-      for (unsigned s = s1[i]; s <= s2[i]; s++)
-      {
+      for (unsigned s = s1[i]; s <= s2[i]; s++) {
         aux = d_psi[s] / NS[0];
         derivatives_Chain[i][0] += aux * faxial_d_fradial_dx[i + chainBeads * s];
         derivatives_Chain[i][1] += aux * faxial_d_fradial_dy[i + chainBeads * s];
@@ -795,8 +746,7 @@ void fusionPoreNucleationP::calculate()
   }
 
   Tensor virial;
-  for (unsigned i = 0; i < chainBeads; i++)
-{
+  for (unsigned i = 0; i < chainBeads; i++) {
   setAtomsDerivatives((i + noChainBeads), derivatives_Chain[i]);
     virial -= Tensor(CylDistances[i], derivatives_Chain[i]);
   }
diff --git a/src/membranefusion/MemFusionP.cpp b/src/membranefusion/MemFusionP.cpp
index b4351a0ae8..16e21980f5 100644
--- a/src/membranefusion/MemFusionP.cpp
+++ b/src/membranefusion/MemFusionP.cpp
@@ -27,10 +27,8 @@ along with plumed.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 #endif
 
-namespace PLMD
-{
-namespace membranefusion
-{
+namespace PLMD {
+namespace membranefusion {
 //+PLUMEDOC MEMBRANEFUSIONMOD_COLVAR MEMFUSIONP
 /*
 Calculate a CV that can induce the formation of the hemifusion stalk between two initially flat and planar bilayers.
@@ -75,8 +73,7 @@ You can test this CV with another example in this <a href="https://github.com/la
 */
 //+ENDPLUMEDOC
 
-class memFusionP : public Colvar
-{
+class memFusionP : public Colvar {
   std::vector<AtomNumber> UMEM, LMEM, TAILS;
   std::vector<double> NSMEM, DSMEM, HMEM, RCYLMEM, ZETAMEM, ONEOVERS2C2CUTOFF, XCYL, YCYL;
 
@@ -88,8 +85,7 @@ class memFusionP : public Colvar
 
 PLUMED_REGISTER_ACTION(memFusionP, "MEMFUSIONP")
 
-void memFusionP::registerKeywords(Keywords &keys)
-{
+void memFusionP::registerKeywords(Keywords &keys) {
   Colvar::registerKeywords(keys);
   keys.add("atoms", "UMEMBRANE", "all the beads of the upper membrane");
   keys.add("atoms", "LMEMBRANE", "all the beads of the lower membrane");
@@ -105,79 +101,93 @@ void memFusionP::registerKeywords(Keywords &keys)
   keys.setValueDescription("the value of the CV");
 }
 
-memFusionP::memFusionP(const ActionOptions &ao) : PLUMED_COLVAR_INIT(ao)
-{
+memFusionP::memFusionP(const ActionOptions &ao) : PLUMED_COLVAR_INIT(ao) {
   parseAtomList("UMEMBRANE", UMEM);
-  if (UMEM.size() == 0)
+  if (UMEM.size() == 0) {
     error("UMEMBRANE has not any atom specified.");
+  }
 
   parseAtomList("LMEMBRANE", LMEM);
-  if (LMEM.size() == 0)
+  if (LMEM.size() == 0) {
     error("LMEMBRANE has not any atom specified.");
+  }
 
   parseAtomList("TAILS", TAILS);
-  if (TAILS.size() == 0)
+  if (TAILS.size() == 0) {
     error("TAILS has not any atom specified.");
+  }
 
   parseVector("NSMEM", NSMEM);
-  if (NSMEM.size() > 1)
+  if (NSMEM.size() > 1) {
     error("NSMEM cannot take more than one value.");
+  }
 
   parseVector("DSMEM", DSMEM);
-  if (DSMEM.size() > 1)
+  if (DSMEM.size() > 1) {
     error("DSMEM cannot take more than one value.");
-  if (DSMEM.size() == 0)
+  }
+  if (DSMEM.size() == 0) {
     DSMEM.push_back(0.1);
+  }
 
   parseVector("HMEM", HMEM);
-  if (HMEM.size() > 1)
+  if (HMEM.size() > 1) {
     error("HMEM cannot take more than one value.");
-  if (HMEM.size() == 0)
+  }
+  if (HMEM.size() == 0) {
     HMEM.push_back(0.25);
+  }
 
   parseVector("RCYLMEM", RCYLMEM);
-  if (RCYLMEM.size() > 1)
+  if (RCYLMEM.size() > 1) {
     error("RCYLMEM cannot take more than one value.");
-  if (RCYLMEM.size() == 0)
+  }
+  if (RCYLMEM.size() == 0) {
     RCYLMEM.push_back(1.75);
+  }
 
   parseVector("ZETAMEM", ZETAMEM);
-  if (ZETAMEM.size() > 1)
+  if (ZETAMEM.size() > 1) {
     error("ZETA cannot take more than one value.");
-  if (ZETAMEM.size() == 0)
+  }
+  if (ZETAMEM.size() == 0) {
     ZETAMEM.push_back(0.5);
+  }
 
   parseVector("ONEOVERS2C2CUTOFF", ONEOVERS2C2CUTOFF);
-  if (ONEOVERS2C2CUTOFF.size() > 1)
+  if (ONEOVERS2C2CUTOFF.size() > 1) {
     error("ONEOVERS2C2CUTOFF cannot take more than one value.");
-  if (ONEOVERS2C2CUTOFF.size() == 0)
+  }
+  if (ONEOVERS2C2CUTOFF.size() == 0) {
     ONEOVERS2C2CUTOFF.push_back(500);
+  }
 
   parseVector("XCYL", XCYL);
-  if (XCYL.size() > 1)
+  if (XCYL.size() > 1) {
     error("XCYL cannot take more than one value.");
-  if (XCYL.size() == 0)
+  }
+  if (XCYL.size() == 0) {
     XCYL.push_back(-1.0);
+  }
 
   parseVector("YCYL", YCYL);
-  if (YCYL.size() > 1)
+  if (YCYL.size() > 1) {
     error("YCYL cannot take more than one value.");
-  if (YCYL.size() == 0)
+  }
+  if (YCYL.size() == 0) {
     YCYL.push_back(-1.0);
+  }
 
   checkRead();
 
   std::vector<AtomNumber> atoms;
-  for (unsigned i = 0; i < UMEM.size(); i++)
-  {
+  for (unsigned i = 0; i < UMEM.size(); i++) {
     atoms.push_back(UMEM[i]);
   }
-  for (unsigned i = 0; i < LMEM.size(); i++)
-  {
+  for (unsigned i = 0; i < LMEM.size(); i++) {
     atoms.push_back(LMEM[i]);
   }
-  for (unsigned i = 0; i < TAILS.size(); i++)
-  {
+  for (unsigned i = 0; i < TAILS.size(); i++) {
     atoms.push_back(TAILS[i]);
   }
 
@@ -186,8 +196,7 @@ memFusionP::memFusionP(const ActionOptions &ao) : PLUMED_COLVAR_INIT(ao)
   requestAtoms(atoms);
 }
 
-void memFusionP::calculate()
-{
+void memFusionP::calculate() {
   /**************************
    *                        *
    *         System         *
@@ -205,8 +214,7 @@ void memFusionP::calculate()
   #pragma omp parallel for private(uMemAngle, lMemAngle) reduction(+:ZuMemcos, ZuMemsin, ZlMemcos, ZlMemsin)
 #endif
 #endif
-  for (unsigned i = 0; i < UMEM.size(); i++)
-  {
+  for (unsigned i = 0; i < UMEM.size(); i++) {
     uMemAngle = 2.0 * M_PI * getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i)))[2];
     lMemAngle = 2.0 * M_PI * getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + UMEM.size())))[2];
     ZuMemcos += cos(uMemAngle);
@@ -294,49 +302,37 @@ void memFusionP::calculate()
   #pragma omp parallel for private(ZTailDistance, PositionS_Mem, TailPosition, x, aux) reduction(vec_double_plus:Fs_Mem, sx_Mem, sy_Mem, cx_Mem, cy_Mem)
 #endif
 #endif
-  for (unsigned i = 0; i < TAILS.size(); i++)
-  {
+  for (unsigned i = 0; i < TAILS.size(); i++) {
     ZTailDistance = pbcDistance(Vector(0.0, 0.0, ZMems), getPosition(i + membraneBeads))[2];
     PositionS_Mem = (ZTailDistance + firstSliceZDist_Mem) / DSMEM[0];
     // If the following condition is met the particle is in the Z space of the cylinder.
-    if ((PositionS_Mem >= (-0.5 - HMEM[0])) && (PositionS_Mem <= (NSMEM[0] + 0.5 - 1.0 + HMEM[0])))
-    {
+    if ((PositionS_Mem >= (-0.5 - HMEM[0])) && (PositionS_Mem <= (NSMEM[0] + 0.5 - 1.0 + HMEM[0]))) {
       analyzeThisParticle_Mem[i] = 1.0;
       // Defining the slices to analyze each particle.
-      if (PositionS_Mem < 1)
-      {
+      if (PositionS_Mem < 1) {
         s1_Mem[i] = 0;
         s2_Mem[i] = 2;
-      }
-      else if (PositionS_Mem <= (NSMEM[0] - 2.0))
-      {
+      } else if (PositionS_Mem <= (NSMEM[0] - 2.0)) {
         s1_Mem[i] = floor(PositionS_Mem) - 1;
         s2_Mem[i] = floor(PositionS_Mem) + 1;
-      }
-      else
-      {
+      } else {
         s1_Mem[i] = NSMEM[0] - 3;
         s2_Mem[i] = NSMEM[0] - 1;
       }
 
       TailPosition = getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + membraneBeads)));
 
-      for (unsigned s = s1_Mem[i]; s <= s2_Mem[i]; s++)
-      {
+      for (unsigned s = s1_Mem[i]; s <= s2_Mem[i]; s++) {
         x = (ZTailDistance - (s + 0.5 - NSMEM[0] / 2.0) * DSMEM[0]) * 2.0 / DSMEM[0];
-        if (!((x <= -1.0 - HMEM[0]) || (x >= 1.0 + HMEM[0])))
-        {
-          if (((-1.0 + HMEM[0]) <= x) && (x <= (1.0 - HMEM[0])))
-          {
+        if (!((x <= -1.0 - HMEM[0]) || (x >= 1.0 + HMEM[0]))) {
+          if (((-1.0 + HMEM[0]) <= x) && (x <= (1.0 - HMEM[0]))) {
             faxial_Mem[i + TAILS.size() * s] = 1.0;
             Fs_Mem[s] += 1.0;
             sx_Mem[s] += sin(2.0 * M_PI * TailPosition[0]);
             sy_Mem[s] += sin(2.0 * M_PI * TailPosition[1]);
             cx_Mem[s] += cos(2.0 * M_PI * TailPosition[0]);
             cy_Mem[s] += cos(2.0 * M_PI * TailPosition[1]);
-          }
-          else if (((1.0 - HMEM[0]) < x) && (x < (1.0 + HMEM[0])))
-          {
+          } else if (((1.0 - HMEM[0]) < x) && (x < (1.0 + HMEM[0]))) {
             aux = 0.5 - ((3.0 * x - 3.0) / (4.0 * HMEM[0])) + (pow((x - 1.0), 3) / (4.0 * pow(HMEM[0], 3)));
             faxial_Mem[i + TAILS.size() * s] = aux;
             d_faxial_Mem_dz[i + TAILS.size() * s] = ((-3.0 / (4.0 * HMEM[0])) + ((3.0 * pow((x - 1), 2)) / (4.0 * pow(HMEM[0], 3)))) * 2.0 / DSMEM[0];
@@ -345,9 +341,7 @@ void memFusionP::calculate()
             sy_Mem[s] += aux * sin(2.0 * M_PI * TailPosition[1]);
             cx_Mem[s] += aux * cos(2.0 * M_PI * TailPosition[0]);
             cy_Mem[s] += aux * cos(2.0 * M_PI * TailPosition[1]);
-          }
-          else if (((-1.0 - HMEM[0]) < x) && (x < (-1.0 + HMEM[0])))
-          {
+          } else if (((-1.0 - HMEM[0]) < x) && (x < (-1.0 + HMEM[0]))) {
             aux = 0.5 + ((3.0 * x + 3.0) / (4.0 * HMEM[0])) - (pow((x + 1.0), 3) / (4.0 * pow(HMEM[0], 3)));
             faxial_Mem[i + TAILS.size() * s] = aux;
             d_faxial_Mem_dz[i + TAILS.size() * s] = ((3.0 / (4.0 * HMEM[0])) - ((3.0 * pow((x + 1), 2)) / (4.0 * pow(HMEM[0], 3)))) * 2.0 / DSMEM[0];
@@ -362,10 +356,8 @@ void memFusionP::calculate()
     }
   }
 
-  for (unsigned s = 0; s < NSMEM[0]; s++)
-  {
-    if (Fs_Mem[s] != 0.0)
-    {
+  for (unsigned s = 0; s < NSMEM[0]; s++) {
+    if (Fs_Mem[s] != 0.0) {
       ws_Mem[s] = tanh(Fs_Mem[s]);
       W_Mem += ws_Mem[s];
       sx_Mem[s] = sx_Mem[s] / Fs_Mem[s];
@@ -387,13 +379,10 @@ void memFusionP::calculate()
   // Eq. 12 Hub & Awasthi JCTC 2017.
   double Xcyl_Mem, Ycyl_Mem;
 
-  if ((XCYL[0] > 0.0) && (YCYL[0] > 0.0))
-  {
+  if ((XCYL[0] > 0.0) && (YCYL[0] > 0.0)) {
     Xcyl_Mem = XCYL[0];
     Ycyl_Mem = YCYL[0];
-  }
-  else
-  {
+  } else {
     Xcyl_Mem = (atan2(-Xsc_Mem, -Xcc_Mem) + M_PI) * Lx / (2 * M_PI);
     Ycyl_Mem = (atan2(-Ysc_Mem, -Ycc_Mem) + M_PI) * Ly / (2 * M_PI);
   }
@@ -428,21 +417,15 @@ void memFusionP::calculate()
   // To avoid rare instabilities auxX_Mem and auxY_Mem are truncated at a configurable value (default = 500).
   double auxX_Mem = (1 / (pow(Xsc_Mem, 2) + pow(Xcc_Mem, 2))), auxY_Mem = (1 / (pow(Ysc_Mem, 2) + pow(Ycc_Mem, 2)));
 
-  if (auxX_Mem > ONEOVERS2C2CUTOFF[0])
-  {
+  if (auxX_Mem > ONEOVERS2C2CUTOFF[0]) {
     auxX_Mem = Lx * ONEOVERS2C2CUTOFF[0] / (2 * M_PI);
-  }
-  else
-  {
+  } else {
     auxX_Mem = Lx * auxX_Mem / (2 * M_PI);
   }
 
-  if (auxY_Mem > ONEOVERS2C2CUTOFF[0])
-  {
+  if (auxY_Mem > ONEOVERS2C2CUTOFF[0]) {
     auxY_Mem = Ly * ONEOVERS2C2CUTOFF[0] / (2 * M_PI);
-  }
-  else
-  {
+  } else {
     auxY_Mem = Ly * auxY_Mem / (2 * M_PI);
   }
 
@@ -466,10 +449,8 @@ void memFusionP::calculate()
   #pragma omp parallel for private(TailPosition,d_Xsc_Mem_dx,d_Xcc_Mem_dx,d_Ysc_Mem_dy,d_Ycc_Mem_dy,d_Xsc_Mem_dz,d_Xcc_Mem_dz,d_Ysc_Mem_dz,d_Ycc_Mem_dz,d_sx_Mem_dx,d_sy_Mem_dy,d_cx_Mem_dx,d_cy_Mem_dy,d_sx_Mem_dz,d_sy_Mem_dz,d_cx_Mem_dz,d_cy_Mem_dz,d_ws_Mem_dz,ri_Mem,x,fradial_Mem) reduction(vec_double_plus: Nsp_Mem, Axs_Mem, Ays_Mem)
 #endif
 #endif
-  for (unsigned i = 0; i < TAILS.size(); i++)
-  {
-    if (analyzeThisParticle_Mem[i])
-    {
+  for (unsigned i = 0; i < TAILS.size(); i++) {
+    if (analyzeThisParticle_Mem[i]) {
       TailPosition = getPbc().realToScaled(pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + membraneBeads)));
       d_Xsc_Mem_dx = 0.0;
       d_Xcc_Mem_dx = 0.0;
@@ -479,10 +460,8 @@ void memFusionP::calculate()
       d_Xcc_Mem_dz = 0.0;
       d_Ysc_Mem_dz = 0.0;
       d_Ycc_Mem_dz = 0.0;
-      for (unsigned s = s1_Mem[i]; s <= s2_Mem[i]; s++)
-      {
-        if (Fs_Mem[s] != 0.0)
-        {
+      for (unsigned s = s1_Mem[i]; s <= s2_Mem[i]; s++) {
+        if (Fs_Mem[s] != 0.0) {
           d_sx_Mem_dx = faxial_Mem[i + TAILS.size() * s] * 2.0 * M_PI * cos(2.0 * M_PI * TailPosition[0]) / (Lx * Fs_Mem[s]);
           d_sy_Mem_dy = faxial_Mem[i + TAILS.size() * s] * 2.0 * M_PI * cos(2.0 * M_PI * TailPosition[1]) / (Ly * Fs_Mem[s]);
           d_cx_Mem_dx = -faxial_Mem[i + TAILS.size() * s] * 2.0 * M_PI * sin(2.0 * M_PI * TailPosition[0]) / (Lx * Fs_Mem[s]);
@@ -511,27 +490,20 @@ void memFusionP::calculate()
       CylDistances_Mem[i] = pbcDistance(xyzCyl_Mem, pbcDistance(Vector(0.0, 0.0, 0.0), getPosition(i + membraneBeads)));
       ri_Mem = sqrt(pow(CylDistances_Mem[i][0], 2) + pow(CylDistances_Mem[i][1], 2));
       x = ri_Mem / RCYLMEM[0];
-      if (!((x <= -1.0 - HMEM[0]) || (x >= 1.0 + HMEM[0])))
-      {
-        if (((-1.0 + HMEM[0]) <= x) && (x <= (1.0 - HMEM[0])))
-        {
+      if (!((x <= -1.0 - HMEM[0]) || (x >= 1.0 + HMEM[0]))) {
+        if (((-1.0 + HMEM[0]) <= x) && (x <= (1.0 - HMEM[0]))) {
           fradial_Mem = 1.0;
-        }
-        else if (((1.0 - HMEM[0]) < x) && (x < (1.0 + HMEM[0])))
-        {
+        } else if (((1.0 - HMEM[0]) < x) && (x < (1.0 + HMEM[0]))) {
           fradial_Mem = 0.5 - ((3.0 * x - 3.0) / (4.0 * HMEM[0])) + (pow((x - 1.0), 3) / (4.0 * pow(HMEM[0], 3)));
           d_fradial_Mem_dx[i] = ((-3.0 / (4.0 * HMEM[0])) + ((3.0 * pow((x - 1), 2)) / (4.0 * pow(HMEM[0], 3)))) * CylDistances_Mem[i][0] / (RCYLMEM[0] * ri_Mem);
           d_fradial_Mem_dy[i] = ((-3.0 / (4.0 * HMEM[0])) + ((3.0 * pow((x - 1), 2)) / (4.0 * pow(HMEM[0], 3)))) * CylDistances_Mem[i][1] / (RCYLMEM[0] * ri_Mem);
-        }
-        else if (((-1.0 - HMEM[0]) < x) && (x < (-1.0 + HMEM[0])))
-        {
+        } else if (((-1.0 - HMEM[0]) < x) && (x < (-1.0 + HMEM[0]))) {
           fradial_Mem = 0.5 + ((3.0 * x + 3.0) / (4.0 * HMEM[0])) - (pow((x + 1.0), 3) / (4.0 * pow(HMEM[0], 3)));
           d_fradial_Mem_dx[i] = ((3.0 / (4.0 * HMEM[0])) - ((3.0 * pow((x + 1), 2)) / (4.0 * pow(HMEM[0], 3)))) * CylDistances_Mem[i][0] / (RCYLMEM[0] * ri_Mem);
           d_fradial_Mem_dy[i] = ((3.0 / (4.0 * HMEM[0])) - ((3.0 * pow((x + 1), 2)) / (4.0 * pow(HMEM[0], 3)))) * CylDistances_Mem[i][1] / (RCYLMEM[0] * ri_Mem);
         }
 
-        for (unsigned s = s1_Mem[i]; s <= s2_Mem[i]; s++)
-        {
+        for (unsigned s = s1_Mem[i]; s <= s2_Mem[i]; s++) {
           Nsp_Mem[s] += fradial_Mem * faxial_Mem[i + TAILS.size() * s];
           Axs_Mem[s] += faxial_Mem[i + TAILS.size() * s] * d_fradial_Mem_dx[i];
           Ays_Mem[s] += faxial_Mem[i + TAILS.size() * s] * d_fradial_Mem_dy[i];
@@ -541,16 +513,12 @@ void memFusionP::calculate()
     }
   }
 
-  for (unsigned s = 0; s < NSMEM[0]; s++)
-  {
-    if (Nsp_Mem[s] <= 1.0)
-    {
+  for (unsigned s = 0; s < NSMEM[0]; s++) {
+    if (Nsp_Mem[s] <= 1.0) {
       psi_Mem[s] = ZETAMEM[0] * Nsp_Mem[s];
       d_psi_Mem[s] = ZETAMEM[0];
       Xi_Mem += psi_Mem[s];
-    }
-    else
-    {
+    } else {
       psi_Mem[s] = 1.0 - c_Mem * exp(-b_Mem * Nsp_Mem[s]);
       d_psi_Mem[s] = b_Mem * c_Mem * exp(-b_Mem * Nsp_Mem[s]);
       Xi_Mem += psi_Mem[s];
@@ -570,22 +538,17 @@ void memFusionP::calculate()
   #pragma omp parallel for private(aux)
 #endif
 #endif
-  for (unsigned i = 0; i < TAILS.size(); i++)
-  {
-    if (analyzeThisParticle_Mem[i])
-    {
-      for (unsigned s = s1_Mem[i]; s <= s2_Mem[i]; s++)
-      {
-        if (faxial_Mem[i + TAILS.size() * s])
-        {
+  for (unsigned i = 0; i < TAILS.size(); i++) {
+    if (analyzeThisParticle_Mem[i]) {
+      for (unsigned s = s1_Mem[i]; s <= s2_Mem[i]; s++) {
+        if (faxial_Mem[i + TAILS.size() * s]) {
           faxial_Mem_d_fradial_Mem_dx[i + TAILS.size() * s] = faxial_Mem[i + TAILS.size() * s] * d_fradial_Mem_dx[i] - d_Xcyl_Mem_dx[i] * Axs_Mem[s];
           faxial_Mem_d_fradial_Mem_dy[i + TAILS.size() * s] = faxial_Mem[i + TAILS.size() * s] * d_fradial_Mem_dy[i] - d_Ycyl_Mem_dy[i] * Ays_Mem[s];
           faxial_Mem_d_fradial_Mem_dz[i + TAILS.size() * s] = -d_Xcyl_Mem_dz[i] * Axs_Mem[s] - d_Ycyl_Mem_dz[i] * Ays_Mem[s];
         }
       }
 
-      for (unsigned s = s1_Mem[i]; s <= s2_Mem[i]; s++)
-      {
+      for (unsigned s = s1_Mem[i]; s <= s2_Mem[i]; s++) {
         aux = d_psi_Mem[s] / NSMEM[0];
         derivatives_Mem[i][0] += aux * faxial_Mem_d_fradial_Mem_dx[i + TAILS.size() * s];
         derivatives_Mem[i][1] += aux * faxial_Mem_d_fradial_Mem_dy[i + TAILS.size() * s];
@@ -596,8 +559,7 @@ void memFusionP::calculate()
 
   // Derivatives and virial for the Xi_Mem.
   Tensor virial;
-  for (unsigned i = 0; i < TAILS.size(); i++)
-  {
+  for (unsigned i = 0; i < TAILS.size(); i++) {
     setAtomsDerivatives((i + membraneBeads), derivatives_Mem[i]);
     virial -= Tensor(CylDistances_Mem[i], derivatives_Mem[i]);
   }
diff --git a/src/multicolvar/AlphaBeta.cpp b/src/multicolvar/AlphaBeta.cpp
index dce98504fe..ad4d3bb3b9 100644
--- a/src/multicolvar/AlphaBeta.cpp
+++ b/src/multicolvar/AlphaBeta.cpp
@@ -60,43 +60,74 @@ void AlphaBeta::registerKeywords(Keywords& keys) {
   keys.add("numbered","COEFFICIENT","the coefficient for each of the torsional angles.  If you use a single COEFFICIENT value the "
            "same reference value is used for all torsional angles");
   keys.setValueDescription("the alpha beta CV");
-  keys.needsAction("CONSTANT"); keys.needsAction("TORSION"); keys.needsAction("COMBINE"); keys.needsAction("CUSTOM"); keys.needsAction("SUM");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("TORSION");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("SUM");
 }
 
 AlphaBeta::AlphaBeta(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in the reference value
-  std::string refstr; parse("REFERENCE",refstr); unsigned nref=0;
+  std::string refstr;
+  parse("REFERENCE",refstr);
+  unsigned nref=0;
   if( refstr.length()==0 ) {
     for(unsigned i=0;; ++i) {
       std::string refval;
-      if( !parseNumbered( "REFERENCE", i+1, refval ) ) break;
-      if( i==0 ) refstr = refval; else refstr += "," + refval;
+      if( !parseNumbered( "REFERENCE", i+1, refval ) ) {
+        break;
+      }
+      if( i==0 ) {
+        refstr = refval;
+      } else {
+        refstr += "," + refval;
+      }
       nref++;
     }
   }
-  std::string coeffstr; parse("COEFFICIENT",coeffstr); unsigned ncoeff=0;
+  std::string coeffstr;
+  parse("COEFFICIENT",coeffstr);
+  unsigned ncoeff=0;
   if( coeffstr.length()==0 ) {
     for(unsigned i=0;; ++i) {
       std::string coeff;
-      if( !parseNumbered( "COEFFICIENT", i+1, coeff) ) break;
-      if( i==0 ) coeffstr = coeff; else coeffstr += "," + coeff;
+      if( !parseNumbered( "COEFFICIENT", i+1, coeff) ) {
+        break;
+      }
+      if( i==0 ) {
+        coeffstr = coeff;
+      } else {
+        coeffstr += "," + coeff;
+      }
       ncoeff++;
     }
   }
-  if( coeffstr.length()==0 ) coeffstr="1";
+  if( coeffstr.length()==0 ) {
+    coeffstr="1";
+  }
   // Calculate angles
   readInputLine( getShortcutLabel() + "_torsions: TORSION " + convertInputLineToString() );
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_torsions" );
   plumed_assert( av && (av->copyOutput(0))->getRank()==1 );
   if( nref==0 ) {
-    std::string refval=refstr; for(unsigned i=1; i<(av->copyOutput(0))->getShape()[0]; ++i) refstr += "," + refval;
-  } else if( nref!=(av->copyOutput(0))->getShape()[0] ) error("mismatch between number of reference values and number of ATOMS specified");
+    std::string refval=refstr;
+    for(unsigned i=1; i<(av->copyOutput(0))->getShape()[0]; ++i) {
+      refstr += "," + refval;
+    }
+  } else if( nref!=(av->copyOutput(0))->getShape()[0] ) {
+    error("mismatch between number of reference values and number of ATOMS specified");
+  }
   if( ncoeff==0 ) {
-    std::string coeff=coeffstr; for(unsigned i=1; i<(av->copyOutput(0))->getShape()[0]; ++i) coeffstr += "," + coeff;
-  } else if( ncoeff!=(av->copyOutput(0))->getShape()[0] ) error("mismatch between number of coefficients and number of ATOMS specified");
+    std::string coeff=coeffstr;
+    for(unsigned i=1; i<(av->copyOutput(0))->getShape()[0]; ++i) {
+      coeffstr += "," + coeff;
+    }
+  } else if( ncoeff!=(av->copyOutput(0))->getShape()[0] ) {
+    error("mismatch between number of coefficients and number of ATOMS specified");
+  }
   readInputLine( getShortcutLabel() + "_ref: CONSTANT VALUES=" + refstr );
   readInputLine( getShortcutLabel() + "_coeff: CONSTANT VALUES=" + coeffstr );
   // Caculate difference from reference using combine
diff --git a/src/multicolvar/Angles.cpp b/src/multicolvar/Angles.cpp
index d035dc28df..e42bd04522 100644
--- a/src/multicolvar/Angles.cpp
+++ b/src/multicolvar/Angles.cpp
@@ -109,57 +109,83 @@ void Angles::registerKeywords( Keywords& keys ) {
            "GROUPC are calculated. The GROUPA atoms are assumed to be the central "
            "atoms");
   keys.add("optional","SWITCH","the switching function specifies that only those bonds that have a length that is less than a certain threshold are considered");
-  MultiColvarShortcuts::shortcutKeywords( keys ); keys.needsAction("ANGLE"); keys.needsAction("COORD_ANGLES");
+  MultiColvarShortcuts::shortcutKeywords( keys );
+  keys.needsAction("ANGLE");
+  keys.needsAction("COORD_ANGLES");
 }
 
 Angles::Angles(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string swit; parse("SWITCH",swit);
+  ActionShortcut(ao) {
+  std::string swit;
+  parse("SWITCH",swit);
   if( swit.length()>0 ) {
-    std::string cat, grp; parse("GROUPA",cat); parse("GROUPB",grp);
-    if( cat.length()==0 || grp.length()==0 ) error("must use GROUPA/GROUPB when using SWITCH");
+    std::string cat, grp;
+    parse("GROUPA",cat);
+    parse("GROUPB",grp);
+    if( cat.length()==0 || grp.length()==0 ) {
+      error("must use GROUPA/GROUPB when using SWITCH");
+    }
     readInputLine( getShortcutLabel() + ": COORD_ANGLES SWITCH={" +  swit + "} CATOMS=" + cat + " GROUP=" + grp + " " + convertInputLineToString() );
     return;
   }
-  std::vector<std::string> group; parseVector("GROUP",group);
-  std::vector<std::string> groupa; parseVector("GROUPA",groupa);
-  std::vector<std::string> groupb; parseVector("GROUPB",groupb);
-  std::vector<std::string> groupc; parseVector("GROUPC",groupc);
+  std::vector<std::string> group;
+  parseVector("GROUP",group);
+  std::vector<std::string> groupa;
+  parseVector("GROUPA",groupa);
+  std::vector<std::string> groupb;
+  parseVector("GROUPB",groupb);
+  std::vector<std::string> groupc;
+  parseVector("GROUPC",groupc);
   if( group.size()>0 ) {
-    if( groupa.size()>0 || groupb.size()>0 || groupc.size()>0 ) error("should only be GROUP keyword in input not GROUPA/GROUPB/GROUPC");
-    Tools::interpretRanges( group ); std::string ainput = getShortcutLabel() + ": ANGLE"; unsigned n=1;
+    if( groupa.size()>0 || groupb.size()>0 || groupc.size()>0 ) {
+      error("should only be GROUP keyword in input not GROUPA/GROUPB/GROUPC");
+    }
+    Tools::interpretRanges( group );
+    std::string ainput = getShortcutLabel() + ": ANGLE";
+    unsigned n=1;
     // Not sure if this triple sum makes any sense
     for(unsigned i=2; i<group.size(); ++i ) {
       for(unsigned j=1; j<i; ++j ) {
         for(unsigned k=0; k<j; ++k) {
-          std::string str_n; Tools::convert( n, str_n );
-          ainput += " ATOMS" + str_n + "=" + group[i] + "," + group[j] + "," + group[k]; n++;
+          std::string str_n;
+          Tools::convert( n, str_n );
+          ainput += " ATOMS" + str_n + "=" + group[i] + "," + group[j] + "," + group[k];
+          n++;
         }
       }
     }
     readInputLine( ainput );
   } else if( groupc.size()>0 ) {
-    Tools::interpretRanges( groupa ); Tools::interpretRanges( groupb ); Tools::interpretRanges( groupc );
-    unsigned n=1; std::string ainput = getShortcutLabel() + ": ANGLE";
+    Tools::interpretRanges( groupa );
+    Tools::interpretRanges( groupb );
+    Tools::interpretRanges( groupc );
+    unsigned n=1;
+    std::string ainput = getShortcutLabel() + ": ANGLE";
     for(unsigned i=0; i<groupa.size(); ++i ) {
       for(unsigned j=0; j<groupb.size(); ++j ) {
         for(unsigned k=0; k<groupc.size(); ++k) {
-          std::string str_n; Tools::convert( n, str_n );
-          ainput += " ATOMS" + str_n + "=" + groupb[j] + "," + groupa[i] + "," + groupc[k]; n++;
+          std::string str_n;
+          Tools::convert( n, str_n );
+          ainput += " ATOMS" + str_n + "=" + groupb[j] + "," + groupa[i] + "," + groupc[k];
+          n++;
         }
       }
     }
     readInputLine( ainput );
   } else if( groupa.size()>0 ) {
-    Tools::interpretRanges( groupa ); Tools::interpretRanges( groupb );
-    unsigned n=1; std::string ainput; ainput = getShortcutLabel() + ": ANGLE";
+    Tools::interpretRanges( groupa );
+    Tools::interpretRanges( groupb );
+    unsigned n=1;
+    std::string ainput;
+    ainput = getShortcutLabel() + ": ANGLE";
     for(unsigned i=0; i<groupa.size(); ++i ) {
       for(unsigned j=1; j<groupb.size(); ++j ) {
         for(unsigned k=0; k<j; ++k) {
-          std::string str_n; Tools::convert( n, str_n );
-          ainput += " ATOMS" + str_n + "=" + groupb[j] + "," + groupa[i] + "," + groupb[k]; n++;
+          std::string str_n;
+          Tools::convert( n, str_n );
+          ainput += " ATOMS" + str_n + "=" + groupb[j] + "," + groupa[i] + "," + groupb[k];
+          n++;
         }
       }
     }
diff --git a/src/multicolvar/CoordAngles.cpp b/src/multicolvar/CoordAngles.cpp
index d3efb6394c..1118a2c607 100644
--- a/src/multicolvar/CoordAngles.cpp
+++ b/src/multicolvar/CoordAngles.cpp
@@ -50,33 +50,52 @@ void CoordAngles::registerKeywords(Keywords& keys) {
   keys.add("atoms","CATOMS","all the angles between the bonds that radiate out from these central atom are computed");
   keys.add("atoms","GROUP","a list of angls between pairs of bonds connecting one of the atoms specified using the CATOM command and two of the atoms specified here are computed");
   keys.add("compulsory","SWITCH","the switching function specifies that only those bonds that have a length that is less than a certain threshold are considered");
-  MultiColvarShortcuts::shortcutKeywords( keys ); pruneShortcuts( keys );
-  keys.needsAction("DISTANCE"); keys.needsAction("COMBINE"); keys.needsAction("CUSTOM");
-  keys.needsAction("VSTACK"); keys.needsAction("TRANSPOSE");
-  keys.needsAction("OUTER_PRODUCT"); keys.needsAction("MATRIX_PRODUCT");
+  MultiColvarShortcuts::shortcutKeywords( keys );
+  pruneShortcuts( keys );
+  keys.needsAction("DISTANCE");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("VSTACK");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("OUTER_PRODUCT");
+  keys.needsAction("MATRIX_PRODUCT");
 }
 
 void CoordAngles::pruneShortcuts(Keywords& keys) {
-  keys.remove("ALT_MIN"); keys.remove("MIN"); keys.remove("MAX"); keys.remove("HIGHEST"); keys.remove("LOWEST");
+  keys.remove("ALT_MIN");
+  keys.remove("MIN");
+  keys.remove("MAX");
+  keys.remove("HIGHEST");
+  keys.remove("LOWEST");
 }
 
 CoordAngles::CoordAngles(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Parse the central atoms
-  std::vector<std::string> catoms; parseVector("CATOMS",catoms); Tools::interpretRanges(catoms);
+  std::vector<std::string> catoms;
+  parseVector("CATOMS",catoms);
+  Tools::interpretRanges(catoms);
   // Parse the coordination sphere
-  std::vector<std::string> group; parseVector("GROUP",group); Tools::interpretRanges(group);
+  std::vector<std::string> group;
+  parseVector("GROUP",group);
+  Tools::interpretRanges(group);
   // Create the list of atoms
-  std::string atlist; unsigned k=1;
+  std::string atlist;
+  unsigned k=1;
   for(unsigned i=0; i<catoms.size(); ++i) {
-    for(unsigned j=0; j<group.size(); ++j) { std::string num; Tools::convert( k, num ); atlist += " ATOMS" + num + "=" + catoms[i] + "," + group[j]; k++; }
+    for(unsigned j=0; j<group.size(); ++j) {
+      std::string num;
+      Tools::convert( k, num );
+      atlist += " ATOMS" + num + "=" + catoms[i] + "," + group[j];
+      k++;
+    }
   }
   // Calculate the distances
   readInputLine( getShortcutLabel() + "_dd: DISTANCE" + atlist );
   // Transform with the switching function
-  std::string switch_input; parse("SWITCH",switch_input);
+  std::string switch_input;
+  parse("SWITCH",switch_input);
   readInputLine( getShortcutLabel() + "_sw: LESS_THAN ARG=" + getShortcutLabel() + "_dd SWITCH={" + switch_input +"}");
   // Now get the normalised vectors
   readInputLine( getShortcutLabel() + "_comp: DISTANCE" + atlist + " COMPONENTS");
@@ -95,8 +114,16 @@ CoordAngles::CoordAngles(const ActionOptions& ao):
   readInputLine( getShortcutLabel() + "_dpmat: MATRIX_PRODUCT ARG=" + getShortcutLabel() + "_stack," + getShortcutLabel() + "_stackT");
   readInputLine( getShortcutLabel() + "_angles: CUSTOM ARG=" + getShortcutLabel() + "_dpmat FUNC=acos(x) PERIODIC=NO");
   // Read the input
-  Keywords keys; MultiColvarShortcuts::shortcutKeywords( keys ); pruneShortcuts( keys ); bool do_mean; parseFlag("MEAN",do_mean);
-  std::map<std::string,std::string> keymap; readShortcutKeywords( keys, keymap ); if( do_mean ) keymap.insert(std::pair<std::string,std::string>("SUM",""));
+  Keywords keys;
+  MultiColvarShortcuts::shortcutKeywords( keys );
+  pruneShortcuts( keys );
+  bool do_mean;
+  parseFlag("MEAN",do_mean);
+  std::map<std::string,std::string> keymap;
+  readShortcutKeywords( keys, keymap );
+  if( do_mean ) {
+    keymap.insert(std::pair<std::string,std::string>("SUM",""));
+  }
   MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel() + "_angles", getShortcutLabel() + "_wmat", keymap, this );
   if( do_mean ) {
     readInputLine( getShortcutLabel() + "_denom: SUM ARG=" + getShortcutLabel() + "_wmat PERIODIC=NO");
diff --git a/src/multicolvar/Dihcor.cpp b/src/multicolvar/Dihcor.cpp
index bb0c4c3ee2..d4bacd1210 100644
--- a/src/multicolvar/Dihcor.cpp
+++ b/src/multicolvar/Dihcor.cpp
@@ -89,7 +89,8 @@ PLUMED_REGISTER_ACTION(Dihcor,"DIHCOR")
 
 void Dihcor::registerKeywords( Keywords& keys ) {
   ActionShortcut::registerKeywords( keys );
-  keys.needsAction("DIHEDRAL_CORRELATION"); keys.needsAction("SUM");
+  keys.needsAction("DIHEDRAL_CORRELATION");
+  keys.needsAction("SUM");
   keys.add("atoms","ATOMS","the set of 8 atoms that are being used each of the dihedral correlation values");
   keys.addFlag("NOPBC",false,"ignore the periodic boundary conditions when calculating distances");
   keys.setValueDescription("the sum of all the dihedral correlations");
@@ -97,8 +98,7 @@ void Dihcor::registerKeywords( Keywords& keys ) {
 
 Dihcor::Dihcor(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   readInputLine( getShortcutLabel() +"_data: DIHEDRAL_CORRELATION " + convertInputLineToString() );
   readInputLine( getShortcutLabel() + ": SUM ARG=" + getShortcutLabel() + "_data PERIODIC=NO");
 }
diff --git a/src/multicolvar/Distances.cpp b/src/multicolvar/Distances.cpp
index 4975f3c963..09c797304f 100644
--- a/src/multicolvar/Distances.cpp
+++ b/src/multicolvar/Distances.cpp
@@ -202,77 +202,137 @@ void Distances::registerKeywords(Keywords& keys) {
   keys.addFlag("COMPONENTS",false,"calculate the x, y and z components of the distance separately and store them as label.x, label.y and label.z");
   keys.addFlag("SCALED_COMPONENTS",false,"calculate the a, b and c scaled components of the distance separately and store them as label.a, label.b and label.c");
   keys.addFlag("LOWMEM",false,"this flag does nothing and is present only to ensure back-compatibility");
-  keys.reset_style("ATOMS","atoms"); MultiColvarShortcuts::shortcutKeywords( keys );
+  keys.reset_style("ATOMS","atoms");
+  MultiColvarShortcuts::shortcutKeywords( keys );
   keys.add("atoms","ORIGIN","calculate the distance of all the atoms specified using the ATOMS keyword from this point");
   keys.add("numbered","LOCATION","the location at which the CV is assumed to be in space");
   keys.reset_style("LOCATION","atoms");
   keys.addOutputComponent("x","COMPONENTS","the x-components of the distance vectors");
   keys.addOutputComponent("y","COMPONENTS","the y-components of the distance vectors");
   keys.addOutputComponent("z","COMPONENTS","the z-components of the distance vectors");
-  keys.needsAction("GROUP"); keys.needsAction("DISTANCE"); keys.needsAction("CENTER");
+  keys.needsAction("GROUP");
+  keys.needsAction("DISTANCE");
+  keys.needsAction("CENTER");
 }
 
 Distances::Distances(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Create distances
-  bool lowmem; parseFlag("LOWMEM",lowmem);
-  if( lowmem ) warning("LOWMEM flag is deprecated and is no longer required for this action");
+  bool lowmem;
+  parseFlag("LOWMEM",lowmem);
+  if( lowmem ) {
+    warning("LOWMEM flag is deprecated and is no longer required for this action");
+  }
   std::string dline = getShortcutLabel() + ": DISTANCE";
-  bool nopbc; parseFlag("NOPBC",nopbc); if( nopbc ) dline += " NOPBC";
+  bool nopbc;
+  parseFlag("NOPBC",nopbc);
+  if( nopbc ) {
+    dline += " NOPBC";
+  }
   if( getName()=="DISTANCES" ) {
-    bool comp; parseFlag("COMPONENTS",comp); if( comp ) dline += " COMPONENTS";
-    bool scomp; parseFlag("SCALED_COMPONENTS",scomp); if( scomp ) dline += " SCALED_COMPONENTS";
-  } else dline += " COMPONENTS";
+    bool comp;
+    parseFlag("COMPONENTS",comp);
+    if( comp ) {
+      dline += " COMPONENTS";
+    }
+    bool scomp;
+    parseFlag("SCALED_COMPONENTS",scomp);
+    if( scomp ) {
+      dline += " SCALED_COMPONENTS";
+    }
+  } else {
+    dline += " COMPONENTS";
+  }
   // Parse origin
-  std::string num, ostr; parse("ORIGIN",ostr);
+  std::string num, ostr;
+  parse("ORIGIN",ostr);
   if( ostr.length()>0 ) {
     // Parse atoms
-    std::vector<std::string> afstr; MultiColvarShortcuts::parseAtomList("ATOMS",afstr,this);
-    for(unsigned i=0; i<afstr.size(); ++i) { Tools::convert( i+1, num ); dline += " ATOMS" + num + "=" + ostr + "," + afstr[i]; }
+    std::vector<std::string> afstr;
+    MultiColvarShortcuts::parseAtomList("ATOMS",afstr,this);
+    for(unsigned i=0; i<afstr.size(); ++i) {
+      Tools::convert( i+1, num );
+      dline += " ATOMS" + num + "=" + ostr + "," + afstr[i];
+    }
   } else {
-    std::vector<std::string> grp; MultiColvarShortcuts::parseAtomList("GROUP",grp,this);
-    std::vector<std::string> grpa; MultiColvarShortcuts::parseAtomList("GROUPA",grpa,this);
+    std::vector<std::string> grp;
+    MultiColvarShortcuts::parseAtomList("GROUP",grp,this);
+    std::vector<std::string> grpa;
+    MultiColvarShortcuts::parseAtomList("GROUPA",grpa,this);
     if( grp.size()>0 ) {
-      if( grpa.size()>0 ) error("should not be using GROUPA in tandem with GROUP");
+      if( grpa.size()>0 ) {
+        error("should not be using GROUPA in tandem with GROUP");
+      }
       unsigned n=0;
       for(unsigned i=1; i<grp.size(); ++i) {
         for(unsigned j=0; j<i; ++j) {
-          std::string num; Tools::convert( n+1, num ); n++;
+          std::string num;
+          Tools::convert( n+1, num );
+          n++;
           dline += " ATOMS" + num + "=" + grp[i] + "," + grp[j];
         }
       }
     } else if( grpa.size()>0 ) {
-      std::vector<std::string> grpb; MultiColvarShortcuts::parseAtomList("GROUPB",grpb,this);
-      if( grpb.size()==0 ) error("found GROUPA but no corresponding GROUPB");
-      std::string grpstr = getShortcutLabel() + "_grp: GROUP ATOMS="; bool printcomment=false;
+      std::vector<std::string> grpb;
+      MultiColvarShortcuts::parseAtomList("GROUPB",grpb,this);
+      if( grpb.size()==0 ) {
+        error("found GROUPA but no corresponding GROUPB");
+      }
+      std::string grpstr = getShortcutLabel() + "_grp: GROUP ATOMS=";
+      bool printcomment=false;
       for(unsigned i=0; i<grpa.size(); ++i) {
         for(unsigned j=0; j<grpb.size(); ++j) {
-          std::string num; Tools::convert( i*grpb.size() + j + 1, num );
+          std::string num;
+          Tools::convert( i*grpb.size() + j + 1, num );
           dline += " ATOMS" + num + "=" + grpa[i] + "," + grpb[j];
-          if( i*grpb.size() + j<6 ) readInputLine( getShortcutLabel() + "_vatom" + num + ": CENTER ATOMS=" + grpa[i] + "," + grpb[j], true );
-          else { readInputLine( getShortcutLabel() + "_vatom" + num + ": CENTER ATOMS=" + grpa[i] + "," + grpb[j], false ); printcomment=true; }
-          if( i+j==0 ) grpstr += getShortcutLabel() + "_vatom" + num; else grpstr += "," + getShortcutLabel() + "_vatom" + num;
+          if( i*grpb.size() + j<6 ) {
+            readInputLine( getShortcutLabel() + "_vatom" + num + ": CENTER ATOMS=" + grpa[i] + "," + grpb[j], true );
+          } else {
+            readInputLine( getShortcutLabel() + "_vatom" + num + ": CENTER ATOMS=" + grpa[i] + "," + grpb[j], false );
+            printcomment=true;
+          }
+          if( i+j==0 ) {
+            grpstr += getShortcutLabel() + "_vatom" + num;
+          } else {
+            grpstr += "," + getShortcutLabel() + "_vatom" + num;
+          }
         }
       }
-      std::string num; Tools::convert( grpa.size()*grpb.size(), num );
-      if( printcomment ) addCommentToShortcutOutput("# A further " + num + " CENTER like the ones above were also created but are not shown");
+      std::string num;
+      Tools::convert( grpa.size()*grpb.size(), num );
+      if( printcomment ) {
+        addCommentToShortcutOutput("# A further " + num + " CENTER like the ones above were also created but are not shown");
+      }
       readInputLine( grpstr );
     } else {
       std::string grpstr = getShortcutLabel() + "_grp: GROUP ATOMS=";
       for(unsigned i=1;; ++i) {
-        std::string atstring; parseNumbered("ATOMS",i,atstring);
-        if( atstring.length()==0 ) break;
-        std::string locstr; parseNumbered("LOCATION",i,locstr);
+        std::string atstring;
+        parseNumbered("ATOMS",i,atstring);
+        if( atstring.length()==0 ) {
+          break;
+        }
+        std::string locstr;
+        parseNumbered("LOCATION",i,locstr);
         if( locstr.length()==0 ) {
-          std::string num; Tools::convert( i, num );
+          std::string num;
+          Tools::convert( i, num );
           readInputLine( getShortcutLabel() + "_vatom" + num + ": CENTER ATOMS=" + atstring );
-          if( i==1 ) grpstr += getShortcutLabel() + "_vatom" + num; else grpstr += "," + getShortcutLabel() + "_vatom" + num;
+          if( i==1 ) {
+            grpstr += getShortcutLabel() + "_vatom" + num;
+          } else {
+            grpstr += "," + getShortcutLabel() + "_vatom" + num;
+          }
         } else {
-          if( i==1 ) grpstr += locstr; else grpstr += "," + locstr;
+          if( i==1 ) {
+            grpstr += locstr;
+          } else {
+            grpstr += "," + locstr;
+          }
         }
-        std::string num; Tools::convert( i, num );
+        std::string num;
+        Tools::convert( i, num );
         dline += " ATOMS" + num + "=" + atstring;
       }
       readInputLine( grpstr );
@@ -280,10 +340,15 @@ Distances::Distances(const ActionOptions& ao):
   }
   readInputLine( dline );
   // Add shortcuts to label
-  if( getName()=="DISTANCES" ) MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel(), "", this );
-  else if( getName()=="XDISTANCES" ) MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel() + ".x", "", this );
-  else if( getName()=="YDISTANCES" ) MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel() + ".y", "", this );
-  else if( getName()=="ZDISTANCES" ) MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel() + ".z", "", this );
+  if( getName()=="DISTANCES" ) {
+    MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel(), "", this );
+  } else if( getName()=="XDISTANCES" ) {
+    MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel() + ".x", "", this );
+  } else if( getName()=="YDISTANCES" ) {
+    MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel() + ".y", "", this );
+  } else if( getName()=="ZDISTANCES" ) {
+    MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel() + ".z", "", this );
+  }
 }
 
 }
diff --git a/src/multicolvar/DumpMultiColvar.cpp b/src/multicolvar/DumpMultiColvar.cpp
index b716a99cef..c46ebc1a86 100644
--- a/src/multicolvar/DumpMultiColvar.cpp
+++ b/src/multicolvar/DumpMultiColvar.cpp
@@ -49,15 +49,16 @@ void DumpMultiColvar::registerKeywords(Keywords& keys) {
   ActionShortcut::registerKeywords( keys );
   keys.add("compulsory","DATA","the vector you wish to transform");
   keys.add("compulsory","FILE","the file that you would like to output the data to");
-  keys.remove("HAS_VALUES"); keys.needsAction("DUMPATOMS");
+  keys.remove("HAS_VALUES");
+  keys.needsAction("DUMPATOMS");
 }
 
 DumpMultiColvar::DumpMultiColvar(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   warning("This action has been depracated.  Look at the log to see how the same result is achieved with the new syntax");
-  std::string dd; parse("DATA",dd);
+  std::string dd;
+  parse("DATA",dd);
   readInputLine("DUMPATOMS ATOMS=" + dd + "_grp ARG=" + dd + " " + convertInputLineToString() );
 }
 
diff --git a/src/multicolvar/InPlaneDistances.cpp b/src/multicolvar/InPlaneDistances.cpp
index a05b281993..291b7f547b 100644
--- a/src/multicolvar/InPlaneDistances.cpp
+++ b/src/multicolvar/InPlaneDistances.cpp
@@ -52,27 +52,37 @@ void InPlaneDistances::registerKeywords( Keywords& keys ) {
   keys.add("atoms","VECTORSTART","The first atom position that is used to define the normal to the plane of interest");
   keys.add("atoms","VECTOREND","The second atom position that is used to defin the normal to the plane of interest");
   MultiColvarShortcuts::shortcutKeywords( keys );
-  keys.needsAction("DISTANCE"); keys.needsAction("ANGLE");
+  keys.needsAction("DISTANCE");
+  keys.needsAction("ANGLE");
 }
 
 InPlaneDistances::InPlaneDistances(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::vector<std::string> str_atomsA; parseVector("VECTORSTART",str_atomsA); Tools::interpretRanges( str_atomsA );
-  std::vector<std::string> str_atomsB; parseVector("VECTOREND",str_atomsB); Tools::interpretRanges( str_atomsB );
-  std::vector<std::string> str_atomsC; parseVector("GROUP",str_atomsC); Tools::interpretRanges( str_atomsC );
-  unsigned n=1; std::string dinput= getShortcutLabel() + "_dis: DISTANCE", ainput = getShortcutLabel() + "_ang: ANGLE";
+  ActionShortcut(ao) {
+  std::vector<std::string> str_atomsA;
+  parseVector("VECTORSTART",str_atomsA);
+  Tools::interpretRanges( str_atomsA );
+  std::vector<std::string> str_atomsB;
+  parseVector("VECTOREND",str_atomsB);
+  Tools::interpretRanges( str_atomsB );
+  std::vector<std::string> str_atomsC;
+  parseVector("GROUP",str_atomsC);
+  Tools::interpretRanges( str_atomsC );
+  unsigned n=1;
+  std::string dinput= getShortcutLabel() + "_dis: DISTANCE", ainput = getShortcutLabel() + "_ang: ANGLE";
   for(unsigned i=0; i<str_atomsA.size(); ++i ) {
     for(unsigned j=0; j<str_atomsB.size(); ++j ) {
       for(unsigned k=0; k<str_atomsC.size(); ++k) {
-        std::string str_n; Tools::convert( n, str_n ); n++;
+        std::string str_n;
+        Tools::convert( n, str_n );
+        n++;
         dinput += " ATOMS" + str_n + "=" + str_atomsA[j] + "," + str_atomsC[k];
         ainput += " ATOMS" + str_n + "=" + str_atomsB[j] + "," + str_atomsA[i] + "," + str_atomsC[k];
       }
     }
   }
-  readInputLine( dinput ); readInputLine( ainput );
+  readInputLine( dinput );
+  readInputLine( ainput );
   readInputLine( getShortcutLabel() + ": CUSTOM PERIODIC=NO FUNC=x*sin(y) ARG=" + getShortcutLabel() + "_dis," + getShortcutLabel() + "_ang");
   MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel(), "", this );
 }
diff --git a/src/multicolvar/MFilterLess.cpp b/src/multicolvar/MFilterLess.cpp
index 93ee48b28c..d767dc58a3 100644
--- a/src/multicolvar/MFilterLess.cpp
+++ b/src/multicolvar/MFilterLess.cpp
@@ -50,16 +50,18 @@ void MFilterLess::registerKeywords(Keywords& keys) {
   keys.add("compulsory","DATA","the vector you wish to transform");
   keys.add("compulsory","SWITCH","the switching function that transform");
   keys.setValueDescription("a vector that has the same dimension as the input vector with elements equal to one if the corresponding component of the vector is less than a tolerance and zero otherwise");
-  keys.needsAction("GROUP"); keys.needsAction("LESS_THAN");
+  keys.needsAction("GROUP");
+  keys.needsAction("LESS_THAN");
 }
 
 MFilterLess::MFilterLess(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   warning("This action has been depracated.  Look at the log to see how the same result is achieved with the new syntax");
-  std::string dd; parse("DATA",dd);
-  std::string swit; parse("SWITCH",swit);
+  std::string dd;
+  parse("DATA",dd);
+  std::string swit;
+  parse("SWITCH",swit);
   readInputLine( getShortcutLabel() + "_grp: GROUP ATOMS=" + dd + "_grp");
   readInputLine( getShortcutLabel() + ": LESS_THAN ARG=" + dd + " SWITCH={" + swit + "}");
 }
diff --git a/src/multicolvar/MFilterMore.cpp b/src/multicolvar/MFilterMore.cpp
index 045ab1910c..8f37f390e0 100644
--- a/src/multicolvar/MFilterMore.cpp
+++ b/src/multicolvar/MFilterMore.cpp
@@ -52,22 +52,29 @@ void MFilterMore::registerKeywords(Keywords& keys) {
   keys.addFlag("LOWMEM",false,"this flag does nothing and is present only to ensure back-compatibility");
   keys.addFlag("HIGHEST",false,"this flag allows you to recover the highest of these variables.");
   keys.addOutputComponent("highest","HIGHEST","the largest of the colvars");
-  keys.needsAction("CUSTOM"); keys.needsAction("GROUP");
-  keys.needsAction("MORE_THAN"); keys.needsAction("HIGHEST");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("GROUP");
+  keys.needsAction("MORE_THAN");
+  keys.needsAction("HIGHEST");
 }
 
 MFilterMore::MFilterMore(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   warning("This action has been depracated.  Look at the log to see how the same result is achieved with the new syntax");
-  bool lowmem; parseFlag("LOWMEM",lowmem);
-  if( lowmem ) warning("LOWMEM flag is deprecated and is no longer required for this action");
-  std::string dd; parse("DATA",dd);
-  std::string swit; parse("SWITCH",swit);
+  bool lowmem;
+  parseFlag("LOWMEM",lowmem);
+  if( lowmem ) {
+    warning("LOWMEM flag is deprecated and is no longer required for this action");
+  }
+  std::string dd;
+  parse("DATA",dd);
+  std::string swit;
+  parse("SWITCH",swit);
   readInputLine( getShortcutLabel() + "_grp: GROUP ATOMS=" + dd + "_grp");
   readInputLine( getShortcutLabel() + ": MORE_THAN ARG=" + dd + " SWITCH={" + swit + "}");
-  bool highest; parseFlag("HIGHEST",highest);
+  bool highest;
+  parseFlag("HIGHEST",highest);
   if( highest ) {
     readInputLine( getShortcutLabel() + "_filtered: CUSTOM ARG=" + dd + "," + getShortcutLabel() + " FUNC=x*y PERIODIC=NO");
     readInputLine( getShortcutLabel() + "_highest: HIGHEST ARG=" + getShortcutLabel() + "_filtered");
diff --git a/src/multicolvar/MultiColvarShortcuts.cpp b/src/multicolvar/MultiColvarShortcuts.cpp
index 1490cb1d8e..9c65f1a85b 100644
--- a/src/multicolvar/MultiColvarShortcuts.cpp
+++ b/src/multicolvar/MultiColvarShortcuts.cpp
@@ -65,39 +65,61 @@ void MultiColvarShortcuts::shortcutKeywords( Keywords& keys ) {
   keys.addOutputComponent("sum","SUM","the sum of the colvars");
   keys.addFlag("MEAN",false,"calculate the mean of all the quantities.");
   keys.addOutputComponent("mean","MEAN","the mean of the colvars");
-  keys.needsAction("SUM"); keys.needsAction("MEAN"); keys.needsAction("CUSTOM"); keys.needsAction("HIGHEST"); keys.needsAction("LOWEST");
-  keys.needsAction("LESS_THAN"); keys.needsAction("MORE_THAN"); keys.needsAction("BETWEEN");
+  keys.needsAction("SUM");
+  keys.needsAction("MEAN");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("HIGHEST");
+  keys.needsAction("LOWEST");
+  keys.needsAction("LESS_THAN");
+  keys.needsAction("MORE_THAN");
+  keys.needsAction("BETWEEN");
 }
 
 void MultiColvarShortcuts::expandFunctions( const std::string& labout, const std::string& argin, const std::string& weights, ActionShortcut* action ) {
-  std::map<std::string,std::string> keymap; readShortcutKeywords( keymap, action ); expandFunctions( labout, argin, weights, keymap, action );
+  std::map<std::string,std::string> keymap;
+  readShortcutKeywords( keymap, action );
+  expandFunctions( labout, argin, weights, keymap, action );
 }
 
 void MultiColvarShortcuts::readShortcutKeywords( std::map<std::string,std::string>& keymap, ActionShortcut* action ) {
-  Keywords keys; shortcutKeywords( keys ); action->readShortcutKeywords( keys, keymap );
+  Keywords keys;
+  shortcutKeywords( keys );
+  action->readShortcutKeywords( keys, keymap );
 }
 
 void MultiColvarShortcuts::parseAtomList( const std::string& key, std::vector<std::string>& atoms, ActionShortcut* action ) {
-  std::vector<std::string> astr; action->parseVector(key,astr); if( astr.size()==0 ) return ;
+  std::vector<std::string> astr;
+  action->parseVector(key,astr);
+  if( astr.size()==0 ) {
+    return ;
+  }
   Tools::interpretRanges( astr );
   for(unsigned i=0; i<astr.size(); ++i) {
     Group* mygr=action->plumed.getActionSet().selectWithLabel<Group*>(astr[i]);
     if( mygr ) {
       std::vector<std::string> grstr( mygr->getGroupAtoms() );
-      for(unsigned j=0; j<grstr.size(); ++j) atoms.push_back(grstr[j]);
+      for(unsigned j=0; j<grstr.size(); ++j) {
+        atoms.push_back(grstr[j]);
+      }
     } else {
       Group* mygr2=action->plumed.getActionSet().selectWithLabel<Group*>(astr[i] + "_grp");
       if( mygr2 ) {
         std::vector<std::string> grstr( mygr2->getGroupAtoms() );
-        for(unsigned j=0; j<grstr.size(); ++j) atoms.push_back(grstr[j]);
-      } else atoms.push_back(astr[i]);
+        for(unsigned j=0; j<grstr.size(); ++j) {
+          atoms.push_back(grstr[j]);
+        }
+      } else {
+        atoms.push_back(astr[i]);
+      }
     }
   }
 }
 
 void MultiColvarShortcuts::expandFunctions( const std::string& labout, const std::string& argin, const std::string& weights,
     const std::map<std::string,std::string>& keymap, ActionShortcut* action ) {
-  if( keymap.empty() ) return;
+  if( keymap.empty() ) {
+    return;
+  }
   // Parse LESS_THAN
   if( keymap.count("LESS_THAN") ) {
     std::string sum_arg = labout + "_lt", lt_string = keymap.find("LESS_THAN")->second;
@@ -110,8 +132,11 @@ void MultiColvarShortcuts::expandFunctions( const std::string& labout, const std
   }
   if( keymap.count("LESS_THAN1") ) {
     for(unsigned i=1;; ++i) {
-      std::string istr; Tools::convert( i, istr );
-      if( !keymap.count("LESS_THAN" + istr ) ) { break; }
+      std::string istr;
+      Tools::convert( i, istr );
+      if( !keymap.count("LESS_THAN" + istr ) ) {
+        break;
+      }
       std::string sum_arg = labout + "_lt" + istr, lt_string1 = keymap.find("LESS_THAN" + istr)->second;
       action->readInputLine( labout + "_lt" + istr + ": LESS_THAN ARG=" + argin + " SWITCH={" + lt_string1 + "}");
       if( weights.length()>0 ) {
@@ -133,8 +158,11 @@ void MultiColvarShortcuts::expandFunctions( const std::string& labout, const std
   }
   if(  keymap.count("MORE_THAN1") ) {
     for(unsigned i=1;; ++i) {
-      std::string istr; Tools::convert( i, istr );
-      if( !keymap.count("MORE_THAN" + istr ) ) { break; }
+      std::string istr;
+      Tools::convert( i, istr );
+      if( !keymap.count("MORE_THAN" + istr ) ) {
+        break;
+      }
       std::string sum_arg = labout + "_mt" + istr, mt_string1 = keymap.find("MORE_THAN" + istr)->second;
       action->readInputLine( labout + "_mt" + istr + ": MORE_THAN ARG=" + argin + " SWITCH={" + mt_string1 + "}");
       if( weights.length()>0 ) {
@@ -146,9 +174,12 @@ void MultiColvarShortcuts::expandFunctions( const std::string& labout, const std
   }
   // Parse ALT_MIN
   if( keymap.count("ALT_MIN") ) {
-    if( weights.length()>0 ) plumed_merror("cannot use ALT_MIN with this shortcut");
+    if( weights.length()>0 ) {
+      plumed_merror("cannot use ALT_MIN with this shortcut");
+    }
     std::string amin_string = keymap.find("ALT_MIN")->second;
-    std::size_t dd = amin_string.find("BETA"); std::string beta_str = amin_string.substr(dd+5);
+    std::size_t dd = amin_string.find("BETA");
+    std::string beta_str = amin_string.substr(dd+5);
     beta_str.erase(std::remove_if(beta_str.begin(), beta_str.end(), ::isspace), beta_str.end());
     action->readInputLine( labout + "_me_altmin: CUSTOM ARG=" + argin + " FUNC=exp(-x*" + beta_str + ") PERIODIC=NO");
     action->readInputLine( labout + "_mec_altmin: SUM ARG=" + labout + "_me_altmin PERIODIC=NO");
@@ -156,9 +187,12 @@ void MultiColvarShortcuts::expandFunctions( const std::string& labout, const std
   }
   // Parse MIN
   if( keymap.count("MIN") ) {
-    if( weights.length()>0 ) plumed_merror("cannot use MIN with this shortcut");
+    if( weights.length()>0 ) {
+      plumed_merror("cannot use MIN with this shortcut");
+    }
     std::string min_string = keymap.find("MIN")->second;
-    std::size_t dd = min_string.find("BETA"); std::string beta_str = min_string.substr(dd+5);
+    std::size_t dd = min_string.find("BETA");
+    std::string beta_str = min_string.substr(dd+5);
     beta_str.erase(std::remove_if(beta_str.begin(), beta_str.end(), ::isspace), beta_str.end());
     action->readInputLine( labout + "_me_min: CUSTOM ARG=" + argin + " FUNC=exp(" + beta_str + "/x) PERIODIC=NO");
     action->readInputLine( labout + "_mec_min: SUM ARG=" + labout + "_me_min PERIODIC=NO");
@@ -166,9 +200,12 @@ void MultiColvarShortcuts::expandFunctions( const std::string& labout, const std
   }
   // Parse MAX
   if( keymap.count("MAX") ) {
-    if( weights.length()>0 ) plumed_merror("cannot use MAX with this shortcut");
+    if( weights.length()>0 ) {
+      plumed_merror("cannot use MAX with this shortcut");
+    }
     std::string max_string = keymap.find("MAX")->second;
-    std::size_t dd = max_string.find("BETA"); std::string beta_str = max_string.substr(dd+5);
+    std::size_t dd = max_string.find("BETA");
+    std::string beta_str = max_string.substr(dd+5);
     beta_str.erase(std::remove_if(beta_str.begin(), beta_str.end(), ::isspace), beta_str.end());
     action->readInputLine( labout + "_me_max: CUSTOM ARG=" + argin + " FUNC=exp(x/" + beta_str + ") PERIODIC=NO");
     action->readInputLine( labout + "_mec_max: SUM ARG=" + labout + "_me_max PERIODIC=NO");
@@ -176,12 +213,16 @@ void MultiColvarShortcuts::expandFunctions( const std::string& labout, const std
   }
   // Parse HIGHEST
   if( keymap.count("HIGHEST") ) {
-    if( weights.length()>0 ) plumed_merror("cannot use HIGHEST with this shortcut");
+    if( weights.length()>0 ) {
+      plumed_merror("cannot use HIGHEST with this shortcut");
+    }
     action->readInputLine( labout + "_highest: HIGHEST ARG=" + argin );
   }
   // Parse LOWEST
   if( keymap.count("LOWEST") ) {
-    if( weights.length()>0 ) plumed_merror("cannot use LOWEST with this shortcut");
+    if( weights.length()>0 ) {
+      plumed_merror("cannot use LOWEST with this shortcut");
+    }
     action->readInputLine( labout + "_lowest: LOWEST ARG=" + argin );
   }
   // Parse SUM
@@ -195,7 +236,9 @@ void MultiColvarShortcuts::expandFunctions( const std::string& labout, const std
   }
   // Parse MEAN
   if( keymap.count("MEAN") ) {
-    if( weights.length()>0 ) plumed_merror("cannot use MEAN with this shortcut");
+    if( weights.length()>0 ) {
+      plumed_merror("cannot use MEAN with this shortcut");
+    }
     action->readInputLine( labout + "_mean: MEAN ARG=" + argin + " PERIODIC=NO");
   }
   // Parse BETWEEN
@@ -211,8 +254,11 @@ void MultiColvarShortcuts::expandFunctions( const std::string& labout, const std
   std::string bt_string1;
   if( keymap.count("BETWEEN1") ) {
     for(unsigned i=1;; ++i) {
-      std::string istr; Tools::convert( i, istr );
-      if( !keymap.count("BETWEEN" + istr) ) break;
+      std::string istr;
+      Tools::convert( i, istr );
+      if( !keymap.count("BETWEEN" + istr) ) {
+        break;
+      }
       std::string sum_arg=labout + "_bt" + istr, bt_string1 = keymap.find("BETWEEN" + istr)->second;
       action->readInputLine( labout + "_bt" + istr + ": BETWEEN ARG=" + argin + " SWITCH={" + bt_string1 + "}" );
       if( weights.length()>0 ) {
@@ -225,18 +271,35 @@ void MultiColvarShortcuts::expandFunctions( const std::string& labout, const std
   // Parse HISTOGRAM
   if( keymap.count("HISTOGRAM") ) {
     std::vector<std::string> words=Tools::getWords( keymap.find("HISTOGRAM")->second );
-    unsigned nbins; bool found=Tools::parse(words,"NBINS",nbins,0); // Need replica index
-    if( !found ) plumed_merror("did not find NBINS in specification for HISTOGRAM");
-    double lower; found=Tools::parse(words,"LOWER",lower,0);
-    if( !found ) plumed_merror("did not find LOWER in specification for HISTOGRAM");
-    double upper; found=Tools::parse(words,"UPPER",upper,0);
-    if( !found ) plumed_merror("did not find UPPER in specification for HISTOGRAM");
+    unsigned nbins;
+    bool found=Tools::parse(words,"NBINS",nbins,0); // Need replica index
+    if( !found ) {
+      plumed_merror("did not find NBINS in specification for HISTOGRAM");
+    }
+    double lower;
+    found=Tools::parse(words,"LOWER",lower,0);
+    if( !found ) {
+      plumed_merror("did not find LOWER in specification for HISTOGRAM");
+    }
+    double upper;
+    found=Tools::parse(words,"UPPER",upper,0);
+    if( !found ) {
+      plumed_merror("did not find UPPER in specification for HISTOGRAM");
+    }
     double delr = ( upper - lower ) / static_cast<double>( nbins );
-    double smear=0.5; found=Tools::parse(words,"SMEAR",smear,0);
-    if( !found ) smear = 0.5;
+    double smear=0.5;
+    found=Tools::parse(words,"SMEAR",smear,0);
+    if( !found ) {
+      smear = 0.5;
+    }
     for(unsigned i=0; i<nbins; ++i) {
-      std::string smstr, istr; Tools::convert( i+1, istr ); Tools::convert( smear, smstr ); std::string sum_arg=labout + "_bt" + istr;
-      std::string low_str, high_str; Tools::convert( lower + i*delr, low_str ); Tools::convert( lower + (i+1)*delr, high_str );
+      std::string smstr, istr;
+      Tools::convert( i+1, istr );
+      Tools::convert( smear, smstr );
+      std::string sum_arg=labout + "_bt" + istr;
+      std::string low_str, high_str;
+      Tools::convert( lower + i*delr, low_str );
+      Tools::convert( lower + (i+1)*delr, high_str );
       action->readInputLine( labout + "_bt" + istr + ": BETWEEN ARG=" + argin + " SWITCH={" + words[0] + " LOWER=" + low_str + " UPPER=" + high_str + " SMEAR=" + smstr + "}");
       if( weights.length()>0 ) {
         sum_arg = labout + "_wbt" + istr;
diff --git a/src/multicolvar/Planes.cpp b/src/multicolvar/Planes.cpp
index e6dd5948cb..d60268b54f 100644
--- a/src/multicolvar/Planes.cpp
+++ b/src/multicolvar/Planes.cpp
@@ -59,31 +59,53 @@ void PlaneShortcut::registerKeywords( Keywords& keys ) {
   keys.addOutputComponent("_vmean","VMEAN","the norm of the mean vector");
   keys.addFlag("VSUM",false,"calculate the norm of the sum of all the vectors");
   keys.addOutputComponent("_vsum","VSUM","the norm of the mean vector");
-  keys.needsAction("CENTER"); keys.needsAction("GROUP"); keys.needsAction("PLANE");
-  keys.needsAction("MEAN"); keys.needsAction("SUM"); keys.needsAction("COMBINE"); keys.needsAction("CUSTOM");
+  keys.needsAction("CENTER");
+  keys.needsAction("GROUP");
+  keys.needsAction("PLANE");
+  keys.needsAction("MEAN");
+  keys.needsAction("SUM");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CUSTOM");
 }
 
 PlaneShortcut::PlaneShortcut(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  bool vmean, vsum; parseFlag("VMEAN",vmean); parseFlag("VSUM",vsum); std::string dline;
+  ActionShortcut(ao) {
+  bool vmean, vsum;
+  parseFlag("VMEAN",vmean);
+  parseFlag("VSUM",vsum);
+  std::string dline;
   std::string grpstr = getShortcutLabel() + "_grp: GROUP ATOMS=";
   for(unsigned i=1;; ++i) {
-    std::string atstring; parseNumbered("ATOMS",i,atstring);
-    if( atstring.length()==0 ) break;
-    std::string locstr; parseNumbered("LOCATION",i,locstr);
+    std::string atstring;
+    parseNumbered("ATOMS",i,atstring);
+    if( atstring.length()==0 ) {
+      break;
+    }
+    std::string locstr;
+    parseNumbered("LOCATION",i,locstr);
     if( locstr.length()==0 ) {
-      std::string num; Tools::convert( i, num );
+      std::string num;
+      Tools::convert( i, num );
       readInputLine( getShortcutLabel() + "_vatom" + num + ": CENTER ATOMS=" + atstring );
-      if( i==1 ) grpstr += getShortcutLabel() + "_vatom" + num; else grpstr += "," + getShortcutLabel() + "_vatom" + num;
+      if( i==1 ) {
+        grpstr += getShortcutLabel() + "_vatom" + num;
+      } else {
+        grpstr += "," + getShortcutLabel() + "_vatom" + num;
+      }
     } else {
-      if( i==1 ) grpstr += locstr; else grpstr += "," + locstr;
+      if( i==1 ) {
+        grpstr += locstr;
+      } else {
+        grpstr += "," + locstr;
+      }
     }
-    std::string num; Tools::convert( i, num );
+    std::string num;
+    Tools::convert( i, num );
     dline += " ATOMS" + num + "=" + atstring;
   }
-  readInputLine( grpstr ); readInputLine( getShortcutLabel() + ": PLANE " + dline + " " + convertInputLineToString() );
+  readInputLine( grpstr );
+  readInputLine( getShortcutLabel() + ": PLANE " + dline + " " + convertInputLineToString() );
   if( vmean ) {
     readInputLine( getShortcutLabel() + "_xs: MEAN ARG=" + getShortcutLabel() + ".x PERIODIC=NO");
     readInputLine( getShortcutLabel() + "_ys: MEAN ARG=" + getShortcutLabel() + ".y PERIODIC=NO");
diff --git a/src/multicolvar/Torsions.cpp b/src/multicolvar/Torsions.cpp
index 406c89b6ff..2b461ced4a 100644
--- a/src/multicolvar/Torsions.cpp
+++ b/src/multicolvar/Torsions.cpp
@@ -78,14 +78,14 @@ class Torsions : public ActionShortcut {
 PLUMED_REGISTER_ACTION(Torsions,"TORSIONS")
 
 void Torsions::registerKeywords(Keywords& keys) {
-  ActionShortcut::registerKeywords( keys ); MultiColvarShortcuts::shortcutKeywords( keys );
+  ActionShortcut::registerKeywords( keys );
+  MultiColvarShortcuts::shortcutKeywords( keys );
   keys.needsAction("TORSION");
 }
 
 Torsions::Torsions(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   log.printf("Action TORSION\n");
   log.printf("  with label %s \n", getShortcutLabel().c_str() );
   readInputLine( getShortcutLabel() + ": TORSION " + convertInputLineToString() );
diff --git a/src/multicolvar/UWalls.cpp b/src/multicolvar/UWalls.cpp
index fd5487d10b..0a88a46378 100644
--- a/src/multicolvar/UWalls.cpp
+++ b/src/multicolvar/UWalls.cpp
@@ -64,9 +64,9 @@ void UWalls::registerKeywords(Keywords& keys) {
 
 UWalls::UWalls(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string data; parse("DATA",data);
+  ActionShortcut(ao) {
+  std::string data;
+  parse("DATA",data);
   readInputLine( getShortcutLabel() + ": UPPER_WALLS ARG=" + data + " " + convertInputLineToString() );
 }
 
diff --git a/src/multicolvar/XAngle.cpp b/src/multicolvar/XAngle.cpp
index 63775f2b13..90bfacce8c 100644
--- a/src/multicolvar/XAngle.cpp
+++ b/src/multicolvar/XAngle.cpp
@@ -67,20 +67,26 @@ PLUMED_REGISTER_ACTION(XAngle,"ZANGLES")
 void XAngle::registerKeywords(Keywords& keys) {
   ActionShortcut::registerKeywords( keys );
   keys.add("numbered","ATOMS","the pairs of atoms that you would like to calculate the angles for");
-  keys.reset_style("ATOMS","atoms"); MultiColvarShortcuts::shortcutKeywords( keys );
-  keys.needsAction("DISTANCE"); keys.needsAction("COMBINE"); keys.needsAction("CUSTOM");
+  keys.reset_style("ATOMS","atoms");
+  MultiColvarShortcuts::shortcutKeywords( keys );
+  keys.needsAction("DISTANCE");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CUSTOM");
 }
 
 XAngle::XAngle(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Create distances
   std::string dline = getShortcutLabel() + "_dists: DISTANCE COMPONENTS";
   for(unsigned i=1;; ++i) {
-    std::string atstring; parseNumbered("ATOMS",i,atstring);
-    if( atstring.length()==0 ) break;
-    std::string num; Tools::convert( i, num );
+    std::string atstring;
+    parseNumbered("ATOMS",i,atstring);
+    if( atstring.length()==0 ) {
+      break;
+    }
+    std::string num;
+    Tools::convert( i, num );
     dline += " ATOMS" + num + "=" + atstring;
   }
   readInputLine( dline );
@@ -91,9 +97,15 @@ XAngle::XAngle(const ActionOptions& ao):
   readInputLine( getShortcutLabel() + "_norm_y: CUSTOM ARG=" + getShortcutLabel() + "_dists.y," + getShortcutLabel() + "_norm FUNC=x/y PERIODIC=NO");
   readInputLine( getShortcutLabel() + "_norm_z: CUSTOM ARG=" + getShortcutLabel() + "_dists.z," + getShortcutLabel() + "_norm FUNC=x/y PERIODIC=NO");
   // Now compute the angles with matheval
-  if( getName()=="XANGLES" ) readInputLine( getShortcutLabel() + "_ang: CUSTOM FUNC=acos(x) PERIODIC=NO ARG=" + getShortcutLabel() + "_norm_x");
-  if( getName()=="YANGLES" ) readInputLine( getShortcutLabel() + "_ang: CUSTOM FUNC=acos(x) PERIODIC=NO ARG=" + getShortcutLabel() + "_norm_y");
-  if( getName()=="ZANGLES" ) readInputLine( getShortcutLabel() + "_ang: CUSTOM FUNC=acos(x) PERIODIC=NO ARG=" + getShortcutLabel() + "_norm_z");
+  if( getName()=="XANGLES" ) {
+    readInputLine( getShortcutLabel() + "_ang: CUSTOM FUNC=acos(x) PERIODIC=NO ARG=" + getShortcutLabel() + "_norm_x");
+  }
+  if( getName()=="YANGLES" ) {
+    readInputLine( getShortcutLabel() + "_ang: CUSTOM FUNC=acos(x) PERIODIC=NO ARG=" + getShortcutLabel() + "_norm_y");
+  }
+  if( getName()=="ZANGLES" ) {
+    readInputLine( getShortcutLabel() + "_ang: CUSTOM FUNC=acos(x) PERIODIC=NO ARG=" + getShortcutLabel() + "_norm_z");
+  }
   // Add shortcuts to label
   MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel() + "_ang", "", this );
 }
diff --git a/src/multicolvar/XYTorsions.cpp b/src/multicolvar/XYTorsions.cpp
index 61de8b50d5..0390835f31 100644
--- a/src/multicolvar/XYTorsions.cpp
+++ b/src/multicolvar/XYTorsions.cpp
@@ -96,14 +96,15 @@ PLUMED_REGISTER_ACTION(XYTorsions,"ZYTORSIONS")
 void XYTorsions::registerKeywords(Keywords& keys) {
   ActionShortcut::registerKeywords( keys );
   keys.add("numbered","ATOMS","the pairs of atoms that you would like to calculate the angles for");
-  keys.reset_style("ATOMS","atoms"); MultiColvarShortcuts::shortcutKeywords( keys );
-  keys.needsAction("FIXEDATOM"); keys.needsAction("TORSION");
+  keys.reset_style("ATOMS","atoms");
+  MultiColvarShortcuts::shortcutKeywords( keys );
+  keys.needsAction("FIXEDATOM");
+  keys.needsAction("TORSION");
 }
 
 XYTorsions::XYTorsions(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   std::string vdir = getShortcutLabel() + "_vec2," + getShortcutLabel() + "_origin";
   std::string adir = getShortcutLabel() + "_axis," + getShortcutLabel() + "_origin";
   // Create action for position of origin
@@ -136,9 +137,13 @@ XYTorsions::XYTorsions(const ActionOptions& ao):
   // Now create action to compute all torsions
   std::string torsions_str = getShortcutLabel() + ": TORSION";
   for(unsigned i=1;; ++i) {
-    std::string atstring; parseNumbered("ATOMS",i,atstring);
-    if( atstring.length()==0 ) break;
-    std::string num; Tools::convert( i, num );
+    std::string atstring;
+    parseNumbered("ATOMS",i,atstring);
+    if( atstring.length()==0 ) {
+      break;
+    }
+    std::string num;
+    Tools::convert( i, num );
     torsions_str += " VECTORA" + num + "=" + atstring + " VECTORB" + num + "=" + vdir + " AXIS" + num + "=" + adir;
   }
   readInputLine( torsions_str );
diff --git a/src/opes/ECVcustom.cpp b/src/opes/ECVcustom.cpp
index 8e87f18b5c..21d14094d0 100644
--- a/src/opes/ECVcustom.cpp
+++ b/src/opes/ECVcustom.cpp
@@ -59,8 +59,7 @@ opes: OPES_EXPANDED ARG=ecv.* PACE=500
 //+ENDPLUMEDOC
 
 class ECVcustom :
-  public ExpansionCVs
-{
+  public ExpansionCVs {
 private:
   unsigned P0_contribution_;
   double barrier_;
@@ -84,8 +83,7 @@ class ECVcustom :
 
 PLUMED_REGISTER_ACTION(ECVcustom,"ECV_CUSTOM")
 
-void ECVcustom::registerKeywords(Keywords& keys)
-{
+void ECVcustom::registerKeywords(Keywords& keys) {
   ExpansionCVs::registerKeywords(keys);
   keys.remove("ARG");
   keys.add("compulsory","ARG","the labels of the single ECVs. Delta U_i, in energy units");
@@ -97,21 +95,22 @@ void ECVcustom::registerKeywords(Keywords& keys)
 ECVcustom::ECVcustom(const ActionOptions&ao)
   : Action(ao)
   , ExpansionCVs(ao)
-  , beta0_(1./kbt_)
-{
+  , beta0_(1./kbt_) {
 //set beta0_
   bool dimensionless;
   parseFlag("DIMENSIONLESS",dimensionless);
-  if(dimensionless)
+  if(dimensionless) {
     beta0_=1;
+  }
 
 //set P0_contribution_
   bool add_P0=false;
   parseFlag("ADD_P0",add_P0);
-  if(add_P0)
+  if(add_P0) {
     P0_contribution_=1;
-  else
+  } else {
     P0_contribution_=0;
+  }
 
 //set barrier_
   barrier_=std::numeric_limits<double>::infinity();
@@ -123,106 +122,105 @@ ECVcustom::ECVcustom(const ActionOptions&ao)
   totNumECVs_=getNumberOfArguments()+P0_contribution_;
   ECVs_.resize(getNumberOfArguments(),std::vector<double>(totNumECVs_));
   derECVs_.resize(getNumberOfArguments(),std::vector<double>(totNumECVs_));
-  for(unsigned j=0; j<getNumberOfArguments(); j++)
-    derECVs_[j][j+P0_contribution_]=beta0_; //always constant
+  for(unsigned j=0; j<getNumberOfArguments(); j++) {
+    derECVs_[j][j+P0_contribution_]=beta0_;  //always constant
+  }
 
 //print some info
-  if(dimensionless)
+  if(dimensionless) {
     log.printf(" -- DIMENSIONLESS: the ARG is not multiplied by beta\n");
-  if(barrier_!=std::numeric_limits<double>::infinity())
-  {
+  }
+  if(barrier_!=std::numeric_limits<double>::infinity()) {
     log.printf("  guess for free energy BARRIER = %g\n",barrier_);
-    if(dimensionless)
+    if(dimensionless) {
       log.printf("    also the BARRIER is considered to be DIMENSIONLESS\n");
+    }
   }
-  if(P0_contribution_==1)
+  if(P0_contribution_==1) {
     log.printf(" -- ADD_P0: the target includes also the unbiased probability itself\n");
+  }
 }
 
-void ECVcustom::calculateECVs(const double * cv)
-{
-  for(unsigned j=0; j<getNumberOfArguments(); j++)
+void ECVcustom::calculateECVs(const double * cv) {
+  for(unsigned j=0; j<getNumberOfArguments(); j++) {
     ECVs_[j][j+P0_contribution_]=beta0_*cv[j];
+  }
   //derivative is constant
 }
 
-const double * ECVcustom::getPntrToECVs(unsigned j)
-{
+const double * ECVcustom::getPntrToECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j<getNumberOfArguments(),getName()+" has fewer CVs");
   return &ECVs_[j][0];
 }
 
-const double * ECVcustom::getPntrToDerECVs(unsigned j)
-{
+const double * ECVcustom::getPntrToDerECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j<getNumberOfArguments(),getName()+" has fewer CVs");
   return &derECVs_[j][0];
 }
 
-std::vector< std::vector<unsigned> > ECVcustom::getIndex_k() const
-{
+std::vector< std::vector<unsigned> > ECVcustom::getIndex_k() const {
   plumed_massert(isReady_ && totNumECVs_>0,"cannot access getIndex_k() of ECV before initialization");
   std::vector< std::vector<unsigned> > index_k(totNumECVs_,std::vector<unsigned>(getNumberOfArguments()));
   for(unsigned k=0; k<totNumECVs_; k++)
     for(unsigned j=0; j<getNumberOfArguments(); j++)
-      if(k==j+P0_contribution_)
+      if(k==j+P0_contribution_) {
         index_k[k][j]=k;
+      }
   return index_k;
 }
 
-std::vector<std::string> ECVcustom::getLambdas() const
-{
+std::vector<std::string> ECVcustom::getLambdas() const {
   std::vector<std::string> lambdas(totNumECVs_);
-  if(P0_contribution_==1)
-  {
+  if(P0_contribution_==1) {
     std::ostringstream subs;
     subs<<"P0";
-    for(unsigned j=1; j<getNumberOfArguments(); j++)
+    for(unsigned j=1; j<getNumberOfArguments(); j++) {
       subs<<"_P0";
+    }
     lambdas[0]=subs.str();
   }
-  for(unsigned k=P0_contribution_; k<totNumECVs_; k++)
-  {
+  for(unsigned k=P0_contribution_; k<totNumECVs_; k++) {
     const unsigned kk=k-P0_contribution_;
     std::ostringstream subs;
 //the getLambdas method is const, so it complains if one tries to access a non-const pointer, hence the const_cast
-    if(kk==0)
+    if(kk==0) {
       subs<<const_cast<ECVcustom *>(this)->getPntrToArgument(kk)->getName();
-    else
+    } else {
       subs<<"NaN";
-    for(unsigned j=1; j<getNumberOfArguments(); j++)
-    {
-      if(kk==j)
+    }
+    for(unsigned j=1; j<getNumberOfArguments(); j++) {
+      if(kk==j) {
         subs<<"_"<<const_cast<ECVcustom *>(this)->getPntrToArgument(kk)->getName();
-      else
+      } else {
         subs<<"_NaN";
+      }
     }
     lambdas[k]=subs.str();
   }
   return lambdas;
 }
 
-void ECVcustom::initECVs()
-{
+void ECVcustom::initECVs() {
   plumed_massert(!isReady_,"initialization should not be called twice");
   isReady_=true;
   log.printf("  *%4u ECVs for %s\n",totNumECVs_,getName().c_str());
 }
 
-void ECVcustom::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j)
-{
+void ECVcustom::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j) {
   initECVs();
   calculateECVs(&all_obs_cvs[index_j]);
-  for(unsigned j=0; j<getNumberOfArguments(); j++)
+  for(unsigned j=0; j<getNumberOfArguments(); j++) {
     ECVs_[j][j+P0_contribution_]=std::min(barrier_*beta0_,ECVs_[j][j+P0_contribution_]);
+  }
 }
 
-void ECVcustom::initECVs_restart(const std::vector<std::string>& lambdas)
-{
+void ECVcustom::initECVs_restart(const std::vector<std::string>& lambdas) {
   std::size_t pos=0;
-  for(unsigned j=0; j<getNumberOfArguments()-1; j++)
-    pos=lambdas[0].find("_",pos+1); //checking only lambdas[0] is hopefully enough
+  for(unsigned j=0; j<getNumberOfArguments()-1; j++) {
+    pos=lambdas[0].find("_",pos+1);  //checking only lambdas[0] is hopefully enough
+  }
   plumed_massert(pos<lambdas[0].length(),"this should not happen, fewer '_' than expected in "+getName());
   pos=lambdas[0].find("_",pos+1);
   plumed_massert(pos>lambdas[0].length(),"this should not happen, more '_' than expected in "+getName());
diff --git a/src/opes/ECVlinear.cpp b/src/opes/ECVlinear.cpp
index 48650d607d..852877363d 100644
--- a/src/opes/ECVlinear.cpp
+++ b/src/opes/ECVlinear.cpp
@@ -70,8 +70,7 @@ Notice that by defauly LAMBDA=0, LAMBDA_MIN=0 and LAMBDA_MAX=1, which is the typ
 //+ENDPLUMEDOC
 
 class ECVlinear :
-  public ExpansionCVs
-{
+  public ExpansionCVs {
 private:
   bool todoAutomatic_;
   bool geom_spacing_;
@@ -94,8 +93,7 @@ class ECVlinear :
 
 PLUMED_REGISTER_ACTION(ECVlinear,"ECV_LINEAR")
 
-void ECVlinear::registerKeywords(Keywords& keys)
-{
+void ECVlinear::registerKeywords(Keywords& keys) {
   ExpansionCVs::registerKeywords(keys);
   keys.remove("ARG");
   keys.add("compulsory","ARG","the label of the Hamiltonian difference. Delta U");
@@ -112,15 +110,15 @@ ECVlinear::ECVlinear(const ActionOptions&ao)
   : Action(ao)
   , ExpansionCVs(ao)
   , todoAutomatic_(false)
-  , beta0_(1./kbt_)
-{
+  , beta0_(1./kbt_) {
   plumed_massert(getNumberOfArguments()==1,"only DeltaU should be given as ARG");
 
 //set beta0_
   bool dimensionless;
   parseFlag("DIMENSIONLESS",dimensionless);
-  if(dimensionless)
+  if(dimensionless) {
     beta0_=1;
+  }
 
 //parse lambda info
   parse("LAMBDA",lambda0_);
@@ -138,28 +136,26 @@ ECVlinear::ECVlinear(const ActionOptions&ao)
   checkRead();
 
 //set the diff vector using lambdas
-  if(lambdas.size()>0)
-  {
+  if(lambdas.size()>0) {
     plumed_massert(lambda_steps==0,"cannot set both LAMBDA_STEPS and LAMBDA_SET_ALL");
     plumed_massert(lambda_min==myNone && lambda_max==myNone,"cannot set both LAMBDA_SET_ALL and LAMBDA_MIN/MAX");
     plumed_massert(lambdas.size()>=2,"set at least 2 lambdas with LAMBDA_SET_ALL");
-    for(unsigned k=0; k<lambdas.size()-1; k++)
+    for(unsigned k=0; k<lambdas.size()-1; k++) {
       plumed_massert(lambdas[k]<=lambdas[k+1],"LAMBDA_SET_ALL must be properly ordered");
+    }
     lambda_min=lambdas[0];
     lambda_max=lambdas[lambdas.size()-1];
     derECVs_.resize(lambdas.size());
-    for(unsigned k=0; k<derECVs_.size(); k++)
+    for(unsigned k=0; k<derECVs_.size(); k++) {
       derECVs_[k]=beta0_*(lambdas[k]-lambda0_);
-  }
-  else
-  { //get LAMBDA_MIN and LAMBDA_MAX
-    if(lambda_min==myNone)
-    {
+    }
+  } else {
+    //get LAMBDA_MIN and LAMBDA_MAX
+    if(lambda_min==myNone) {
       lambda_min=0;
       log.printf("  no LAMBDA_MIN provided, using LAMBDA_MIN = %g\n",lambda_min);
     }
-    if(lambda_max==myNone)
-    {
+    if(lambda_max==myNone) {
       lambda_max=1;
       log.printf("  no LAMBDA_MAX provided, using LAMBDA_MAX = %g\n",lambda_max);
     }
@@ -167,52 +163,53 @@ ECVlinear::ECVlinear(const ActionOptions&ao)
     derECVs_.resize(2);
     derECVs_[0]=beta0_*(lambda_min-lambda0_);
     derECVs_[1]=beta0_*(lambda_max-lambda0_);
-    if(lambda_min==lambda_max && lambda_steps==0)
+    if(lambda_min==lambda_max && lambda_steps==0) {
       lambda_steps=1;
-    if(lambda_steps>0)
+    }
+    if(lambda_steps>0) {
       derECVs_=getSteps(derECVs_[0],derECVs_[1],lambda_steps,"LAMBDA",geom_spacing_,beta0_*lambda0_);
-    else
+    } else {
       todoAutomatic_=true;
+    }
   }
-  if(lambda0_<lambda_min || lambda0_>lambda_max)
+  if(lambda0_<lambda_min || lambda0_>lambda_max) {
     log.printf(" +++ WARNING +++ running at LAMBDA=%g which is outside the chosen lambda range\n",lambda0_);
+  }
 
 //print some info
   log.printf("  running at LAMBDA=%g\n",lambda0_);
   log.printf("  targeting a lambda range from LAMBDA_MIN=%g to LAMBDA_MAX=%g\n",lambda_min,lambda_max);
-  if(dimensionless)
+  if(dimensionless) {
     log.printf(" -- DIMENSIONLESS: the ARG is not multiplied by beta\n");
-  if(geom_spacing_)
+  }
+  if(geom_spacing_) {
     log.printf(" -- GEOM_SPACING: lambdas will be geometrically spaced\n");
+  }
 }
 
-void ECVlinear::calculateECVs(const double * DeltaU)
-{
-  for(unsigned k=0; k<derECVs_.size(); k++)
+void ECVlinear::calculateECVs(const double * DeltaU) {
+  for(unsigned k=0; k<derECVs_.size(); k++) {
     ECVs_[k]=derECVs_[k]*DeltaU[0];
+  }
 // derivatives never change: derECVs_k=beta0*(lambda_k-lambda0)
 }
 
-const double * ECVlinear::getPntrToECVs(unsigned j)
-{
+const double * ECVlinear::getPntrToECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j==0,getName()+" has only one CV, the DeltaU");
   return &ECVs_[0];
 }
 
-const double * ECVlinear::getPntrToDerECVs(unsigned j)
-{
+const double * ECVlinear::getPntrToDerECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j==0,getName()+" has only one CV, the DeltaU");
   return &derECVs_[0];
 }
 
-std::vector<std::string> ECVlinear::getLambdas() const
-{
+std::vector<std::string> ECVlinear::getLambdas() const {
   plumed_massert(!todoAutomatic_,"cannot access lambdas before initializing them");
   std::vector<std::string> lambdas(derECVs_.size());
-  for(unsigned k=0; k<derECVs_.size(); k++)
-  {
+  for(unsigned k=0; k<derECVs_.size(); k++) {
     std::ostringstream subs;
     subs<<derECVs_[k]/beta0_+lambda0_; //lambda_k
     lambdas[k]=subs.str();
@@ -220,8 +217,7 @@ std::vector<std::string> ECVlinear::getLambdas() const
   return lambdas;
 }
 
-void ECVlinear::initECVs()
-{
+void ECVlinear::initECVs() {
   plumed_massert(!isReady_,"initialization should not be called twice");
   plumed_massert(!todoAutomatic_,"this should not happen");
   totNumECVs_=derECVs_.size();
@@ -230,17 +226,17 @@ void ECVlinear::initECVs()
   log.printf("  *%4lu lambdas for %s\n",derECVs_.size(),getName().c_str());
 }
 
-void ECVlinear::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j)
-{
-  if(todoAutomatic_) //estimate the steps in lambda from observations
-  {
+void ECVlinear::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j) {
+  if(todoAutomatic_) { //estimate the steps in lambda from observations
     plumed_massert(all_obs_cvs.size()%ncv==0 && index_j<ncv,"initECVs_observ parameters are inconsistent");
     std::vector<double> obs_cv(all_obs_cvs.size()/ncv); //copy only useful observation (would be better not to copy...)
-    for(unsigned t=0; t<obs_cv.size(); t++)
+    for(unsigned t=0; t<obs_cv.size(); t++) {
       obs_cv[t]=all_obs_cvs[t*ncv+index_j];
+    }
     const unsigned lambda_steps=estimateNumSteps(derECVs_[0],derECVs_[1],obs_cv,"LAMBDA");
-    if(beta0_!=1)
+    if(beta0_!=1) {
       log.printf("    (spacing is in beta0 units)\n");
+    }
     derECVs_=getSteps(derECVs_[0],derECVs_[1],lambda_steps,"LAMBDA",geom_spacing_,beta0_*lambda0_);
     todoAutomatic_=false;
   }
@@ -248,12 +244,10 @@ void ECVlinear::initECVs_observ(const std::vector<double>& all_obs_cvs,const uns
   calculateECVs(&all_obs_cvs[index_j]);
 }
 
-void ECVlinear::initECVs_restart(const std::vector<std::string>& lambdas)
-{
+void ECVlinear::initECVs_restart(const std::vector<std::string>& lambdas) {
   std::size_t pos=lambdas[0].find("_");
   plumed_massert(pos==std::string::npos,"this should not happen, only one CV is used in "+getName());
-  if(todoAutomatic_)
-  {
+  if(todoAutomatic_) {
     derECVs_=getSteps(derECVs_[0],derECVs_[1],lambdas.size(),"LAMBDA",geom_spacing_,beta0_*lambda0_);
     todoAutomatic_=false;
   }
diff --git a/src/opes/ECVmultiThermal.cpp b/src/opes/ECVmultiThermal.cpp
index 9ab1ce1a49..7066330ca3 100644
--- a/src/opes/ECVmultiThermal.cpp
+++ b/src/opes/ECVmultiThermal.cpp
@@ -78,8 +78,7 @@ Notice that \f$p=0.06022140857\f$ corresponds to 1 bar when using the default PL
 //+ENDPLUMEDOC
 
 class ECVmultiThermal :
-  public ExpansionCVs
-{
+  public ExpansionCVs {
 private:
   bool todoAutomatic_;
   bool geom_spacing_;
@@ -100,8 +99,7 @@ class ECVmultiThermal :
 
 PLUMED_REGISTER_ACTION(ECVmultiThermal,"ECV_MULTITHERMAL")
 
-void ECVmultiThermal::registerKeywords(Keywords& keys)
-{
+void ECVmultiThermal::registerKeywords(Keywords& keys) {
   ExpansionCVs::registerKeywords(keys);
   keys.remove("ARG");
   keys.add("compulsory","ARG","the label of the internal energy of the system. If volume is fixed it is calculated by the ENERGY colvar");
@@ -115,8 +113,7 @@ void ECVmultiThermal::registerKeywords(Keywords& keys)
 ECVmultiThermal::ECVmultiThermal(const ActionOptions&ao)
   : Action(ao)
   , ExpansionCVs(ao)
-  , todoAutomatic_(false)
-{
+  , todoAutomatic_(false) {
   plumed_massert(getNumberOfArguments()==1,"only the internal energy should be given as ARG");
 
 //set temp0
@@ -137,31 +134,27 @@ ECVmultiThermal::ECVmultiThermal(const ActionOptions&ao)
   checkRead();
 
 //set the intermediate temperatures
-  if(temps.size()>0)
-  {
+  if(temps.size()>0) {
     plumed_massert(temp_steps==0,"cannot set both TEMP_STEPS and TEMP_SET_ALL");
     plumed_massert(temp_min==-1 && temp_max==-1,"cannot set both TEMP_SET_ALL and TEMP_MIN/MAX");
     plumed_massert(temps.size()>=2,"set at least 2 temperatures");
     temp_min=temps[0];
     temp_max=temps[temps.size()-1];
     derECVs_.resize(temps.size());
-    for(unsigned k=0; k<derECVs_.size(); k++)
-    {
+    for(unsigned k=0; k<derECVs_.size(); k++) {
       derECVs_[k]=(temp0/temps[k]-1.)/kbt_;
-      if(k<derECVs_.size()-1)
+      if(k<derECVs_.size()-1) {
         plumed_massert(temps[k]<=temps[k+1],"TEMP_SET_ALL must be properly ordered");
+      }
     }
-  }
-  else
-  { //get TEMP_MIN and TEMP_MAX
+  } else {
+    //get TEMP_MIN and TEMP_MAX
     plumed_massert(temp_min!=-1 || temp_max!=-1,"TEMP_MIN, TEMP_MAX or both, should be set");
-    if(temp_min==-1)
-    {
+    if(temp_min==-1) {
       temp_min=temp0;
       log.printf("  no TEMP_MIN provided, using TEMP_MIN=TEMP\n");
     }
-    if(temp_max==-1)
-    {
+    if(temp_max==-1) {
       temp_max=temp0;
       log.printf("  no TEMP_MAX provided, using TEMP_MAX=TEMP\n");
     }
@@ -169,51 +162,51 @@ ECVmultiThermal::ECVmultiThermal(const ActionOptions&ao)
     derECVs_.resize(2);
     derECVs_[0]=(temp0/temp_min-1.)/kbt_;
     derECVs_[1]=(temp0/temp_max-1.)/kbt_;
-    if(temp_min==temp_max && temp_steps==0)
+    if(temp_min==temp_max && temp_steps==0) {
       temp_steps=1;
-    if(temp_steps>0)
+    }
+    if(temp_steps>0) {
       derECVs_=getSteps(derECVs_[0],derECVs_[1],temp_steps,"TEMP",geom_spacing_,1./kbt_);
-    else
+    } else {
       todoAutomatic_=true;
+    }
   }
   const double tol=1e-3; //if temp is taken from MD engine it might be numerically slightly different
-  if(temp0<(1-tol)*temp_min || temp0>(1+tol)*temp_max)
+  if(temp0<(1-tol)*temp_min || temp0>(1+tol)*temp_max) {
     log.printf(" +++ WARNING +++ running at TEMP=%g which is outside the chosen temperature range\n",temp0);
+  }
 
 //print some info
   log.printf("  targeting a temperature range from TEMP_MIN=%g to TEMP_MAX=%g\n",temp_min,temp_max);
-  if(!geom_spacing_)
+  if(!geom_spacing_) {
     log.printf(" -- NO_GEOM_SPACING: inverse temperatures will be linearly spaced\n");
+  }
 }
 
-void ECVmultiThermal::calculateECVs(const double * ene)
-{
-  for(unsigned k=0; k<derECVs_.size(); k++)
+void ECVmultiThermal::calculateECVs(const double * ene) {
+  for(unsigned k=0; k<derECVs_.size(); k++) {
     ECVs_[k]=derECVs_[k]*ene[0];
+  }
 // derivatives never change: derECVs_k=(beta_k-beta0)
 }
 
-const double * ECVmultiThermal::getPntrToECVs(unsigned j)
-{
+const double * ECVmultiThermal::getPntrToECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j==0,getName()+" has only one CV, the ENERGY");
   return &ECVs_[0];
 }
 
-const double * ECVmultiThermal::getPntrToDerECVs(unsigned j)
-{
+const double * ECVmultiThermal::getPntrToDerECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j==0,getName()+" has only one CV, the ENERGY");
   return &derECVs_[0];
 }
 
-std::vector<std::string> ECVmultiThermal::getLambdas() const
-{
+std::vector<std::string> ECVmultiThermal::getLambdas() const {
   plumed_massert(!todoAutomatic_,"cannot access lambdas before initializing them");
   const double temp0=kbt_/getKBoltzmann();
   std::vector<std::string> lambdas(derECVs_.size());
-  for(unsigned k=0; k<derECVs_.size(); k++)
-  {
+  for(unsigned k=0; k<derECVs_.size(); k++) {
     std::ostringstream subs;
     subs<<temp0/(derECVs_[k]*kbt_+1); //temp_k
     lambdas[k]=subs.str();
@@ -221,8 +214,7 @@ std::vector<std::string> ECVmultiThermal::getLambdas() const
   return lambdas;
 }
 
-void ECVmultiThermal::initECVs()
-{
+void ECVmultiThermal::initECVs() {
   plumed_massert(!isReady_,"initialization should not be called twice");
   plumed_massert(!todoAutomatic_,"this should not happen");
   totNumECVs_=derECVs_.size();
@@ -231,14 +223,13 @@ void ECVmultiThermal::initECVs()
   log.printf("  *%4lu temperatures for %s\n",derECVs_.size(),getName().c_str());
 }
 
-void ECVmultiThermal::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j)
-{
-  if(todoAutomatic_) //estimate the steps in beta from observations
-  {
+void ECVmultiThermal::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j) {
+  if(todoAutomatic_) { //estimate the steps in beta from observations
     plumed_massert(all_obs_cvs.size()%ncv==0 && index_j<ncv,"initECVs_observ parameters are inconsistent");
     std::vector<double> obs_ene(all_obs_cvs.size()/ncv); //copy only useful observation (would be better not to copy...)
-    for(unsigned t=0; t<obs_ene.size(); t++)
+    for(unsigned t=0; t<obs_ene.size(); t++) {
       obs_ene[t]=all_obs_cvs[t*ncv+index_j];
+    }
     const unsigned temp_steps=estimateNumSteps(derECVs_[0],derECVs_[1],obs_ene,"TEMP");
     log.printf("    (spacing is in beta, not in temperature)\n");
     derECVs_=getSteps(derECVs_[0],derECVs_[1],temp_steps,"TEMP",geom_spacing_,1./kbt_);
@@ -248,12 +239,10 @@ void ECVmultiThermal::initECVs_observ(const std::vector<double>& all_obs_cvs,con
   calculateECVs(&all_obs_cvs[index_j]);
 }
 
-void ECVmultiThermal::initECVs_restart(const std::vector<std::string>& lambdas)
-{
+void ECVmultiThermal::initECVs_restart(const std::vector<std::string>& lambdas) {
   std::size_t pos=lambdas[0].find("_");
   plumed_massert(pos==std::string::npos,"this should not happen, only one CV is used in "+getName());
-  if(todoAutomatic_)
-  {
+  if(todoAutomatic_) {
     derECVs_=getSteps(derECVs_[0],derECVs_[1],lambdas.size(),"TEMP",geom_spacing_,1./kbt_);
     todoAutomatic_=false;
   }
diff --git a/src/opes/ECVmultiThermalBaric.cpp b/src/opes/ECVmultiThermalBaric.cpp
index 059fec82cc..390e81d0d8 100644
--- a/src/opes/ECVmultiThermalBaric.cpp
+++ b/src/opes/ECVmultiThermalBaric.cpp
@@ -72,8 +72,7 @@ If you modify them via the \ref UNITS command, then the pressure has to be resca
 //+ENDPLUMEDOC
 
 class ECVmultiThermalBaric :
-  public ExpansionCVs
-{
+  public ExpansionCVs {
 private:
   bool todoAutomatic_beta_;
   bool todoAutomatic_pres_;
@@ -107,8 +106,7 @@ class ECVmultiThermalBaric :
 
 PLUMED_REGISTER_ACTION(ECVmultiThermalBaric,"ECV_MULTITHERMAL_MULTIBARIC")
 
-void ECVmultiThermalBaric::registerKeywords(Keywords& keys)
-{
+void ECVmultiThermalBaric::registerKeywords(Keywords& keys) {
   ExpansionCVs::registerKeywords(keys);
   keys.remove("ARG");
   keys.add("compulsory","ARG","the labels of the potential energy and of the volume of the system. You can calculate them with ENERGY and VOLUME respectively");
@@ -136,8 +134,7 @@ ECVmultiThermalBaric::ECVmultiThermalBaric(const ActionOptions&ao)
   , todoAutomatic_pres_(false)
   , coeff_(0)
   , pres_low_(0)
-  , kB_temp_low_(0)
-{
+  , kB_temp_low_(0) {
   plumed_massert(getNumberOfArguments()==2,"ENERGY and VOLUME should be given as ARG");
 
 //set temp0
@@ -172,8 +169,7 @@ ECVmultiThermalBaric::ECVmultiThermalBaric(const ActionOptions&ao)
 
   checkRead();
 
-  if(custom_lambdas_.size()>0)
-  {
+  if(custom_lambdas_.size()>0) {
     //make sure no incompatible options are used
     plumed_massert(temps.size()==0,"cannot set both SET_ALL_TEMP_PRESSURE and TEMP_SET_ALL");
     plumed_massert(pres_.size()==0,"cannot set both SET_ALL_TEMP_PRESSURE and PRESSURE_SET_ALL");
@@ -186,10 +182,8 @@ ECVmultiThermalBaric::ECVmultiThermalBaric(const ActionOptions&ao)
     derECVs_beta_.resize(custom_lambdas_.size());
     derECVs_pres_.resize(custom_lambdas_.size());
     const std::string error_msg="SET_ALL_TEMP_PRESSURE: two underscore-separated values are expected for each comma-separated point, cannot understand: ";
-    for(unsigned i=0; i<custom_lambdas_.size(); i++)
-    {
-      try
-      {
+    for(unsigned i=0; i<custom_lambdas_.size(); i++) {
+      try {
         std::size_t pos1;
         const double temp_i=std::stod(custom_lambdas_[i],&pos1);
         plumed_massert(pos1+1<custom_lambdas_[i].size(),error_msg+custom_lambdas_[i]);
@@ -200,40 +194,32 @@ ECVmultiThermalBaric::ECVmultiThermalBaric(const ActionOptions&ao)
 
         derECVs_beta_[i]=(temp0/temp_i-1.)/kbt_;
         derECVs_pres_[i]=(temp0/temp_i*pres_i-pres0_)/kbt_;
-      }
-      catch (std::exception &ex)
-      {
+      } catch (std::exception &ex) {
         plumed_merror(error_msg+custom_lambdas_[i]);
       }
     }
-  }
-  else
-  {
+  } else {
     //set the intermediate temperatures
-    if(temps.size()>0)
-    {
+    if(temps.size()>0) {
       plumed_massert(temp_steps==0,"cannot set both TEMP_STEPS and TEMP_SET_ALL");
       plumed_massert(temp_min==-1 && temp_max==-1,"cannot set both TEMP_SET_ALL and TEMP_MIN/MAX");
       plumed_massert(temps.size()>=2,"set at least 2 temperatures");
       temp_min=temps[0];
       temp_max=temps[temps.size()-1];
       derECVs_beta_.resize(temps.size());
-      for(unsigned k=0; k<derECVs_beta_.size(); k++)
-      {
+      for(unsigned k=0; k<derECVs_beta_.size(); k++) {
         derECVs_beta_[k]=(temp0/temps[k]-1.)/kbt_;
-        if(k<derECVs_beta_.size()-1)
+        if(k<derECVs_beta_.size()-1) {
           plumed_massert(temps[k]<=temps[k+1],"TEMP_SET_ALL must be properly ordered");
+        }
       }
-    }
-    else
-    { //get TEMP_MIN and TEMP_MAX
-      if(temp_min==-1)
-      {
+    } else {
+      //get TEMP_MIN and TEMP_MAX
+      if(temp_min==-1) {
         temp_min=temp0;
         log.printf("  no TEMP_MIN provided, using TEMP_MIN=TEMP\n");
       }
-      if(temp_max==-1)
-      {
+      if(temp_max==-1) {
         temp_max=temp0;
         log.printf("  no TEMP_MAX provided, using TEMP_MAX=TEMP\n");
       }
@@ -241,60 +227,60 @@ ECVmultiThermalBaric::ECVmultiThermalBaric(const ActionOptions&ao)
       derECVs_beta_.resize(2);
       derECVs_beta_[0]=(temp0/temp_min-1.)/kbt_;
       derECVs_beta_[1]=(temp0/temp_max-1.)/kbt_;
-      if(temp_min==temp_max && temp_steps==0)
+      if(temp_min==temp_max && temp_steps==0) {
         temp_steps=1;
-      if(temp_steps>0)
+      }
+      if(temp_steps>0) {
         derECVs_beta_=getSteps(derECVs_beta_[0],derECVs_beta_[1],temp_steps,"TEMP",geom_spacing_,1./kbt_);
-      else
+      } else {
         todoAutomatic_beta_=true;
+      }
     }
     const double tol=1e-3; //if temp is taken from MD engine it might be numerically slightly different
-    if(temp0<(1-tol)*temp_min || temp0>(1+tol)*temp_max)
+    if(temp0<(1-tol)*temp_min || temp0>(1+tol)*temp_max) {
       log.printf(" +++ WARNING +++ running at TEMP=%g which is outside the chosen temperature range\n",temp0);
+    }
 
     //set the intermediate pressures
-    if(pres_.size()>0)
-    {
+    if(pres_.size()>0) {
       plumed_massert(pres_steps==0,"cannot set both PRESSURE_STEPS and PRESSURE_SET_ALL");
       plumed_massert(pres_min==myNone && pres_max==myNone,"cannot set both PRESSURE_SET_ALL and PRESSURE_MIN/MAX");
       plumed_massert(pres_.size()>=2,"set at least 2 pressures");
-      for(unsigned kk=0; kk<pres_.size()-1; kk++)
+      for(unsigned kk=0; kk<pres_.size()-1; kk++) {
         plumed_massert(pres_[kk]<=pres_[kk+1],"PRESSURE_SET_ALL must be properly ordered");
+      }
       pres_min=pres_[0];
       pres_max=pres_[pres_.size()-1];
-    }
-    else
-    { //get PRESSURE_MIN and PRESSURE_MAX
-      if(pres_min==myNone)
-      {
+    } else {
+      //get PRESSURE_MIN and PRESSURE_MAX
+      if(pres_min==myNone) {
         pres_min=pres0_;
         log.printf("  no PRESSURE_MIN provided, using PRESSURE_MIN=PRESSURE\n");
       }
-      if(pres_max==myNone)
-      {
+      if(pres_max==myNone) {
         pres_max=pres0_;
         log.printf("  no PRESSURE_MAX provided, using PRESSURE_MAX=PRESSURE\n");
       }
       plumed_massert(pres_max>=pres_min,"PRESSURE_MAX should be bigger than PRESSURE_MIN");
-      if(pres_min==pres_max && pres_steps==0)
+      if(pres_min==pres_max && pres_steps==0) {
         pres_steps=1;
-      if(pres_steps>0)
+      }
+      if(pres_steps>0) {
         pres_=getSteps(pres_min,pres_max,pres_steps,"PRESSURE",false,0);
-      else
-      {
+      } else {
         pres_.resize(2);
         pres_[0]=pres_min;
         pres_[1]=pres_max;
         todoAutomatic_pres_=true;
       }
     }
-    if(pres0_<pres_min || pres0_>pres_max)
+    if(pres0_<pres_min || pres0_>pres_max) {
       log.printf(" +++ WARNING +++ running at PRESSURE=%g which is outside the chosen pressure range\n",pres0_);
+    }
 
     //set CUT_CORNER
     std::string cc_usage("CUT_CORNER=temp_low,pres_low,temp_high,pres_high");
-    if(cut_corner.size()==4)
-    {
+    if(cut_corner.size()==4) {
       const double temp_low=cut_corner[0];
       const double pres_low=cut_corner[1];
       const double temp_high=cut_corner[2];
@@ -311,9 +297,7 @@ ECVmultiThermalBaric::ECVmultiThermalBaric(const ActionOptions&ao)
       const double small_value=(temp_high-pres_low)/1e4;
       pres_low_=pres_low-small_value; //make sure pres_max is included
       plumed_massert(pres_max>=coeff_*(kB*temp_max-kB_temp_low_)+pres_low_,"please chose a pres_high slightly smaller than PRESSURE_MAX in "+cc_usage);
-    }
-    else
-    {
+    } else {
       plumed_massert(cut_corner.size()==0,"expected 4 values: "+cc_usage);
     }
   }
@@ -321,67 +305,66 @@ ECVmultiThermalBaric::ECVmultiThermalBaric(const ActionOptions&ao)
 //print some info
   log.printf("  running at TEMP=%g and PRESSURE=%g\n",temp0,pres0_);
   log.printf("  targeting a temperature range from TEMP_MIN=%g to TEMP_MAX=%g\n",temp_min,temp_max);
-  if(temp_min==temp_max)
+  if(temp_min==temp_max) {
     log.printf(" +++ WARNING +++ if you only need a multibaric simulation it is more efficient to set it up with ECV_LINEAR\n");
+  }
   log.printf("   and a pressure range from PRESSURE_MIN=%g to PRESSURE_MAX=%g\n",pres_min,pres_max);
-  if(pres_min==pres_max)
+  if(pres_min==pres_max) {
     log.printf(" +++ WARNING +++ if you only need a multithermal simulation it is more efficient to set it up with ECV_MULTITHERMAL\n");
-  if(!geom_spacing_)
+  }
+  if(!geom_spacing_) {
     log.printf(" -- NO_GEOM_SPACING: inverse temperatures will be linearly spaced\n");
-  if(coeff_!=0)
+  }
+  if(coeff_!=0) {
     log.printf(" -- CUT_CORNER: ignoring some high temperature and low pressure values\n");
+  }
 }
 
-void ECVmultiThermalBaric::calculateECVs(const double * ene_vol)
-{
-  for(unsigned k=0; k<derECVs_beta_.size(); k++)
+void ECVmultiThermalBaric::calculateECVs(const double * ene_vol) {
+  for(unsigned k=0; k<derECVs_beta_.size(); k++) {
     ECVs_beta_[k]=derECVs_beta_[k]*ene_vol[0];
-  for(unsigned i=0; i<derECVs_pres_.size(); i++)
+  }
+  for(unsigned i=0; i<derECVs_pres_.size(); i++) {
     ECVs_pres_[i]=derECVs_pres_[i]*ene_vol[1];
+  }
 // derivatives are constant, as usual in linear expansions
 }
 
-const double * ECVmultiThermalBaric::getPntrToECVs(unsigned j)
-{
+const double * ECVmultiThermalBaric::getPntrToECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j==0 || j==1,getName()+" has only two CVs, the ENERGY and the VOLUME");
-  if(j==0)
+  if(j==0) {
     return &ECVs_beta_[0];
-  else //if (j==1)
+  } else { //if (j==1)
     return &ECVs_pres_[0];
+  }
 }
 
-const double * ECVmultiThermalBaric::getPntrToDerECVs(unsigned j)
-{
+const double * ECVmultiThermalBaric::getPntrToDerECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j==0 || j==1,getName()+" has only two CVs, the ENERGY and the VOLUME");
-  if(j==0)
+  if(j==0) {
     return &derECVs_beta_[0];
-  else //if (j==1)
+  } else { //if (j==1)
     return &derECVs_pres_[0];
+  }
 }
 
-std::vector< std::vector<unsigned> > ECVmultiThermalBaric::getIndex_k() const
-{
+std::vector< std::vector<unsigned> > ECVmultiThermalBaric::getIndex_k() const {
   plumed_massert(isReady_ && totNumECVs_>0,"cannot access getIndex_k() of ECV before initialization");
   std::vector< std::vector<unsigned> > index_k;
-  if(custom_lambdas_.size()>0)
-  { //same as default getIndex_k() function
+  if(custom_lambdas_.size()>0) {
+    //same as default getIndex_k() function
     plumed_massert(totNumECVs_==custom_lambdas_.size(),"this should not happen");
     for(unsigned i=0; i<totNumECVs_; i++)
       index_k.emplace_back(std::vector<unsigned> {i,i});
-  }
-  else
-  {
+  } else {
     unsigned i=0;
-    for(unsigned k=0; k<derECVs_beta_.size(); k++)
-    {
+    for(unsigned k=0; k<derECVs_beta_.size(); k++) {
       const double kB_temp_k=kbt_/(derECVs_beta_[k]*kbt_+1);
       const double line_k=coeff_*(kB_temp_k-kB_temp_low_)+pres_low_;
-      for(unsigned kk=0; kk<pres_.size(); kk++)
-      {
-        if(coeff_==0 || pres_[kk]>=line_k) //important to be inclusive, thus >=, not just >
-        {
+      for(unsigned kk=0; kk<pres_.size(); kk++) {
+        if(coeff_==0 || pres_[kk]>=line_k) { //important to be inclusive, thus >=, not just >
           index_k.emplace_back(std::vector<unsigned> {k,i});
           i++;
         }
@@ -392,22 +375,19 @@ std::vector< std::vector<unsigned> > ECVmultiThermalBaric::getIndex_k() const
   return index_k;
 }
 
-std::vector<std::string> ECVmultiThermalBaric::getLambdas() const
-{
-  if(custom_lambdas_.size()>0)
+std::vector<std::string> ECVmultiThermalBaric::getLambdas() const {
+  if(custom_lambdas_.size()>0) {
     return custom_lambdas_;
+  }
 
   plumed_massert(!todoAutomatic_beta_ && !todoAutomatic_pres_,"cannot access lambdas before initializing them");
   std::vector<std::string> lambdas;
   const double kB=getKBoltzmann();
-  for(unsigned k=0; k<derECVs_beta_.size(); k++)
-  {
+  for(unsigned k=0; k<derECVs_beta_.size(); k++) {
     const double kB_temp_k=kbt_/(derECVs_beta_[k]*kbt_+1);
     const double line_k=coeff_*(kB_temp_k-kB_temp_low_)+pres_low_;
-    for(unsigned kk=0; kk<pres_.size(); kk++)
-    {
-      if(coeff_==0 || pres_[kk]>=line_k)
-      {
+    for(unsigned kk=0; kk<pres_.size(); kk++) {
+      if(coeff_==0 || pres_[kk]>=line_k) {
         std::ostringstream subs;
         subs<<kB_temp_k/kB<<"_"<<pres_[kk];
         lambdas.emplace_back(subs.str());
@@ -417,32 +397,25 @@ std::vector<std::string> ECVmultiThermalBaric::getLambdas() const
   return lambdas;
 }
 
-void ECVmultiThermalBaric::initECVs()
-{
+void ECVmultiThermalBaric::initECVs() {
   plumed_massert(!isReady_,"initialization should not be called twice");
   plumed_massert(!todoAutomatic_beta_ && !todoAutomatic_pres_,"this should not happen");
   totNumECVs_=getLambdas().size(); //slow, but runs only once
-  if(custom_lambdas_.size()>0)
-  {
+  if(custom_lambdas_.size()>0) {
     log.printf("  *%4lu temperatures for %s\n",derECVs_beta_.size(),getName().c_str());
     log.printf("  *%4lu beta-pressures for %s\n",derECVs_pres_.size(),getName().c_str());
     log.printf("    -- SET_ALL_TEMP_PRESSURE: total number of temp-pres points is %u\n",totNumECVs_);
-  }
-  else
-  {
+  } else {
     plumed_massert(derECVs_beta_.size()*pres_.size()>=totNumECVs_,"this should not happen, is something wrong with CUT_CORNER ?");
     derECVs_pres_.resize(totNumECVs_); //pres is mixed with temp (beta*p*V), thus we need to store all possible
     //initialize the derECVs.
     //this could be done before and one could avoid storing also beta0, beta_k, etc. but this way the code should be more readable
     unsigned i=0;
-    for(unsigned k=0; k<derECVs_beta_.size(); k++)
-    {
+    for(unsigned k=0; k<derECVs_beta_.size(); k++) {
       const double kB_temp_k=kbt_/(derECVs_beta_[k]*kbt_+1);
       const double line_k=coeff_*(kB_temp_k-kB_temp_low_)+pres_low_;
-      for(unsigned kk=0; kk<pres_.size(); kk++)
-      {
-        if(coeff_==0 || pres_[kk]>=line_k)
-        {
+      for(unsigned kk=0; kk<pres_.size(); kk++) {
+        if(coeff_==0 || pres_[kk]>=line_k) {
           derECVs_pres_[i]=(pres_[kk]/kB_temp_k-pres0_/kbt_);
           i++;
         }
@@ -450,33 +423,33 @@ void ECVmultiThermalBaric::initECVs()
     }
     log.printf("  *%4lu temperatures for %s\n",derECVs_beta_.size(),getName().c_str());
     log.printf("  *%4lu pressures for %s\n",pres_.size(),getName().c_str());
-    if(coeff_!=0)
+    if(coeff_!=0) {
       log.printf("    -- CUT_CORNER: %lu temp-pres points were excluded, thus total is %u\n",derECVs_beta_.size()*pres_.size()-totNumECVs_,totNumECVs_);
+    }
   }
   ECVs_beta_.resize(derECVs_beta_.size());
   ECVs_pres_.resize(derECVs_pres_.size());
   isReady_=true;
 }
 
-void ECVmultiThermalBaric::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j)
-{
-  if(todoAutomatic_beta_) //estimate the steps in beta from observations
-  {
+void ECVmultiThermalBaric::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j) {
+  if(todoAutomatic_beta_) { //estimate the steps in beta from observations
     plumed_massert(all_obs_cvs.size()%ncv==0 && index_j<ncv,"initECVs_observ parameters are inconsistent");
     std::vector<double> obs_ene(all_obs_cvs.size()/ncv); //copy only useful observations
-    for(unsigned t=0; t<obs_ene.size(); t++)
-      obs_ene[t]=all_obs_cvs[t*ncv+index_j]+pres0_*all_obs_cvs[t*ncv+index_j+1]; //U=E+pV
+    for(unsigned t=0; t<obs_ene.size(); t++) {
+      obs_ene[t]=all_obs_cvs[t*ncv+index_j]+pres0_*all_obs_cvs[t*ncv+index_j+1];  //U=E+pV
+    }
     const unsigned temp_steps=estimateNumSteps(derECVs_beta_[0],derECVs_beta_[1],obs_ene,"TEMP");
     log.printf("    (spacing is on beta, not on temperature)\n");
     derECVs_beta_=getSteps(derECVs_beta_[0],derECVs_beta_[1],temp_steps,"TEMP",geom_spacing_,1./kbt_);
     todoAutomatic_beta_=false;
   }
-  if(todoAutomatic_pres_) //estimate the steps in pres from observations
-  {
+  if(todoAutomatic_pres_) { //estimate the steps in pres from observations
     plumed_massert(all_obs_cvs.size()%ncv==0 && index_j+1<ncv,"initECVs_observ parameters are inconsistent");
     std::vector<double> obs_vol(all_obs_cvs.size()/ncv); //copy only useful observations
-    for(unsigned t=0; t<obs_vol.size(); t++)
+    for(unsigned t=0; t<obs_vol.size(); t++) {
       obs_vol[t]=all_obs_cvs[t*ncv+index_j+1];
+    }
     const unsigned pres_steps=estimateNumSteps((pres_[0]-pres0_)/kbt_,(pres_[1]-pres0_)/kbt_,obs_vol,"PRESSURE");
     log.printf("    (spacing is in beta0 units)\n");
     pres_=getSteps(pres_[0],pres_[1],pres_steps,"PRESSURE",false,0);
@@ -486,35 +459,35 @@ void ECVmultiThermalBaric::initECVs_observ(const std::vector<double>& all_obs_cv
   calculateECVs(&all_obs_cvs[index_j]);
 }
 
-void ECVmultiThermalBaric::initECVs_restart(const std::vector<std::string>& lambdas)
-{
+void ECVmultiThermalBaric::initECVs_restart(const std::vector<std::string>& lambdas) {
   std::size_t pos=lambdas[0].find("_");
   plumed_massert(pos!=std::string::npos,"this should not happen, two CVs are used in "+getName()+", not less");
   pos=lambdas[0].find("_",pos+1);
   plumed_massert(pos==std::string::npos,"this should not happen, two CVs are used in "+getName()+", not more");
 
-  auto getPres=[&lambdas](const unsigned i) {return lambdas[i].substr(lambdas[i].find("_")+1);};
-  if(todoAutomatic_pres_)
-  {
+  auto getPres=[&lambdas](const unsigned i) {
+    return lambdas[i].substr(lambdas[i].find("_")+1);
+  };
+  if(todoAutomatic_pres_) {
     unsigned pres_steps=1;
     std::string pres_min=getPres(0);
-    for(unsigned i=1; i<lambdas.size(); i++) //pres is second, thus increas by 1
-    {
-      if(getPres(i)==pres_min)
+    for(unsigned i=1; i<lambdas.size(); i++) { //pres is second, thus increas by 1
+      if(getPres(i)==pres_min) {
         break;
+      }
       pres_steps++;
     }
     pres_=getSteps(pres_[0],pres_[1],pres_steps,"PRESSURE",false,0);
     todoAutomatic_pres_=false;
   }
-  if(todoAutomatic_beta_)
-  {
+  if(todoAutomatic_beta_) {
     unsigned temp_steps=1;
     std::string pres_max=getPres(pres_.size()-1);
-    for(unsigned i=pres_.size(); i<lambdas.size(); i++)
-    { //even if CUT_CORNER, the max pressures are all present, for each temp
-      if(getPres(i)==pres_max)
+    for(unsigned i=pres_.size(); i<lambdas.size(); i++) {
+      //even if CUT_CORNER, the max pressures are all present, for each temp
+      if(getPres(i)==pres_max) {
         temp_steps++;
+      }
     }
     derECVs_beta_=getSteps(derECVs_beta_[0],derECVs_beta_[1],temp_steps,"TEMP",geom_spacing_,1./kbt_);
     todoAutomatic_beta_=false;
diff --git a/src/opes/ECVumbrellasFile.cpp b/src/opes/ECVumbrellasFile.cpp
index 6f1342bdd4..9ff4f9fccc 100644
--- a/src/opes/ECVumbrellasFile.cpp
+++ b/src/opes/ECVumbrellasFile.cpp
@@ -68,8 +68,7 @@ The umbrellas file might look like this:
 //+ENDPLUMEDOC
 
 class ECVumbrellasFile :
-  public ExpansionCVs
-{
+  public ExpansionCVs {
 private:
   double barrier_;
   unsigned P0_contribution_;
@@ -95,8 +94,7 @@ class ECVumbrellasFile :
 
 PLUMED_REGISTER_ACTION(ECVumbrellasFile,"ECV_UMBRELLAS_FILE")
 
-void ECVumbrellasFile::registerKeywords(Keywords& keys)
-{
+void ECVumbrellasFile::registerKeywords(Keywords& keys) {
   ExpansionCVs::registerKeywords(keys);
   keys.use("ARG");
   keys.add("compulsory","FILE","the name of the file containing the umbrellas");
@@ -107,8 +105,7 @@ void ECVumbrellasFile::registerKeywords(Keywords& keys)
 
 ECVumbrellasFile::ECVumbrellasFile(const ActionOptions&ao):
   Action(ao),
-  ExpansionCVs(ao)
-{
+  ExpansionCVs(ao) {
 //get number of CVs
   const unsigned ncv=getNumberOfArguments();
   centers_.resize(ncv);
@@ -117,10 +114,11 @@ ECVumbrellasFile::ECVumbrellasFile(const ActionOptions&ao):
 //set P0_contribution_
   bool add_P0=false;
   parseFlag("ADD_P0",add_P0);
-  if(add_P0)
+  if(add_P0) {
     P0_contribution_=1;
-  else
+  } else {
     P0_contribution_=0;
+  }
 
 //set barrier_
   barrier_=std::numeric_limits<double>::infinity();
@@ -132,38 +130,33 @@ ECVumbrellasFile::ECVumbrellasFile(const ActionOptions&ao):
   parse("FILE",umbrellasFileName);
   IFile ifile;
   ifile.link(*this);
-  if(ifile.FileExist(umbrellasFileName))
-  {
+  if(ifile.FileExist(umbrellasFileName)) {
     log.printf("  reading from FILE '%s'\n",umbrellasFileName.c_str());
     ifile.open(umbrellasFileName);
     ifile.allowIgnoredFields();
     double time; //first field is ignored
-    while(ifile.scanField("time",time))
-    {
-      for(unsigned j=0; j<ncv; j++)
-      {
+    while(ifile.scanField("time",time)) {
+      for(unsigned j=0; j<ncv; j++) {
         double centers_j;
         ifile.scanField(getPntrToArgument(j)->getName(),centers_j);
         centers_[j].push_back(centers_j); //this might be slow
       }
-      for(unsigned j=0; j<ncv; j++)
-      {
+      for(unsigned j=0; j<ncv; j++) {
         double sigmas_j;
         ifile.scanField("sigma_"+getPntrToArgument(j)->getName(),sigmas_j);
         sigmas_[j].push_back(sigmas_j);
       }
       ifile.scanField();
     }
-  }
-  else
+  } else {
     plumed_merror("Umbrellas FILE '"+umbrellasFileName+"' not found");
+  }
 
   checkRead();
 
 //extra consistency checks
   const unsigned sizeUmbrellas=centers_[0].size();
-  for(unsigned j=0; j<ncv; j++)
-  {
+  for(unsigned j=0; j<ncv; j++) {
     plumed_massert(centers_[j].size()==sizeUmbrellas,"mismatch in the number of centers read from file");
     plumed_massert(sigmas_[j].size()==sizeUmbrellas,"mismatch in the number of sigmas read from file");
   }
@@ -175,43 +168,35 @@ ECVumbrellasFile::ECVumbrellasFile(const ActionOptions&ao):
 
 //printing some info
   log.printf("  total number of umbrellas = %u\n",sizeUmbrellas);
-  if(barrier_!=std::numeric_limits<double>::infinity())
+  if(barrier_!=std::numeric_limits<double>::infinity()) {
     log.printf("  guess for free energy BARRIER = %g\n",barrier_);
-  if(P0_contribution_==1)
+  }
+  if(P0_contribution_==1) {
     log.printf(" -- ADD_P0: the target includes also the unbiased probability itself\n");
-  if(lower_only_)
+  }
+  if(lower_only_) {
     log.printf(" -- LOWER_HALF_ONLY: the ECVs are set to zero for values of the CV above the respective center\n");
+  }
 }
 
-void ECVumbrellasFile::calculateECVs(const double * cv)
-{
-  if(lower_only_)
-  {
-    for(unsigned j=0; j<getNumberOfArguments(); j++)
-    {
-      for(unsigned k=P0_contribution_; k<totNumECVs_; k++) //if ADD_P0, the first ECVs=0
-      {
+void ECVumbrellasFile::calculateECVs(const double * cv) {
+  if(lower_only_) {
+    for(unsigned j=0; j<getNumberOfArguments(); j++) {
+      for(unsigned k=P0_contribution_; k<totNumECVs_; k++) { //if ADD_P0, the first ECVs=0
         const unsigned kk=k-P0_contribution_;
         const double dist_jk=difference(j,centers_[j][kk],cv[j])/sigmas_[j][kk]; //PBC might be present
-        if(dist_jk>=0)
-        {
+        if(dist_jk>=0) {
           ECVs_[j][k]=0;
           derECVs_[j][k]=0;
-        }
-        else
-        {
+        } else {
           ECVs_[j][k]=0.5*std::pow(dist_jk,2);
           derECVs_[j][k]=dist_jk/sigmas_[j][kk];
         }
       }
     }
-  }
-  else
-  {
-    for(unsigned j=0; j<getNumberOfArguments(); j++)
-    {
-      for(unsigned k=P0_contribution_; k<totNumECVs_; k++) //if ADD_P0, the first ECVs=0
-      {
+  } else {
+    for(unsigned j=0; j<getNumberOfArguments(); j++) {
+      for(unsigned k=P0_contribution_; k<totNumECVs_; k++) { //if ADD_P0, the first ECVs=0
         const unsigned kk=k-P0_contribution_;
         const double dist_jk=difference(j,centers_[j][kk],cv[j])/sigmas_[j][kk]; //PBC might be present
         ECVs_[j][k]=0.5*std::pow(dist_jk,2);
@@ -221,65 +206,62 @@ void ECVumbrellasFile::calculateECVs(const double * cv)
   }
 }
 
-const double * ECVumbrellasFile::getPntrToECVs(unsigned j)
-{
+const double * ECVumbrellasFile::getPntrToECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j<getNumberOfArguments(),getName()+" has fewer CVs");
   return &ECVs_[j][0];
 }
 
-const double * ECVumbrellasFile::getPntrToDerECVs(unsigned j)
-{
+const double * ECVumbrellasFile::getPntrToDerECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j<getNumberOfArguments(),getName()+" has fewer CVs");
   return &derECVs_[j][0];
 }
 
-std::vector<std::string> ECVumbrellasFile::getLambdas() const
-{ //notice that sigmas are not considered!
+std::vector<std::string> ECVumbrellasFile::getLambdas() const {
+  //notice that sigmas are not considered!
   std::vector<std::string> lambdas(totNumECVs_);
-  if(P0_contribution_==1)
-  {
+  if(P0_contribution_==1) {
     std::ostringstream subs;
     subs<<"P0";
-    for(unsigned j=1; j<getNumberOfArguments(); j++)
+    for(unsigned j=1; j<getNumberOfArguments(); j++) {
       subs<<"_P0";
+    }
     lambdas[0]=subs.str();
   }
-  for(unsigned k=P0_contribution_; k<totNumECVs_; k++)
-  {
+  for(unsigned k=P0_contribution_; k<totNumECVs_; k++) {
     const unsigned kk=k-P0_contribution_;
     std::ostringstream subs;
     subs<<centers_[0][kk];
-    for(unsigned j=1; j<getNumberOfArguments(); j++)
+    for(unsigned j=1; j<getNumberOfArguments(); j++) {
       subs<<"_"<<centers_[j][kk];
+    }
     lambdas[k]=subs.str();
   }
   return lambdas;
 }
 
-void ECVumbrellasFile::initECVs()
-{
+void ECVumbrellasFile::initECVs() {
   plumed_massert(!isReady_,"initialization should not be called twice");
   isReady_=true;
   log.printf("  *%4u windows for %s\n",totNumECVs_,getName().c_str());
 }
 
-void ECVumbrellasFile::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j)
-{
+void ECVumbrellasFile::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j) {
   //this non-linear exansion never uses automatic initialization
   initECVs();
   calculateECVs(&all_obs_cvs[index_j]); //use only first obs point
   for(unsigned j=0; j<getNumberOfArguments(); j++)
-    for(unsigned k=P0_contribution_; k<totNumECVs_; k++)
+    for(unsigned k=P0_contribution_; k<totNumECVs_; k++) {
       ECVs_[j][k]=std::min(barrier_/kbt_,ECVs_[j][k]);
+    }
 }
 
-void ECVumbrellasFile::initECVs_restart(const std::vector<std::string>& lambdas)
-{
+void ECVumbrellasFile::initECVs_restart(const std::vector<std::string>& lambdas) {
   std::size_t pos=0;
-  for(unsigned j=0; j<getNumberOfArguments()-1; j++)
-    pos=lambdas[0].find("_",pos+1); //checking only lambdas[0] is hopefully enough
+  for(unsigned j=0; j<getNumberOfArguments()-1; j++) {
+    pos=lambdas[0].find("_",pos+1);  //checking only lambdas[0] is hopefully enough
+  }
   plumed_massert(pos<lambdas[0].length(),"this should not happen, fewer '_' than expected in "+getName());
   pos=lambdas[0].find("_",pos+1);
   plumed_massert(pos>lambdas[0].length(),"this should not happen, more '_' than expected in "+getName());
diff --git a/src/opes/ECVumbrellasLine.cpp b/src/opes/ECVumbrellasLine.cpp
index 0ab817422f..3c420889bc 100644
--- a/src/opes/ECVumbrellasLine.cpp
+++ b/src/opes/ECVumbrellasLine.cpp
@@ -69,8 +69,7 @@ opes: OPES_EXPANDED ARG=ecv1.*,ecv2.* PACE=500
 //+ENDPLUMEDOC
 
 class ECVumbrellasLine :
-  public ExpansionCVs
-{
+  public ExpansionCVs {
 private:
   double barrier_;
   unsigned P0_contribution_;
@@ -96,8 +95,7 @@ class ECVumbrellasLine :
 
 PLUMED_REGISTER_ACTION(ECVumbrellasLine,"ECV_UMBRELLAS_LINE")
 
-void ECVumbrellasLine::registerKeywords(Keywords& keys)
-{
+void ECVumbrellasLine::registerKeywords(Keywords& keys) {
   ExpansionCVs::registerKeywords(keys);
   keys.use("ARG");
   keys.add("compulsory","CV_MIN","the minimum of the CV range to be explored");
@@ -111,15 +109,15 @@ void ECVumbrellasLine::registerKeywords(Keywords& keys)
 
 ECVumbrellasLine::ECVumbrellasLine(const ActionOptions&ao):
   Action(ao),
-  ExpansionCVs(ao)
-{
+  ExpansionCVs(ao) {
 //set P0_contribution_
   bool add_P0=false;
   parseFlag("ADD_P0",add_P0);
-  if(add_P0)
+  if(add_P0) {
     P0_contribution_=1;
-  else
+  } else {
     P0_contribution_=0;
+  }
 
 //set barrier_
   barrier_=std::numeric_limits<double>::infinity();
@@ -137,37 +135,38 @@ ECVumbrellasLine::ECVumbrellasLine(const ActionOptions&ao):
   double spacing;
   parse("SPACING",spacing);
   double length=0;
-  for(unsigned j=0; j<getNumberOfArguments(); j++)
+  for(unsigned j=0; j<getNumberOfArguments(); j++) {
     length+=std::pow(cv_max[j]-cv_min[j],2);
+  }
   length=std::sqrt(length);
   unsigned sizeUmbrellas=1+std::round(length/(sigma_*spacing));
   centers_.resize(getNumberOfArguments()); //centers_[cv][umbrellas]
   unsigned full_period=0;
-  for(unsigned j=0; j<getNumberOfArguments(); j++)
-  {
+  for(unsigned j=0; j<getNumberOfArguments(); j++) {
     centers_[j].resize(sizeUmbrellas);
     if(sizeUmbrellas>1)
-      for(unsigned k=0; k<sizeUmbrellas; k++)
+      for(unsigned k=0; k<sizeUmbrellas; k++) {
         centers_[j][k]=cv_min[j]+k*(cv_max[j]-cv_min[j])/(sizeUmbrellas-1);
-    else
+      } else {
       centers_[j][0]=(cv_min[j]+cv_max[j])/2.;
-    if(getPntrToArgument(j)->isPeriodic())
-    {
+    }
+    if(getPntrToArgument(j)->isPeriodic()) {
       double min,max;
       std::string min_str,max_str;
       getPntrToArgument(j)->getDomain(min,max);
       getPntrToArgument(j)->getDomain(min_str,max_str);
       plumed_massert(cv_min[j]>=min,"ARG "+std::to_string(j)+": CV_MIN cannot be smaller than the periodic bound "+min_str);
       plumed_massert(cv_max[j]<=max,"ARG "+std::to_string(j)+": CV_MAX cannot be greater than the periodic bound "+max_str);
-      if(cv_min[j]==min && cv_max[j]==max)
+      if(cv_min[j]==min && cv_max[j]==max) {
         full_period++;
+      }
     }
   }
-  if(full_period==getNumberOfArguments() && sizeUmbrellas>1) //first and last are the same point
-  {
+  if(full_period==getNumberOfArguments() && sizeUmbrellas>1) { //first and last are the same point
     sizeUmbrellas--;
-    for(unsigned j=0; j<getNumberOfArguments(); j++)
+    for(unsigned j=0; j<getNumberOfArguments(); j++) {
       centers_[j].pop_back();
+    }
   }
 
   checkRead();
@@ -181,43 +180,35 @@ ECVumbrellasLine::ECVumbrellasLine(const ActionOptions&ao):
   log.printf("  total number of umbrellas = %u\n",sizeUmbrellas);
   log.printf("    with SIGMA = %g\n",sigma_);
   log.printf("    and SPACING = %g\n",spacing);
-  if(barrier_!=std::numeric_limits<double>::infinity())
+  if(barrier_!=std::numeric_limits<double>::infinity()) {
     log.printf("  guess for free energy BARRIER = %g\n",barrier_);
-  if(P0_contribution_==1)
+  }
+  if(P0_contribution_==1) {
     log.printf(" -- ADD_P0: the target includes also the unbiased probability itself\n");
-  if(lower_only_)
+  }
+  if(lower_only_) {
     log.printf(" -- LOWER_HALF_ONLY: the ECVs are set to zero for values of the CV above the respective center\n");
+  }
 }
 
-void ECVumbrellasLine::calculateECVs(const double * cv)
-{
-  if(lower_only_)
-  {
-    for(unsigned j=0; j<getNumberOfArguments(); j++)
-    {
-      for(unsigned k=P0_contribution_; k<totNumECVs_; k++) //if ADD_P0, the first ECVs=0
-      {
+void ECVumbrellasLine::calculateECVs(const double * cv) {
+  if(lower_only_) {
+    for(unsigned j=0; j<getNumberOfArguments(); j++) {
+      for(unsigned k=P0_contribution_; k<totNumECVs_; k++) { //if ADD_P0, the first ECVs=0
         const unsigned kk=k-P0_contribution_;
         const double dist_jk=difference(j,centers_[j][kk],cv[j])/sigma_; //PBC might be present
-        if(dist_jk>=0)
-        {
+        if(dist_jk>=0) {
           ECVs_[j][k]=0;
           derECVs_[j][k]=0;
-        }
-        else
-        {
+        } else {
           ECVs_[j][k]=0.5*std::pow(dist_jk,2);
           derECVs_[j][k]=dist_jk/sigma_;
         }
       }
     }
-  }
-  else
-  {
-    for(unsigned j=0; j<getNumberOfArguments(); j++)
-    {
-      for(unsigned k=P0_contribution_; k<totNumECVs_; k++) //if ADD_P0, the first ECVs=0
-      {
+  } else {
+    for(unsigned j=0; j<getNumberOfArguments(); j++) {
+      for(unsigned k=P0_contribution_; k<totNumECVs_; k++) { //if ADD_P0, the first ECVs=0
         const unsigned kk=k-P0_contribution_;
         const double dist_jk=difference(j,centers_[j][kk],cv[j])/sigma_; //PBC might be present
         ECVs_[j][k]=0.5*std::pow(dist_jk,2);
@@ -227,65 +218,61 @@ void ECVumbrellasLine::calculateECVs(const double * cv)
   }
 }
 
-const double * ECVumbrellasLine::getPntrToECVs(unsigned j)
-{
+const double * ECVumbrellasLine::getPntrToECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j<getNumberOfArguments(),getName()+" has fewer CVs");
   return &ECVs_[j][0];
 }
 
-const double * ECVumbrellasLine::getPntrToDerECVs(unsigned j)
-{
+const double * ECVumbrellasLine::getPntrToDerECVs(unsigned j) {
   plumed_massert(isReady_,"cannot access ECVs before initialization");
   plumed_massert(j<getNumberOfArguments(),getName()+" has fewer CVs");
   return &derECVs_[j][0];
 }
 
-std::vector<std::string> ECVumbrellasLine::getLambdas() const
-{
+std::vector<std::string> ECVumbrellasLine::getLambdas() const {
   std::vector<std::string> lambdas(totNumECVs_);
-  if(P0_contribution_==1)
-  {
+  if(P0_contribution_==1) {
     std::ostringstream subs;
     subs<<"P0";
-    for(unsigned j=1; j<getNumberOfArguments(); j++)
+    for(unsigned j=1; j<getNumberOfArguments(); j++) {
       subs<<"_P0";
+    }
     lambdas[0]=subs.str();
   }
-  for(unsigned k=P0_contribution_; k<totNumECVs_; k++)
-  {
+  for(unsigned k=P0_contribution_; k<totNumECVs_; k++) {
     const unsigned kk=k-P0_contribution_;
     std::ostringstream subs;
     subs<<centers_[0][kk];
-    for(unsigned j=1; j<getNumberOfArguments(); j++)
+    for(unsigned j=1; j<getNumberOfArguments(); j++) {
       subs<<"_"<<centers_[j][kk];
+    }
     lambdas[k]=subs.str();
   }
   return lambdas;
 }
 
-void ECVumbrellasLine::initECVs()
-{
+void ECVumbrellasLine::initECVs() {
   plumed_massert(!isReady_,"initialization should not be called twice");
   isReady_=true;
   log.printf("  *%4u windows for %s\n",totNumECVs_,getName().c_str());
 }
 
-void ECVumbrellasLine::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j)
-{
+void ECVumbrellasLine::initECVs_observ(const std::vector<double>& all_obs_cvs,const unsigned ncv,const unsigned index_j) {
   //this non-linear exansion never uses automatic initialization
   initECVs();
   calculateECVs(&all_obs_cvs[index_j]); //use only first obs point
   for(unsigned j=0; j<getNumberOfArguments(); j++)
-    for(unsigned k=P0_contribution_; k<totNumECVs_; k++)
+    for(unsigned k=P0_contribution_; k<totNumECVs_; k++) {
       ECVs_[j][k]=std::min(barrier_/kbt_,ECVs_[j][k]);
+    }
 }
 
-void ECVumbrellasLine::initECVs_restart(const std::vector<std::string>& lambdas)
-{
+void ECVumbrellasLine::initECVs_restart(const std::vector<std::string>& lambdas) {
   std::size_t pos=0;
-  for(unsigned j=0; j<getNumberOfArguments()-1; j++)
-    pos=lambdas[0].find("_",pos+1); //checking only lambdas[0] is hopefully enough
+  for(unsigned j=0; j<getNumberOfArguments()-1; j++) {
+    pos=lambdas[0].find("_",pos+1);  //checking only lambdas[0] is hopefully enough
+  }
   plumed_massert(pos<lambdas[0].length(),"this should not happen, fewer '_' than expected in "+getName());
   pos=lambdas[0].find("_",pos+1);
   plumed_massert(pos>lambdas[0].length(),"this should not happen, more '_' than expected in "+getName());
diff --git a/src/opes/ExpansionCVs.cpp b/src/opes/ExpansionCVs.cpp
index 4d2b3632c9..4b2636377c 100644
--- a/src/opes/ExpansionCVs.cpp
+++ b/src/opes/ExpansionCVs.cpp
@@ -23,8 +23,7 @@
 namespace PLMD {
 namespace opes {
 
-void ExpansionCVs::registerKeywords(Keywords& keys)
-{
+void ExpansionCVs::registerKeywords(Keywords& keys) {
   Action::registerKeywords(keys);
   ActionWithValue::registerKeywords(keys);
   ActionWithArguments::registerKeywords(keys);
@@ -37,8 +36,7 @@ ExpansionCVs::ExpansionCVs(const ActionOptions&ao)
   , ActionWithValue(ao)
   , ActionWithArguments(ao)
   , isReady_(false)
-  , totNumECVs_(0)
-{
+  , totNumECVs_(0) {
 //set kbt_
   const double kB=getKBoltzmann();
   kbt_=getkBT();
@@ -46,19 +44,17 @@ ExpansionCVs::ExpansionCVs(const ActionOptions&ao)
 
 //set components
   plumed_massert( getNumberOfArguments()!=0, "you must specify the underlying CV");
-  for(unsigned j=0; j<getNumberOfArguments(); j++)
-  {
+  for(unsigned j=0; j<getNumberOfArguments(); j++) {
     std::string name_j=getPntrToArgument(j)->getName();
     ActionWithValue::addComponentWithDerivatives(name_j);
     getPntrToComponent(j)->resizeDerivatives(1);
-    if(getPntrToArgument(j)->isPeriodic()) //it should not be necessary, but why not
-    {
+    if(getPntrToArgument(j)->isPeriodic()) { //it should not be necessary, but why not
       std::string min,max;
       getPntrToArgument(j)->getDomain(min,max);
       getPntrToComponent(j)->setDomain(min,max);
-    }
-    else
+    } else {
       getPntrToComponent(j)->setNotPeriodic();
+    }
   }
   plumed_massert((int)getNumberOfArguments()==getNumberOfComponents(),"Expansion CVs have same number of arguments and components");
 }
@@ -67,87 +63,78 @@ std::string ExpansionCVs::getOutputComponentDescription( const std::string& cnam
   return "the value of the argument named " + cname;
 }
 
-void ExpansionCVs::calculate()
-{
+void ExpansionCVs::calculate() {
   std::vector<double> args(getNumberOfArguments());
-  for(unsigned j=0; j<getNumberOfArguments(); j++)
-  {
+  for(unsigned j=0; j<getNumberOfArguments(); j++) {
     args[j]=getArgument(j);
     getPntrToComponent(j)->set(args[j]); //components are equal to arguments
     getPntrToComponent(j)->addDerivative(0,1.); //the derivative of the identity is 1
   }
-  if(isReady_)
+  if(isReady_) {
     calculateECVs(&args[0]);
+  }
 }
 
-void ExpansionCVs::apply()
-{
-  for(unsigned j=0; j<getNumberOfArguments(); j++)
-  {
+void ExpansionCVs::apply() {
+  for(unsigned j=0; j<getNumberOfArguments(); j++) {
     std::vector<double> force_j(1);
-    if(getPntrToComponent(j)->applyForce(force_j)) //a bias is applied?
-      getPntrToArgument(j)->addForce(force_j[0]); //just tell it to the CV!
+    if(getPntrToComponent(j)->applyForce(force_j)) { //a bias is applied?
+      getPntrToArgument(j)->addForce(force_j[0]);  //just tell it to the CV!
+    }
   }
 }
 
-std::vector< std::vector<unsigned> > ExpansionCVs::getIndex_k() const
-{
+std::vector< std::vector<unsigned> > ExpansionCVs::getIndex_k() const {
   plumed_massert(isReady_ && totNumECVs_>0,"cannot access getIndex_k() of ECV before initialization");
   std::vector< std::vector<unsigned> > index_k(totNumECVs_,std::vector<unsigned>(getNumberOfArguments()));
   for(unsigned k=0; k<totNumECVs_; k++)
-    for(unsigned j=0; j<getNumberOfArguments(); j++)
-      index_k[k][j]=k; //each CV gives rise to the same number of ECVs
+    for(unsigned j=0; j<getNumberOfArguments(); j++) {
+      index_k[k][j]=k;  //each CV gives rise to the same number of ECVs
+    }
   return index_k;
 }
 
 //following methods are meant to be used only in case of linear expansions
-std::vector<double> ExpansionCVs::getSteps(double lambda_min,double lambda_max,const unsigned lambda_steps,const std::string& msg,const bool geom_spacing, const double shift) const
-{
+std::vector<double> ExpansionCVs::getSteps(double lambda_min,double lambda_max,const unsigned lambda_steps,const std::string& msg,const bool geom_spacing, const double shift) const {
   plumed_massert(!(lambda_min==lambda_max && lambda_steps>1),"cannot have multiple "+msg+"_STEPS if "+msg+"_MIN=="+msg+"_MAX");
   std::vector<double> lambda(lambda_steps);
-  if(lambda_steps==1)
-  {
+  if(lambda_steps==1) {
     lambda[0]=(lambda_min+lambda_max)/2.;
     log.printf(" +++ WARNING +++ using one single %s as target = %g\n",msg.c_str(),lambda[0]);
-  }
-  else
-  {
-    if(geom_spacing) //geometric spacing
-    { //this way lambda[k]/lambda[k+1] is constant
+  } else {
+    if(geom_spacing) { //geometric spacing
+      //this way lambda[k]/lambda[k+1] is constant
       lambda_min+=shift;
       lambda_max+=shift;
       plumed_massert(lambda_min>0,"cannot use GEOM_SPACING when %s_MIN is not greater than zero");
       plumed_massert(lambda_max>0,"cannot use GEOM_SPACING when %s_MAX is not greater than zero");
       const double log_lambda_min=std::log(lambda_min);
       const double log_lambda_max=std::log(lambda_max);
-      for(unsigned k=0; k<lambda.size(); k++)
+      for(unsigned k=0; k<lambda.size(); k++) {
         lambda[k]=std::exp(log_lambda_min+k*(log_lambda_max-log_lambda_min)/(lambda_steps-1))-shift;
-    }
-    else //linear spacing
-      for(unsigned k=0; k<lambda.size(); k++)
+      }
+    } else //linear spacing
+      for(unsigned k=0; k<lambda.size(); k++) {
         lambda[k]=lambda_min+k*(lambda_max-lambda_min)/(lambda_steps-1);
+      }
   }
   return lambda;
 }
 
-unsigned ExpansionCVs::estimateNumSteps(const double left_side,const double right_side,const std::vector<double>& obs,const std::string& msg) const
-{ //for linear expansions only, it uses effective sample size (Neff) to estimate the grid spacing
-  if(left_side==0 && right_side==0)
-  {
+unsigned ExpansionCVs::estimateNumSteps(const double left_side,const double right_side,const std::vector<double>& obs,const std::string& msg) const {
+  //for linear expansions only, it uses effective sample size (Neff) to estimate the grid spacing
+  if(left_side==0 && right_side==0) {
     log.printf(" +++ WARNING +++ %s_MIN and %s_MAX are equal to %s, using single step\n",msg.c_str(),msg.c_str(),msg.c_str());
     return 1;
   }
-  auto get_neff_HWHM=[](const double side,const std::vector<double>& obs) //HWHM = half width at half maximum. neff is in general not symmetric
-  {
+  auto get_neff_HWHM=[](const double side,const std::vector<double>& obs) { //HWHM = half width at half maximum. neff is in general not symmetric
     //func: Neff/N-0.5 is a function between -0.5 and 0.5
-    auto func=[](const double delta,const std::vector<double>& obs)
-    {
+    auto func=[](const double delta,const std::vector<double>& obs) {
       double sum_w=0;
       double sum_w2=0;
       //we could avoid recomputing safe_shift every time, but here speed is not a concern
       const double safe_shift=delta<0?*std::max_element(obs.begin(),obs.end()):*std::min_element(obs.begin(),obs.end());
-      for(unsigned t=0; t<obs.size(); t++)
-      {
+      for(unsigned t=0; t<obs.size(); t++) {
         const double w=std::exp(-delta*(obs[t]-safe_shift)); //robust to overflow
         sum_w+=w;
         sum_w2+=w*w;
@@ -161,24 +148,20 @@ unsigned ExpansionCVs::estimateNumSteps(const double left_side,const double righ
     double func_a=0.5;
     double b=side;
     double func_b=func(side,obs);
-    if(func_b>=0)
-      return 0.0; //no zero is present!
-    if(b<0) //left side case
-    {
+    if(func_b>=0) {
+      return 0.0;  //no zero is present!
+    }
+    if(b<0) { //left side case
       std::swap(a,b);
       std::swap(func_a,func_b);
     }
     double c=a;
     double func_c=func_a;
-    while(std::abs(func_c)>tolerance)
-    {
-      if(func_a*func_c>0)
-      {
+    while(std::abs(func_c)>tolerance) {
+      if(func_a*func_c>0) {
         a=c;
         func_a=func_c;
-      }
-      else
-      {
+      } else {
         b=c;
         func_b=func_c;
       }
@@ -190,32 +173,33 @@ unsigned ExpansionCVs::estimateNumSteps(const double left_side,const double righ
 
 //estimation
   double left_HWHM=0;
-  if(left_side!=0)
+  if(left_side!=0) {
     left_HWHM=get_neff_HWHM(left_side,obs);
+  }
   double right_HWHM=0;
-  if(right_side!=0)
+  if(right_side!=0) {
     right_HWHM=get_neff_HWHM(right_side,obs);
-  if(left_HWHM==0)
-  {
+  }
+  if(left_HWHM==0) {
     right_HWHM*=2;
-    if(left_side==0)
+    if(left_side==0) {
       log.printf(" --- %s_MIN is equal to %s\n",msg.c_str(),msg.c_str());
-    else
+    } else {
       log.printf(" +++ WARNING +++ %s_MIN is very close to %s\n",msg.c_str(),msg.c_str());
+    }
   }
-  if(right_HWHM==0)
-  {
+  if(right_HWHM==0) {
     left_HWHM*=2;
-    if(right_side==0)
+    if(right_side==0) {
       log.printf(" --- %s_MAX is equal to %s\n",msg.c_str(),msg.c_str());
-    else
+    } else {
       log.printf(" +++ WARNING +++ %s_MAX is very close to %s\n",msg.c_str(),msg.c_str());
+    }
   }
   const double grid_spacing=left_HWHM+right_HWHM;
   log.printf("   estimated %s spacing = %g\n",msg.c_str(),grid_spacing);
   unsigned steps=std::ceil(std::abs(right_side-left_side)/grid_spacing);
-  if(steps<2 || grid_spacing==0)
-  {
+  if(steps<2 || grid_spacing==0) {
     log.printf(" +++ WARNING +++ %s range is very narrow, using %s_MIN and %s_MAX as only steps\n",msg.c_str(),msg.c_str(),msg.c_str());
     steps=2;
   }
diff --git a/src/opes/ExpansionCVs.h b/src/opes/ExpansionCVs.h
index bad74897bb..842bfc8f0c 100644
--- a/src/opes/ExpansionCVs.h
+++ b/src/opes/ExpansionCVs.h
@@ -34,8 +34,7 @@ They take as argument regular CVs, and output them as components without modific
 
 class ExpansionCVs:
   public ActionWithValue,
-  public ActionWithArguments
-{
+  public ActionWithArguments {
 protected:
   bool isReady_; //true only after initECVs
   double kbt_;
@@ -52,10 +51,17 @@ class ExpansionCVs:
   void apply() override;
   void calculate() override;
   static void registerKeywords(Keywords&);
-  inline unsigned getNumberOfDerivatives() override {return 1;};
+  inline unsigned getNumberOfDerivatives() override {
+    return 1;
+  };
 
-  inline double getKbT() const {return kbt_;};
-  inline unsigned getTotNumECVs() const {plumed_massert(isReady_,"cannot ask for totNumECVs before ECV isReady"); return totNumECVs_;};
+  inline double getKbT() const {
+    return kbt_;
+  };
+  inline unsigned getTotNumECVs() const {
+    plumed_massert(isReady_,"cannot ask for totNumECVs before ECV isReady");
+    return totNumECVs_;
+  };
   virtual std::vector< std::vector<unsigned> > getIndex_k() const; //might need to override this
 
   virtual void calculateECVs(const double *) = 0;
diff --git a/src/opes/OPESexpanded.cpp b/src/opes/OPESexpanded.cpp
index afb309b20f..f824fb55b7 100644
--- a/src/opes/OPESexpanded.cpp
+++ b/src/opes/OPESexpanded.cpp
@@ -178,8 +178,7 @@ class OPESexpanded : public bias::Bias {
 
 PLUMED_REGISTER_ACTION(OPESexpanded,"OPES_EXPANDED")
 
-void OPESexpanded::registerKeywords(Keywords& keys)
-{
+void OPESexpanded::registerKeywords(Keywords& keys) {
   Bias::registerKeywords(keys);
   keys.remove("ARG");
   keys.add("compulsory","ARG","the label of the ECVs that define the expansion. You can use an * to make sure all the output components of the ECVs are used, as in the examples above");
@@ -212,8 +211,7 @@ OPESexpanded::OPESexpanded(const ActionOptions&ao)
   , ncv_(getNumberOfArguments())
   , deltaF_size_(0)
   , rct_(0)
-  , work_(0)
-{
+  , work_(0) {
 //set pace
   parse("PACE",stride_);
   parse("OBSERVATION_STEPS",obs_steps_);
@@ -235,12 +233,15 @@ OPESexpanded::OPESexpanded(const ActionOptions&ao)
   parse("STATE_WSTRIDE",wStateStride_);
   storeOldStates_=false;
   parseFlag("STORE_STATES",storeOldStates_);
-  if(wStateStride_!=0 || storeOldStates_)
+  if(wStateStride_!=0 || storeOldStates_) {
     plumed_massert(stateFileName.length()>0,"filename for storing simulation status not specified, use STATE_WFILE");
-  if(wStateStride_>0)
+  }
+  if(wStateStride_>0) {
     plumed_massert(wStateStride_>=(int)stride_,"STATE_WSTRIDE is in units of MD steps, thus should be a multiple of PACE");
-  if(stateFileName.length()>0 && wStateStride_==0)
-    wStateStride_=-1;//will print only on CPT events (checkpoints set by some MD engines, like gromacs)
+  }
+  if(stateFileName.length()>0 && wStateStride_==0) {
+    wStateStride_=-1;  //will print only on CPT events (checkpoints set by some MD engines, like gromacs)
+  }
 
 //work flag
   parseFlag("CALC_WORK",calc_work_);
@@ -248,22 +249,18 @@ OPESexpanded::OPESexpanded(const ActionOptions&ao)
 //multiple walkers //external MW for cp2k not supported, but anyway cp2k cannot put bias on energy!
   bool walkers_mpi=false;
   parseFlag("WALKERS_MPI",walkers_mpi);
-  if(walkers_mpi)
-  {
+  if(walkers_mpi) {
     //If this Action is not compiled with MPI the user is informed and we exit gracefully
     plumed_massert(Communicator::plumedHasMPI(),"Invalid walkers configuration: WALKERS_MPI flag requires MPI compilation");
     plumed_massert(Communicator::initialized(),"Invalid walkers configuration: WALKERS_MPI needs the communicator correctly initialized.");
 
-    if(comm.Get_rank()==0) //multi_sim_comm works on first rank only
-    {
+    if(comm.Get_rank()==0) { //multi_sim_comm works on first rank only
       NumWalkers_=multi_sim_comm.Get_size();
       walker_rank_=multi_sim_comm.Get_rank();
     }
     comm.Bcast(NumWalkers_,0); //if each walker has more than one processor update them all
     comm.Bcast(walker_rank_,0);
-  }
-  else
-  {
+  } else {
     NumWalkers_=1;
     walker_rank_=0;
   }
@@ -274,8 +271,7 @@ OPESexpanded::OPESexpanded(const ActionOptions&ao)
   rank_=comm.Get_rank();
   bool serial=false;
   parseFlag("SERIAL",serial);
-  if(serial)
-  {
+  if(serial) {
     NumOMP_=1;
     NumParallel_=1;
     rank_=0;
@@ -287,38 +283,33 @@ OPESexpanded::OPESexpanded(const ActionOptions&ao)
   init_pntrToECVsClass();
 //set kbt_
   kbt_=pntrToECVsClass_[0]->getKbT();
-  for(unsigned l=0; l<pntrToECVsClass_.size(); l++)
+  for(unsigned l=0; l<pntrToECVsClass_.size(); l++) {
     plumed_massert(std::abs(kbt_-pntrToECVsClass_[l]->getKbT())<1e-4,"must set same TEMP for each ECV");
+  }
 
 //restart if needed
-  if(getRestart())
-  {
+  if(getRestart()) {
     bool stateRestart=true;
-    if(restartFileName.length()==0)
-    {
+    if(restartFileName.length()==0) {
       stateRestart=false;
       restartFileName=deltaFsFileName;
     }
     IFile ifile;
     ifile.link(*this);
-    if(ifile.FileExist(restartFileName))
-    {
+    if(ifile.FileExist(restartFileName)) {
       log.printf("  RESTART - make sure all ECVs used are the same as before\n");
       log.printf("    restarting from: %s\n",restartFileName.c_str());
       ifile.open(restartFileName);
-      if(stateRestart) //get all info
-      {
+      if(stateRestart) { //get all info
         log.printf("    it should be a STATE file (not a DELTAFS file)\n");
         double time; //not used
         ifile.scanField("time",time);
         ifile.scanField("counter",counter_);
         ifile.scanField("rct",rct_);
         std::string tmp_lambda;
-        while(ifile.scanField(getPntrToArgument(0)->getName(),tmp_lambda))
-        {
+        while(ifile.scanField(getPntrToArgument(0)->getName(),tmp_lambda)) {
           std::string subs="DeltaF_"+tmp_lambda;
-          for(unsigned jj=1; jj<ncv_; jj++)
-          {
+          for(unsigned jj=1; jj<ncv_; jj++) {
             tmp_lambda.clear();
             ifile.scanField(getPntrToArgument(jj)->getName(),tmp_lambda);
             subs+="_"+tmp_lambda;
@@ -331,11 +322,10 @@ OPESexpanded::OPESexpanded(const ActionOptions&ao)
           tmp_lambda.clear();
         }
         log.printf("  successfully read %lu DeltaF values\n",deltaF_name_.size());
-        if(NumParallel_>1)
+        if(NumParallel_>1) {
           all_deltaF_=deltaF_;
-      }
-      else //get just deltaFs names
-      {
+        }
+      } else { //get just deltaFs names
         ifile.scanFieldList(deltaF_name_);
         plumed_massert(deltaF_name_.size()>=4,"RESTART - fewer than expected FIELDS found in '"+deltaFsFileName+"' file");
         plumed_massert(deltaF_name_[deltaF_name_.size()-1]=="print_stride","RESTART - coult not find expected FIELDS in '"+deltaFsFileName+"' file");
@@ -344,38 +334,39 @@ OPESexpanded::OPESexpanded(const ActionOptions&ao)
         deltaF_name_.pop_back();
         deltaF_name_.erase(deltaF_name_.begin(),deltaF_name_.begin()+2);
         std::size_t pos=5; //each name starts with "DeltaF"
-        for(unsigned j=0; j<ncv_; j++)
-          pos=deltaF_name_[0].find("_",pos+1); //checking only first one, hopefully is enough
+        for(unsigned j=0; j<ncv_; j++) {
+          pos=deltaF_name_[0].find("_",pos+1);  //checking only first one, hopefully is enough
+        }
         plumed_massert(pos<deltaF_name_[0].length(),"RESTART - fewer '_' than expected in DeltaF fields: did you remove any CV?");
         pos=deltaF_name_[0].find("_",pos+1);
         plumed_massert(pos>deltaF_name_[0].length(),"RESTART - more '_' than expected in DeltaF fields: did you add new CV?");
       }
       //get lambdas, init ECVs and Link them
       deltaF_size_=deltaF_name_.size();
-      auto getLambdaName=[](const std::string& name,const unsigned start,const unsigned dim)
-      {
+      auto getLambdaName=[](const std::string& name,const unsigned start,const unsigned dim) {
         std::size_t pos_start=5; //each name starts with "DeltaF"
-        for(unsigned j=0; j<=start; j++)
+        for(unsigned j=0; j<=start; j++) {
           pos_start=name.find("_",pos_start+1);
+        }
         std::size_t pos_end=pos_start;
-        for(unsigned j=0; j<dim; j++)
+        for(unsigned j=0; j<dim; j++) {
           pos_end=name.find("_",pos_end+1);
+        }
         pos_start++; //do not include heading "_"
         return name.substr(pos_start,pos_end-pos_start);
       };
       unsigned index_j=ncv_;
       unsigned sizeSkip=1;
-      for(int l=pntrToECVsClass_.size()-1; l>=0; l--)
-      {
+      for(int l=pntrToECVsClass_.size()-1; l>=0; l--) {
         const unsigned dim_l=pntrToECVsClass_[l]->getNumberOfArguments();
         index_j-=dim_l;
         std::vector<std::string> lambdas_l(1);
         lambdas_l[0]=getLambdaName(deltaF_name_[0],index_j,dim_l);
-        for(unsigned i=sizeSkip; i<deltaF_size_; i+=sizeSkip)
-        {
+        for(unsigned i=sizeSkip; i<deltaF_size_; i+=sizeSkip) {
           std::string tmp_lambda=getLambdaName(deltaF_name_[i],index_j,dim_l);
-          if(tmp_lambda==lambdas_l[0])
+          if(tmp_lambda==lambdas_l[0]) {
             break;
+          }
           lambdas_l.push_back(tmp_lambda);
         }
         pntrToECVsClass_[l]->initECVs_restart(lambdas_l);
@@ -385,42 +376,38 @@ OPESexpanded::OPESexpanded(const ActionOptions&ao)
       init_linkECVs(); //link ECVs and initializes index_k_
       log.printf(" ->%4u DeltaFs in total\n",deltaF_size_);
       obs_steps_=0; //avoid initializing again
-      if(stateRestart)
-      {
-        if(NumParallel_>1)
-        {
+      if(stateRestart) {
+        if(NumParallel_>1) {
           const unsigned start=(deltaF_size_/NumParallel_)*rank_+std::min(rank_,deltaF_size_%NumParallel_);
           unsigned iter=0;
-          for(unsigned i=start; i<start+deltaF_.size(); i++)
+          for(unsigned i=start; i<start+deltaF_.size(); i++) {
             deltaF_[iter++]=all_deltaF_[i];
+          }
         }
-      }
-      else //read each step
-      {
+      } else { //read each step
         counter_=1;
         unsigned count_lines=0;
         ifile.allowIgnoredFields(); //this allows for multiple restart, but without checking for consistency between them!
         double time;
-        while(ifile.scanField("time",time)) //only number of lines and last line is important
-        {
+        while(ifile.scanField("time",time)) { //only number of lines and last line is important
           unsigned restart_stride;
           ifile.scanField("print_stride",restart_stride);
           ifile.scanField("rct",rct_);
-          if(NumParallel_==1)
-          {
-            for(unsigned i=0; i<deltaF_size_; i++)
+          if(NumParallel_==1) {
+            for(unsigned i=0; i<deltaF_size_; i++) {
               ifile.scanField(deltaF_name_[i],deltaF_[i]);
-          }
-          else
-          {
+            }
+          } else {
             const unsigned start=(deltaF_size_/NumParallel_)*rank_+std::min(rank_,deltaF_size_%NumParallel_);
             unsigned iter=0;
-            for(unsigned i=start; i<start+deltaF_.size(); i++)
+            for(unsigned i=start; i<start+deltaF_.size(); i++) {
               ifile.scanField(deltaF_name_[i],deltaF_[iter++]);
+            }
           }
           ifile.scanField();
-          if(count_lines>0)
+          if(count_lines>0) {
             counter_+=restart_stride;
+          }
           count_lines++;
         }
         counter_*=NumWalkers_;
@@ -428,63 +415,65 @@ OPESexpanded::OPESexpanded(const ActionOptions&ao)
       }
       ifile.reset(false);
       ifile.close();
-    }
-    else //same behaviour as METAD
+    } else { //same behaviour as METAD
       plumed_merror("RESTART requested, but file '"+restartFileName+"' was not found!\n  Set RESTART=NO or provide a restart file");
-    if(NumWalkers_>1) //make sure that all walkers are doing the same thing
-    {
+    }
+    if(NumWalkers_>1) { //make sure that all walkers are doing the same thing
       std::vector<unsigned long long> all_counter(NumWalkers_);
-      if(comm.Get_rank()==0)
+      if(comm.Get_rank()==0) {
         multi_sim_comm.Allgather(counter_,all_counter);
+      }
       comm.Bcast(all_counter,0);
       bool same_number_of_steps=true;
       for(unsigned w=1; w<NumWalkers_; w++)
-        if(all_counter[0]!=all_counter[w])
+        if(all_counter[0]!=all_counter[w]) {
           same_number_of_steps=false;
+        }
       plumed_massert(same_number_of_steps,"RESTART - not all walkers are reading the same file!");
     }
-  }
-  else if(restartFileName.length()>0)
+  } else if(restartFileName.length()>0) {
     log.printf(" +++ WARNING +++ the provided STATE_RFILE will be ignored, since RESTART was not requested\n");
+  }
 
 //sync all walkers to avoid opening files before reding is over (see also METAD)
   comm.Barrier();
-  if(comm.Get_rank()==0 && walkers_mpi)
+  if(comm.Get_rank()==0 && walkers_mpi) {
     multi_sim_comm.Barrier();
+  }
 
 //setup DeltaFs file
   deltaFsOfile_.link(*this);
-  if(NumWalkers_>1)
-  {
-    if(walker_rank_>0)
-      deltaFsFileName="/dev/null"; //only first walker writes on file
+  if(NumWalkers_>1) {
+    if(walker_rank_>0) {
+      deltaFsFileName="/dev/null";  //only first walker writes on file
+    }
     deltaFsOfile_.enforceSuffix("");
   }
   deltaFsOfile_.open(deltaFsFileName);
-  if(fmt.length()>0)
+  if(fmt.length()>0) {
     deltaFsOfile_.fmtField(" "+fmt);
+  }
   deltaFsOfile_.setHeavyFlush(); //do I need it?
   deltaFsOfile_.addConstantField("print_stride");
   deltaFsOfile_.printField("print_stride",print_stride_);
 
 //open file for storing state
-  if(wStateStride_!=0)
-  {
+  if(wStateStride_!=0) {
     stateOfile_.link(*this);
-    if(NumWalkers_>1)
-    {
-      if(walker_rank_>0)
-        stateFileName="/dev/null"; //only first walker writes on file
+    if(NumWalkers_>1) {
+      if(walker_rank_>0) {
+        stateFileName="/dev/null";  //only first walker writes on file
+      }
       stateOfile_.enforceSuffix("");
     }
     stateOfile_.open(stateFileName);
-    if(fmt.length()>0)
+    if(fmt.length()>0) {
       stateOfile_.fmtField(" "+fmt);
+    }
   }
 
 //add output components
-  if(calc_work_)
-  {
+  if(calc_work_) {
     addComponent("work");
     componentIsNotPeriodic("work");
   }
@@ -492,90 +481,96 @@ OPESexpanded::OPESexpanded(const ActionOptions&ao)
 //printing some info
   log.printf("  updating the bias with PACE = %u\n",stride_);
   log.printf("  initial unbiased OBSERVATION_STEPS = %u (in units of PACE)\n",obs_steps_);
-  if(wStateStride_>0)
+  if(wStateStride_>0) {
     log.printf("  state checkpoints are written on file %s every %d MD steps\n",stateFileName.c_str(),wStateStride_);
-  if(wStateStride_==-1)
+  }
+  if(wStateStride_==-1) {
     log.printf("  state checkpoints are written on file '%s' only on CPT events (or never if MD code does define them!)\n",stateFileName.c_str());
-  if(walkers_mpi)
+  }
+  if(walkers_mpi) {
     log.printf(" -- WALKERS_MPI: if multiple replicas are present, they will share the same bias via MPI\n");
-  if(NumWalkers_>1)
-  {
+  }
+  if(NumWalkers_>1) {
     log.printf("  using multiple walkers\n");
     log.printf("    number of walkers: %u\n",NumWalkers_);
     log.printf("    walker rank: %u\n",walker_rank_);
   }
   int mw_warning=0;
-  if(!walkers_mpi && comm.Get_rank()==0 && multi_sim_comm.Get_size()>(int)NumWalkers_)
+  if(!walkers_mpi && comm.Get_rank()==0 && multi_sim_comm.Get_size()>(int)NumWalkers_) {
     mw_warning=1;
+  }
   comm.Bcast(mw_warning,0);
-  if(mw_warning) //log.printf messes up with comm, so never use it without Bcast!
+  if(mw_warning) { //log.printf messes up with comm, so never use it without Bcast!
     log.printf(" +++ WARNING +++ multiple replicas will NOT communicate unless the flag WALKERS_MPI is used\n");
-  if(NumParallel_>1)
+  }
+  if(NumParallel_>1) {
     log.printf("  using multiple MPI processes per simulation: %u\n",NumParallel_);
-  if(NumOMP_>1)
+  }
+  if(NumOMP_>1) {
     log.printf("  using multiple OpenMP threads per simulation: %u\n",NumOMP_);
-  if(serial)
+  }
+  if(serial) {
     log.printf(" -- SERIAL: no loop parallelization, despite %d MPI processes and %u OpenMP threads available\n",comm.Get_size(),OpenMP::getNumThreads());
+  }
   log.printf("  Bibliography: ");
   log<<plumed.cite("M. Invernizzi, P.M. Piaggi, and M. Parrinello, Phys. Rev. X 10, 041034 (2020)");
   log.printf("\n");
 }
 
-void OPESexpanded::calculate()
-{
-  if(deltaF_size_==0) //no bias before initialization
+void OPESexpanded::calculate() {
+  if(deltaF_size_==0) { //no bias before initialization
     return;
+  }
 
 //get diffMax, to avoid over/underflow
   double diffMax=-std::numeric_limits<double>::max();
   #pragma omp parallel num_threads(NumOMP_)
   {
     #pragma omp for reduction(max:diffMax)
-    for(unsigned i=0; i<deltaF_.size(); i++)
-    {
+    for(unsigned i=0; i<deltaF_.size(); i++) {
       diff_[i]=(-getExpansion(i)+deltaF_[i]/kbt_);
-      if(diff_[i]>diffMax)
+      if(diff_[i]>diffMax) {
         diffMax=diff_[i];
+      }
     }
   }
-  if(NumParallel_>1)
+  if(NumParallel_>1) {
     comm.Max(diffMax);
+  }
 
 //calculate the bias and the forces
   double sum=0;
   std::vector<double> der_sum_cv(ncv_,0);
-  if(NumOMP_==1)
-  {
-    for(unsigned i=0; i<deltaF_.size(); i++)
-    {
+  if(NumOMP_==1) {
+    for(unsigned i=0; i<deltaF_.size(); i++) {
       double add_i=std::exp(diff_[i]-diffMax);
       sum+=add_i;
       //set derivatives
-      for(unsigned j=0; j<ncv_; j++)
+      for(unsigned j=0; j<ncv_; j++) {
         der_sum_cv[j]-=derECVs_[j][index_k_[i][j]]*add_i;
+      }
     }
-  }
-  else
-  {
+  } else {
     #pragma omp parallel num_threads(NumOMP_)
     {
       std::vector<double> omp_der_sum_cv(ncv_,0);
       #pragma omp for reduction(+:sum) nowait
-      for(unsigned i=0; i<deltaF_.size(); i++)
-      {
+      for(unsigned i=0; i<deltaF_.size(); i++) {
         double add_i=std::exp(diff_[i]-diffMax);
         sum+=add_i;
         //set derivatives
-        for(unsigned j=0; j<ncv_; j++)
+        for(unsigned j=0; j<ncv_; j++) {
           omp_der_sum_cv[j]-=derECVs_[j][index_k_[i][j]]*add_i;
+        }
       }
       #pragma omp critical
-      for(unsigned j=0; j<ncv_; j++)
+      for(unsigned j=0; j<ncv_; j++) {
         der_sum_cv[j]+=omp_der_sum_cv[j];
+      }
     }
   }
-  if(NumParallel_>1)
-  { //each MPI process has part of the full deltaF_ vector, so must Sum
+  if(NumParallel_>1) {
+    //each MPI process has part of the full deltaF_ vector, so must Sum
     comm.Sum(sum);
     comm.Sum(der_sum_cv);
   }
@@ -583,27 +578,25 @@ void OPESexpanded::calculate()
 //set bias and forces
   const double bias=-kbt_*(diffMax+std::log(sum/deltaF_size_));
   setBias(bias);
-  for(unsigned j=0; j<ncv_; j++)
+  for(unsigned j=0; j<ncv_; j++) {
     setOutputForce(j,kbt_*der_sum_cv[j]/sum);
+  }
 }
 
-void OPESexpanded::update()
-{
-  if(isFirstStep_) //skip very first step, as in METAD
-  {
+void OPESexpanded::update() {
+  if(isFirstStep_) { //skip very first step, as in METAD
     isFirstStep_=false;
-    if(obs_steps_!=1) //if obs_steps_==1 go on with initialization
+    if(obs_steps_!=1) { //if obs_steps_==1 go on with initialization
       return;
+    }
   }
-  if(getStep()%stride_==0)
-  {
-    if(obs_steps_>0)
-    {
-      for(unsigned j=0; j<ncv_; j++)
+  if(getStep()%stride_==0) {
+    if(obs_steps_>0) {
+      for(unsigned j=0; j<ncv_; j++) {
         obs_cvs_[counter_*ncv_+j]=getArgument(j);
+      }
       counter_++;
-      if(counter_==obs_steps_)
-      {
+      if(counter_==obs_steps_) {
         log.printf("\nAction %s\n",getName().c_str());
         init_fromObs();
         log.printf("Finished initialization\n\n");
@@ -615,28 +608,25 @@ void OPESexpanded::update()
 
     //update averages
     const double current_bias=getOutputQuantity(0); //the first value is always the bias
-    if(NumWalkers_==1)
+    if(NumWalkers_==1) {
       updateDeltaF(current_bias);
-    else
-    {
+    } else {
       std::vector<double> cvs(ncv_);
-      for(unsigned j=0; j<ncv_; j++)
+      for(unsigned j=0; j<ncv_; j++) {
         cvs[j]=getArgument(j);
+      }
       std::vector<double> all_bias(NumWalkers_);
       std::vector<double> all_cvs(NumWalkers_*ncv_);
-      if(comm.Get_rank()==0)
-      {
+      if(comm.Get_rank()==0) {
         multi_sim_comm.Allgather(current_bias,all_bias);
         multi_sim_comm.Allgather(cvs,all_cvs);
       }
       comm.Bcast(all_bias,0);
       comm.Bcast(all_cvs,0);
-      for(unsigned w=0; w<NumWalkers_; w++)
-      {
+      for(unsigned w=0; w<NumWalkers_; w++) {
         //calculate ECVs
         unsigned index_wj=w*ncv_;
-        for(unsigned k=0; k<pntrToECVsClass_.size(); k++)
-        {
+        for(unsigned k=0; k<pntrToECVsClass_.size(); k++) {
           pntrToECVsClass_[k]->calculateECVs(&all_cvs[index_wj]);
           index_wj+=pntrToECVsClass_[k]->getNumberOfArguments();
         }
@@ -645,36 +635,40 @@ void OPESexpanded::update()
     }
 
     //write DeltaFs to file
-    if((counter_/NumWalkers_-1)%print_stride_==0)
+    if((counter_/NumWalkers_-1)%print_stride_==0) {
       printDeltaF();
+    }
 
     //calculate work if requested
-    if(calc_work_)
-    { //some copy and paste from calculate()
+    if(calc_work_) {
+      //some copy and paste from calculate()
       //get diffMax, to avoid over/underflow
       double diffMax=-std::numeric_limits<double>::max();
       #pragma omp parallel num_threads(NumOMP_)
       {
         #pragma omp for reduction(max:diffMax)
-        for(unsigned i=0; i<deltaF_.size(); i++)
-        {
+        for(unsigned i=0; i<deltaF_.size(); i++) {
           diff_[i]=(-getExpansion(i)+deltaF_[i]/kbt_);
-          if(diff_[i]>diffMax)
+          if(diff_[i]>diffMax) {
             diffMax=diff_[i];
+          }
         }
       }
-      if(NumParallel_>1)
+      if(NumParallel_>1) {
         comm.Max(diffMax);
+      }
       //calculate the bias
       double sum=0;
       #pragma omp parallel num_threads(NumOMP_)
       {
         #pragma omp for reduction(+:sum) nowait
-        for(unsigned i=0; i<deltaF_.size(); i++)
+        for(unsigned i=0; i<deltaF_.size(); i++) {
           sum+=std::exp(diff_[i]-diffMax);
+        }
       }
-      if(NumParallel_>1)
+      if(NumParallel_>1) {
         comm.Sum(sum);
+      }
       const double new_bias=-kbt_*(diffMax+std::log(sum/deltaF_size_));
       //accumulate work
       work_+=new_bias-current_bias;
@@ -683,30 +677,26 @@ void OPESexpanded::update()
   }
 
 //dump state if requested
-  if( (wStateStride_>0 && getStep()%wStateStride_==0) || (wStateStride_==-1 && getCPT()) )
+  if( (wStateStride_>0 && getStep()%wStateStride_==0) || (wStateStride_==-1 && getCPT()) ) {
     dumpStateToFile();
+  }
 }
 
-void OPESexpanded::init_pntrToECVsClass()
-{
+void OPESexpanded::init_pntrToECVsClass() {
   std::vector<opes::ExpansionCVs*> all_pntrToECVsClass=plumed.getActionSet().select<opes::ExpansionCVs*>();
   plumed_massert(all_pntrToECVsClass.size()>0,"no Expansion CVs found");
-  for(unsigned j=0; j<ncv_; j++)
-  {
+  for(unsigned j=0; j<ncv_; j++) {
     std::string error_notECV("all the ARGs of "+getName()+" must be Expansion Collective Variables (ECV)");
     const unsigned dot_pos=getPntrToArgument(j)->getName().find(".");
     plumed_massert(dot_pos<getPntrToArgument(j)->getName().size(),error_notECV+", thus contain a dot in the name");
     unsigned foundECV_l=all_pntrToECVsClass.size();
-    for(unsigned l=0; l<all_pntrToECVsClass.size(); l++)
-    {
-      if(getPntrToArgument(j)->getName().substr(0,dot_pos)==all_pntrToECVsClass[l]->getLabel())
-      {
+    for(unsigned l=0; l<all_pntrToECVsClass.size(); l++) {
+      if(getPntrToArgument(j)->getName().substr(0,dot_pos)==all_pntrToECVsClass[l]->getLabel()) {
         foundECV_l=l;
         pntrToECVsClass_.push_back(all_pntrToECVsClass[l]);
         std::string missing_arg="some ECV component is missing from ARG";
         plumed_massert(j+all_pntrToECVsClass[l]->getNumberOfArguments()<=getNumberOfArguments(),missing_arg);
-        for(unsigned h=0; h<all_pntrToECVsClass[l]->getNumberOfArguments(); h++)
-        {
+        for(unsigned h=0; h<all_pntrToECVsClass[l]->getNumberOfArguments(); h++) {
           std::string argName=getPntrToArgument(j+h)->getName();
           std::string expectedECVname=all_pntrToECVsClass[l]->getComponentsVector()[h];
           plumed_massert(argName==expectedECVname,missing_arg+", or is in wrong order: given ARG="+argName+" expected ARG="+expectedECVname);
@@ -718,12 +708,12 @@ void OPESexpanded::init_pntrToECVsClass()
     plumed_massert(foundECV_l<all_pntrToECVsClass.size(),error_notECV);
   }
   for(unsigned l=0; l<pntrToECVsClass_.size(); l++)
-    for(unsigned ll=l+1; ll<pntrToECVsClass_.size(); ll++)
+    for(unsigned ll=l+1; ll<pntrToECVsClass_.size(); ll++) {
       plumed_massert(pntrToECVsClass_[l]->getLabel()!=pntrToECVsClass_[ll]->getLabel(),"cannot use same ECV twice");
+    }
 }
 
-void OPESexpanded::init_linkECVs()
-{
+void OPESexpanded::init_linkECVs() {
   //TODO It should be possible to make all of this more straightforward (and probably also faster):
   //     - get rid of index_k_, making it trivial for each ECV
   //     - store the ECVs_ and derECVs_ vectors here as a contiguous vector, and use pointers in the ECV classes
@@ -731,20 +721,19 @@ void OPESexpanded::init_linkECVs()
   //     - ECVmultiThermalBaric has a nontrivial index_k_ to avoid duplicates. use duplicates instead
   //     - can the ECVs be MPI parallel or it's too complicated?
   plumed_massert(deltaF_size_>0,"must set deltaF_size_ before calling init_linkECVs()");
-  if(NumParallel_==1)
+  if(NumParallel_==1) {
     deltaF_.resize(deltaF_size_);
-  else
-  {
+  } else {
     const unsigned extra=(rank_<(deltaF_size_%NumParallel_)?1:0);
     deltaF_.resize(deltaF_size_/NumParallel_+extra);
     //these are used when printing deltaF_ to file
     all_deltaF_.resize(deltaF_size_);
     all_size_.resize(NumParallel_,deltaF_size_/NumParallel_);
     disp_.resize(NumParallel_);
-    for(unsigned r=0; r<NumParallel_-1; r++)
-    {
-      if(r<deltaF_size_%NumParallel_)
+    for(unsigned r=0; r<NumParallel_-1; r++) {
+      if(r<deltaF_size_%NumParallel_) {
         all_size_[r]++;
+      }
       disp_[r+1]=disp_[r]+all_size_[r];
     }
   }
@@ -754,27 +743,24 @@ void OPESexpanded::init_linkECVs()
   index_k_.resize(deltaF_.size(),std::vector<unsigned>(ncv_));
   unsigned index_j=0;
   unsigned sizeSkip=deltaF_size_;
-  for(unsigned l=0; l<pntrToECVsClass_.size(); l++)
-  {
+  for(unsigned l=0; l<pntrToECVsClass_.size(); l++) {
     std::vector< std::vector<unsigned> > l_index_k(pntrToECVsClass_[l]->getIndex_k());
     plumed_massert(deltaF_size_%l_index_k.size()==0,"buggy ECV: mismatch between getTotNumECVs() and getIndex_k().size()");
     plumed_massert(l_index_k[0].size()==pntrToECVsClass_[l]->getNumberOfArguments(),"buggy ECV: mismatch between number of ARG and underlying CVs");
     sizeSkip/=l_index_k.size();
-    for(unsigned h=0; h<pntrToECVsClass_[l]->getNumberOfArguments(); h++)
-    {
+    for(unsigned h=0; h<pntrToECVsClass_[l]->getNumberOfArguments(); h++) {
       ECVs_[index_j+h]=pntrToECVsClass_[l]->getPntrToECVs(h);
       derECVs_[index_j+h]=pntrToECVsClass_[l]->getPntrToDerECVs(h);
-      if(NumParallel_==1)
-      {
-        for(unsigned i=0; i<deltaF_size_; i++)
+      if(NumParallel_==1) {
+        for(unsigned i=0; i<deltaF_size_; i++) {
           index_k_[i][index_j+h]=l_index_k[(i/sizeSkip)%l_index_k.size()][h];
-      }
-      else
-      {
+        }
+      } else {
         const unsigned start=(deltaF_size_/NumParallel_)*rank_+std::min(rank_,deltaF_size_%NumParallel_);
         unsigned iter=0;
-        for(unsigned i=start; i<start+deltaF_.size(); i++)
+        for(unsigned i=start; i<start+deltaF_.size(); i++) {
           index_k_[iter++][index_j+h]=l_index_k[(i/sizeSkip)%l_index_k.size()][h];
+        }
       }
     }
     index_j+=pntrToECVsClass_[l]->getNumberOfArguments();
@@ -782,14 +768,13 @@ void OPESexpanded::init_linkECVs()
   plumed_massert(sizeSkip==1,"this should not happen!");
 }
 
-void OPESexpanded::init_fromObs() //This could probably be faster and/or require less memory...
-{
+void OPESexpanded::init_fromObs() { //This could probably be faster and/or require less memory...
 //in case of multiple walkers gather all the statistics
-  if(NumWalkers_>1)
-  {
+  if(NumWalkers_>1) {
     std::vector<double> all_obs_cv(ncv_*obs_steps_*NumWalkers_);
-    if(comm.Get_rank()==0)
+    if(comm.Get_rank()==0) {
       multi_sim_comm.Allgather(obs_cvs_,all_obs_cv);
+    }
     comm.Bcast(all_obs_cv,0);
     obs_cvs_=all_obs_cv; //could this lead to memory issues?
     obs_steps_*=NumWalkers_;
@@ -798,8 +783,7 @@ void OPESexpanded::init_fromObs() //This could probably be faster and/or require
 //initialize ECVs from observations
   unsigned index_j=0;
   deltaF_size_=1;
-  for(unsigned l=0; l<pntrToECVsClass_.size(); l++)
-  {
+  for(unsigned l=0; l<pntrToECVsClass_.size(); l++) {
     pntrToECVsClass_[l]->initECVs_observ(obs_cvs_,ncv_,index_j);
     deltaF_size_*=pntrToECVsClass_[l]->getTotNumECVs(); //ECVs from different exansions will be combined
     index_j+=pntrToECVsClass_[l]->getNumberOfArguments();
@@ -812,23 +796,22 @@ void OPESexpanded::init_fromObs() //This could probably be faster and/or require
 //for the first point, t=0, the ECVs are calculated by initECVs_observ, setting also any initial guess
   index_j=0;
   for(unsigned i=0; i<deltaF_.size(); i++)
-    for(unsigned j=0; j<ncv_; j++)
+    for(unsigned j=0; j<ncv_; j++) {
       deltaF_[i]+=kbt_*ECVs_[j][index_k_[i][j]];
-  for(unsigned t=1; t<obs_steps_; t++) //starts from t=1
-  {
+    }
+  for(unsigned t=1; t<obs_steps_; t++) { //starts from t=1
     unsigned index_j=0;
-    for(unsigned l=0; l<pntrToECVsClass_.size(); l++)
-    {
+    for(unsigned l=0; l<pntrToECVsClass_.size(); l++) {
       pntrToECVsClass_[l]->calculateECVs(&obs_cvs_[t*ncv_+index_j]);
       index_j+=pntrToECVsClass_[l]->getNumberOfArguments();
     }
-    for(unsigned i=0; i<deltaF_.size(); i++)
-    {
+    for(unsigned i=0; i<deltaF_.size(); i++) {
       const double diff_i=(-getExpansion(i)+deltaF_[i]/kbt_-std::log(t));
-      if(diff_i>0) //save exp from overflow
+      if(diff_i>0) { //save exp from overflow
         deltaF_[i]-=kbt_*(diff_i+std::log1p(std::exp(-diff_i))+std::log1p(-1./(1.+t)));
-      else
+      } else {
         deltaF_[i]-=kbt_*(std::log1p(std::exp(diff_i))+std::log1p(-1./(1.+t)));
+      }
     }
   }
   obs_cvs_.clear();
@@ -836,13 +819,13 @@ void OPESexpanded::init_fromObs() //This could probably be faster and/or require
 //set deltaF_name_
   deltaF_name_.resize(deltaF_size_,"DeltaF");
   unsigned sizeSkip=deltaF_size_;
-  for(unsigned l=0; l<pntrToECVsClass_.size(); l++)
-  {
+  for(unsigned l=0; l<pntrToECVsClass_.size(); l++) {
     std::vector<std::string> lambdas_l=pntrToECVsClass_[l]->getLambdas();
     plumed_massert(lambdas_l.size()==pntrToECVsClass_[l]->getTotNumECVs(),"buggy ECV: mismatch between getTotNumECVs() and getLambdas().size()");
     sizeSkip/=lambdas_l.size();
-    for(unsigned i=0; i<deltaF_size_; i++)
+    for(unsigned i=0; i<deltaF_size_; i++) {
       deltaF_name_[i]+="_"+lambdas_l[(i/sizeSkip)%lambdas_l.size()];
+    }
   }
 
 //print initialization to file
@@ -850,31 +833,29 @@ void OPESexpanded::init_fromObs() //This could probably be faster and/or require
   printDeltaF();
 }
 
-void OPESexpanded::printDeltaF()
-{
+void OPESexpanded::printDeltaF() {
   deltaFsOfile_.printField("time",getTime());
   deltaFsOfile_.printField("rct",rct_);
-  if(NumParallel_==1)
-  {
-    for(unsigned i=0; i<deltaF_.size(); i++)
+  if(NumParallel_==1) {
+    for(unsigned i=0; i<deltaF_.size(); i++) {
       deltaFsOfile_.printField(deltaF_name_[i],deltaF_[i]);
-  }
-  else
-  {
+    }
+  } else {
     comm.Allgatherv(deltaF_,all_deltaF_,&all_size_[0],&disp_[0]); //can we avoid using this big vector?
-    for(unsigned i=0; i<deltaF_size_; i++)
+    for(unsigned i=0; i<deltaF_size_; i++) {
       deltaFsOfile_.printField(deltaF_name_[i],all_deltaF_[i]);
+    }
   }
   deltaFsOfile_.printField();
 }
 
-void OPESexpanded::dumpStateToFile()
-{
+void OPESexpanded::dumpStateToFile() {
 //rewrite header or rewind file
-  if(storeOldStates_)
+  if(storeOldStates_) {
     stateOfile_.clearFields();
-  else if(walker_rank_==0)
+  } else if(walker_rank_==0) {
     stateOfile_.rewind();
+  }
 //define fields
   stateOfile_.addConstantField("time");
   stateOfile_.addConstantField("counter");
@@ -883,59 +864,60 @@ void OPESexpanded::dumpStateToFile()
   stateOfile_.printField("time",getTime());
   stateOfile_.printField("counter",counter_);
   stateOfile_.printField("rct",rct_);
-  if(NumParallel_>1)
-    comm.Allgatherv(deltaF_,all_deltaF_,&all_size_[0],&disp_[0]); //can we avoid using this big vector?
-  for(unsigned i=0; i<deltaF_size_; i++)
-  {
+  if(NumParallel_>1) {
+    comm.Allgatherv(deltaF_,all_deltaF_,&all_size_[0],&disp_[0]);  //can we avoid using this big vector?
+  }
+  for(unsigned i=0; i<deltaF_size_; i++) {
     std::size_t pos_start=7; //skip "DeltaF_"
-    for(unsigned j=0; j<ncv_; j++)
-    {
+    for(unsigned j=0; j<ncv_; j++) {
       plumed_dbg_massert(pos_start>6,"not enought _ in deltaF_name_"+std::to_string(i-1)+" string?");
       const std::size_t pos_end=deltaF_name_[i].find("_",pos_start);
       stateOfile_.printField(getPntrToArgument(j)->getName(),"  "+deltaF_name_[i].substr(pos_start,pos_end-pos_start));
       pos_start=pos_end+1;
     }
-    if(NumParallel_==1)
+    if(NumParallel_==1) {
       stateOfile_.printField("DeltaF",deltaF_[i]);
-    else
+    } else {
       stateOfile_.printField("DeltaF",all_deltaF_[i]);
+    }
     stateOfile_.printField();
   }
 //make sure file is written even if small
-  if(!storeOldStates_)
+  if(!storeOldStates_) {
     stateOfile_.flush();
+  }
 }
 
-void OPESexpanded::updateDeltaF(double bias)
-{
+void OPESexpanded::updateDeltaF(double bias) {
   plumed_dbg_massert(counter_>0,"deltaF_ must be initialized");
   counter_++;
   const double arg=(bias-rct_)/kbt_-std::log(counter_-1.);
   double increment;
-  if(arg>0) //save exp from overflow
+  if(arg>0) { //save exp from overflow
     increment=kbt_*(arg+std::log1p(std::exp(-arg)));
-  else
+  } else {
     increment=kbt_*(std::log1p(std::exp(arg)));
+  }
   #pragma omp parallel num_threads(NumOMP_)
   {
     #pragma omp for
-    for(unsigned i=0; i<deltaF_.size(); i++)
-    {
+    for(unsigned i=0; i<deltaF_.size(); i++) {
       const double diff_i=(-getExpansion(i)+(bias-rct_+deltaF_[i])/kbt_-std::log(counter_-1.));
-      if(diff_i>0) //save exp from overflow
+      if(diff_i>0) { //save exp from overflow
         deltaF_[i]+=increment-kbt_*(diff_i+std::log1p(std::exp(-diff_i)));
-      else
+      } else {
         deltaF_[i]+=increment-kbt_*std::log1p(std::exp(diff_i));
+      }
     }
   }
   rct_+=increment+kbt_*std::log1p(-1./counter_);
 }
 
-double OPESexpanded::getExpansion(unsigned i) const
-{
+double OPESexpanded::getExpansion(unsigned i) const {
   double expansion=0;
-  for(unsigned j=0; j<ncv_; j++)
-    expansion+=ECVs_[j][index_k_[i][j]]; //the index_k could be trivially guessed for most ECVs, but unfourtunately not all
+  for(unsigned j=0; j<ncv_; j++) {
+    expansion+=ECVs_[j][index_k_[i][j]];  //the index_k could be trivially guessed for most ECVs, but unfourtunately not all
+  }
   return expansion;
 }
 
diff --git a/src/opes/OPESmetad.cpp b/src/opes/OPESmetad.cpp
index 2e9aa7555d..30d1844c62 100644
--- a/src/opes/OPESmetad.cpp
+++ b/src/opes/OPESmetad.cpp
@@ -199,8 +199,7 @@ class OPESmetad : public bias::Bias {
   double threshold2_;
   bool recursive_merge_;
 //kernels are truncated diagonal Gaussians
-  struct kernel
-  {
+  struct kernel {
     double height;
     std::vector<double> center;
     std::vector<double> sigma;
@@ -250,7 +249,9 @@ class OPESmetad : public bias::Bias {
   static void registerKeywords(Keywords& keys);
 };
 
-struct convergence { static const bool explore=false; };
+struct convergence {
+  static const bool explore=false;
+};
 typedef OPESmetad<convergence> OPESmetad_c;
 PLUMED_REGISTER_ACTION(OPESmetad_c,"OPES_METAD")
 
@@ -294,20 +295,22 @@ PRINT STRIDE=100 FILE=COLVAR ARG=cv,opes.*
 */
 //+ENDPLUMEDOC
 
-struct exploration { static const bool explore=true; };
+struct exploration {
+  static const bool explore=true;
+};
 typedef OPESmetad<exploration> OPESmetad_e;
 PLUMED_REGISTER_ACTION(OPESmetad_e,"OPES_METAD_EXPLORE")
 
 template <class mode>
-void OPESmetad<mode>::registerKeywords(Keywords& keys)
-{
+void OPESmetad<mode>::registerKeywords(Keywords& keys) {
   Bias::registerKeywords(keys);
   keys.use("ARG");
   keys.add("compulsory","TEMP","-1","temperature. If not set, it is taken from MD engine, but not all MD codes provide it");
   keys.add("compulsory","PACE","the frequency for kernel deposition");
   std::string info_sigma("the initial widths of the kernels");
-  if(mode::explore)
+  if(mode::explore) {
     info_sigma+=", divided by the square root of gamma";
+  }
   info_sigma+=". If not set, an adaptive sigma will be used with the given ADAPTIVE_SIGMA_STRIDE";
   keys.add("compulsory","SIGMA","ADAPTIVE",info_sigma);
   keys.add("compulsory","BARRIER","the free energy barrier to be overcome. It is used to set BIASFACTOR, EPSILON, and KERNEL_CUTOFF to reasonable values");
@@ -316,10 +319,11 @@ void OPESmetad<mode>::registerKeywords(Keywords& keys)
   keys.add("optional","ADAPTIVE_SIGMA_STRIDE","number of steps for measuring adaptive sigma. Default is 10xPACE");
   keys.add("optional","SIGMA_MIN","never reduce SIGMA below this value");
   std::string info_biasfactor("the gamma bias factor used for the well-tempered target distribution. ");
-  if(mode::explore)
+  if(mode::explore) {
     info_biasfactor+="Cannot be 'inf'";
-  else
+  } else {
     info_biasfactor+="Set to 'inf' for uniform flat target";
+  }
   keys.add("optional","BIASFACTOR",info_biasfactor);
   keys.add("optional","EPSILON","the value of the regularization constant for the probability");
   keys.add("optional","KERNEL_CUTOFF","truncate kernels at this distance, in units of sigma");
@@ -338,8 +342,9 @@ void OPESmetad<mode>::registerKeywords(Keywords& keys)
   keys.addFlag("STORE_STATES",false,"append to STATE_WFILE instead of ovewriting it each time");
 //miscellaneous
   keys.add("optional","EXCLUDED_REGION","kernels are not deposited when the action provided here has a nonzero value, see example above");
-  if(!mode::explore)
+  if(!mode::explore) {
     keys.add("optional","EXTRA_BIAS","consider also these other bias potentials for the internal reweighting. This can be used e.g. for sampling a custom target distribution (see example above)");
+  }
   keys.addFlag("CALC_WORK",false,"calculate the total accumulated work done by the bias since last restart");
   keys.addFlag("WALKERS_MPI",false,"switch on MPI version of multiple walkers");
   keys.addFlag("SERIAL",false,"perform calculations in serial");
@@ -365,8 +370,7 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
   , ncv_(getNumberOfArguments())
   , Zed_(1)
   , work_(0)
-  , excluded_region_(NULL)
-{
+  , excluded_region_(NULL) {
   std::string error_in_input1("Error in input in action "+getName()+" with label "+getLabel()+": the keyword ");
   std::string error_in_input2(" could not be read correctly");
 
@@ -384,20 +388,17 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
   biasfactor_=barrier/kbt_;
   std::string biasfactor_str;
   parse("BIASFACTOR",biasfactor_str);
-  if(biasfactor_str=="inf" || biasfactor_str=="INF")
-  {
+  if(biasfactor_str=="inf" || biasfactor_str=="INF") {
     biasfactor_=std::numeric_limits<double>::infinity();
     bias_prefactor_=1;
-  }
-  else
-  {
-    if(biasfactor_str.length()>0)
+  } else {
+    if(biasfactor_str.length()>0) {
       plumed_massert(Tools::convertNoexcept(biasfactor_str,biasfactor_),error_in_input1+"BIASFACTOR"+error_in_input2);
+    }
     plumed_massert(biasfactor_>1,"BIASFACTOR must be greater than one (use 'inf' for uniform target)");
     bias_prefactor_=1-1./biasfactor_;
   }
-  if(mode::explore)
-  {
+  if(mode::explore) {
     plumed_massert(!std::isinf(biasfactor_),"BIASFACTOR=inf is not compatible with EXPLORE mode");
     bias_prefactor_=biasfactor_-1;
   }
@@ -409,35 +410,33 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
   parseVector("SIGMA",sigma_str);
   sigma0_.resize(ncv_);
   double dummy;
-  if(sigma_str.size()==1 && !Tools::convertNoexcept(sigma_str[0],dummy))
-  {
+  if(sigma_str.size()==1 && !Tools::convertNoexcept(sigma_str[0],dummy)) {
     plumed_massert(sigma_str[0]=="ADAPTIVE" || sigma_str[0]=="adaptive",error_in_input1+"SIGMA"+error_in_input2);
     plumed_massert(!std::isinf(biasfactor_),"cannot use BIASFACTOR=inf with adaptive SIGMA");
     adaptive_counter_=0;
-    if(adaptive_sigma_stride_==0)
-      adaptive_sigma_stride_=10*stride_; //NB: this is arbitrary, chosen from few tests
+    if(adaptive_sigma_stride_==0) {
+      adaptive_sigma_stride_=10*stride_;  //NB: this is arbitrary, chosen from few tests
+    }
     av_cv_.resize(ncv_,0);
     av_M2_.resize(ncv_,0);
     plumed_massert(adaptive_sigma_stride_>=stride_,"better to chose ADAPTIVE_SIGMA_STRIDE > PACE");
     adaptive_sigma_=true;
-  }
-  else
-  {
+  } else {
     plumed_massert(sigma_str.size()==ncv_,"number of SIGMA parameters does not match number of arguments");
     plumed_massert(adaptive_sigma_stride_==0,"if SIGMA is not ADAPTIVE you cannot set an ADAPTIVE_SIGMA_STRIDE");
-    for(unsigned i=0; i<ncv_; i++)
-    {
+    for(unsigned i=0; i<ncv_; i++) {
       plumed_massert(Tools::convertNoexcept(sigma_str[i],sigma0_[i]),error_in_input1+"SIGMA"+error_in_input2);
-      if(mode::explore)
-        sigma0_[i]*=std::sqrt(biasfactor_); //the sigma of the target is broader Ftg(s)=1/gamma*F(s)
+      if(mode::explore) {
+        sigma0_[i]*=std::sqrt(biasfactor_);  //the sigma of the target is broader Ftg(s)=1/gamma*F(s)
+      }
     }
   }
   parseVector("SIGMA_MIN",sigma_min_);
   plumed_massert(sigma_min_.size()==0 || sigma_min_.size()==ncv_,"number of SIGMA_MIN does not match number of arguments");
-  if(sigma_min_.size()>0 && !adaptive_sigma_)
-  {
-    for(unsigned i=0; i<ncv_; i++)
+  if(sigma_min_.size()>0 && !adaptive_sigma_) {
+    for(unsigned i=0; i<ncv_; i++) {
       plumed_massert(sigma_min_[i]<=sigma0_[i],"SIGMA_MIN should be smaller than SIGMA");
+    }
   }
 
   epsilon_=std::exp(-barrier/bias_prefactor_/kbt_);
@@ -447,8 +446,9 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
   sum_weights2_=sum_weights_*sum_weights_;
 
   double cutoff=sqrt(2.*barrier/bias_prefactor_/kbt_);
-  if(mode::explore)
-    cutoff=sqrt(2.*barrier/kbt_); //otherwise it is too small
+  if(mode::explore) {
+    cutoff=sqrt(2.*barrier/kbt_);  //otherwise it is too small
+  }
   parse("KERNEL_CUTOFF",cutoff);
   plumed_massert(cutoff>0,"you must choose a value for KERNEL_CUTOFF greater than zero");
   cutoff2_=cutoff*cutoff;
@@ -457,25 +457,24 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
   threshold2_=1;
   parse("COMPRESSION_THRESHOLD",threshold2_);
   threshold2_*=threshold2_;
-  if(threshold2_!=0)
+  if(threshold2_!=0) {
     plumed_massert(threshold2_>0 && threshold2_<cutoff2_,"COMPRESSION_THRESHOLD cannot be bigger than the KERNEL_CUTOFF");
+  }
 
 //setup neighbor list
   nlist_=false;
   parseFlag("NLIST",nlist_);
   nlist_pace_reset_=false;
   parseFlag("NLIST_PACE_RESET",nlist_pace_reset_);
-  if(nlist_pace_reset_)
+  if(nlist_pace_reset_) {
     nlist_=true;
+  }
   std::vector<double> nlist_param;
   parseVector("NLIST_PARAMETERS",nlist_param);
-  if(nlist_param.size()==0)
-  {
+  if(nlist_param.size()==0) {
     nlist_param_[0]=3.0;//*cutoff2_ -> max distance of neighbors
     nlist_param_[1]=0.5;//*nlist_dev2_[i] -> condition for rebuilding
-  }
-  else
-  {
+  } else {
     nlist_=true;
     plumed_massert(nlist_param.size()==2,"two cutoff parameters are needed for the neighbor list");
     plumed_massert(nlist_param[0]>1.0,"the first of NLIST_PARAMETERS must be greater than 1. The smaller the first, the smaller should be the second as well");
@@ -493,8 +492,8 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
 //optional stuff
   no_Zed_=false;
   parseFlag("NO_ZED",no_Zed_);
-  if(no_Zed_)
-  { //this makes it more gentle in the initial phase
+  if(no_Zed_) {
+    //this makes it more gentle in the initial phase
     sum_weights_=1;
     sum_weights2_=1;
   }
@@ -508,17 +507,16 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
 //options involving extra arguments
   std::vector<Value*> args;
   parseArgumentList("EXCLUDED_REGION",args);
-  if(args.size()>0)
-  {
+  if(args.size()>0) {
     plumed_massert(args.size()==1,"only one characteristic function should define the region to be excluded");
     requestExtraDependencies(args);
     excluded_region_=args[0];
   }
-  if(!mode::explore)
-  {
+  if(!mode::explore) {
     parseArgumentList("EXTRA_BIAS",extra_biases_);
-    if(extra_biases_.size()>0)
+    if(extra_biases_.size()>0) {
       requestExtraDependencies(extra_biases_);
+    }
   }
 
 //kernels file
@@ -536,32 +534,31 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
   parse("STATE_WSTRIDE",wStateStride_);
   storeOldStates_=false;
   parseFlag("STORE_STATES",storeOldStates_);
-  if(wStateStride_!=0 || storeOldStates_)
+  if(wStateStride_!=0 || storeOldStates_) {
     plumed_massert(stateFileName.length()>0,"filename for storing simulation status not specified, use STATE_WFILE");
-  if(wStateStride_>0)
+  }
+  if(wStateStride_>0) {
     plumed_massert(wStateStride_>=(int)stride_,"STATE_WSTRIDE is in units of MD steps, thus it is suggested to use a multiple of PACE");
-  if(stateFileName.length()>0 && wStateStride_==0)
-    wStateStride_=-1;//will print only on CPT events (checkpoints set by some MD engines, like gromacs)
+  }
+  if(stateFileName.length()>0 && wStateStride_==0) {
+    wStateStride_=-1;  //will print only on CPT events (checkpoints set by some MD engines, like gromacs)
+  }
 
 //multiple walkers //TODO implement also external mw for cp2k
   bool walkers_mpi=false;
   parseFlag("WALKERS_MPI",walkers_mpi);
-  if(walkers_mpi)
-  {
+  if(walkers_mpi) {
     //If this Action is not compiled with MPI the user is informed and we exit gracefully
     plumed_massert(Communicator::plumedHasMPI(),"Invalid walkers configuration: WALKERS_MPI flag requires MPI compilation");
     plumed_massert(Communicator::initialized(),"Invalid walkers configuration: WALKERS_MPI needs the communicator correctly initialized.");
 
-    if(comm.Get_rank()==0)//multi_sim_comm works on first rank only
-    {
+    if(comm.Get_rank()==0) { //multi_sim_comm works on first rank only
       NumWalkers_=multi_sim_comm.Get_size();
       walker_rank_=multi_sim_comm.Get_rank();
     }
     comm.Bcast(NumWalkers_,0); //if each walker has more than one processor update them all
     comm.Bcast(walker_rank_,0);
-  }
-  else
-  {
+  } else {
     NumWalkers_=1;
     walker_rank_=0;
   }
@@ -572,8 +569,7 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
   rank_=comm.Get_rank();
   bool serial=false;
   parseFlag("SERIAL",serial);
-  if(serial)
-  {
+  if(serial) {
     NumOMP_=1;
     NumParallel_=1;
     rank_=0;
@@ -583,31 +579,25 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
 
 //restart if needed
   bool convertKernelsToState=false;
-  if(getRestart())
-  {
+  if(getRestart()) {
     bool stateRestart=true;
-    if(restartFileName.length()==0)
-    {
+    if(restartFileName.length()==0) {
       stateRestart=false;
       restartFileName=kernelsFileName;
     }
     IFile ifile;
     ifile.link(*this);
-    if(ifile.FileExist(restartFileName))
-    {
+    if(ifile.FileExist(restartFileName)) {
       bool tmp_nlist=nlist_;
       nlist_=false; // NLIST is not needed while restarting
       ifile.open(restartFileName);
       log.printf("  RESTART - make sure all used options are compatible\n");
       log.printf("    restarting from: %s\n",restartFileName.c_str());
       std::string action_name=getName();
-      if(stateRestart)
-      {
+      if(stateRestart) {
         log.printf("    it should be a STATE file (not a KERNELS file)\n");
         action_name+="_state";
-      }
-      else
-      {
+      } else {
         log.printf(" +++ WARNING +++ RESTART from KERNELS might be approximate, use STATE_WFILE and STATE_RFILE to restart from the exact state\n");
         action_name+="_kernels";
       }
@@ -616,61 +606,55 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
       plumed_massert(action_name==old_action_name,"RESTART - mismatch between old and new action name. Expected '"+action_name+"', but found '"+old_action_name+"'");
       std::string old_biasfactor_str;
       ifile.scanField("biasfactor",old_biasfactor_str);
-      if(old_biasfactor_str=="inf" || old_biasfactor_str=="INF")
-      {
-        if(!std::isinf(biasfactor_))
+      if(old_biasfactor_str=="inf" || old_biasfactor_str=="INF") {
+        if(!std::isinf(biasfactor_)) {
           log.printf(" +++ WARNING +++ previous bias factor was inf while now it is %g\n",biasfactor_);
-      }
-      else
-      {
+        }
+      } else {
         double old_biasfactor;
         ifile.scanField("biasfactor",old_biasfactor);
-        if(std::abs(biasfactor_-old_biasfactor)>1e-6*biasfactor_)
+        if(std::abs(biasfactor_-old_biasfactor)>1e-6*biasfactor_) {
           log.printf(" +++ WARNING +++ previous bias factor was %g while now it is %g. diff = %g\n",old_biasfactor,biasfactor_,biasfactor_-old_biasfactor);
+        }
       }
       double old_epsilon;
       ifile.scanField("epsilon",old_epsilon);
-      if(std::abs(epsilon_-old_epsilon)>1e-6*epsilon_)
+      if(std::abs(epsilon_-old_epsilon)>1e-6*epsilon_) {
         log.printf(" +++ WARNING +++ previous epsilon was %g while now it is %g. diff = %g\n",old_epsilon,epsilon_,epsilon_-old_epsilon);
+      }
       double old_cutoff;
       ifile.scanField("kernel_cutoff",old_cutoff);
-      if(std::abs(cutoff-old_cutoff)>1e-6*cutoff)
+      if(std::abs(cutoff-old_cutoff)>1e-6*cutoff) {
         log.printf(" +++ WARNING +++ previous kernel_cutoff was %g while now it is %g. diff = %g\n",old_cutoff,cutoff,cutoff-old_cutoff);
+      }
       double old_threshold;
       const double threshold=sqrt(threshold2_);
       ifile.scanField("compression_threshold",old_threshold);
-      if(std::abs(threshold-old_threshold)>1e-6*threshold)
+      if(std::abs(threshold-old_threshold)>1e-6*threshold) {
         log.printf(" +++ WARNING +++ previous compression_threshold was %g while now it is %g. diff = %g\n",old_threshold,threshold,threshold-old_threshold);
-      if(stateRestart)
-      {
+      }
+      if(stateRestart) {
         ifile.scanField("zed",Zed_);
         ifile.scanField("sum_weights",sum_weights_);
         ifile.scanField("sum_weights2",sum_weights2_);
         ifile.scanField("counter",counter_);
-        if(adaptive_sigma_)
-        {
+        if(adaptive_sigma_) {
           ifile.scanField("adaptive_counter",adaptive_counter_);
-          if(NumWalkers_==1)
-          {
-            for(unsigned i=0; i<ncv_; i++)
-            {
+          if(NumWalkers_==1) {
+            for(unsigned i=0; i<ncv_; i++) {
               ifile.scanField("sigma0_"+getPntrToArgument(i)->getName(),sigma0_[i]);
               ifile.scanField("av_cv_"+getPntrToArgument(i)->getName(),av_cv_[i]);
               ifile.scanField("av_M2_"+getPntrToArgument(i)->getName(),av_M2_[i]);
             }
-          }
-          else
-          {
+          } else {
             for(unsigned w=0; w<NumWalkers_; w++)
-              for(unsigned i=0; i<ncv_; i++)
-              {
+              for(unsigned i=0; i<ncv_; i++) {
                 double tmp0,tmp1,tmp2;
                 const std::string arg_iw=getPntrToArgument(i)->getName()+"_"+std::to_string(w);
                 ifile.scanField("sigma0_"+arg_iw,tmp0);
                 ifile.scanField("av_cv_"+arg_iw,tmp1);
                 ifile.scanField("av_M2_"+arg_iw,tmp2);
-                if(w==walker_rank_)
-                {
+                if(w==walker_rank_) {
                   sigma0_[i]=tmp0;
                   av_cv_[i]=tmp1;
                   av_M2_[i]=tmp2;
@@ -679,10 +663,8 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
           }
         }
       }
-      for(unsigned i=0; i<ncv_; i++)
-      {
-        if(getPntrToArgument(i)->isPeriodic())
-        {
+      for(unsigned i=0; i<ncv_; i++) {
+        if(getPntrToArgument(i)->isPeriodic()) {
           std::string arg_min,arg_max;
           getPntrToArgument(i)->getDomain(arg_min,arg_max);
           std::string file_min,file_max;
@@ -692,40 +674,40 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
           plumed_massert(file_max==arg_max,"RESTART - mismatch between old and new ARG periodicity");
         }
       }
-      if(stateRestart)
-      {
+      if(stateRestart) {
         double time;
-        while(ifile.scanField("time",time))
-        {
+        while(ifile.scanField("time",time)) {
           std::vector<double> center(ncv_);
           std::vector<double> sigma(ncv_);
           double height;
-          for(unsigned i=0; i<ncv_; i++)
+          for(unsigned i=0; i<ncv_; i++) {
             ifile.scanField(getPntrToArgument(i)->getName(),center[i]);
-          for(unsigned i=0; i<ncv_; i++)
+          }
+          for(unsigned i=0; i<ncv_; i++) {
             ifile.scanField("sigma_"+getPntrToArgument(i)->getName(),sigma[i]);
+          }
           ifile.scanField("height",height);
           ifile.scanField();
           kernels_.emplace_back(height,center,sigma);
         }
         log.printf("    a total of %lu kernels where read\n",kernels_.size());
-      }
-      else
-      {
+      } else {
         ifile.allowIgnoredFields(); //this allows for multiple restart, but without checking for consistency between them!
         double time;
-        while(ifile.scanField("time",time))
-        {
+        while(ifile.scanField("time",time)) {
           std::vector<double> center(ncv_);
           std::vector<double> sigma(ncv_);
           double height;
           double logweight;
-          for(unsigned i=0; i<ncv_; i++)
+          for(unsigned i=0; i<ncv_; i++) {
             ifile.scanField(getPntrToArgument(i)->getName(),center[i]);
-          for(unsigned i=0; i<ncv_; i++)
+          }
+          for(unsigned i=0; i<ncv_; i++) {
             ifile.scanField("sigma_"+getPntrToArgument(i)->getName(),sigma[i]);
-          if(counter_==(1+walker_rank_) && adaptive_sigma_)
+          }
+          if(counter_==(1+walker_rank_) && adaptive_sigma_) {
             sigma0_=sigma;
+          }
           ifile.scanField("height",height);
           ifile.scanField("logweight",logweight);
           ifile.scanField();
@@ -736,14 +718,15 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
           counter_++;
         }
         KDEnorm_=mode::explore?counter_:sum_weights_;
-        if(!no_Zed_)
-        {
+        if(!no_Zed_) {
           double sum_uprob=0;
           for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_)
-            for(unsigned kk=0; kk<kernels_.size(); kk++)
+            for(unsigned kk=0; kk<kernels_.size(); kk++) {
               sum_uprob+=evaluateKernel(kernels_[kk],kernels_[k].center);
-          if(NumParallel_>1)
+            }
+          if(NumParallel_>1) {
             comm.Sum(sum_uprob);
+          }
           Zed_=sum_uprob/KDEnorm_/kernels_.size();
         }
         log.printf("    a total of %llu kernels where read, and compressed to %lu\n",counter_-1,kernels_.size());
@@ -752,42 +735,45 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
       ifile.reset(false);
       ifile.close();
       nlist_=tmp_nlist;
-    }
-    else //same behaviour as METAD
+    } else { //same behaviour as METAD
       plumed_merror("RESTART requested, but file '"+restartFileName+"' was not found!\n  Set RESTART=NO or provide a restart file");
-    if(NumWalkers_>1) //make sure that all walkers are doing the same thing
-    {
+    }
+    if(NumWalkers_>1) { //make sure that all walkers are doing the same thing
       const unsigned kernels_size=kernels_.size();
       std::vector<unsigned> all_kernels_size(NumWalkers_);
-      if(comm.Get_rank()==0)
+      if(comm.Get_rank()==0) {
         multi_sim_comm.Allgather(kernels_size,all_kernels_size);
+      }
       comm.Bcast(all_kernels_size,0);
       bool same_number_of_kernels=true;
       for(unsigned w=1; w<NumWalkers_; w++)
-        if(all_kernels_size[0]!=all_kernels_size[w])
+        if(all_kernels_size[0]!=all_kernels_size[w]) {
           same_number_of_kernels=false;
+        }
       plumed_massert(same_number_of_kernels,"RESTART - not all walkers are reading the same file!");
     }
-  }
-  else if(restartFileName.length()>0)
+  } else if(restartFileName.length()>0) {
     log.printf(" +++ WARNING +++ the provided STATE_RFILE will be ignored, since RESTART was not requested\n");
+  }
 
 //sync all walkers to avoid opening files before reading is over (see also METAD)
   comm.Barrier();
-  if(comm.Get_rank()==0 && walkers_mpi)
+  if(comm.Get_rank()==0 && walkers_mpi) {
     multi_sim_comm.Barrier();
+  }
 
 //setup output kernels file
   kernelsOfile_.link(*this);
-  if(NumWalkers_>1)
-  {
-    if(walker_rank_>0)
-      kernelsFileName="/dev/null"; //only first walker writes on file
+  if(NumWalkers_>1) {
+    if(walker_rank_>0) {
+      kernelsFileName="/dev/null";  //only first walker writes on file
+    }
     kernelsOfile_.enforceSuffix("");
   }
   kernelsOfile_.open(kernelsFileName);
-  if(fmt.length()>0)
+  if(fmt.length()>0) {
     kernelsOfile_.fmtField(" "+fmt);
+  }
   kernelsOfile_.setHeavyFlush(); //do I need it?
   //define and set const fields
   kernelsOfile_.addConstantField("action");
@@ -795,8 +781,9 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
   kernelsOfile_.addConstantField("epsilon");
   kernelsOfile_.addConstantField("kernel_cutoff");
   kernelsOfile_.addConstantField("compression_threshold");
-  for(unsigned i=0; i<ncv_; i++)
+  for(unsigned i=0; i<ncv_; i++) {
     kernelsOfile_.setupPrintValue(getPntrToArgument(i));
+  }
   kernelsOfile_.printField("action",getName()+"_kernels");
   kernelsOfile_.printField("biasfactor",biasfactor_);
   kernelsOfile_.printField("epsilon",epsilon_);
@@ -804,20 +791,21 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
   kernelsOfile_.printField("compression_threshold",sqrt(threshold2_));
 
 //open file for storing state
-  if(wStateStride_!=0)
-  {
+  if(wStateStride_!=0) {
     stateOfile_.link(*this);
-    if(NumWalkers_>1)
-    {
-      if(walker_rank_>0)
-        stateFileName="/dev/null"; //only first walker writes on file
+    if(NumWalkers_>1) {
+      if(walker_rank_>0) {
+        stateFileName="/dev/null";  //only first walker writes on file
+      }
       stateOfile_.enforceSuffix("");
     }
     stateOfile_.open(stateFileName);
-    if(fmt.length()>0)
+    if(fmt.length()>0) {
       stateOfile_.fmtField(" "+fmt);
-    if(convertKernelsToState)
+    }
+    if(convertKernelsToState) {
       dumpStateToFile();
+    }
   }
 
 //set initial old values
@@ -837,13 +825,11 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
   addComponent("nker");
   componentIsNotPeriodic("nker");
   getPntrToComponent("nker")->set(kernels_.size());
-  if(calc_work_)
-  {
+  if(calc_work_) {
     addComponent("work");
     componentIsNotPeriodic("work");
   }
-  if(nlist_)
-  {
+  if(nlist_) {
     addComponent("nlker");
     componentIsNotPeriodic("nlker");
     addComponent("nlsteps");
@@ -856,116 +842,129 @@ OPESmetad<mode>::OPESmetad(const ActionOptions& ao)
   log.printf("  depositing new kernels with PACE = %u\n",stride_);
   log.printf("  expected BARRIER is %g\n",barrier);
   log.printf("  using target distribution with BIASFACTOR gamma = %g\n",biasfactor_);
-  if(std::isinf(biasfactor_))
+  if(std::isinf(biasfactor_)) {
     log.printf("    (thus a uniform flat target distribution, no well-tempering)\n");
-  if(excluded_region_!=NULL)
+  }
+  if(excluded_region_!=NULL) {
     log.printf(" -- EXCLUDED_REGION: kernels will be deposited only when '%s' is equal to zero\n",excluded_region_->getName().c_str());
-  if(extra_biases_.size()>0)
-  {
+  }
+  if(extra_biases_.size()>0) {
     log.printf(" -- EXTRA_BIAS: ");
-    for(unsigned e=0; e<extra_biases_.size(); e++)
+    for(unsigned e=0; e<extra_biases_.size(); e++) {
       log.printf("%s ",extra_biases_[e]->getName().c_str());
+    }
     log.printf("will be reweighted\n");
   }
-  if(adaptive_sigma_)
-  {
+  if(adaptive_sigma_) {
     log.printf("  adaptive SIGMA will be used, with ADAPTIVE_SIGMA_STRIDE = %u\n",adaptive_sigma_stride_);
     unsigned x=std::ceil(adaptive_sigma_stride_/stride_);
     log.printf("    thus the first x kernel depositions will be skipped, x = ADAPTIVE_SIGMA_STRIDE/PACE = %u\n",x);
-  }
-  else
-  {
+  } else {
     log.printf("  kernels have initial SIGMA = ");
-    for(unsigned i=0; i<ncv_; i++)
+    for(unsigned i=0; i<ncv_; i++) {
       log.printf(" %g",sigma0_[i]);
+    }
     log.printf("\n");
   }
-  if(sigma_min_.size()>0)
-  {
+  if(sigma_min_.size()>0) {
     log.printf("  kernels have a SIGMA_MIN = ");
-    for(unsigned i=0; i<ncv_; i++)
+    for(unsigned i=0; i<ncv_; i++) {
       log.printf(" %g",sigma_min_[i]);
+    }
     log.printf("\n");
   }
-  if(fixed_sigma_)
+  if(fixed_sigma_) {
     log.printf(" -- FIXED_SIGMA: sigma will not decrease as the simulation proceeds\n");
+  }
   log.printf("  kernels are truncated with KERNELS_CUTOFF = %g\n",cutoff);
-  if(cutoff<3.5)
+  if(cutoff<3.5) {
     log.printf(" +++ WARNING +++ probably kernels are truncated too much\n");
+  }
   log.printf("  the value at cutoff is = %g\n",val_at_cutoff_);
   log.printf("  regularization EPSILON = %g\n",epsilon_);
-  if(val_at_cutoff_>epsilon_*(1+1e-6))
+  if(val_at_cutoff_>epsilon_*(1+1e-6)) {
     log.printf(" +++ WARNING +++ the KERNEL_CUTOFF might be too small for the given EPSILON\n");
+  }
   log.printf("  kernels will be compressed when closer than COMPRESSION_THRESHOLD = %g\n",sqrt(threshold2_));
-  if(threshold2_==0)
+  if(threshold2_==0) {
     log.printf(" +++ WARNING +++ kernels will never merge, expect slowdowns\n");
-  if(!recursive_merge_)
+  }
+  if(!recursive_merge_) {
     log.printf(" -- RECURSIVE_MERGE_OFF: only one merge for each new kernel will be attempted. This is faster only if total number of kernels does not grow too much\n");
-  if(nlist_)
+  }
+  if(nlist_) {
     log.printf(" -- NLIST: using neighbor list for kernels, with parameters: %g,%g\n",nlist_param_[0],nlist_param_[1]);
-  if(nlist_pace_reset_)
+  }
+  if(nlist_pace_reset_) {
     log.printf(" -- NLIST_PACE_RESET: forcing the neighbor list to update every PACE\n");
-  if(no_Zed_)
+  }
+  if(no_Zed_) {
     log.printf(" -- NO_ZED: using fixed normalization factor = %g\n",Zed_);
-  if(wStateStride_>0)
+  }
+  if(wStateStride_>0) {
     log.printf("  state checkpoints are written on file %s every %d MD steps\n",stateFileName.c_str(),wStateStride_);
-  if(wStateStride_==-1)
+  }
+  if(wStateStride_==-1) {
     log.printf("  state checkpoints are written on file %s only on CPT events (or never if MD code does define them!)\n",stateFileName.c_str());
-  if(walkers_mpi)
+  }
+  if(walkers_mpi) {
     log.printf(" -- WALKERS_MPI: if multiple replicas are present, they will share the same bias via MPI\n");
-  if(NumWalkers_>1)
-  {
+  }
+  if(NumWalkers_>1) {
     log.printf("  using multiple walkers\n");
     log.printf("    number of walkers: %u\n",NumWalkers_);
     log.printf("    walker rank: %u\n",walker_rank_);
   }
   int mw_warning=0;
-  if(!walkers_mpi && comm.Get_rank()==0 && multi_sim_comm.Get_size()>(int)NumWalkers_)
+  if(!walkers_mpi && comm.Get_rank()==0 && multi_sim_comm.Get_size()>(int)NumWalkers_) {
     mw_warning=1;
+  }
   comm.Bcast(mw_warning,0);
-  if(mw_warning) //log.printf messes up with comm, so never use it without Bcast!
+  if(mw_warning) { //log.printf messes up with comm, so never use it without Bcast!
     log.printf(" +++ WARNING +++ multiple replicas will NOT communicate unless the flag WALKERS_MPI is used\n");
-  if(NumParallel_>1)
+  }
+  if(NumParallel_>1) {
     log.printf("  using multiple MPI processes per simulation: %u\n",NumParallel_);
-  if(NumOMP_>1)
+  }
+  if(NumOMP_>1) {
     log.printf("  using multiple OpenMP threads per simulation: %u\n",NumOMP_);
-  if(serial)
+  }
+  if(serial) {
     log.printf(" -- SERIAL: no loop parallelization, despite %d MPI processes and %u OpenMP threads available\n",comm.Get_size(),OpenMP::getNumThreads());
+  }
   log.printf("  Bibliography: ");
   log<<plumed.cite("M. Invernizzi and M. Parrinello, J. Phys. Chem. Lett. 11, 2731-2736 (2020)");
-  if(mode::explore || adaptive_sigma_)
+  if(mode::explore || adaptive_sigma_) {
     log<<plumed.cite("M. Invernizzi and M. Parrinello, J. Chem. Theory Comput. 18, 3988-3996 (2022)");
+  }
   log.printf("\n");
 }
 
 template <class mode>
-void OPESmetad<mode>::calculate()
-{
+void OPESmetad<mode>::calculate() {
 //get cv
   std::vector<double> cv(ncv_);
-  for(unsigned i=0; i<ncv_; i++)
+  for(unsigned i=0; i<ncv_; i++) {
     cv[i]=getArgument(i);
+  }
 
 //check neighbor list
-  if(nlist_)
-  {
+  if(nlist_) {
     nlist_steps_++;
-    if(getExchangeStep())
+    if(getExchangeStep()) {
       nlist_update_=true;
-    else
-    {
-      for(unsigned i=0; i<ncv_; i++)
-      {
+    } else {
+      for(unsigned i=0; i<ncv_; i++) {
         const double diff_i=difference(i,cv[i],nlist_center_[i]);
-        if(diff_i*diff_i>nlist_param_[1]*nlist_dev2_[i])
-        {
+        if(diff_i*diff_i>nlist_param_[1]*nlist_dev2_[i]) {
           nlist_update_=true;
           break;
         }
       }
     }
-    if(nlist_update_)
+    if(nlist_update_) {
       updateNlist(cv);
+    }
   }
 
 //set bias and forces
@@ -973,57 +972,55 @@ void OPESmetad<mode>::calculate()
   const double prob=getProbAndDerivatives(cv,der_prob);
   const double bias=kbt_*bias_prefactor_*std::log(prob/Zed_+epsilon_);
   setBias(bias);
-  for(unsigned i=0; i<ncv_; i++)
+  for(unsigned i=0; i<ncv_; i++) {
     setOutputForce(i,-kbt_*bias_prefactor_/(prob/Zed_+epsilon_)*der_prob[i]/Zed_);
+  }
 }
 
 template <class mode>
-void OPESmetad<mode>::update()
-{
-  if(isFirstStep_)//same in MetaD, useful for restarts?
-  {
+void OPESmetad<mode>::update() {
+  if(isFirstStep_) { //same in MetaD, useful for restarts?
     isFirstStep_=false;
     return;
   }
 
 //update variance if adaptive sigma
-  if(adaptive_sigma_)
-  {
+  if(adaptive_sigma_) {
     adaptive_counter_++;
     unsigned tau=adaptive_sigma_stride_;
-    if(adaptive_counter_<adaptive_sigma_stride_)
+    if(adaptive_counter_<adaptive_sigma_stride_) {
       tau=adaptive_counter_;
-    for(unsigned i=0; i<ncv_; i++)
-    { //Welford's online algorithm for standard deviation
+    }
+    for(unsigned i=0; i<ncv_; i++) {
+      //Welford's online algorithm for standard deviation
       const double cv_i=getArgument(i);
       const double diff_i=difference(i,av_cv_[i],cv_i);
       av_cv_[i]+=diff_i/tau; //exponentially decaying average
       av_M2_[i]+=diff_i*difference(i,av_cv_[i],cv_i);
     }
-    if(adaptive_counter_<adaptive_sigma_stride_ && counter_==1) //counter_>1 if restarting
-      return; //do not apply bias before having measured sigma
+    if(adaptive_counter_<adaptive_sigma_stride_ && counter_==1) { //counter_>1 if restarting
+      return;  //do not apply bias before having measured sigma
+    }
   }
 
 //do update
-  if(getStep()%stride_==0 && (excluded_region_==NULL || excluded_region_->get()==0))
-  {
+  if(getStep()%stride_==0 && (excluded_region_==NULL || excluded_region_->get()==0)) {
     old_KDEnorm_=KDEnorm_;
     delta_kernels_.clear();
     unsigned old_nker=kernels_.size();
 
     //get new kernel height
     double log_weight=getOutputQuantity(0)/kbt_; //first value is always the current bias
-    for(unsigned e=0; e<extra_biases_.size(); e++)
-      log_weight+=extra_biases_[e]->get()/kbt_; //extra biases contribute to the weight
+    for(unsigned e=0; e<extra_biases_.size(); e++) {
+      log_weight+=extra_biases_[e]->get()/kbt_;  //extra biases contribute to the weight
+    }
     double height=std::exp(log_weight);
 
     //update sum_weights_ and neff
     double sum_heights=height;
     double sum_heights2=height*height;
-    if(NumWalkers_>1)
-    {
-      if(comm.Get_rank()==0)
-      {
+    if(NumWalkers_>1) {
+      if(comm.Get_rank()==0) {
         multi_sim_comm.Sum(sum_heights);
         multi_sim_comm.Sum(sum_heights2);
       }
@@ -1036,90 +1033,85 @@ void OPESmetad<mode>::update()
     const double neff=std::pow(1+sum_weights_,2)/(1+sum_weights2_); //adding 1 makes it more robust at the start
     getPntrToComponent("rct")->set(kbt_*std::log(sum_weights_/counter_));
     getPntrToComponent("neff")->set(neff);
-    if(mode::explore)
-    {
+    if(mode::explore) {
       KDEnorm_=counter_;
       height=1; //plain KDE, bias reweight does not enter here
-    }
-    else
+    } else {
       KDEnorm_=sum_weights_;
+    }
 
     //if needed, rescale sigma and height
     std::vector<double> sigma=sigma0_;
-    if(adaptive_sigma_)
-    {
+    if(adaptive_sigma_) {
       const double factor=mode::explore?1:biasfactor_;
-      if(counter_==1+NumWalkers_) //first time only
-      {
-        for(unsigned i=0; i<ncv_; i++)
-          av_M2_[i]*=biasfactor_; //from unbiased, thus must be adjusted
-        for(unsigned i=0; i<ncv_; i++)
+      if(counter_==1+NumWalkers_) { //first time only
+        for(unsigned i=0; i<ncv_; i++) {
+          av_M2_[i]*=biasfactor_;  //from unbiased, thus must be adjusted
+        }
+        for(unsigned i=0; i<ncv_; i++) {
           sigma0_[i]=std::sqrt(av_M2_[i]/adaptive_counter_/factor);
-        if(sigma_min_.size()==0)
-        {
-          for(unsigned i=0; i<ncv_; i++)
-            plumed_massert(sigma0_[i]>1e-6,"ADAPTIVE SIGMA is suspiciously small for CV i="+std::to_string(i)+"\nManually provide SIGMA or set a safe SIGMA_MIN to avoid possible issues");
         }
-        else
-        {
-          for(unsigned i=0; i<ncv_; i++)
+        if(sigma_min_.size()==0) {
+          for(unsigned i=0; i<ncv_; i++) {
+            plumed_massert(sigma0_[i]>1e-6,"ADAPTIVE SIGMA is suspiciously small for CV i="+std::to_string(i)+"\nManually provide SIGMA or set a safe SIGMA_MIN to avoid possible issues");
+          }
+        } else {
+          for(unsigned i=0; i<ncv_; i++) {
             sigma0_[i]=std::max(sigma0_[i],sigma_min_[i]);
+          }
         }
       }
-      for(unsigned i=0; i<ncv_; i++)
+      for(unsigned i=0; i<ncv_; i++) {
         sigma[i]=std::sqrt(av_M2_[i]/adaptive_counter_/factor);
-      if(sigma_min_.size()==0)
-      {
-        for(unsigned i=0; i<ncv_; i++)
-        {
-          if(sigma[i]<1e-6)
-          {
+      }
+      if(sigma_min_.size()==0) {
+        for(unsigned i=0; i<ncv_; i++) {
+          if(sigma[i]<1e-6) {
             log.printf("+++ WARNING +++ the ADAPTIVE SIGMA is suspiciously small, you should set a safe SIGMA_MIN. 1e-6 will be used here\n");
             sigma[i]=1e-6;
             sigma_min_.resize(ncv_,1e-6);
           }
         }
-      }
-      else
-      {
-        for(unsigned i=0; i<ncv_; i++)
+      } else {
+        for(unsigned i=0; i<ncv_; i++) {
           sigma[i]=std::max(sigma[i],sigma_min_[i]);
+        }
       }
     }
-    if(!fixed_sigma_)
-    {
+    if(!fixed_sigma_) {
       const double size=mode::explore?counter_:neff; //for EXPLORE neff is not relevant
       const double s_rescaling=std::pow(size*(ncv_+2.)/4.,-1./(4+ncv_));
-      for(unsigned i=0; i<ncv_; i++)
+      for(unsigned i=0; i<ncv_; i++) {
         sigma[i]*=s_rescaling;
-      if(sigma_min_.size()>0)
-      {
-        for(unsigned i=0; i<ncv_; i++)
+      }
+      if(sigma_min_.size()>0) {
+        for(unsigned i=0; i<ncv_; i++) {
           sigma[i]=std::max(sigma[i],sigma_min_[i]);
+        }
       }
     }
     //the height should be divided by sqrt(2*pi)*sigma0_,
     //but this overall factor would be canceled when dividing by Zed
     //thus we skip it altogether, but keep any other sigma rescaling
-    for(unsigned i=0; i<ncv_; i++)
+    for(unsigned i=0; i<ncv_; i++) {
       height*=(sigma0_[i]/sigma[i]);
+    }
 
     //get new kernel center
     std::vector<double> center(ncv_);
-    for(unsigned i=0; i<ncv_; i++)
+    for(unsigned i=0; i<ncv_; i++) {
       center[i]=getArgument(i);
+    }
 
     //add new kernel(s)
-    if(NumWalkers_==1)
+    if(NumWalkers_==1) {
       addKernel(height,center,sigma,log_weight);
-    else
-    {
+    } else {
       std::vector<double> all_height(NumWalkers_,0.0);
       std::vector<double> all_center(NumWalkers_*ncv_,0.0);
       std::vector<double> all_sigma(NumWalkers_*ncv_,0.0);
       std::vector<double> all_logweight(NumWalkers_,0.0);
-      if(comm.Get_rank()==0)
-      {
+      if(comm.Get_rank()==0) {
         multi_sim_comm.Allgather(height,all_height);
         multi_sim_comm.Allgather(center,all_center);
         multi_sim_comm.Allgather(sigma,all_sigma);
@@ -1129,111 +1121,102 @@ void OPESmetad<mode>::update()
       comm.Bcast(all_center,0);
       comm.Bcast(all_sigma,0);
       comm.Bcast(all_logweight,0);
-      if(nlist_)
-      { //gather all the nlist_index_, so merging can be done using it
+      if(nlist_) {
+        //gather all the nlist_index_, so merging can be done using it
         std::vector<int> all_nlist_size(NumWalkers_);
-        if(comm.Get_rank()==0)
-        {
+        if(comm.Get_rank()==0) {
           all_nlist_size[walker_rank_]=nlist_index_.size();
           multi_sim_comm.Sum(all_nlist_size);
         }
         comm.Bcast(all_nlist_size,0);
         unsigned tot_size=0;
-        for(unsigned w=0; w<NumWalkers_; w++)
+        for(unsigned w=0; w<NumWalkers_; w++) {
           tot_size+=all_nlist_size[w];
-        if(tot_size>0)
-        {
+        }
+        if(tot_size>0) {
           std::vector<int> disp(NumWalkers_);
-          for(unsigned w=0; w<NumWalkers_-1; w++)
+          for(unsigned w=0; w<NumWalkers_-1; w++) {
             disp[w+1]=disp[w]+all_nlist_size[w];
+          }
           std::vector<unsigned> all_nlist_index(tot_size);
-          if(comm.Get_rank()==0)
+          if(comm.Get_rank()==0) {
             multi_sim_comm.Allgatherv(nlist_index_,all_nlist_index,&all_nlist_size[0],&disp[0]);
+          }
           comm.Bcast(all_nlist_index,0);
           std::set<unsigned> nlist_index_set(all_nlist_index.begin(),all_nlist_index.end()); //remove duplicates and sort
           nlist_index_.assign(nlist_index_set.begin(),nlist_index_set.end());
         }
       }
-      for(unsigned w=0; w<NumWalkers_; w++)
-      {
+      for(unsigned w=0; w<NumWalkers_; w++) {
         std::vector<double> center_w(all_center.begin()+ncv_*w,all_center.begin()+ncv_*(w+1));
         std::vector<double> sigma_w(all_sigma.begin()+ncv_*w,all_sigma.begin()+ncv_*(w+1));
         addKernel(all_height[w],center_w,sigma_w,all_logweight[w]);
       }
     }
     getPntrToComponent("nker")->set(kernels_.size());
-    if(nlist_)
-    {
+    if(nlist_) {
       getPntrToComponent("nlker")->set(nlist_index_.size());
-      if(nlist_pace_reset_)
+      if(nlist_pace_reset_) {
         nlist_update_=true;
+      }
     }
 
     //update Zed_
-    if(!no_Zed_)
-    {
+    if(!no_Zed_) {
       double sum_uprob=0;
       const unsigned ks=kernels_.size();
       const unsigned ds=delta_kernels_.size();
       const bool few_kernels=(ks*ks<(3*ks*ds+2*ds*ds*NumParallel_+100)); //this seems reasonable, but is not rigorous...
-      if(few_kernels) //really needed? Probably is almost always false
-      {
+      if(few_kernels) { //really needed? Probably is almost always false
         #pragma omp parallel num_threads(NumOMP_)
         {
           #pragma omp for reduction(+:sum_uprob) nowait
           for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_)
-            for(unsigned kk=0; kk<kernels_.size(); kk++)
+            for(unsigned kk=0; kk<kernels_.size(); kk++) {
               sum_uprob+=evaluateKernel(kernels_[kk],kernels_[k].center);
+            }
         }
-        if(NumParallel_>1)
+        if(NumParallel_>1) {
           comm.Sum(sum_uprob);
-      }
-      else
-      {
+        }
+      } else {
         // Here instead of redoing the full summation, we add only the changes, knowing that
         // uprob = old_uprob + delta_uprob
         // and we also need to consider that in the new sum there are some novel centers and some disappeared ones
         double delta_sum_uprob=0;
-        if(!nlist_)
-        {
+        if(!nlist_) {
           #pragma omp parallel num_threads(NumOMP_)
           {
             #pragma omp for reduction(+:delta_sum_uprob) nowait
-            for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_)
-            {
-              for(unsigned d=0; d<delta_kernels_.size(); d++)
-              {
+            for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_) {
+              for(unsigned d=0; d<delta_kernels_.size(); d++) {
                 const double sign=delta_kernels_[d].height<0?-1:1; //take away contribution from kernels that are gone, and add the one from new ones
                 delta_sum_uprob+=evaluateKernel(delta_kernels_[d],kernels_[k].center)+sign*evaluateKernel(kernels_[k],delta_kernels_[d].center);
               }
             }
           }
-        }
-        else
-        {
+        } else {
           #pragma omp parallel num_threads(NumOMP_)
           {
             #pragma omp for reduction(+:delta_sum_uprob) nowait
-            for(unsigned nk=rank_; nk<nlist_index_.size(); nk+=NumParallel_)
-            {
+            for(unsigned nk=rank_; nk<nlist_index_.size(); nk+=NumParallel_) {
               const unsigned k=nlist_index_[nk];
-              for(unsigned d=0; d<delta_kernels_.size(); d++)
-              {
+              for(unsigned d=0; d<delta_kernels_.size(); d++) {
                 const double sign=delta_kernels_[d].height<0?-1:1; //take away contribution from kernels that are gone, and add the one from new ones
                 delta_sum_uprob+=evaluateKernel(delta_kernels_[d],kernels_[k].center)+sign*evaluateKernel(kernels_[k],delta_kernels_[d].center);
               }
             }
           }
         }
-        if(NumParallel_>1)
+        if(NumParallel_>1) {
           comm.Sum(delta_sum_uprob);
+        }
         #pragma omp parallel num_threads(NumOMP_)
         {
           #pragma omp for reduction(+:delta_sum_uprob)
-          for(unsigned d=0; d<delta_kernels_.size(); d++)
-          {
-            for(unsigned dd=0; dd<delta_kernels_.size(); dd++)
-            { //now subtract the delta_uprob added before, but not needed
+          for(unsigned d=0; d<delta_kernels_.size(); d++) {
+            for(unsigned dd=0; dd<delta_kernels_.size(); dd++) {
+              //now subtract the delta_uprob added before, but not needed
               const double sign=delta_kernels_[d].height<0?-1:1;
               delta_sum_uprob-=sign*evaluateKernel(delta_kernels_[dd],delta_kernels_[d].center);
             }
@@ -1246,8 +1229,7 @@ void OPESmetad<mode>::update()
     }
 
     //calculate work if requested
-    if(calc_work_)
-    {
+    if(calc_work_) {
       std::vector<double> dummy(ncv_); //derivatives are not actually needed
       const double prob=getProbAndDerivatives(center,dummy);
       const double new_bias=kbt_*bias_prefactor_*std::log(prob/Zed_+epsilon_);
@@ -1257,113 +1239,104 @@ void OPESmetad<mode>::update()
   }
 
 //dump state if requested
-  if( (wStateStride_>0 && getStep()%wStateStride_==0) || (wStateStride_==-1 && getCPT()) )
+  if( (wStateStride_>0 && getStep()%wStateStride_==0) || (wStateStride_==-1 && getCPT()) ) {
     dumpStateToFile();
+  }
 }
 
 template <class mode>
-double OPESmetad<mode>::getProbAndDerivatives(const std::vector<double>& cv,std::vector<double>& der_prob)
-{
+double OPESmetad<mode>::getProbAndDerivatives(const std::vector<double>& cv,std::vector<double>& der_prob) {
   double prob=0.0;
-  if(!nlist_)
-  {
-    if(NumOMP_==1 || (unsigned)kernels_.size()<2*NumOMP_*NumParallel_)
-    {
+  if(!nlist_) {
+    if(NumOMP_==1 || (unsigned)kernels_.size()<2*NumOMP_*NumParallel_) {
       // for performances and thread safety
       std::vector<double> dist(ncv_);
-      for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_)
+      for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_) {
         prob+=evaluateKernel(kernels_[k],cv,der_prob,dist);
-    }
-    else
-    {
+      }
+    } else {
       #pragma omp parallel num_threads(NumOMP_)
       {
         std::vector<double> omp_deriv(der_prob.size(),0.);
         // for performances and thread safety
         std::vector<double> dist(ncv_);
         #pragma omp for reduction(+:prob) nowait
-        for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_)
+        for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_) {
           prob+=evaluateKernel(kernels_[k],cv,omp_deriv,dist);
+        }
         #pragma omp critical
-        for(unsigned i=0; i<ncv_; i++)
+        for(unsigned i=0; i<ncv_; i++) {
           der_prob[i]+=omp_deriv[i];
+        }
       }
     }
-  }
-  else
-  {
-    if(NumOMP_==1 || (unsigned)nlist_index_.size()<2*NumOMP_*NumParallel_)
-    {
+  } else {
+    if(NumOMP_==1 || (unsigned)nlist_index_.size()<2*NumOMP_*NumParallel_) {
       // for performances and thread safety
       std::vector<double> dist(ncv_);
-      for(unsigned nk=rank_; nk<nlist_index_.size(); nk+=NumParallel_)
+      for(unsigned nk=rank_; nk<nlist_index_.size(); nk+=NumParallel_) {
         prob+=evaluateKernel(kernels_[nlist_index_[nk]],cv,der_prob,dist);
-    }
-    else
-    {
+      }
+    } else {
       #pragma omp parallel num_threads(NumOMP_)
       {
         std::vector<double> omp_deriv(der_prob.size(),0.);
         // for performances and thread safety
         std::vector<double> dist(ncv_);
         #pragma omp for reduction(+:prob) nowait
-        for(unsigned nk=rank_; nk<nlist_index_.size(); nk+=NumParallel_)
+        for(unsigned nk=rank_; nk<nlist_index_.size(); nk+=NumParallel_) {
           prob+=evaluateKernel(kernels_[nlist_index_[nk]],cv,omp_deriv,dist);
+        }
         #pragma omp critical
-        for(unsigned i=0; i<ncv_; i++)
+        for(unsigned i=0; i<ncv_; i++) {
           der_prob[i]+=omp_deriv[i];
+        }
       }
     }
   }
-  if(NumParallel_>1)
-  {
+  if(NumParallel_>1) {
     comm.Sum(prob);
     comm.Sum(der_prob);
   }
 //normalize the estimate
   prob/=KDEnorm_;
-  for(unsigned i=0; i<ncv_; i++)
+  for(unsigned i=0; i<ncv_; i++) {
     der_prob[i]/=KDEnorm_;
+  }
 
   return prob;
 }
 
 template <class mode>
-void OPESmetad<mode>::addKernel(const double height,const std::vector<double>& center,const std::vector<double>& sigma)
-{
+void OPESmetad<mode>::addKernel(const double height,const std::vector<double>& center,const std::vector<double>& sigma) {
   bool no_match=true;
-  if(threshold2_!=0)
-  {
+  if(threshold2_!=0) {
     unsigned taker_k=getMergeableKernel(center,kernels_.size());
-    if(taker_k<kernels_.size())
-    {
+    if(taker_k<kernels_.size()) {
       no_match=false;
       delta_kernels_.emplace_back(-1*kernels_[taker_k].height,kernels_[taker_k].center,kernels_[taker_k].sigma);
       mergeKernels(kernels_[taker_k],kernel(height,center,sigma));
       delta_kernels_.push_back(kernels_[taker_k]);
-      if(recursive_merge_) //the overhead is worth it if it keeps low the total number of kernels
-      {
+      if(recursive_merge_) { //the overhead is worth it if it keeps low the total number of kernels
         unsigned giver_k=taker_k;
         taker_k=getMergeableKernel(kernels_[giver_k].center,giver_k);
-        while(taker_k<kernels_.size())
-        {
+        while(taker_k<kernels_.size()) {
           delta_kernels_.pop_back();
           delta_kernels_.emplace_back(-1*kernels_[taker_k].height,kernels_[taker_k].center,kernels_[taker_k].sigma);
-          if(taker_k>giver_k) //saves time when erasing
+          if(taker_k>giver_k) { //saves time when erasing
             std::swap(taker_k,giver_k);
+          }
           mergeKernels(kernels_[taker_k],kernels_[giver_k]);
           delta_kernels_.push_back(kernels_[taker_k]);
           kernels_.erase(kernels_.begin()+giver_k);
-          if(nlist_)
-          {
+          if(nlist_) {
             unsigned giver_nk=0;
             bool found_giver=false;
-            for(unsigned nk=0; nk<nlist_index_.size(); nk++)
-            {
-              if(found_giver)
-                nlist_index_[nk]--; //all the indexes shift due to erase
-              if(nlist_index_[nk]==giver_k)
-              {
+            for(unsigned nk=0; nk<nlist_index_.size(); nk++) {
+              if(found_giver) {
+                nlist_index_[nk]--;  //all the indexes shift due to erase
+              }
+              if(nlist_index_[nk]==giver_k) {
                 giver_nk=nk;
                 found_giver=true;
               }
@@ -1377,108 +1350,101 @@ void OPESmetad<mode>::addKernel(const double height,const std::vector<double>& c
       }
     }
   }
-  if(no_match)
-  {
+  if(no_match) {
     kernels_.emplace_back(height,center,sigma);
     delta_kernels_.emplace_back(height,center,sigma);
-    if(nlist_)
+    if(nlist_) {
       nlist_index_.push_back(kernels_.size()-1);
+    }
   }
 }
 
 template <class mode>
-void OPESmetad<mode>::addKernel(const double height,const std::vector<double>& center,const std::vector<double>& sigma,const double logweight)
-{
+void OPESmetad<mode>::addKernel(const double height,const std::vector<double>& center,const std::vector<double>& sigma,const double logweight) {
   addKernel(height,center,sigma);
 //write to file
   kernelsOfile_.printField("time",getTime());
-  for(unsigned i=0; i<ncv_; i++)
+  for(unsigned i=0; i<ncv_; i++) {
     kernelsOfile_.printField(getPntrToArgument(i),center[i]);
-  for(unsigned i=0; i<ncv_; i++)
+  }
+  for(unsigned i=0; i<ncv_; i++) {
     kernelsOfile_.printField("sigma_"+getPntrToArgument(i)->getName(),sigma[i]);
+  }
   kernelsOfile_.printField("height",height);
   kernelsOfile_.printField("logweight",logweight);
   kernelsOfile_.printField();
 }
 
 template <class mode>
-unsigned OPESmetad<mode>::getMergeableKernel(const std::vector<double>& giver_center,const unsigned giver_k)
-{ //returns kernels_.size() if no match is found
+unsigned OPESmetad<mode>::getMergeableKernel(const std::vector<double>& giver_center,const unsigned giver_k) {
+  //returns kernels_.size() if no match is found
   unsigned min_k=kernels_.size();
   double min_norm2=threshold2_;
-  if(!nlist_)
-  {
+  if(!nlist_) {
     #pragma omp parallel num_threads(NumOMP_)
     {
       unsigned min_k_omp = min_k;
       double min_norm2_omp = threshold2_;
       #pragma omp for nowait
-      for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_)
-      {
-        if(k==giver_k) //a kernel should not be merged with itself
+      for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_) {
+        if(k==giver_k) { //a kernel should not be merged with itself
           continue;
+        }
         double norm2=0;
-        for(unsigned i=0; i<ncv_; i++)
-        {
+        for(unsigned i=0; i<ncv_; i++) {
           const double dist_i=difference(i,giver_center[i],kernels_[k].center[i])/kernels_[k].sigma[i];
           norm2+=dist_i*dist_i;
-          if(norm2>=min_norm2_omp)
+          if(norm2>=min_norm2_omp) {
             break;
+          }
         }
-        if(norm2<min_norm2_omp)
-        {
+        if(norm2<min_norm2_omp) {
           min_norm2_omp=norm2;
           min_k_omp=k;
         }
       }
       #pragma omp critical
       {
-        if(min_norm2_omp < min_norm2)
-        {
+        if(min_norm2_omp < min_norm2) {
           min_norm2 = min_norm2_omp;
           min_k = min_k_omp;
         }
       }
     }
-  }
-  else
-  {
+  } else {
     #pragma omp parallel num_threads(NumOMP_)
     {
       unsigned min_k_omp = min_k;
       double min_norm2_omp = threshold2_;
       #pragma omp for nowait
-      for(unsigned nk=rank_; nk<nlist_index_.size(); nk+=NumParallel_)
-      {
+      for(unsigned nk=rank_; nk<nlist_index_.size(); nk+=NumParallel_) {
         const unsigned k=nlist_index_[nk];
-        if(k==giver_k) //a kernel should not be merged with itself
+        if(k==giver_k) { //a kernel should not be merged with itself
           continue;
+        }
         double norm2=0;
-        for(unsigned i=0; i<ncv_; i++)
-        {
+        for(unsigned i=0; i<ncv_; i++) {
           const double dist_i=difference(i,giver_center[i],kernels_[k].center[i])/kernels_[k].sigma[i];
           norm2+=dist_i*dist_i;
-          if(norm2>=min_norm2)
+          if(norm2>=min_norm2) {
             break;
+          }
         }
-        if(norm2<min_norm2_omp)
-        {
+        if(norm2<min_norm2_omp) {
           min_norm2_omp=norm2;
           min_k_omp=k;
         }
       }
       #pragma omp critical
       {
-        if(min_norm2_omp < min_norm2)
-        {
+        if(min_norm2_omp < min_norm2) {
           min_norm2 = min_norm2_omp;
           min_k = min_k_omp;
         }
       }
     }
   }
-  if(NumParallel_>1)
-  {
+  if(NumParallel_>1) {
     std::vector<double> all_min_norm2(NumParallel_);
     std::vector<unsigned> all_min_k(NumParallel_);
     comm.Allgather(min_norm2,all_min_norm2);
@@ -1490,89 +1456,85 @@ unsigned OPESmetad<mode>::getMergeableKernel(const std::vector<double>& giver_ce
 }
 
 template <class mode>
-void OPESmetad<mode>::updateNlist(const std::vector<double>& new_center)
-{
-  if(kernels_.size()==0) //no need to check for neighbors
+void OPESmetad<mode>::updateNlist(const std::vector<double>& new_center) {
+  if(kernels_.size()==0) { //no need to check for neighbors
     return;
+  }
 
   nlist_center_=new_center;
   nlist_index_.clear();
   //first we gather all the nlist_index
-  if(NumOMP_==1 || (unsigned)kernels_.size()<2*NumOMP_*NumParallel_)
-  {
-    for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_)
-    {
+  if(NumOMP_==1 || (unsigned)kernels_.size()<2*NumOMP_*NumParallel_) {
+    for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_) {
       double norm2_k=0;
-      for(unsigned i=0; i<ncv_; i++)
-      {
+      for(unsigned i=0; i<ncv_; i++) {
         const double dist_ik=difference(i,nlist_center_[i],kernels_[k].center[i])/kernels_[k].sigma[i];
         norm2_k+=dist_ik*dist_ik;
       }
-      if(norm2_k<=nlist_param_[0]*cutoff2_)
+      if(norm2_k<=nlist_param_[0]*cutoff2_) {
         nlist_index_.push_back(k);
+      }
     }
-  }
-  else
-  {
+  } else {
     #pragma omp parallel num_threads(NumOMP_)
     {
       std::vector<unsigned> private_nlist_index;
       #pragma omp for nowait
-      for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_)
-      {
+      for(unsigned k=rank_; k<kernels_.size(); k+=NumParallel_) {
         double norm2_k=0;
-        for(unsigned i=0; i<ncv_; i++)
-        {
+        for(unsigned i=0; i<ncv_; i++) {
           const double dist_ik=difference(i,nlist_center_[i],kernels_[k].center[i])/kernels_[k].sigma[i];
           norm2_k+=dist_ik*dist_ik;
         }
-        if(norm2_k<=nlist_param_[0]*cutoff2_)
+        if(norm2_k<=nlist_param_[0]*cutoff2_) {
           private_nlist_index.push_back(k);
+        }
       }
       #pragma omp critical
       nlist_index_.insert(nlist_index_.end(),private_nlist_index.begin(),private_nlist_index.end());
     }
-    if(recursive_merge_)
+    if(recursive_merge_) {
       std::sort(nlist_index_.begin(),nlist_index_.end());
+    }
   }
-  if(NumParallel_>1)
-  {
+  if(NumParallel_>1) {
     std::vector<int> all_nlist_size(NumParallel_);
     all_nlist_size[rank_]=nlist_index_.size();
     comm.Sum(all_nlist_size);
     unsigned tot_size=0;
-    for(unsigned r=0; r<NumParallel_; r++)
+    for(unsigned r=0; r<NumParallel_; r++) {
       tot_size+=all_nlist_size[r];
-    if(tot_size>0)
-    {
+    }
+    if(tot_size>0) {
       std::vector<int> disp(NumParallel_);
-      for(unsigned r=0; r<NumParallel_-1; r++)
+      for(unsigned r=0; r<NumParallel_-1; r++) {
         disp[r+1]=disp[r]+all_nlist_size[r];
+      }
       std::vector<unsigned> local_nlist_index=nlist_index_;
       nlist_index_.resize(tot_size);
       comm.Allgatherv(local_nlist_index,nlist_index_,&all_nlist_size[0],&disp[0]);
-      if(recursive_merge_)
+      if(recursive_merge_) {
         std::sort(nlist_index_.begin(),nlist_index_.end());
+      }
     }
   }
   //calculate the square deviation
   std::vector<double> dev2(ncv_,0.);
-  for(unsigned k=rank_; k<nlist_index_.size(); k+=NumParallel_)
-  {
-    for(unsigned i=0; i<ncv_; i++)
-    {
+  for(unsigned k=rank_; k<nlist_index_.size(); k+=NumParallel_) {
+    for(unsigned i=0; i<ncv_; i++) {
       const double diff_ik=difference(i,nlist_center_[i],kernels_[nlist_index_[k]].center[i]);
       dev2[i]+=diff_ik*diff_ik;
     }
   }
-  if(NumParallel_>1)
+  if(NumParallel_>1) {
     comm.Sum(dev2);
-  for(unsigned i=0; i<ncv_; i++)
-  {
-    if(dev2[i]==0) //e.g. if nlist_index_.size()==0
+  }
+  for(unsigned i=0; i<ncv_; i++) {
+    if(dev2[i]==0) { //e.g. if nlist_index_.size()==0
       nlist_dev2_[i]=std::pow(kernels_.back().sigma[i],2);
-    else
+    } else {
       nlist_dev2_[i]=dev2[i]/nlist_index_.size();
+    }
   }
   getPntrToComponent("nlker")->set(nlist_index_.size());
   getPntrToComponent("nlsteps")->set(nlist_steps_);
@@ -1581,20 +1543,17 @@ void OPESmetad<mode>::updateNlist(const std::vector<double>& new_center)
 }
 
 template <class mode>
-void OPESmetad<mode>::dumpStateToFile()
-{
+void OPESmetad<mode>::dumpStateToFile() {
 //gather adaptive sigma info if needed
 //doing this while writing to file can lead to misterious slowdowns
   std::vector<double> all_sigma0;
   std::vector<double> all_av_cv;
   std::vector<double> all_av_M2;
-  if(adaptive_sigma_ && NumWalkers_>1)
-  {
+  if(adaptive_sigma_ && NumWalkers_>1) {
     all_sigma0.resize(NumWalkers_*ncv_);
     all_av_cv.resize(NumWalkers_*ncv_);
     all_av_M2.resize(NumWalkers_*ncv_);
-    if(comm.Get_rank()==0)
-    {
+    if(comm.Get_rank()==0) {
       multi_sim_comm.Allgather(sigma0_,all_sigma0);
       multi_sim_comm.Allgather(av_cv_,all_av_cv);
       multi_sim_comm.Allgather(av_M2_,all_av_M2);
@@ -1605,10 +1564,11 @@ void OPESmetad<mode>::dumpStateToFile()
   }
 
 //rewrite header or rewind file
-  if(storeOldStates_)
+  if(storeOldStates_) {
     stateOfile_.clearFields();
-  else if(walker_rank_==0)
+  } else if(walker_rank_==0) {
     stateOfile_.rewind();
+  }
 //define fields
   stateOfile_.addConstantField("action");
   stateOfile_.addConstantField("biasfactor");
@@ -1619,23 +1579,17 @@ void OPESmetad<mode>::dumpStateToFile()
   stateOfile_.addConstantField("sum_weights");
   stateOfile_.addConstantField("sum_weights2");
   stateOfile_.addConstantField("counter");
-  if(adaptive_sigma_)
-  {
+  if(adaptive_sigma_) {
     stateOfile_.addConstantField("adaptive_counter");
-    if(NumWalkers_==1)
-    {
-      for(unsigned i=0; i<ncv_; i++)
-      {
+    if(NumWalkers_==1) {
+      for(unsigned i=0; i<ncv_; i++) {
         stateOfile_.addConstantField("sigma0_"+getPntrToArgument(i)->getName());
         stateOfile_.addConstantField("av_cv_"+getPntrToArgument(i)->getName());
         stateOfile_.addConstantField("av_M2_"+getPntrToArgument(i)->getName());
       }
-    }
-    else
-    {
+    } else {
       for(unsigned w=0; w<NumWalkers_; w++)
-        for(unsigned i=0; i<ncv_; i++)
-        {
+        for(unsigned i=0; i<ncv_; i++) {
           const std::string arg_iw=getPntrToArgument(i)->getName()+"_"+std::to_string(w);
           stateOfile_.addConstantField("sigma0_"+arg_iw);
           stateOfile_.addConstantField("av_cv_"+arg_iw);
@@ -1644,8 +1598,9 @@ void OPESmetad<mode>::dumpStateToFile()
     }
   }
 //print fields
-  for(unsigned i=0; i<ncv_; i++) //periodicity of CVs
+  for(unsigned i=0; i<ncv_; i++) { //periodicity of CVs
     stateOfile_.setupPrintValue(getPntrToArgument(i));
+  }
   stateOfile_.printField("action",getName()+"_state");
   stateOfile_.printField("biasfactor",biasfactor_);
   stateOfile_.printField("epsilon",epsilon_);
@@ -1655,23 +1610,17 @@ void OPESmetad<mode>::dumpStateToFile()
   stateOfile_.printField("sum_weights",sum_weights_);
   stateOfile_.printField("sum_weights2",sum_weights2_);
   stateOfile_.printField("counter",counter_);
-  if(adaptive_sigma_)
-  {
+  if(adaptive_sigma_) {
     stateOfile_.printField("adaptive_counter",adaptive_counter_);
-    if(NumWalkers_==1)
-    {
-      for(unsigned i=0; i<ncv_; i++)
-      {
+    if(NumWalkers_==1) {
+      for(unsigned i=0; i<ncv_; i++) {
         stateOfile_.printField("sigma0_"+getPntrToArgument(i)->getName(),sigma0_[i]);
         stateOfile_.printField("av_cv_"+getPntrToArgument(i)->getName(),av_cv_[i]);
         stateOfile_.printField("av_M2_"+getPntrToArgument(i)->getName(),av_M2_[i]);
       }
-    }
-    else
-    {
+    } else {
       for(unsigned w=0; w<NumWalkers_; w++)
-        for(unsigned i=0; i<ncv_; i++)
-        {
+        for(unsigned i=0; i<ncv_; i++) {
           const std::string arg_iw=getPntrToArgument(i)->getName()+"_"+std::to_string(w);
           stateOfile_.printField("sigma0_"+arg_iw,all_sigma0[w*ncv_+i]);
           stateOfile_.printField("av_cv_"+arg_iw,all_av_cv[w*ncv_+i]);
@@ -1680,69 +1629,72 @@ void OPESmetad<mode>::dumpStateToFile()
     }
   }
 //print kernels
-  for(unsigned k=0; k<kernels_.size(); k++)
-  {
+  for(unsigned k=0; k<kernels_.size(); k++) {
     stateOfile_.printField("time",getTime()); //this is not very usefull
-    for(unsigned i=0; i<ncv_; i++)
+    for(unsigned i=0; i<ncv_; i++) {
       stateOfile_.printField(getPntrToArgument(i),kernels_[k].center[i]);
-    for(unsigned i=0; i<ncv_; i++)
+    }
+    for(unsigned i=0; i<ncv_; i++) {
       stateOfile_.printField("sigma_"+getPntrToArgument(i)->getName(),kernels_[k].sigma[i]);
+    }
     stateOfile_.printField("height",kernels_[k].height);
     stateOfile_.printField();
   }
 //make sure file is written even if small
-  if(!storeOldStates_)
+  if(!storeOldStates_) {
     stateOfile_.flush();
+  }
 }
 
 template <class mode>
-inline double OPESmetad<mode>::evaluateKernel(const kernel& G,const std::vector<double>& x) const
-{ //NB: cannot be a method of kernel class, because uses external variables (for cutoff)
+inline double OPESmetad<mode>::evaluateKernel(const kernel& G,const std::vector<double>& x) const {
+  //NB: cannot be a method of kernel class, because uses external variables (for cutoff)
   double norm2=0;
-  for(unsigned i=0; i<ncv_; i++)
-  {
+  for(unsigned i=0; i<ncv_; i++) {
     const double dist_i=difference(i,G.center[i],x[i])/G.sigma[i];
     norm2+=dist_i*dist_i;
-    if(norm2>=cutoff2_)
+    if(norm2>=cutoff2_) {
       return 0;
+    }
   }
   return G.height*(std::exp(-0.5*norm2)-val_at_cutoff_);
 }
 
 template <class mode>
-inline double OPESmetad<mode>::evaluateKernel(const kernel& G,const std::vector<double>& x, std::vector<double>& acc_der, std::vector<double>& dist)
-{ //NB: cannot be a method of kernel class, because uses external variables (for cutoff)
+inline double OPESmetad<mode>::evaluateKernel(const kernel& G,const std::vector<double>& x, std::vector<double>& acc_der, std::vector<double>& dist) {
+  //NB: cannot be a method of kernel class, because uses external variables (for cutoff)
   double norm2=0;
-  for(unsigned i=0; i<ncv_; i++)
-  {
+  for(unsigned i=0; i<ncv_; i++) {
     dist[i]=difference(i,G.center[i],x[i])/G.sigma[i];
     norm2+=dist[i]*dist[i];
-    if(norm2>=cutoff2_)
+    if(norm2>=cutoff2_) {
       return 0;
+    }
   }
   const double val=G.height*(std::exp(-0.5*norm2)-val_at_cutoff_);
-  for(unsigned i=0; i<ncv_; i++)
-    acc_der[i]-=dist[i]/G.sigma[i]*val; //NB: we accumulate the derivative into der
+  for(unsigned i=0; i<ncv_; i++) {
+    acc_der[i]-=dist[i]/G.sigma[i]*val;  //NB: we accumulate the derivative into der
+  }
   return val;
 }
 
 template <class mode>
-inline void OPESmetad<mode>::mergeKernels(kernel& k1,const kernel& k2)
-{
+inline void OPESmetad<mode>::mergeKernels(kernel& k1,const kernel& k2) {
   const double h=k1.height+k2.height;
-  for(unsigned i=0; i<k1.center.size(); i++)
-  {
+  for(unsigned i=0; i<k1.center.size(); i++) {
     const bool isPeriodic_i=getPntrToArgument(i)->isPeriodic();
-    if(isPeriodic_i)
-      k1.center[i]=k2.center[i]+difference(i,k2.center[i],k1.center[i]); //fix PBC
+    if(isPeriodic_i) {
+      k1.center[i]=k2.center[i]+difference(i,k2.center[i],k1.center[i]);  //fix PBC
+    }
     const double c_i=(k1.height*k1.center[i]+k2.height*k2.center[i])/h;
     const double ss_k1_part=k1.height*(k1.sigma[i]*k1.sigma[i]+k1.center[i]*k1.center[i]);
     const double ss_k2_part=k2.height*(k2.sigma[i]*k2.sigma[i]+k2.center[i]*k2.center[i]);
     const double ss_i=(ss_k1_part+ss_k2_part)/h-c_i*c_i;
-    if(isPeriodic_i)
+    if(isPeriodic_i) {
       k1.center[i]=bringBackInPbc(i,c_i);
-    else
+    } else {
       k1.center[i]=c_i;
+    }
     k1.sigma[i]=sqrt(ss_i);
   }
   k1.height=h;
diff --git a/src/pamm/HBPammMatrix.cpp b/src/pamm/HBPammMatrix.cpp
index d2b85ed537..3978d4db82 100644
--- a/src/pamm/HBPammMatrix.cpp
+++ b/src/pamm/HBPammMatrix.cpp
@@ -85,87 +85,157 @@ class HBPammMatrix : public adjmat::AdjacencyMatrixBase {
 PLUMED_REGISTER_ACTION(HBPammMatrix,"HBPAMM_MATRIX")
 
 void HBPammMatrix::registerKeywords( Keywords& keys ) {
-  adjmat::AdjacencyMatrixBase::registerKeywords( keys ); keys.use("GROUPC");
+  adjmat::AdjacencyMatrixBase::registerKeywords( keys );
+  keys.use("GROUPC");
   keys.add("compulsory","ORDER","dah","the order in which the groups are specified in the input.  Can be dah (donor/acceptor/hydrogens), "
            "adh (acceptor/donor/hydrogens) or hda (hydrogens/donor/hydrogens");
   keys.add("compulsory","CLUSTERS","the name of the file that contains the definitions of all the kernels for PAMM");
   keys.add("compulsory","REGULARISE","0.001","don't allow the denominator to be smaller then this value");
   keys.add("compulsory","GAUSS_CUTOFF","6.25","the cutoff at which to stop evaluating the kernel function is set equal to sqrt(2*x)*(max(adc)+cov(adc))");
-  keys.needsAction("PAMM"); keys.needsAction("ONES"); keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("PAMM");
+  keys.needsAction("ONES");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
 }
 
 HBPammMatrix::HBPammMatrix(const ActionOptions& ao):
   Action(ao),
-  AdjacencyMatrixBase(ao)
-{
-  double DP2CUTOFF; parse("GAUSS_CUTOFF",DP2CUTOFF); std::string sorder; parse("ORDER",sorder);
+  AdjacencyMatrixBase(ao) {
+  double DP2CUTOFF;
+  parse("GAUSS_CUTOFF",DP2CUTOFF);
+  std::string sorder;
+  parse("ORDER",sorder);
   if( sorder=="dah" ) {
-    incoord_to_hbcoord(0,0)=1; incoord_to_hbcoord(0,1)=-1; incoord_to_hbcoord(0,2)=0;
-    incoord_to_hbcoord(1,0)=1; incoord_to_hbcoord(1,1)=1; incoord_to_hbcoord(1,2)=0;
-    incoord_to_hbcoord(2,0)=0; incoord_to_hbcoord(2,1)=0; incoord_to_hbcoord(2,2)=1;
+    incoord_to_hbcoord(0,0)=1;
+    incoord_to_hbcoord(0,1)=-1;
+    incoord_to_hbcoord(0,2)=0;
+    incoord_to_hbcoord(1,0)=1;
+    incoord_to_hbcoord(1,1)=1;
+    incoord_to_hbcoord(1,2)=0;
+    incoord_to_hbcoord(2,0)=0;
+    incoord_to_hbcoord(2,1)=0;
+    incoord_to_hbcoord(2,2)=1;
     log.printf("  GROUPA is list of donor atoms \n");
   } else if( sorder=="adh" ) {
-    incoord_to_hbcoord(0,0)=-1; incoord_to_hbcoord(0,1)=1; incoord_to_hbcoord(0,2)=0;
-    incoord_to_hbcoord(1,0)=1; incoord_to_hbcoord(1,1)=1; incoord_to_hbcoord(1,2)=0;
-    incoord_to_hbcoord(2,0)=0; incoord_to_hbcoord(2,1)=0; incoord_to_hbcoord(2,2)=1;
+    incoord_to_hbcoord(0,0)=-1;
+    incoord_to_hbcoord(0,1)=1;
+    incoord_to_hbcoord(0,2)=0;
+    incoord_to_hbcoord(1,0)=1;
+    incoord_to_hbcoord(1,1)=1;
+    incoord_to_hbcoord(1,2)=0;
+    incoord_to_hbcoord(2,0)=0;
+    incoord_to_hbcoord(2,1)=0;
+    incoord_to_hbcoord(2,2)=1;
     log.printf("  GROUPA is list of acceptor atoms \n");
   } else if( sorder=="hda" ) {
-    incoord_to_hbcoord(0,0)=-1; incoord_to_hbcoord(0,1)=0; incoord_to_hbcoord(0,2)=1;
-    incoord_to_hbcoord(1,0)=1; incoord_to_hbcoord(1,1)=0; incoord_to_hbcoord(1,2)=1;
-    incoord_to_hbcoord(2,0)=0; incoord_to_hbcoord(2,1)=1; incoord_to_hbcoord(2,2)=0;
+    incoord_to_hbcoord(0,0)=-1;
+    incoord_to_hbcoord(0,1)=0;
+    incoord_to_hbcoord(0,2)=1;
+    incoord_to_hbcoord(1,0)=1;
+    incoord_to_hbcoord(1,1)=0;
+    incoord_to_hbcoord(1,2)=1;
+    incoord_to_hbcoord(2,0)=0;
+    incoord_to_hbcoord(2,1)=1;
+    incoord_to_hbcoord(2,2)=0;
     log.printf("  GROUPA is list of hydrogen atoms \n");
-  } else plumed_error();
+  } else {
+    plumed_error();
+  }
   // Read in the regularisation parameter
   parse("REGULARISE",regulariser);
 
   // Read in the kernels
-  double sqr2pi = sqrt(2*pi); double sqrt2pi3 = sqr2pi*sqr2pi*sqr2pi;
-  std::string fname; parse("CLUSTERS", fname); double sfmax=0, ww; Vector cent; Tensor covar;
-  IFile ifile; ifile.open(fname); ifile.allowIgnoredFields();
+  double sqr2pi = sqrt(2*pi);
+  double sqrt2pi3 = sqr2pi*sqr2pi*sqr2pi;
+  std::string fname;
+  parse("CLUSTERS", fname);
+  double sfmax=0, ww;
+  Vector cent;
+  Tensor covar;
+  IFile ifile;
+  ifile.open(fname);
+  ifile.allowIgnoredFields();
   for(unsigned k=0;; ++k) {
-    if( !ifile.scanField("height",ww) ) break;
-    ifile.scanField("ptc",cent[0]); ifile.scanField("ssc",cent[1]); ifile.scanField("adc",cent[2]);
-    ifile.scanField("sigma_ptc_ptc",covar[0][0]); ifile.scanField("sigma_ptc_ssc",covar[0][1]); ifile.scanField("sigma_ptc_adc",covar[0][2]);
-    covar[1][0] = covar[0][1]; ifile.scanField("sigma_ssc_ssc",covar[1][1]); ifile.scanField("sigma_ssc_adc",covar[1][2]);
-    covar[2][0] = covar[0][2]; covar[2][1] = covar[1][2]; ifile.scanField("sigma_adc_adc",covar[2][2]);
+    if( !ifile.scanField("height",ww) ) {
+      break;
+    }
+    ifile.scanField("ptc",cent[0]);
+    ifile.scanField("ssc",cent[1]);
+    ifile.scanField("adc",cent[2]);
+    ifile.scanField("sigma_ptc_ptc",covar[0][0]);
+    ifile.scanField("sigma_ptc_ssc",covar[0][1]);
+    ifile.scanField("sigma_ptc_adc",covar[0][2]);
+    covar[1][0] = covar[0][1];
+    ifile.scanField("sigma_ssc_ssc",covar[1][1]);
+    ifile.scanField("sigma_ssc_adc",covar[1][2]);
+    covar[2][0] = covar[0][2];
+    covar[2][1] = covar[1][2];
+    ifile.scanField("sigma_adc_adc",covar[2][2]);
     weight.push_back( ww / ( sqrt2pi3 * sqrt(covar.determinant()) ) );
-    centers.push_back( cent ); kmat.push_back( covar.inverse() );
-
-    Vector eigval; Tensor eigvec; diagMatSym( covar, eigval, eigvec );
-    unsigned ind_maxeval=0; double max_eval=eigval[0];
+    centers.push_back( cent );
+    kmat.push_back( covar.inverse() );
+
+    Vector eigval;
+    Tensor eigvec;
+    diagMatSym( covar, eigval, eigvec );
+    unsigned ind_maxeval=0;
+    double max_eval=eigval[0];
     for(unsigned i=1; i<3; ++i) {
-      if( eigval[i]>max_eval ) { max_eval=eigval[i]; ind_maxeval=i; }
+      if( eigval[i]>max_eval ) {
+        max_eval=eigval[i];
+        ind_maxeval=i;
+      }
     }
     double rcut = cent[2] + sqrt(2.0*DP2CUTOFF)*fabs(sqrt(max_eval)*eigvec(2,ind_maxeval));
-    if( rcut > sfmax ) sfmax = rcut;
+    if( rcut > sfmax ) {
+      sfmax = rcut;
+    }
     ifile.scanField();
   }
-  ifile.close(); setLinkCellCutoff( false, sfmax );
+  ifile.close();
+  setLinkCellCutoff( false, sfmax );
 }
 
 double HBPammMatrix::calculateWeight( const Vector& pos1, const Vector& pos2, const unsigned& natoms, MultiValue& myvals ) const {
   Vector ddij, ddik, ddin, in_dists, hb_pamm_dists, hb_pamm_ders, real_ders;
-  ddin = pbcDistance( pos1, pos2 ); in_dists[2] = ddin.modulo();
-  if( in_dists[2]<epsilon ) return 0;
+  ddin = pbcDistance( pos1, pos2 );
+  in_dists[2] = ddin.modulo();
+  if( in_dists[2]<epsilon ) {
+    return 0;
+  }
 
-  double tot=0; Vector disp, der, tmp_der;
+  double tot=0;
+  Vector disp, der, tmp_der;
   for(unsigned i=0; i<natoms; ++i) {
-    ddij = getPosition(i,myvals); in_dists[0] = ddij.modulo();
-    ddik = pbcDistance( pos2, getPosition(i,myvals) ); in_dists[1] = ddik.modulo();
-    if( in_dists[1]<epsilon ) continue;
+    ddij = getPosition(i,myvals);
+    in_dists[0] = ddij.modulo();
+    ddik = pbcDistance( pos2, getPosition(i,myvals) );
+    in_dists[1] = ddik.modulo();
+    if( in_dists[1]<epsilon ) {
+      continue;
+    }
 
     hb_pamm_dists = matmul( incoord_to_hbcoord, in_dists );
-    disp = hb_pamm_dists - centers[0]; der = matmul( kmat[0], disp );
-    double vv = weight[0]*exp( -dotProduct( disp, der ) / 2. ); der *= -vv;
-
-    double denom = regulariser + vv; for(unsigned j=0; j<3; ++j) hb_pamm_ders[j] = der[j];
+    disp = hb_pamm_dists - centers[0];
+    der = matmul( kmat[0], disp );
+    double vv = weight[0]*exp( -dotProduct( disp, der ) / 2. );
+    der *= -vv;
+
+    double denom = regulariser + vv;
+    for(unsigned j=0; j<3; ++j) {
+      hb_pamm_ders[j] = der[j];
+    }
     for(unsigned k=1; k<weight.size(); ++k) {
-      disp = hb_pamm_dists - centers[k]; tmp_der = matmul( kmat[k], disp );
+      disp = hb_pamm_dists - centers[k];
+      tmp_der = matmul( kmat[k], disp );
       double tval = weight[k]*exp( -dotProduct( disp, tmp_der ) / 2. );
-      denom += tval; hb_pamm_ders += -tmp_der*tval;
+      denom += tval;
+      hb_pamm_ders += -tmp_der*tval;
+    }
+    double vf = vv / denom;
+    tot += vf;
+    if( fabs(vf)<epsilon ) {
+      continue;
     }
-    double vf = vv / denom; tot += vf;
-    if( fabs(vf)<epsilon ) continue;
     // Now get derivatives
     real_ders = matmul( der / denom - vf*hb_pamm_ders/denom, incoord_to_hbcoord );
 
@@ -191,7 +261,11 @@ PLUMED_REGISTER_ACTION(HBPammShortcut,"HBPAMM_SA")
 PLUMED_REGISTER_ACTION(HBPammShortcut,"HBPAMM_SH")
 
 void HBPammShortcut::registerKeywords( Keywords& keys ) {
-  HBPammMatrix::registerKeywords( keys ); keys.remove("GROUP"); keys.remove("GROUPA"); keys.remove("GROUPB"); keys.remove("COMPONENTS");
+  HBPammMatrix::registerKeywords( keys );
+  keys.remove("GROUP");
+  keys.remove("GROUPA");
+  keys.remove("GROUPB");
+  keys.remove("COMPONENTS");
   keys.add("optional","SITES","The list of atoms which can be part of a hydrogen bond.  When this command is used the set of atoms that can donate a "
            "hydrogen bond is assumed to be the same as the set of atoms that can form hydrogen bonds.  The atoms involved must be specified"
            "as a list of labels of \\ref mcolv or labels of a \\ref multicolvarfunction actions.  If you would just like to use "
@@ -210,45 +284,71 @@ void HBPammShortcut::registerKeywords( Keywords& keys ) {
            "variety of functions of the contact matrix as described in \\ref contactmatrix");
   keys.add("compulsory","HYDROGENS","The list of hydrogen atoms that can form part of a hydrogen bond.  The atoms must be specified using a comma separated list, "
            "an index range or by using a \\ref GROUP");
-  multicolvar::MultiColvarShortcuts::shortcutKeywords( keys ); keys.needsAction("HBPAMM_MATRIX");
+  multicolvar::MultiColvarShortcuts::shortcutKeywords( keys );
+  keys.needsAction("HBPAMM_MATRIX");
 }
 
 HBPammShortcut::HBPammShortcut(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   std::string mwords = getShortcutLabel() + "_mat: HBPAMM_MATRIX";
   if( getName()=="HBPAMM_SD" ) {
-    std::string site_str; parse("SITES",site_str);
-    if( site_str.length()>0 ) mwords += " GROUP=" + site_str;
-    else {
-      std::string d_str; parse("DONORS",d_str); mwords += " GROUPA=" + d_str;
-      std::string a_str; parse("ACCEPTORS",a_str); mwords += " GROUPB=" + a_str;
+    std::string site_str;
+    parse("SITES",site_str);
+    if( site_str.length()>0 ) {
+      mwords += " GROUP=" + site_str;
+    } else {
+      std::string d_str;
+      parse("DONORS",d_str);
+      mwords += " GROUPA=" + d_str;
+      std::string a_str;
+      parse("ACCEPTORS",a_str);
+      mwords += " GROUPB=" + a_str;
     }
-    std::string h_str; parse("HYDROGENS",h_str); mwords += " GROUPC=" + h_str + " ORDER=dah";
+    std::string h_str;
+    parse("HYDROGENS",h_str);
+    mwords += " GROUPC=" + h_str + " ORDER=dah";
   } else if( getName()=="HBPAMM_SA" ) {
-    std::string site_str; parse("SITES",site_str);
-    if( site_str.length()>0 ) mwords += " GROUP=" + site_str;
-    else {
-      std::string a_str; parse("ACCEPTORS",a_str); mwords += " GROUPA=" + a_str;
-      std::string d_str; parse("DONORS",d_str); mwords += " GROUPB=" + d_str;
+    std::string site_str;
+    parse("SITES",site_str);
+    if( site_str.length()>0 ) {
+      mwords += " GROUP=" + site_str;
+    } else {
+      std::string a_str;
+      parse("ACCEPTORS",a_str);
+      mwords += " GROUPA=" + a_str;
+      std::string d_str;
+      parse("DONORS",d_str);
+      mwords += " GROUPB=" + d_str;
     }
-    std::string h_str; parse("HYDROGENS",h_str); mwords += " GROUPC=" + h_str + " ORDER=adh";
+    std::string h_str;
+    parse("HYDROGENS",h_str);
+    mwords += " GROUPC=" + h_str + " ORDER=adh";
   } else if( getName()=="HBPAMM_SH" ) {
-    std::string h_str; parse("HYDROGENS",h_str); mwords += " GROUPA=" + h_str + " ORDER=hda";
-    std::string site_str; parse("SITES",site_str);
+    std::string h_str;
+    parse("HYDROGENS",h_str);
+    mwords += " GROUPA=" + h_str + " ORDER=hda";
+    std::string site_str;
+    parse("SITES",site_str);
     if( site_str.length()>0 ) {
       mwords += " GROUPB=" + site_str;
       mwords += " GROUPC=" + site_str;
     } else {
-      std::string d_str; parse("DONORS",d_str); mwords += " GROUPB=" + d_str;
-      std::string a_str; parse("ACCEPTORS",a_str); mwords += " GROUPC=" + a_str;
+      std::string d_str;
+      parse("DONORS",d_str);
+      mwords += " GROUPB=" + d_str;
+      std::string a_str;
+      parse("ACCEPTORS",a_str);
+      mwords += " GROUPC=" + a_str;
     }
   }
-  std::map<std::string,std::string> keymap; multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
+  std::map<std::string,std::string> keymap;
+  multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
   readInputLine( mwords + " " + convertInputLineToString() );
   ActionWithValue* mb=plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_mat");
-  plumed_assert( mb ); std::string nsize; Tools::convert( (mb->copyOutput(getShortcutLabel() + "_mat"))->getShape()[1], nsize );
+  plumed_assert( mb );
+  std::string nsize;
+  Tools::convert( (mb->copyOutput(getShortcutLabel() + "_mat"))->getShape()[1], nsize );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + nsize );
   readInputLine( getShortcutLabel() + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_mat," + getShortcutLabel() + "_ones");
   multicolvar::MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel(), "", keymap, this );
diff --git a/src/pamm/PAMM.cpp b/src/pamm/PAMM.cpp
index 00842de148..eb28385fb3 100644
--- a/src/pamm/PAMM.cpp
+++ b/src/pamm/PAMM.cpp
@@ -124,58 +124,79 @@ void PAMM::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","REGULARISE","0.001","don't allow the denominator to be smaller then this value");
   keys.add("compulsory","KERNELS","all","which kernels are we computing the PAMM values for");
   multicolvar::MultiColvarShortcuts::shortcutKeywords( keys );
-  keys.needsAction("KERNEL"); keys.needsAction("COMBINE");
+  keys.needsAction("KERNEL");
+  keys.needsAction("COMBINE");
 }
 
 PAMM::PAMM(const ActionOptions& ao) :
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Must get list of input value names
-  std::vector<std::string> valnames; parseVector("ARG",valnames);
+  std::vector<std::string> valnames;
+  parseVector("ARG",valnames);
   // Create input values
   std::string argstr=" ARG=" + valnames[0];
-  for(unsigned j=1; j<valnames.size(); ++j) argstr += "," + valnames[j];
+  for(unsigned j=1; j<valnames.size(); ++j) {
+    argstr += "," + valnames[j];
+  }
 
   // Create actions to calculate all pamm kernels
-  unsigned nkernels = 0;  double h;
-  std::string fname; parse("CLUSTERS",fname);
-  IFile ifile; ifile.open(fname); ifile.allowIgnoredFields();
+  unsigned nkernels = 0;
+  double h;
+  std::string fname;
+  parse("CLUSTERS",fname);
+  IFile ifile;
+  ifile.open(fname);
+  ifile.allowIgnoredFields();
   for(unsigned k=0;; ++k) {
-    if( !ifile.scanField("height",h) ) break;
+    if( !ifile.scanField("height",h) ) {
+      break;
+    }
     // Create a kernel for this cluster
-    std::string num, wstr, ktype; Tools::convert( k+1, num ); Tools::convert(h,wstr); ifile.scanField("kerneltype",ktype);
+    std::string num, wstr, ktype;
+    Tools::convert( k+1, num );
+    Tools::convert(h,wstr);
+    ifile.scanField("kerneltype",ktype);
     readInputLine( getShortcutLabel() + "_kernel-" + num + ": KERNEL NORMALIZED" + argstr  + " NUMBER=" + num + " REFERENCE=" + fname + " WEIGHT=" + wstr + " TYPE=" + ktype );
-    nkernels++; ifile.scanField();
+    nkernels++;
+    ifile.scanField();
   }
   ifile.close();
 
   // And add on the regularization
-  std::string regparam; parse("REGULARISE",regparam);
+  std::string regparam;
+  parse("REGULARISE",regparam);
   // Now combine all the PAMM objects with the regparam
   std::string paramstr, cinput = getShortcutLabel() + "_ksum: COMBINE PERIODIC=NO";
   for(unsigned k=0; k<nkernels; ++k) {
-    std::string num; Tools::convert( k+1, num );
+    std::string num;
+    Tools::convert( k+1, num );
     if( k==0 ) {
-      cinput += " ARG="; paramstr=" PARAMETERS=-" + regparam;
+      cinput += " ARG=";
+      paramstr=" PARAMETERS=-" + regparam;
     } else {
-      cinput += ","; paramstr += ",0";
+      cinput += ",";
+      paramstr += ",0";
     }
     cinput += getShortcutLabel() + "_kernel-" + num;
   }
   readInputLine( cinput + paramstr );
 
   // And now compute all the pamm kernels
-  std::string kchoice; parse("KERNELS",kchoice);
-  std::map<std::string,std::string> keymap; multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
+  std::string kchoice;
+  parse("KERNELS",kchoice);
+  std::map<std::string,std::string> keymap;
+  multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
   if( kchoice=="all" ) {
     for(unsigned k=0; k<nkernels; ++k) {
-      std::string num; Tools::convert( k+1, num );
+      std::string num;
+      Tools::convert( k+1, num );
       readInputLine( getShortcutLabel() + "-" + num + ": CUSTOM ARG=" + getShortcutLabel() + "_kernel-" + num + "," + getShortcutLabel() + "_ksum FUNC=x/y PERIODIC=NO");
       multicolvar::MultiColvarShortcuts::expandFunctions( getShortcutLabel() + "-" + num, getShortcutLabel() + "-" + num, "", keymap, this );
     }
   } else {
-    std::vector<std::string> awords=Tools::getWords(kchoice,"\t\n ,"); Tools::interpretRanges( awords );
+    std::vector<std::string> awords=Tools::getWords(kchoice,"\t\n ,");
+    Tools::interpretRanges( awords );
     for(unsigned k=0; k<awords.size(); ++k) {
       readInputLine( getShortcutLabel() + "-" + awords[k] + ": CUSTOM ARG=" + getShortcutLabel() + "_kernel-" + awords[k] + "," + getShortcutLabel() + "_ksum FUNC=x/y PERIODIC=NO");
       multicolvar::MultiColvarShortcuts::expandFunctions( getShortcutLabel() + "-" + awords[k], getShortcutLabel() + "-" + awords[k], "", keymap, this );
diff --git a/src/piv/PIV.cpp b/src/piv/PIV.cpp
index 849a1aad19..f16dfdc05d 100644
--- a/src/piv/PIV.cpp
+++ b/src/piv/PIV.cpp
@@ -32,10 +32,8 @@ along with plumed.  If not, see <http://www.gnu.org/licenses/>.
 
 using namespace std;
 
-namespace PLMD
-{
-namespace piv
-{
+namespace PLMD {
+namespace piv {
 
 //+PLUMEDOC PIVMOD_COLVAR PIV
 /*
@@ -183,8 +181,7 @@ When using PIV please cite \cite pipolo2017navigating .
 */
 //+ENDPLUMEDOC
 
-class PIV      : public Colvar
-{
+class PIV      : public Colvar {
 private:
   bool pbc, serial, timer;
   ForwardDecl<Stopwatch> stopwatch_fwd;
@@ -234,8 +231,7 @@ class PIV      : public Colvar
 
 PLUMED_REGISTER_ACTION(PIV,"PIV")
 
-void PIV::registerKeywords( Keywords& keys )
-{
+void PIV::registerKeywords( Keywords& keys ) {
   Colvar::registerKeywords( keys );
   keys.add("numbered","SWITCH","The switching functions parameter."
            "You should specify a Switching function for all PIV blocks."
@@ -294,8 +290,7 @@ PIV::PIV(const ActionOptions&ao):
   doneigh(false),
   test(false),
   CompDer(false),
-  com(false)
-{
+  com(false) {
   log << "Starting PIV Constructor\n";
 
   {
@@ -322,7 +317,9 @@ PIV::PIV(const ActionOptions&ao):
 
   // Precision on the real-to-integer transformation for the sorting
   parse("PRECISION",Nprec);
-  if(Nprec<2) error("Precision must be => 2");
+  if(Nprec<2) {
+    error("Precision must be => 2");
+  }
 
   // PBC
   bool nopbc=!pbc;
@@ -344,7 +341,9 @@ PIV::PIV(const ActionOptions&ao):
 
   // Derivatives
   parseFlag("DERIVATIVES",CompDer);
-  if(CompDer) log << "Computing Derivatives\n";
+  if(CompDer) {
+    log << "Computing Derivatives\n";
+  }
 
   // Timing
   parseFlag("TIMER",timer);
@@ -364,7 +363,9 @@ PIV::PIV(const ActionOptions&ao):
 
   // Test
   parseFlag("COM",com);
-  if(com) log << "Building PIV using COMs\n";
+  if(com) {
+    log << "Building PIV using COMs\n";
+  }
 
   // Volume Scaling
   parse("VOLUME",Vol0);
@@ -546,9 +547,15 @@ PIV::PIV(const ActionOptions&ao):
     parseVector("NL_SKIN",nl_skin);
     //if(nl_skin.size()!=getNumberOfArguments() && nl_skin.size()!=0) error("not enough values for NL_SKIN");
     for (unsigned j=0; j<Nlist; j++) {
-      if(nl_cut[j]<=0.0) error("NL_CUTOFF should be explicitly specified and positive");
-      if(nl_st[j]<=0) error("NL_STRIDE should be explicitly specified and positive");
-      if(nl_skin[j]<=0.) error("NL_SKIN should be explicitly specified and positive");
+      if(nl_cut[j]<=0.0) {
+        error("NL_CUTOFF should be explicitly specified and positive");
+      }
+      if(nl_st[j]<=0) {
+        error("NL_STRIDE should be explicitly specified and positive");
+      }
+      if(nl_skin[j]<=0.) {
+        error("NL_SKIN should be explicitly specified and positive");
+      }
       nl_cut[j]=nl_cut[j]+nl_skin[j];
     }
     log << "Creating Neighbor Lists \n";
@@ -644,7 +651,9 @@ PIV::PIV(const ActionOptions&ao):
   r00.resize(Nlist);
   sw.resize(Nlist);
   for (unsigned j=0; j<Nlist; j++) {
-    if( !parseNumbered( "SWITCH", j+1, sw[j] ) ) break;
+    if( !parseNumbered( "SWITCH", j+1, sw[j] ) ) {
+      break;
+    }
   }
   if(CompDer) {
     // Set switching function parameters here only if computing derivatives
@@ -661,14 +670,17 @@ PIV::PIV(const ActionOptions&ao):
         Tools::parse(data,"R_0",old_r0);
         Tools::convert(old_r0,r0);
         r0*=Fvol;
-        std::string new_r0; Tools::convert(r0,new_r0);
+        std::string new_r0;
+        Tools::convert(r0,new_r0);
         std::size_t pos = sw[j].find("R_0");
         sw[j].replace(pos+4,old_r0.size(),new_r0);
       }
       sfs[j].set(sw[j],errors);
       std::string num;
       Tools::convert(j+1, num);
-      if( errors.length()!=0 ) error("problem reading SWITCH" + num + " keyword : " + errors );
+      if( errors.length()!=0 ) {
+        error("problem reading SWITCH" + num + " keyword : " + errors );
+      }
       r00[j]=sfs[j].get_r0();
       log << "  Swf: " << j << "  r0=" << (sfs[j].description()).c_str() << " \n";
     }
@@ -746,8 +758,7 @@ PIV::PIV(const ActionOptions&ao):
   m_deriv.resize(getNumberOfAtoms());
 }
 
-void PIV::calculate()
-{
+void PIV::calculate() {
 
   // Local variables
 
@@ -783,7 +794,9 @@ void PIV::calculate()
 
   // Transform (and sort) the rPIV before starting the dynamics
   if (((prev_stp==-1) || (init_stp==1)) &&!CompDer) {
-    if(prev_stp!=-1) {init_stp=0;}
+    if(prev_stp!=-1) {
+      init_stp=0;
+    }
     // Calculate the volume scaling factor
     if(Svol) {
       Fvol=cbrt(Vol0/getBox().determinant());
@@ -805,14 +818,17 @@ void PIV::calculate()
         Tools::parse(data,"R_0",old_r0);
         Tools::convert(old_r0,r0);
         r0*=Fvol;
-        std::string new_r0; Tools::convert(r0,new_r0);
+        std::string new_r0;
+        Tools::convert(r0,new_r0);
         std::size_t pos = sw[j].find("R_0");
         sw[j].replace(pos+4,old_r0.size(),new_r0);
       }
       sfs[j].set(sw[j],errors);
       std::string num;
       Tools::convert(j+1, num);
-      if( errors.length()!=0 ) error("problem reading SWITCH" + num + " keyword : " + errors );
+      if( errors.length()!=0 ) {
+        error("problem reading SWITCH" + num + " keyword : " + errors );
+      }
       r00[j]=sfs[j].get_r0();
       log << "  Swf: " << j << "  r0=" << (sfs[j].description()).c_str() << " \n";
     }
@@ -843,11 +859,15 @@ void PIV::calculate()
   }
   // Do the sorting only once per timestep to avoid building the PIV N times for N rPIV PDB structures!
   if ((getStep()>prev_stp&&getStep()%updatePIV==0)||CompDer) {
-    if (CompDer) log << " Step " << getStep() << "  Computing Derivatives NON-SORTED PIV \n";
+    if (CompDer) {
+      log << " Step " << getStep() << "  Computing Derivatives NON-SORTED PIV \n";
+    }
     //
     // build COMs from positions if requested
     if(com) {
-      if(pbc) makeWhole();
+      if(pbc) {
+        makeWhole();
+      }
       for(unsigned j=0; j<compos.size(); j++) {
         compos[j][0]=0.;
         compos[j][1]=0.;
@@ -926,7 +946,9 @@ void PIV::calculate()
         Atom0[j].resize(0);
         Atom1[j].resize(0);
         // Building distances for the PIV vector at time t
-        if(timer) stopwatch.start("1 Build cPIV");
+        if(timer) {
+          stopwatch.start("1 Build cPIV");
+        }
         for(unsigned i=rank; i<nl[j]->size(); i+=stride) {
           unsigned i0=(nl[j]->getClosePairAtomNumber(i).first).index();
           unsigned i1=(nl[j]->getClosePairAtomNumber(i).second).index();
@@ -953,8 +975,12 @@ void PIV::calculate()
           A0[Vint].push_back(i0);
           A1[Vint].push_back(i1);
         }
-        if(timer) stopwatch.stop("1 Build cPIV");
-        if(timer) stopwatch.start("2 Sort cPIV");
+        if(timer) {
+          stopwatch.stop("1 Build cPIV");
+        }
+        if(timer) {
+          stopwatch.start("2 Sort cPIV");
+        }
         if(!doserial && comm.initialized()) {
           // Vectors keeping track of the dimension and the starting-position of the rank-specific pair vector in the big pair vector.
           std:: vector<int> Vdim(stride,0);
@@ -1017,8 +1043,12 @@ void PIV::calculate()
           // Loop on blocks
           //for(unsigned m=0;m<Nlist;m++) {
           // Loop on Ordering Vector size excluding zeros (i=1)
-          if(timer) stopwatch.stop("2 Sort cPIV");
-          if(timer) stopwatch.start("3 Reconstruct cPIV");
+          if(timer) {
+            stopwatch.stop("2 Sort cPIV");
+          }
+          if(timer) {
+            stopwatch.start("3 Reconstruct cPIV");
+          }
           for(unsigned i=1; i<Nprec; i++) {
             // Loop on the ranks
             for(unsigned l=0; l<stride; l++) {
@@ -1032,7 +1062,9 @@ void PIV::calculate()
               }
             }
           }
-          if(timer) stopwatch.stop("3 Reconstruct cPIV");
+          if(timer) {
+            stopwatch.stop("3 Reconstruct cPIV");
+          }
         } else {
           for(unsigned i=1; i<Nprec; i++) {
             for(unsigned m=0; m<OrdVec[i]; m++) {
@@ -1103,14 +1135,18 @@ void PIV::calculate()
     exit();
   }
 
-  if(timer) stopwatch.start("4 Build For Derivatives");
+  if(timer) {
+    stopwatch.start("4 Build For Derivatives");
+  }
   // non-global variables Nder and Scalevol defined to speedup if structures in cycles
   bool Nder=CompDer;
   bool Scalevol=Svol;
   if(getStep()%updatePIV==0) {
     // set to zero PIVdistance, derivatives and virial when they are calculated
     for(unsigned j=0; j<m_deriv.size(); j++) {
-      for(unsigned k=0; k<3; k++) {m_deriv[j][k]=0.;}
+      for(unsigned k=0; k<3; k++) {
+        m_deriv[j][k]=0.;
+      }
     }
     for(unsigned j=0; j<3; j++) {
       for(unsigned k=0; k<3; k++) {
@@ -1240,21 +1276,27 @@ void PIV::calculate()
     if (!serial && comm.initialized()) {
       comm.Barrier();
       comm.Sum(&m_PIVdistance,1);
-      if(!m_deriv.empty()) comm.Sum(&m_deriv[0][0],3*m_deriv.size());
+      if(!m_deriv.empty()) {
+        comm.Sum(&m_deriv[0][0],3*m_deriv.size());
+      }
       comm.Sum(&m_virial[0][0],9);
     }
   }
   prev_stp=getStep();
 
   //Timing
-  if(timer) stopwatch.stop("4 Build For Derivatives");
+  if(timer) {
+    stopwatch.stop("4 Build For Derivatives");
+  }
   if(timer) {
     log.printf("Timings for action %s with label %s \n", getName().c_str(), getLabel().c_str() );
     log<<stopwatch;
   }
 
   // Update derivatives, virial, and variable (PIV-distance^2)
-  for(unsigned i=0; i<m_deriv.size(); ++i) setAtomsDerivatives(i,m_deriv[i]);
+  for(unsigned i=0; i<m_deriv.size(); ++i) {
+    setAtomsDerivatives(i,m_deriv[i]);
+  }
   setValue           (m_PIVdistance);
   setBoxDerivatives  (m_virial);
 }
diff --git a/src/pytorch/PytorchModel.cpp b/src/pytorch/PytorchModel.cpp
index 7a7775e759..bf69295b22 100644
--- a/src/pytorch/PytorchModel.cpp
+++ b/src/pytorch/PytorchModel.cpp
@@ -75,8 +75,7 @@ PRINT FILE=COLVAR ARG=model.node-0,model.node-1
 
 
 class PytorchModel :
-  public Function
-{
+  public Function {
   unsigned _n_in;
   unsigned _n_out;
   torch::jit::script::Module _model;
@@ -106,8 +105,7 @@ std::vector<float> PytorchModel::tensor_to_vector(const torch::Tensor& x) {
 
 PytorchModel::PytorchModel(const ActionOptions&ao):
   Action(ao),
-  Function(ao)
-{
+  Function(ao) {
   // print libtorch version
   std::stringstream ss;
   ss << TORCH_VERSION_MAJOR << "." << TORCH_VERSION_MINOR << "." << TORCH_VERSION_PATCH;
@@ -134,8 +132,7 @@ PytorchModel::PytorchModel(const ActionOptions&ao):
     infile.close();
     if (exist) {
       plumed_merror("Cannot load FILE: '"+fname+"'. Please check that it is a Pytorch compiled model (exported with 'torch.jit.trace' or 'torch.jit.script').");
-    }
-    else {
+    } else {
       plumed_merror("The FILE: '"+fname+"' does not exist.");
     }
   }
@@ -200,8 +197,9 @@ void PytorchModel::calculate() {
 
   // retrieve arguments
   vector<float> current_S(_n_in);
-  for(unsigned i=0; i<_n_in; i++)
+  for(unsigned i=0; i<_n_in; i++) {
     current_S[i]=getArgument(i);
+  }
   //convert to tensor
   torch::Tensor input_S = torch::tensor(current_S).view({1,_n_in}).to(device);
   input_S.set_requires_grad(true);
@@ -223,8 +221,9 @@ void PytorchModel::calculate() {
     vector<float> der = this->tensor_to_vector ( gradient );
     string name_comp = "node-"+std::to_string(j);
     //set derivatives of component j
-    for(unsigned i=0; i<_n_in; i++)
+    for(unsigned i=0; i<_n_in; i++) {
       setDerivative( getPntrToComponent(name_comp),i, der[i] );
+    }
   }
 
   //set CV values
diff --git a/src/refdist/Difference.cpp b/src/refdist/Difference.cpp
index e58c3de4c9..3e389b3dbc 100644
--- a/src/refdist/Difference.cpp
+++ b/src/refdist/Difference.cpp
@@ -82,39 +82,58 @@ void Difference::registerKeywords(Keywords& keys) {
 }
 
 void Difference::read( ActionWithArguments* action ) {
-  if( action->getNumberOfArguments()!=2 ) action->error("should be two arguments to this action");
+  if( action->getNumberOfArguments()!=2 ) {
+    action->error("should be two arguments to this action");
+  }
   if( action->getPntrToArgument(0)->getRank()==action->getPntrToArgument(1)->getRank() ) {
     std::vector<unsigned> shape( action->getPntrToArgument(0)->getShape() );
     for(unsigned i=0; i<shape.size(); ++i) {
-      if( shape[i]!=action->getPntrToArgument(1)->getShape()[i] ) action->error("shapes of input actions do not match");
+      if( shape[i]!=action->getPntrToArgument(1)->getShape()[i] ) {
+        action->error("shapes of input actions do not match");
+      }
     }
   }
 
   periodic=false;
   if( action->getPntrToArgument(0)->isPeriodic() ) {
-    periodic=true; action->getPntrToArgument(0)->getDomain( min0, max0 );
+    periodic=true;
+    action->getPntrToArgument(0)->getDomain( min0, max0 );
     if( !action->getPntrToArgument(1)->isConstant() && !action->getPntrToArgument(1)->isPeriodic() ) {
       action->error("period for input variables " + action->getPntrToArgument(0)->getName() + " and " + action->getPntrToArgument(1)->getName() + " should be the same 0");
     }
     if( !action->getPntrToArgument(1)->isConstant() ) {
-      std::string min1, max1; action->getPntrToArgument(1)->getDomain( min1, max1 );
-      if( min0!=min0 || max0!=max1 ) action->error("domain for input variables should be the same");
-    } else action->getPntrToArgument(1)->setDomain( min0, max0 );
+      std::string min1, max1;
+      action->getPntrToArgument(1)->getDomain( min1, max1 );
+      if( min0!=min0 || max0!=max1 ) {
+        action->error("domain for input variables should be the same");
+      }
+    } else {
+      action->getPntrToArgument(1)->setDomain( min0, max0 );
+    }
   } else if( action->getPntrToArgument(1)->isPeriodic() ) {
-    periodic=true; action->getPntrToArgument(1)->getDomain( min0, max0 );
+    periodic=true;
+    action->getPntrToArgument(1)->getDomain( min0, max0 );
     if( !action->getPntrToArgument(1)->isConstant() ) {
       action->error("period for input variables " + action->getPntrToArgument(0)->getName() + " and " + action->getPntrToArgument(1)->getName() + " should be the same 1");
-    } else action->getPntrToArgument(0)->setDomain( min0, max0 );
+    } else {
+      action->getPntrToArgument(0)->setDomain( min0, max0 );
+    }
   }
 }
 
 void Difference::setPeriodicityForOutputs( ActionWithValue* action ) {
-  if( periodic ) action->setPeriodic( min0, max0 );
-  else action->setNotPeriodic();
+  if( periodic ) {
+    action->setPeriodic( min0, max0 );
+  } else {
+    action->setNotPeriodic();
+  }
 }
 
 void Difference::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
-  plumed_dbg_assert( args.size()==2 ); vals[0] = action->getPntrToArgument(0)->difference( args[1], args[0] ); derivatives(0,0) = 1.0; derivatives(0,1)=-1;
+  plumed_dbg_assert( args.size()==2 );
+  vals[0] = action->getPntrToArgument(0)->difference( args[1], args[0] );
+  derivatives(0,0) = 1.0;
+  derivatives(0,1)=-1;
 }
 
 }
diff --git a/src/refdist/Displacement.cpp b/src/refdist/Displacement.cpp
index 5db52c395a..ca8da2afda 100644
--- a/src/refdist/Displacement.cpp
+++ b/src/refdist/Displacement.cpp
@@ -53,23 +53,31 @@ void Displacement::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","ARG1","The point that we are calculating the distance from");
   keys.add("compulsory","ARG2","The point that we are calculating the distance to");
   keys.setValueDescription("the differences between the input arguments");
-  keys.needsAction("DIFFERENCE"); keys.needsAction("TRANSPOSE"); keys.needsAction("VSTACK");
+  keys.needsAction("DIFFERENCE");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("VSTACK");
 }
 
 std::string Displacement::fixArgumentDot( const std::string& argin ) {
-  std::string argout = argin; std::size_t dot=argin.find(".");
-  if( dot!=std::string::npos ) argout = argin.substr(0,dot) + "_" + argin.substr(dot+1);
+  std::string argout = argin;
+  std::size_t dot=argin.find(".");
+  if( dot!=std::string::npos ) {
+    argout = argin.substr(0,dot) + "_" + argin.substr(dot+1);
+  }
   return argout;
 }
 
 Displacement::Displacement( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in argument names
-  std::vector<std::string> arg1f, arg2f; parseVector("ARG1",arg1f); parseVector("ARG2",arg2f);
+  std::vector<std::string> arg1f, arg2f;
+  parseVector("ARG1",arg1f);
+  parseVector("ARG2",arg2f);
   // Check if one of the input arguments is a reference cluster
-  if( arg1f.size()!=arg2f.size() ) error("number of arguments specified to ARG1 should be same as number for ARG2");
+  if( arg1f.size()!=arg2f.size() ) {
+    error("number of arguments specified to ARG1 should be same as number for ARG2");
+  }
 
   Value* val1=getValueWithLabel( arg1f[0] );
   if( arg1f.size()==1 && val1->getRank()!=0 ) {
@@ -77,20 +85,34 @@ Displacement::Displacement( const ActionOptions& ao):
     if( val1->getNumberOfValues()==val2->getNumberOfValues() ) {
       readInputLine( getShortcutLabel() + "_" + fixArgumentDot(arg1f[0]) + "_diff: DIFFERENCE ARG=" + arg1f[0] + "," + arg2f[0] );
       readInputLine( getShortcutLabel() + ": TRANSPOSE ARG=" + getShortcutLabel() + "_" + fixArgumentDot(arg1f[0]) + "_diff");
-    } else readInputLine( getShortcutLabel() + ": DIFFERENCE ARG=" + arg1f[0] + "," + arg2f[0] );
+    } else {
+      readInputLine( getShortcutLabel() + ": DIFFERENCE ARG=" + arg1f[0] + "," + arg2f[0] );
+    }
   } else {
-    for(unsigned i=0; i<arg1f.size(); ++i) readInputLine( getShortcutLabel() + "_" + fixArgumentDot(arg1f[i]) + "_diff: DIFFERENCE ARG=" + arg1f[i] + "," + arg2f[i] );
-    std::string argdat = "ARG=" + getShortcutLabel() + "_" + fixArgumentDot(arg1f[0]) + "_diff"; for(unsigned i=1; i<arg1f.size(); ++i) argdat += "," +  getShortcutLabel() + "_" + fixArgumentDot(arg1f[i]) + "_diff";
+    for(unsigned i=0; i<arg1f.size(); ++i) {
+      readInputLine( getShortcutLabel() + "_" + fixArgumentDot(arg1f[i]) + "_diff: DIFFERENCE ARG=" + arg1f[i] + "," + arg2f[i] );
+    }
+    std::string argdat = "ARG=" + getShortcutLabel() + "_" + fixArgumentDot(arg1f[0]) + "_diff";
+    for(unsigned i=1; i<arg1f.size(); ++i) {
+      argdat += "," +  getShortcutLabel() + "_" + fixArgumentDot(arg1f[i]) + "_diff";
+    }
     readInputLine( getShortcutLabel() + ": VSTACK " + argdat );
   }
 }
 
 Value* Displacement::getValueWithLabel( const std::string& name ) const {
-  std::size_t dot=name.find("."); std::string sname = name.substr(0,dot);
+  std::size_t dot=name.find(".");
+  std::string sname = name.substr(0,dot);
   ActionWithValue* vv=plumed.getActionSet().selectWithLabel<ActionWithValue*>( sname );
-  if( !vv ) error("cannot find value with name " + name );
-  if( dot==std::string::npos ) return vv->copyOutput(0);
-  if( !vv->exists(name) ) error("cannot find value with name " + name );
+  if( !vv ) {
+    error("cannot find value with name " + name );
+  }
+  if( dot==std::string::npos ) {
+    return vv->copyOutput(0);
+  }
+  if( !vv->exists(name) ) {
+    error("cannot find value with name " + name );
+  }
   return vv->copyOutput( name );
 }
 
diff --git a/src/refdist/EuclideanDistance.cpp b/src/refdist/EuclideanDistance.cpp
index c1a1943eb2..7f3858b61c 100644
--- a/src/refdist/EuclideanDistance.cpp
+++ b/src/refdist/EuclideanDistance.cpp
@@ -51,21 +51,30 @@ void EuclideanDistance::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","ARG2","The point that we are calculating the distance to");
   keys.addFlag("SQUARED",false,"The squared distance should be calculated");
   keys.setValueDescription("the euclidean distances between the input vectors");
-  keys.needsAction("DISPLACEMENT"); keys.needsAction("CUSTOM");
-  keys.needsAction("TRANSPOSE"); keys.needsAction("MATRIX_PRODUCT_DIAGONAL");
+  keys.needsAction("DISPLACEMENT");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("MATRIX_PRODUCT_DIAGONAL");
 }
 
 EuclideanDistance::EuclideanDistance( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string arg1, arg2; parse("ARG1",arg1); parse("ARG2",arg2);
+  ActionShortcut(ao) {
+  std::string arg1, arg2;
+  parse("ARG1",arg1);
+  parse("ARG2",arg2);
   // Vectors are in rows here
   readInputLine( getShortcutLabel() + "_diff: DISPLACEMENT ARG1=" + arg1 + " ARG2=" + arg2 );
   // Get the action that computes the differences
-  ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_diff"); plumed_assert( av );
+  ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_diff");
+  plumed_assert( av );
   // Check if squared
-  bool squared; parseFlag("SQUARED",squared); std::string olab = getShortcutLabel(); if( !squared ) olab += "_2";
+  bool squared;
+  parseFlag("SQUARED",squared);
+  std::string olab = getShortcutLabel();
+  if( !squared ) {
+    olab += "_2";
+  }
   // Deal with an annoying corner case when displacement has a single argument
   if( av->copyOutput(0)->getRank()==0 ) {
     readInputLine( olab + ": CUSTOM ARG=" + getShortcutLabel() + "_diff FUNC=x*x PERIODIC=NO");
@@ -74,7 +83,9 @@ EuclideanDistance::EuclideanDistance( const ActionOptions& ao):
     readInputLine( getShortcutLabel() + "_diffT: TRANSPOSE ARG=" + getShortcutLabel() + "_diff");
     readInputLine( olab + ": MATRIX_PRODUCT_DIAGONAL ARG=" + getShortcutLabel() + "_diff," + getShortcutLabel() + "_diffT");
   }
-  if( !squared ) readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_2 FUNC=sqrt(x) PERIODIC=NO");
+  if( !squared ) {
+    readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_2 FUNC=sqrt(x) PERIODIC=NO");
+  }
 }
 
 }
diff --git a/src/refdist/Kernel.cpp b/src/refdist/Kernel.cpp
index 5176ea3c77..a8ea4cb9d1 100644
--- a/src/refdist/Kernel.cpp
+++ b/src/refdist/Kernel.cpp
@@ -63,98 +63,169 @@ void Kernel::registerKeywords(Keywords& keys) {
   keys.add("compulsory","NUMBER","1","if there are multiple sets of kernel parameters in the input file which set of kernel parameters would you like to read in here");
   keys.addFlag("NORMALIZED",false,"would you like the kernel function to be normalized");
   keys.setValueDescription("the value of the kernel evaluated at the argument values");
-  keys.needsAction("CONSTANT"); keys.needsAction("CUSTOM"); keys.needsAction("NORMALIZED_EUCLIDEAN_DISTANCE");
-  keys.needsAction("PRODUCT"); keys.needsAction("INVERT_MATRIX"); keys.needsAction("MAHALANOBIS_DISTANCE");
-  keys.needsAction("DIAGONALIZE"); keys.needsAction("CONCATENATE"); keys.needsAction("DETERMINANT");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("NORMALIZED_EUCLIDEAN_DISTANCE");
+  keys.needsAction("PRODUCT");
+  keys.needsAction("INVERT_MATRIX");
+  keys.needsAction("MAHALANOBIS_DISTANCE");
+  keys.needsAction("DIAGONALIZE");
+  keys.needsAction("CONCATENATE");
+  keys.needsAction("DETERMINANT");
   keys.needsAction("BESSEL");
 }
 
 std::string Kernel::fixArgumentDot( const std::string& argin ) {
-  std::string argout = argin; std::size_t dot=argin.find(".");
-  if( dot!=std::string::npos ) argout = argin.substr(0,dot) + "_" + argin.substr(dot+1);
+  std::string argout = argin;
+  std::size_t dot=argin.find(".");
+  if( dot!=std::string::npos ) {
+    argout = argin.substr(0,dot) + "_" + argin.substr(dot+1);
+  }
   return argout;
 }
 
 Kernel::Kernel(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in the arguments
-  std::vector<std::string> argnames; parseVector("ARG",argnames);
-  if( argnames.size()==0 ) error("no arguments were specified");
+  std::vector<std::string> argnames;
+  parseVector("ARG",argnames);
+  if( argnames.size()==0 ) {
+    error("no arguments were specified");
+  }
   // Now sort out the parameters
-  double weight; std::string fname; parse("REFERENCE",fname); bool usemahalanobis=false;
+  double weight;
+  std::string fname;
+  parse("REFERENCE",fname);
+  bool usemahalanobis=false;
   if( fname.length()>0 ) {
-    IFile ifile; ifile.open(fname); ifile.allowIgnoredFields();
-    unsigned number; parse("NUMBER",number); bool readline=false;
+    IFile ifile;
+    ifile.open(fname);
+    ifile.allowIgnoredFields();
+    unsigned number;
+    parse("NUMBER",number);
+    bool readline=false;
     // Create actions to hold the position of the center
     for(unsigned line=0; line<number; ++line) {
       for(unsigned i=0; i<argnames.size(); ++i) {
-        std::string val; ifile.scanField(argnames[i], val);
-        if( line==number-1 ) readInputLine( getShortcutLabel() + "_" + fixArgumentDot(argnames[i]) + "_ref: CONSTANT VALUES=" + val );
+        std::string val;
+        ifile.scanField(argnames[i], val);
+        if( line==number-1 ) {
+          readInputLine( getShortcutLabel() + "_" + fixArgumentDot(argnames[i]) + "_ref: CONSTANT VALUES=" + val );
+        }
       }
       if( ifile.FieldExist("sigma_" + argnames[0]) ) {
         std::string varstr;
         for(unsigned i=0; i<argnames.size(); ++i) {
-          std::string val; ifile.scanField("sigma_" + argnames[i], val);
-          if( i==0 ) varstr = val; else varstr += "," + val;
+          std::string val;
+          ifile.scanField("sigma_" + argnames[i], val);
+          if( i==0 ) {
+            varstr = val;
+          } else {
+            varstr += "," + val;
+          }
+        }
+        if( line==number-1 ) {
+          readInputLine( getShortcutLabel() + "_var: CONSTANT VALUES=" + varstr );
         }
-        if( line==number-1 ) readInputLine( getShortcutLabel() + "_var: CONSTANT VALUES=" + varstr );
       } else {
-        std::string varstr, nvals; Tools::convert( argnames.size(), nvals ); usemahalanobis=(argnames.size()>1);
+        std::string varstr, nvals;
+        Tools::convert( argnames.size(), nvals );
+        usemahalanobis=(argnames.size()>1);
         for(unsigned i=0; i<argnames.size(); ++i) {
           for(unsigned j=0; j<argnames.size(); j++) {
-            std::string val; ifile.scanField("sigma_" +argnames[i] + "_" + argnames[j], val );
-            if(i==0 && j==0 ) varstr = val; else varstr += "," + val;
+            std::string val;
+            ifile.scanField("sigma_" +argnames[i] + "_" + argnames[j], val );
+            if(i==0 && j==0 ) {
+              varstr = val;
+            } else {
+              varstr += "," + val;
+            }
           }
         }
         if( line==number-1 ) {
-          if( !usemahalanobis ) readInputLine( getShortcutLabel() + "_var: CONSTANT VALUES=" + varstr );
-          else readInputLine( getShortcutLabel() + "_cov: CONSTANT NCOLS=" + nvals + " NROWS=" + nvals + " VALUES=" + varstr );
+          if( !usemahalanobis ) {
+            readInputLine( getShortcutLabel() + "_var: CONSTANT VALUES=" + varstr );
+          } else {
+            readInputLine( getShortcutLabel() + "_cov: CONSTANT NCOLS=" + nvals + " NROWS=" + nvals + " VALUES=" + varstr );
+          }
         }
       }
-      if( line==number-1 ) { readline=true; break; }
+      if( line==number-1 ) {
+        readline=true;
+        break;
+      }
       ifile.scanField();
     }
-    if( !readline ) error("could not read reference configuration");
-    ifile.scanField(); ifile.close();
+    if( !readline ) {
+      error("could not read reference configuration");
+    }
+    ifile.scanField();
+    ifile.close();
   } else {
     // Create actions to hold the position of the center
-    std::vector<std::string> center(argnames.size()); parseVector("CENTER",center);
-    for(unsigned i=0; i<argnames.size(); ++i) readInputLine( getShortcutLabel() + "_" + fixArgumentDot(argnames[i]) + "_ref: CONSTANT VALUES=" + center[i] );
-    std::vector<std::string> sig; parseVector("SIGMA",sig);
+    std::vector<std::string> center(argnames.size());
+    parseVector("CENTER",center);
+    for(unsigned i=0; i<argnames.size(); ++i) {
+      readInputLine( getShortcutLabel() + "_" + fixArgumentDot(argnames[i]) + "_ref: CONSTANT VALUES=" + center[i] );
+    }
+    std::vector<std::string> sig;
+    parseVector("SIGMA",sig);
     if( sig.size()==0 ) {
       // Create actions to hold the covariance
-      std::string cov; parse("COVAR",cov); usemahalanobis=(argnames.size()>1);
+      std::string cov;
+      parse("COVAR",cov);
+      usemahalanobis=(argnames.size()>1);
       if( !usemahalanobis ) {
         readInputLine( getShortcutLabel() + "_var: CONSTANT VALUES=" + cov );
       } else {
-        std::string nvals; Tools::convert( argnames.size(), nvals );
+        std::string nvals;
+        Tools::convert( argnames.size(), nvals );
         readInputLine( getShortcutLabel() + "_cov: CONSTANT NCOLS=" + nvals + " NROWS=" + nvals + " VALUES=" + cov );
       }
     } else if( sig.size()==argnames.size() ) {
       // And actions to hold the standard deviation
-      std::string valstr = sig[0]; for(unsigned i=1; i<sig.size(); ++i) valstr += "," + sig[i];
+      std::string valstr = sig[0];
+      for(unsigned i=1; i<sig.size(); ++i) {
+        valstr += "," + sig[i];
+      }
       readInputLine( getShortcutLabel() + "_sigma: CONSTANT VALUES=" + valstr );
       readInputLine( getShortcutLabel() + "_var: CUSTOM ARG=" + getShortcutLabel() + "_sigma FUNC=x*x PERIODIC=NO");
-    } else error("sigma has wrong length");
+    } else {
+      error("sigma has wrong length");
+    }
   }
 
   // Create the reference point and arguments
   std::string refpoint, argstr;
   for(unsigned i=0; i<argnames.size(); ++i) {
-    if( i==0 ) { argstr = argnames[0]; refpoint = getShortcutLabel() + "_" + fixArgumentDot(argnames[i]) + "_ref"; }
-    else { argstr += "," + argnames[1]; refpoint += "," + getShortcutLabel() + "_" + fixArgumentDot(argnames[i]) + "_ref"; }
+    if( i==0 ) {
+      argstr = argnames[0];
+      refpoint = getShortcutLabel() + "_" + fixArgumentDot(argnames[i]) + "_ref";
+    } else {
+      argstr += "," + argnames[1];
+      refpoint += "," + getShortcutLabel() + "_" + fixArgumentDot(argnames[i]) + "_ref";
+    }
   }
 
   // Get the information on the kernel type
-  std::string func_str, ktype; parse("TYPE",ktype);
-  if( ktype=="gaussian" || ktype=="von-misses" ) func_str = "exp(-x/2)";
-  else if( ktype=="triangular" ) func_str = "step(1.-sqrt(x))*(1.-sqrt(x))";
-  else func_str = ktype;
-  std::string vm_str=""; if(  ktype=="von-misses" ) vm_str=" VON_MISSES";
+  std::string func_str, ktype;
+  parse("TYPE",ktype);
+  if( ktype=="gaussian" || ktype=="von-misses" ) {
+    func_str = "exp(-x/2)";
+  } else if( ktype=="triangular" ) {
+    func_str = "step(1.-sqrt(x))*(1.-sqrt(x))";
+  } else {
+    func_str = ktype;
+  }
+  std::string vm_str="";
+  if(  ktype=="von-misses" ) {
+    vm_str=" VON_MISSES";
+  }
 
-  unsigned nvals = argnames.size(); bool norm; parseFlag("NORMALIZED",norm);
+  unsigned nvals = argnames.size();
+  bool norm;
+  parseFlag("NORMALIZED",norm);
   if( !usemahalanobis ) {
     // Invert the variance
     readInputLine( getShortcutLabel() + "_icov: CUSTOM ARG=" + getShortcutLabel() + "_var FUNC=1/x PERIODIC=NO");
@@ -162,8 +233,11 @@ Kernel::Kernel(const ActionOptions&ao):
     readInputLine( getShortcutLabel() + "_dist_2: NORMALIZED_EUCLIDEAN_DISTANCE SQUARED" + vm_str +" ARG1=" + argstr + " ARG2=" + refpoint + " METRIC=" + getShortcutLabel() + "_icov");
     // And compute a determinent for the input covariance matrix if it is required
     if( norm ) {
-      if( ktype=="von-misses" ) readInputLine( getShortcutLabel() + "_vec: CUSTOM ARG=" + getShortcutLabel() + "_icov FUNC=x PERIODIC=NO" );
-      else readInputLine( getShortcutLabel() + "_det: PRODUCT ARG=" + getShortcutLabel() + "_var");
+      if( ktype=="von-misses" ) {
+        readInputLine( getShortcutLabel() + "_vec: CUSTOM ARG=" + getShortcutLabel() + "_icov FUNC=x PERIODIC=NO" );
+      } else {
+        readInputLine( getShortcutLabel() + "_det: PRODUCT ARG=" + getShortcutLabel() + "_var");
+      }
     }
   } else {
     // Invert the input covariance matrix
@@ -175,7 +249,10 @@ Kernel::Kernel(const ActionOptions&ao):
       if( ktype=="von-misses" ) {
         readInputLine( getShortcutLabel() + "_det: DIAGONALIZE ARG=" + getShortcutLabel() + "_cov VECTORS=all" );
         std::string num, argnames= getShortcutLabel() + "_det.vals-1";
-        for(unsigned i=1; i<nvals; ++i) { Tools::convert( i+1, num ); argnames += "," + getShortcutLabel() + "_det.vals-" + num; }
+        for(unsigned i=1; i<nvals; ++i) {
+          Tools::convert( i+1, num );
+          argnames += "," + getShortcutLabel() + "_det.vals-" + num;
+        }
         readInputLine( getShortcutLabel() + "_comp: CONCATENATE ARG=" + argnames );
         readInputLine( getShortcutLabel() + "_vec: CUSTOM ARG=" + getShortcutLabel() + "_comp FUNC=1/x PERIODIC=NO");
       } else {
@@ -185,20 +262,27 @@ Kernel::Kernel(const ActionOptions&ao):
   }
 
   // Compute the Gaussian
-  std::string wstr; parse("WEIGHT",wstr);
+  std::string wstr;
+  parse("WEIGHT",wstr);
   if( norm ) {
     if( ktype=="gaussian" ) {
-      std::string pstr; Tools::convert( sqrt(pow(2*pi,nvals)), pstr );
+      std::string pstr;
+      Tools::convert( sqrt(pow(2*pi,nvals)), pstr );
       readInputLine( getShortcutLabel() + "_vol: CUSTOM ARG=" + getShortcutLabel() + "_det FUNC=(sqrt(x)*" + pstr + ") PERIODIC=NO");
     } else if( ktype=="von-misses" ) {
       std::string wstr, min, max;
-      ActionWithValue* av=plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_dist_2_diff" ); plumed_assert( av );
-      if( !av->copyOutput(0)->isPeriodic() ) error("VON_MISSES only works with periodic variables");
+      ActionWithValue* av=plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_dist_2_diff" );
+      plumed_assert( av );
+      if( !av->copyOutput(0)->isPeriodic() ) {
+        error("VON_MISSES only works with periodic variables");
+      }
       av->copyOutput(0)->getDomain(min,max);
       readInputLine( getShortcutLabel() + "_bes: BESSEL ORDER=0 ARG=" + getShortcutLabel() + "_vec");
       readInputLine( getShortcutLabel() + "_cc: CUSTOM ARG=" + getShortcutLabel() + "_bes FUNC=("+max+"-"+min+")*x PERIODIC=NO");
       readInputLine( getShortcutLabel() + "_vol: PRODUCT ARG=" + getShortcutLabel() + "_cc");
-    } else error("only gaussian and von-misses kernels are normalizable");
+    } else {
+      error("only gaussian and von-misses kernels are normalizable");
+    }
     // And the (suitably normalized) kernel
     readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_dist_2," + getShortcutLabel() + "_vol FUNC=" + wstr + "*exp(-x/2)/y PERIODIC=NO");
   } else {
diff --git a/src/refdist/MahalanobisDistance.cpp b/src/refdist/MahalanobisDistance.cpp
index 69dfe9659d..4bd003d342 100644
--- a/src/refdist/MahalanobisDistance.cpp
+++ b/src/refdist/MahalanobisDistance.cpp
@@ -53,44 +53,70 @@ void MahalanobisDistance::registerKeywords( Keywords& keys ) {
   keys.addFlag("SQUARED",false,"The squared distance should be calculated");
   keys.addFlag("VON_MISSES",false,"Compute the mahalanobis distance in a way that is more sympathetic to the periodic boundary conditions");
   keys.setValueDescription("the Mahalanobis distances between the input vectors");
-  keys.needsAction("DISPLACEMENT"); keys.needsAction("CUSTOM"); keys.needsAction("OUTER_PRODUCT");
-  keys.needsAction("TRANSPOSE"); keys.needsAction("MATRIX_PRODUCT_DIAGONAL"); keys.needsAction("CONSTANT");
-  keys.needsAction("MATRIX_VECTOR_PRODUCT"); keys.needsAction("MATRIX_PRODUCT"); keys.needsAction("COMBINE");
+  keys.needsAction("DISPLACEMENT");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("OUTER_PRODUCT");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("MATRIX_PRODUCT_DIAGONAL");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("MATRIX_PRODUCT");
+  keys.needsAction("COMBINE");
 }
 
 MahalanobisDistance::MahalanobisDistance( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string arg1, arg2, metstr; parse("ARG1",arg1); parse("ARG2",arg2); parse("METRIC",metstr);
+  ActionShortcut(ao) {
+  std::string arg1, arg2, metstr;
+  parse("ARG1",arg1);
+  parse("ARG2",arg2);
+  parse("METRIC",metstr);
   // Check on input metric
   ActionWithValue* mav=plumed.getActionSet().selectWithLabel<ActionWithValue*>( metstr );
-  if( !mav ) error("could not find action named " + metstr + " to use for metric");
-  if( mav->copyOutput(0)->getRank()!=2 ) error("metric has incorrect rank");
+  if( !mav ) {
+    error("could not find action named " + metstr + " to use for metric");
+  }
+  if( mav->copyOutput(0)->getRank()!=2 ) {
+    error("metric has incorrect rank");
+  }
 
   readInputLine( getShortcutLabel() + "_diff: DISPLACEMENT ARG1=" + arg1 + " ARG2=" + arg2 );
   readInputLine( getShortcutLabel() + "_diffT: TRANSPOSE ARG=" + getShortcutLabel() + "_diff");
-  bool von_miss, squared; parseFlag("VON_MISSES",von_miss); parseFlag("SQUARED",squared);
+  bool von_miss, squared;
+  parseFlag("VON_MISSES",von_miss);
+  parseFlag("SQUARED",squared);
   if( von_miss ) {
     unsigned nrows = mav->copyOutput(0)->getShape()[0];
-    if( mav->copyOutput(0)->getShape()[1]!=nrows ) error("metric is not symmetric");
+    if( mav->copyOutput(0)->getShape()[1]!=nrows ) {
+      error("metric is not symmetric");
+    }
     // Create a matrix that can be used to compute the off diagonal elements
     std::string valstr, nrstr;
-    Tools::convert( mav->copyOutput(0)->get(0), valstr ); Tools::convert( nrows, nrstr );
+    Tools::convert( mav->copyOutput(0)->get(0), valstr );
+    Tools::convert( nrows, nrstr );
     std::string diagmet = getShortcutLabel() + "_diagmet: CONSTANT VALUES=" + valstr;
     std::string offdiagmet = getShortcutLabel() + "_offdiagmet: CONSTANT NROWS=" + nrstr + " NCOLS=" + nrstr + " VALUES=0";
     for(unsigned i=0; i<nrows; ++i) {
       for(unsigned j=0; j<nrows; ++j) {
         Tools::convert( mav->copyOutput(0)->get(i*nrows+j), valstr );
-        if( i==j && i>0 ) { offdiagmet += ",0"; diagmet += "," + valstr; }
-        else if( i!=j ) { offdiagmet += "," + valstr; }
+        if( i==j && i>0 ) {
+          offdiagmet += ",0";
+          diagmet += "," + valstr;
+        } else if( i!=j ) {
+          offdiagmet += "," + valstr;
+        }
       }
     }
-    readInputLine( diagmet ); readInputLine( offdiagmet );
+    readInputLine( diagmet );
+    readInputLine( offdiagmet );
     // Compute distances scaled by periods
-    ActionWithValue* av=plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_diff" ); plumed_assert( av );
-    if( !av->copyOutput(0)->isPeriodic() ) error("VON_MISSES only works with periodic variables");
-    std::string min, max; av->copyOutput(0)->getDomain(min,max);
+    ActionWithValue* av=plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_diff" );
+    plumed_assert( av );
+    if( !av->copyOutput(0)->isPeriodic() ) {
+      error("VON_MISSES only works with periodic variables");
+    }
+    std::string min, max;
+    av->copyOutput(0)->getDomain(min,max);
     readInputLine( getShortcutLabel() + "_scaled: CUSTOM ARG=" + getShortcutLabel() + "_diffT FUNC=2*pi*x/(" + max +"-" + min + ") PERIODIC=NO");
     // We start calculating off-diagonal elements by computing the sines of the scaled differences (this is a column vector)
     readInputLine( getShortcutLabel() + "_sinediffT: CUSTOM ARG=" + getShortcutLabel() + "_scaled FUNC=sin(x) PERIODIC=NO");
@@ -104,7 +130,10 @@ MahalanobisDistance::MahalanobisDistance( const ActionOptions& ao):
     // If this is a matrix we need create a matrix to multiply by
     if( av->copyOutput(0)->getShape()[0]>1 ) {
       // Create some ones
-      std::string ones=" VALUES=1"; for(unsigned i=1; i<av->copyOutput(0)->getShape()[0]; ++i ) ones += ",1";
+      std::string ones=" VALUES=1";
+      for(unsigned i=1; i<av->copyOutput(0)->getShape()[0]; ++i ) {
+        ones += ",1";
+      }
       readInputLine( getShortcutLabel() + "_ones: CONSTANT " + ones );
       // Now do some multiplication to create a matrix that can be multiplied by our "inverse variance" vector
       readInputLine( getShortcutLabel() + "_" + metstr + ": OUTER_PRODUCT ARG=" + metstr2 + "," + getShortcutLabel() + "_ones");
@@ -112,21 +141,38 @@ MahalanobisDistance::MahalanobisDistance( const ActionOptions& ao):
     }
     // Compute the diagonal elements
     readInputLine( getShortcutLabel() + "_prod: CUSTOM ARG=" + getShortcutLabel() + "_scaled," + metstr2 + " FUNC=2*(1-cos(x))*y PERIODIC=NO");
-    std::string ncstr; Tools::convert( nrows, ncstr ); Tools::convert( av->copyOutput(0)->getShape()[0], nrstr );
-    std::string ones=" VALUES=1"; for(unsigned i=1; i<av->copyOutput(0)->getNumberOfValues(); ++i) ones += ",1";
+    std::string ncstr;
+    Tools::convert( nrows, ncstr );
+    Tools::convert( av->copyOutput(0)->getShape()[0], nrstr );
+    std::string ones=" VALUES=1";
+    for(unsigned i=1; i<av->copyOutput(0)->getNumberOfValues(); ++i) {
+      ones += ",1";
+    }
     readInputLine( getShortcutLabel() + "_matones: CONSTANT NROWS=" + nrstr + " NCOLS=" + ncstr + ones );
     readInputLine( getShortcutLabel() + "_diag: MATRIX_PRODUCT_DIAGONAL ARG=" + getShortcutLabel() + "_matones," + getShortcutLabel() + "_prod");
     // Sum everything
-    if( !squared ) readInputLine( getShortcutLabel() + "_2: COMBINE ARG=" + getShortcutLabel() + "_offdiag," + getShortcutLabel() + "_diag PERIODIC=NO");
-    else readInputLine( getShortcutLabel() + ": COMBINE ARG=" + getShortcutLabel() + "_offdiag," + getShortcutLabel() + "_diag PERIODIC=NO");
+    if( !squared ) {
+      readInputLine( getShortcutLabel() + "_2: COMBINE ARG=" + getShortcutLabel() + "_offdiag," + getShortcutLabel() + "_diag PERIODIC=NO");
+    } else {
+      readInputLine( getShortcutLabel() + ": COMBINE ARG=" + getShortcutLabel() + "_offdiag," + getShortcutLabel() + "_diag PERIODIC=NO");
+    }
   } else {
-    ActionWithValue* av=plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_diffT" ); plumed_assert( av && av->getNumberOfComponents()==1 );
-    if( (av->copyOutput(0))->getRank()==1 ) readInputLine( getShortcutLabel() + "_matvec: MATRIX_VECTOR_PRODUCT ARG=" + metstr + "," + getShortcutLabel() +"_diffT");
-    else readInputLine( getShortcutLabel() + "_matvec: MATRIX_PRODUCT ARG=" + metstr + "," + getShortcutLabel() +"_diffT");
-    std::string olab = getShortcutLabel(); if( !squared ) olab += "_2";
+    ActionWithValue* av=plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_diffT" );
+    plumed_assert( av && av->getNumberOfComponents()==1 );
+    if( (av->copyOutput(0))->getRank()==1 ) {
+      readInputLine( getShortcutLabel() + "_matvec: MATRIX_VECTOR_PRODUCT ARG=" + metstr + "," + getShortcutLabel() +"_diffT");
+    } else {
+      readInputLine( getShortcutLabel() + "_matvec: MATRIX_PRODUCT ARG=" + metstr + "," + getShortcutLabel() +"_diffT");
+    }
+    std::string olab = getShortcutLabel();
+    if( !squared ) {
+      olab += "_2";
+    }
     readInputLine( olab + ": MATRIX_PRODUCT_DIAGONAL ARG=" + getShortcutLabel() + "_diff," + getShortcutLabel() +"_matvec");
   }
-  if( !squared ) readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_2 FUNC=sqrt(x) PERIODIC=NO");
+  if( !squared ) {
+    readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_2 FUNC=sqrt(x) PERIODIC=NO");
+  }
 }
 
 }
diff --git a/src/refdist/MatrixProductDiagonal.cpp b/src/refdist/MatrixProductDiagonal.cpp
index 74e32fc7fd..fdeba02c20 100644
--- a/src/refdist/MatrixProductDiagonal.cpp
+++ b/src/refdist/MatrixProductDiagonal.cpp
@@ -47,54 +47,81 @@ class MatrixProductDiagonal : public ActionWithVector {
 PLUMED_REGISTER_ACTION(MatrixProductDiagonal,"MATRIX_PRODUCT_DIAGONAL")
 
 void MatrixProductDiagonal::registerKeywords( Keywords& keys ) {
-  ActionWithVector::registerKeywords(keys); keys.use("ARG");
+  ActionWithVector::registerKeywords(keys);
+  keys.use("ARG");
   keys.setValueDescription("a vector containing the diagonal elements of the matrix that obtaned by multiplying the two input matrices together");
 }
 
 MatrixProductDiagonal::MatrixProductDiagonal(const ActionOptions&ao):
   Action(ao),
-  ActionWithVector(ao)
-{
-  if( getNumberOfArguments()!=2 ) error("should be two arguments to this action, a matrix and a vector");
+  ActionWithVector(ao) {
+  if( getNumberOfArguments()!=2 ) {
+    error("should be two arguments to this action, a matrix and a vector");
+  }
 
   unsigned ncols;
   if( getPntrToArgument(0)->getRank()==1 ) {
-    if( getPntrToArgument(0)->hasDerivatives() ) error("first argument to this action should be a vector or matrix");
+    if( getPntrToArgument(0)->hasDerivatives() ) {
+      error("first argument to this action should be a vector or matrix");
+    }
     ncols = 1;
   } else if( getPntrToArgument(0)->getRank()==2 ) {
-    if( getPntrToArgument(0)->hasDerivatives() ) error("first argument to this action should be a matrix");
+    if( getPntrToArgument(0)->hasDerivatives() ) {
+      error("first argument to this action should be a matrix");
+    }
     ncols = getPntrToArgument(0)->getShape()[1];
   }
 
   if( getPntrToArgument(1)->getRank()==1 ) {
-    if( getPntrToArgument(1)->hasDerivatives() ) error("second argument to this action should be a vector or matrix");
-    if( ncols!=getPntrToArgument(1)->getShape()[0] ) error("number of columns in first matrix does not equal number of elements in vector");
-    if( getPntrToArgument(0)->getShape()[0]!=1 ) error("matrix output by this action must be square");
-    addValueWithDerivatives(); setNotPeriodic();
+    if( getPntrToArgument(1)->hasDerivatives() ) {
+      error("second argument to this action should be a vector or matrix");
+    }
+    if( ncols!=getPntrToArgument(1)->getShape()[0] ) {
+      error("number of columns in first matrix does not equal number of elements in vector");
+    }
+    if( getPntrToArgument(0)->getShape()[0]!=1 ) {
+      error("matrix output by this action must be square");
+    }
+    addValueWithDerivatives();
+    setNotPeriodic();
   } else {
-    if( getPntrToArgument(1)->getRank()!=2 || getPntrToArgument(1)->hasDerivatives() ) error("second argument to this action should be a vector or a matrix");
-    if( ncols!=getPntrToArgument(1)->getShape()[0] ) error("number of columns in first matrix does not equal number of rows in second matrix");
-    if( getPntrToArgument(0)->getShape()[0]!=getPntrToArgument(1)->getShape()[1] ) error("matrix output by this action must be square");
-    std::vector<unsigned> shape(1); shape[0]=getPntrToArgument(0)->getShape()[0];
-    addValue( shape ); setNotPeriodic();
+    if( getPntrToArgument(1)->getRank()!=2 || getPntrToArgument(1)->hasDerivatives() ) {
+      error("second argument to this action should be a vector or a matrix");
+    }
+    if( ncols!=getPntrToArgument(1)->getShape()[0] ) {
+      error("number of columns in first matrix does not equal number of rows in second matrix");
+    }
+    if( getPntrToArgument(0)->getShape()[0]!=getPntrToArgument(1)->getShape()[1] ) {
+      error("matrix output by this action must be square");
+    }
+    std::vector<unsigned> shape(1);
+    shape[0]=getPntrToArgument(0)->getShape()[0];
+    addValue( shape );
+    setNotPeriodic();
   }
-  getPntrToArgument(0)->buildDataStore(); getPntrToArgument(1)->buildDataStore();
+  getPntrToArgument(0)->buildDataStore();
+  getPntrToArgument(1)->buildDataStore();
 }
 
 unsigned MatrixProductDiagonal::getNumberOfDerivatives() {
-  if( doNotCalculateDerivatives() ) return 0;
+  if( doNotCalculateDerivatives() ) {
+    return 0;
+  }
   return getPntrToArgument(0)->getNumberOfValues() + getPntrToArgument(1)->getNumberOfValues();;
 }
 
 void MatrixProductDiagonal::performTask( const unsigned& task_index, MultiValue& myvals ) const {
   unsigned ostrn = getConstPntrToComponent(0)->getPositionInStream();
-  Value* arg1 = getPntrToArgument(0); Value* arg2 = getPntrToArgument(1);
+  Value* arg1 = getPntrToArgument(0);
+  Value* arg2 = getPntrToArgument(1);
   if( arg1->getRank()==1 ) {
     double val1 = arg1->get( task_index );
     double val2 = arg2->get( task_index );
     myvals.addValue( ostrn, val1*val2 );
 
-    if( doNotCalculateDerivatives() ) return;
+    if( doNotCalculateDerivatives() ) {
+      return;
+    }
 
     myvals.addDerivative( ostrn, task_index, val2 );
     myvals.updateIndex( ostrn, task_index );
@@ -104,7 +131,10 @@ void MatrixProductDiagonal::performTask( const unsigned& task_index, MultiValue&
   } else {
     unsigned nmult = arg1->getRowLength(task_index);
     unsigned nrowsA = getPntrToArgument(0)->getShape()[1];
-    unsigned nrowsB = 1; if( getPntrToArgument(1)->getRank()>1 ) nrowsB = getPntrToArgument(1)->getShape()[1];
+    unsigned nrowsB = 1;
+    if( getPntrToArgument(1)->getRank()>1 ) {
+      nrowsB = getPntrToArgument(1)->getShape()[1];
+    }
     unsigned nvals1 = getPntrToArgument(0)->getNumberOfValues();
 
     double matval = 0;
@@ -114,7 +144,9 @@ void MatrixProductDiagonal::performTask( const unsigned& task_index, MultiValue&
       double val2 = arg2->get( kind*nrowsB + task_index );
       matval += val1*val2;
 
-      if( doNotCalculateDerivatives() ) continue;
+      if( doNotCalculateDerivatives() ) {
+        continue;
+      }
 
       myvals.addDerivative( ostrn, task_index*nrowsA + kind, val2 );
       myvals.updateIndex( ostrn, task_index*nrowsA + kind );
@@ -129,11 +161,17 @@ void MatrixProductDiagonal::performTask( const unsigned& task_index, MultiValue&
 void MatrixProductDiagonal::calculate() {
   if( getPntrToArgument(1)->getRank()==1 ) {
     unsigned nder = getNumberOfDerivatives();
-    MultiValue myvals( 1, nder, 0, 0, 0 ); performTask( 0, myvals );
+    MultiValue myvals( 1, nder, 0, 0, 0 );
+    performTask( 0, myvals );
 
-    Value* myval=getPntrToComponent(0); myval->set( myvals.get(0) );
-    for(unsigned i=0; i<nder; ++i) myval->setDerivative( i, myvals.getDerivative(0,i) );
-  } else runAllTasks();
+    Value* myval=getPntrToComponent(0);
+    myval->set( myvals.get(0) );
+    for(unsigned i=0; i<nder; ++i) {
+      myval->setDerivative( i, myvals.getDerivative(0,i) );
+    }
+  } else {
+    runAllTasks();
+  }
 }
 
 }
diff --git a/src/refdist/NormalizedEuclideanDistance.cpp b/src/refdist/NormalizedEuclideanDistance.cpp
index efa96fdfec..b0bfc692f7 100644
--- a/src/refdist/NormalizedEuclideanDistance.cpp
+++ b/src/refdist/NormalizedEuclideanDistance.cpp
@@ -52,38 +52,55 @@ void NormalizedEuclideanDistance::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","METRIC","The inverse covariance matrix that should be used when calculating the distance");
   keys.addFlag("SQUARED",false,"The squared distance should be calculated");
   keys.setValueDescription("the normalized euclidean distances between the input vectors");
-  keys.needsAction("DISPLACEMENT"); keys.needsAction("CUSTOM"); keys.needsAction("OUTER_PRODUCT");
-  keys.needsAction("TRANSPOSE"); keys.needsAction("MATRIX_PRODUCT_DIAGONAL"); keys.needsAction("ONES");
+  keys.needsAction("DISPLACEMENT");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("OUTER_PRODUCT");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("MATRIX_PRODUCT_DIAGONAL");
+  keys.needsAction("ONES");
 }
 
 NormalizedEuclideanDistance::NormalizedEuclideanDistance( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string arg1, arg2, metstr; parse("ARG1",arg1); parse("ARG2",arg2); parse("METRIC",metstr);
+  ActionShortcut(ao) {
+  std::string arg1, arg2, metstr;
+  parse("ARG1",arg1);
+  parse("ARG2",arg2);
+  parse("METRIC",metstr);
   // Vectors are in rows here
   readInputLine( getShortcutLabel() + "_diff: DISPLACEMENT ARG1=" + arg1 + " ARG2=" + arg2 );
   // Vectors are in columns here
   readInputLine( getShortcutLabel() + "_diffT: TRANSPOSE ARG=" + getShortcutLabel() + "_diff");
   // Get the action that computes the differences
-  ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_diffT"); plumed_assert( av );
+  ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_diffT");
+  plumed_assert( av );
   // If this is a matrix we need create a matrix to multiply by
   if( av->copyOutput(0)->getRank()==2 ) {
     // Create some ones
-    std::string nones; Tools::convert( av->copyOutput(0)->getShape()[1], nones );
+    std::string nones;
+    Tools::convert( av->copyOutput(0)->getShape()[1], nones );
     readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + nones);
     // Now do some multiplication to create a matrix that can be multiplied by our "inverse variance" vector
     if( av->copyOutput(0)->getShape()[0]==1 ) {
       readInputLine( getShortcutLabel() + "_" + metstr + "T: CUSTOM ARG=" + metstr + "," + getShortcutLabel() + "_ones FUNC=x*y PERIODIC=NO");
       readInputLine( getShortcutLabel() + "_" + metstr + ": TRANSPOSE ARG=" + getShortcutLabel() + "_" + metstr + "T");
-    } else readInputLine( getShortcutLabel() + "_" + metstr + ": OUTER_PRODUCT ARG=" + metstr + "," + getShortcutLabel() + "_ones");
+    } else {
+      readInputLine( getShortcutLabel() + "_" + metstr + ": OUTER_PRODUCT ARG=" + metstr + "," + getShortcutLabel() + "_ones");
+    }
     metstr = getShortcutLabel() + "_" + metstr;
   }
   // Now do the multiplication
   readInputLine( getShortcutLabel() + "_sdiff: CUSTOM ARG=" + metstr + "," + getShortcutLabel() +"_diffT FUNC=x*y PERIODIC=NO");
-  bool squared; parseFlag("SQUARED",squared); std::string olab = getShortcutLabel(); if( !squared ) olab += "_2";
+  bool squared;
+  parseFlag("SQUARED",squared);
+  std::string olab = getShortcutLabel();
+  if( !squared ) {
+    olab += "_2";
+  }
   readInputLine( olab + ": MATRIX_PRODUCT_DIAGONAL ARG=" + getShortcutLabel() +"_diff," + getShortcutLabel() + "_sdiff");
-  if( !squared ) readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_2 FUNC=sqrt(x) PERIODIC=NO");
+  if( !squared ) {
+    readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_2 FUNC=sqrt(x) PERIODIC=NO");
+  }
 }
 
 }
diff --git a/src/s2cm/S2ContactModel.cpp b/src/s2cm/S2ContactModel.cpp
index 0fbb3f5f0e..0061dafca3 100644
--- a/src/s2cm/S2ContactModel.cpp
+++ b/src/s2cm/S2ContactModel.cpp
@@ -113,8 +113,7 @@ S2ContactModel::S2ContactModel(const ActionOptions&ao):
   n_i_(0.0),
   total_prefactor_(0.0),
   r_globalshift_(0.0),
-  modeltype_(methyl)
-{
+  modeltype_(methyl) {
 
   parseFlag("SERIAL",serial_);
 
@@ -162,9 +161,13 @@ S2ContactModel::S2ContactModel(const ActionOptions&ao):
   parseFlag("NLIST",doneigh);
   if(doneigh) {
     parse("NL_CUTOFF",nl_cut);
-    if(nl_cut<=0.0) error("NL_CUTOFF should be explicitly specified and positive");
+    if(nl_cut<=0.0) {
+      error("NL_CUTOFF should be explicitly specified and positive");
+    }
     parse("NL_STRIDE",nl_st);
-    if(nl_st<=0) error("NL_STRIDE should be explicitly specified and positive");
+    if(nl_st<=0) {
+      error("NL_STRIDE should be explicitly specified and positive");
+    }
   }
 
   parse("R_EFF",r_eff_);
@@ -187,8 +190,7 @@ S2ContactModel::S2ContactModel(const ActionOptions&ao):
   bool dopair=false;
   if(doneigh) {
     nl=Tools::make_unique<NeighborList>(main_atoms,heavy_atoms,serial_,dopair,pbc_,getPbc(),comm,nl_cut,nl_st);
-  }
-  else {
+  } else {
     nl=Tools::make_unique<NeighborList>(main_atoms,heavy_atoms,serial_,dopair,pbc_,getPbc(),comm);
   }
 
@@ -202,15 +204,16 @@ S2ContactModel::S2ContactModel(const ActionOptions&ao):
     log << plumed.cite("Ming and Bruschweiler, J. Biomol. NMR, 29, 363 (2004) - DOI:10.1023/B:JNMR.0000032612.70767.35");
     log.printf("\n");
     log.printf("  calculation of methyl order parameter using atom %d \n",methyl_atom[0].serial());
-  }
-  else if(modeltype_==nh) {
+  } else if(modeltype_==nh) {
     log << plumed.cite("Zhang and Bruschweiler, J. Am. Chem. Soc. 124, 12654 (2002) - DOI:10.1021/ja027847a");
     log.printf("\n");
     log.printf("  calculation of NH order parameter using atoms %d and %d\n",nh_atoms[0].serial(),nh_atoms[1].serial());
   }
   log.printf("  heavy atoms used in the calculation (%u in total):\n",static_cast<unsigned int>(heavy_atoms.size()));
   for(unsigned int i=0; i<heavy_atoms.size(); ++i) {
-    if( (i+1) % 25 == 0 ) {log.printf("  \n");}
+    if( (i+1) % 25 == 0 ) {
+      log.printf("  \n");
+    }
     log.printf("  %d", heavy_atoms[i].serial());
   }
   log.printf("  \n");
@@ -252,9 +255,13 @@ void S2ContactModel::prepare() {
     } else {
       requestAtoms(nl->getReducedAtomList());
       invalidateList=false;
-      if(getExchangeStep()) error("Neighbor lists should be updated on exchange steps - choose a NL_STRIDE which divides the exchange stride!");
+      if(getExchangeStep()) {
+        error("Neighbor lists should be updated on exchange steps - choose a NL_STRIDE which divides the exchange stride!");
+      }
+    }
+    if(getExchangeStep()) {
+      firsttime=true;
     }
-    if(getExchangeStep()) firsttime=true;
   }
 }
 
@@ -283,7 +290,9 @@ void S2ContactModel::calculate() {
     Vector distance;
     unsigned int i0=nl->getClosePair(i).first;
     unsigned int i1=nl->getClosePair(i).second;
-    if(getAbsoluteIndex(i0)==getAbsoluteIndex(i1)) {continue;}
+    if(getAbsoluteIndex(i0)==getAbsoluteIndex(i1)) {
+      continue;
+    }
 
     if(pbc_) {
       distance=pbcDistance(getPosition(i0),getPosition(i1));
diff --git a/src/sasa/sasa_HASEL.cpp b/src/sasa/sasa_HASEL.cpp
index 0373ec5ce1..580f4a2ffc 100644
--- a/src/sasa/sasa_HASEL.cpp
+++ b/src/sasa/sasa_HASEL.cpp
@@ -182,32 +182,42 @@ SASA_HASEL::SASA_HASEL(const ActionOptions&ao):
   nl_update(0),
   DeltaGValues("absent"),
   Ti(0),
-  firstStepFlag(0)
-{
+  firstStepFlag(0) {
   rs = 0.14;
   parse("DELTAGFILE",DeltaGValues);
   parse("APPROACH", approach);
   parseAtomList("ATOMS",atoms);
-  if(atoms.size()==0) error("no atoms specified");
+  if(atoms.size()==0) {
+    error("no atoms specified");
+  }
   std::string Type;
   parse("TYPE",Type);
   parse("NL_STRIDE", stride);
   parseFlag("NOPBC",nopbc);
   checkRead();
 
-  if(Type=="TOTAL") sasa_type=TOTAL;
-  else if(Type=="TRANSFER") sasa_type=TRANSFER;
-  else error("Unknown SASA type");
+  if(Type=="TOTAL") {
+    sasa_type=TOTAL;
+  } else if(Type=="TRANSFER") {
+    sasa_type=TRANSFER;
+  } else {
+    error("Unknown SASA type");
+  }
 
-  switch(sasa_type)
-  {
-  case TOTAL:   log.printf("  TOTAL SASA;"); break;
-  case TRANSFER: log.printf("  TRANSFER MODEL;"); break;
+  switch(sasa_type) {
+  case TOTAL:
+    log.printf("  TOTAL SASA;");
+    break;
+  case TRANSFER:
+    log.printf("  TRANSFER MODEL;");
+    break;
   }
 
   log.printf("  atoms involved : ");
   for(unsigned i=0; i<atoms.size(); ++i) {
-    if(i%25==0) log<<"\n";
+    if(i%25==0) {
+      log<<"\n";
+    }
     log.printf("%d ",atoms[i].serial());
   }
   log.printf("\n");
@@ -219,7 +229,8 @@ SASA_HASEL::SASA_HASEL(const ActionOptions&ao):
   }
 
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
   requestAtoms(atoms);
 
   natoms = getNumberOfAtoms();
@@ -236,8 +247,7 @@ SASA_HASEL::SASA_HASEL(const ActionOptions&ao):
 
 //splits strings into tokens. Used to read into SASA parameters file and into reference pdb file
 template <class Container>
-void split(const std::string& str, Container& cont)
-{
+void split(const std::string& str, Container& cont) {
   std::istringstream iss(str);
   std::copy(std::istream_iterator<std::string>(iss),
             std::istream_iterator<std::string>(),
@@ -249,7 +259,9 @@ void split(const std::string& str, Container& cont)
 
 void SASA_HASEL::readPDB() {
   auto* moldat = plumed.getActionSet().selectLatest<GenericMolInfo*>(this);
-  if( ! moldat ) error("Unable to find MOLINFO in input");
+  if( ! moldat ) {
+    error("Unable to find MOLINFO in input");
+  }
   AtomResidueName[0].clear();
   AtomResidueName[1].clear();
 
@@ -587,9 +599,12 @@ void SASA_HASEL::readDeltaG() {
         }
       }
     }
-    if ( backboneflag == 0) error("Cannot find backbone value in Delta G parameters file\n");
+    if ( backboneflag == 0) {
+      error("Cannot find backbone value in Delta G parameters file\n");
+    }
+  } else {
+    error("Cannot open DeltaG file");
   }
-  else error("Cannot open DeltaG file");
 
   for(unsigned i=0; i<natoms; i++) {
     if (DeltaG[i].size()==0 ) {
@@ -760,7 +775,9 @@ void SASA_HASEL::computeDeltaG() {
 
 //calculates neighbor list
 void SASA_HASEL::calcNlist() {
-  if(!nopbc) makeWhole();
+  if(!nopbc) {
+    makeWhole();
+  }
 
   for(unsigned i = 0; i < natoms; i++) {
     Nlist[i].clear();
@@ -786,9 +803,13 @@ void SASA_HASEL::calcNlist() {
 
 //calculates SASA according to Hasel et al., Tetrahedron Computer Methodology Vol. 1, No. 2, pp. 103-116, 1988
 void SASA_HASEL::calculate() {
-  if(!nopbc) makeWhole();
+  if(!nopbc) {
+    makeWhole();
+  }
 
-  if(getExchangeStep()) nl_update = 0;
+  if(getExchangeStep()) {
+    nl_update = 0;
+  }
   if (firstStepFlag ==0) {
     readPDB();
     readSASAparam();
@@ -799,7 +820,9 @@ void SASA_HASEL::calculate() {
 
 
   auto* moldat = plumed.getActionSet().selectLatest<GenericMolInfo*>(this);
-  if( ! moldat ) error("Unable to find MOLINFO in input");
+  if( ! moldat ) {
+    error("Unable to find MOLINFO in input");
+  }
   double Si, sasai, bij;
   double sasa = 0;
   vector<Vector> derivatives( natoms );
diff --git a/src/sasa/sasa_LCPO.cpp b/src/sasa/sasa_LCPO.cpp
index 094592f12e..ecf634d014 100755
--- a/src/sasa/sasa_LCPO.cpp
+++ b/src/sasa/sasa_LCPO.cpp
@@ -180,32 +180,42 @@ SASA_LCPO::SASA_LCPO(const ActionOptions&ao):
   Ti(0),
   stride(10),
   nl_update(0),
-  firstStepFlag(0)
-{
+  firstStepFlag(0) {
   rs = 0.14;
   parse("DELTAGFILE",DeltaGValues);
   parse("APPROACH", approach);
   parseAtomList("ATOMS",atoms);
-  if(atoms.size()==0) error("no atoms specified");
+  if(atoms.size()==0) {
+    error("no atoms specified");
+  }
   std::string Type;
   parse("TYPE",Type);
   parse("NL_STRIDE", stride);
   parseFlag("NOPBC",nopbc);
   checkRead();
 
-  if(Type=="TOTAL") sasa_type=TOTAL;
-  else if(Type=="TRANSFER") sasa_type=TRANSFER;
-  else error("Unknown SASA type");
+  if(Type=="TOTAL") {
+    sasa_type=TOTAL;
+  } else if(Type=="TRANSFER") {
+    sasa_type=TRANSFER;
+  } else {
+    error("Unknown SASA type");
+  }
 
-  switch(sasa_type)
-  {
-  case TOTAL:   log.printf("  TOTAL SASA;"); break;
-  case TRANSFER: log.printf("  TRANSFER MODEL;"); break;
+  switch(sasa_type) {
+  case TOTAL:
+    log.printf("  TOTAL SASA;");
+    break;
+  case TRANSFER:
+    log.printf("  TRANSFER MODEL;");
+    break;
   }
 
   log.printf("  atoms involved : ");
   for(unsigned i=0; i<atoms.size(); ++i) {
-    if(i%25==0) log<<"\n";
+    if(i%25==0) {
+      log<<"\n";
+    }
     log.printf("%d ",atoms[i].serial());
   }
   log.printf("\n");
@@ -217,7 +227,8 @@ SASA_LCPO::SASA_LCPO(const ActionOptions&ao):
   }
 
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
   requestAtoms(atoms);
 
   natoms = getNumberOfAtoms();
@@ -233,8 +244,7 @@ SASA_LCPO::SASA_LCPO(const ActionOptions&ao):
 
 //splits strings into tokens. Used to read into LCPO parameters file and into reference pdb file
 template <class Container>
-void split(const std::string& str, Container& cont)
-{
+void split(const std::string& str, Container& cont) {
   std::istringstream iss(str);
   std::copy(std::istream_iterator<std::string>(iss),
             std::istream_iterator<std::string>(),
@@ -246,7 +256,9 @@ void split(const std::string& str, Container& cont)
 
 void SASA_LCPO::readPDB() {
   auto* moldat = plumed.getActionSet().selectLatest<GenericMolInfo*>(this);
-  if( ! moldat ) error("Unable to find MOLINFO in input");
+  if( ! moldat ) {
+    error("Unable to find MOLINFO in input");
+  }
   AtomResidueName[0].clear();
   AtomResidueName[1].clear();
 
@@ -553,9 +565,12 @@ void SASA_LCPO::readDeltaG() {
         }
       }
     }
-    if ( backboneflag == 0) error("Cannot find backbone value in Delta G parameters file\n");
+    if ( backboneflag == 0) {
+      error("Cannot find backbone value in Delta G parameters file\n");
+    }
+  } else {
+    error("Cannot open DeltaG file");
   }
-  else error("Cannot open DeltaG file");
 
   for(unsigned i=0; i<natoms; i++) {
     if (DeltaG[i].size()==0 ) {
@@ -726,7 +741,9 @@ void SASA_LCPO::computeDeltaG() {
 
 //calculates neighbor list
 void SASA_LCPO::calcNlist() {
-  if(!nopbc) makeWhole();
+  if(!nopbc) {
+    makeWhole();
+  }
 
   for(unsigned i = 0; i < natoms; i++) {
     Nlist[i].clear();
@@ -752,9 +769,13 @@ void SASA_LCPO::calcNlist() {
 
 //calculates SASA according to LCPO algorithm
 void SASA_LCPO::calculate() {
-  if(!nopbc) makeWhole();
+  if(!nopbc) {
+    makeWhole();
+  }
 
-  if(getExchangeStep()) nl_update = 0;
+  if(getExchangeStep()) {
+    nl_update = 0;
+  }
   if (firstStepFlag ==0) {
     readPDB();
     readLCPOparam();
@@ -894,7 +915,9 @@ void SASA_LCPO::calculate() {
 
           }
           double sasai = (LCPOparam[i][1]*S1+LCPOparam[i][2]*Aij+LCPOparam[i][3]*Ajk+LCPOparam[i][4]*Aijk);
-          if (sasai > 0 ) sasa += sasai/100;
+          if (sasai > 0 ) {
+            sasa += sasai/100;
+          }
           derivatives[i][0] += (dAijdc_2[0]*LCPOparam[i][2]+dAijdc_4[0]*LCPOparam[i][4])/10;
           derivatives[i][1] += (dAijdc_2[1]*LCPOparam[i][2]+dAijdc_4[1]*LCPOparam[i][4])/10;
           derivatives[i][2] += (dAijdc_2[2]*LCPOparam[i][2]+dAijdc_4[2]*LCPOparam[i][4])/10;
@@ -1047,14 +1070,18 @@ void SASA_LCPO::calculate() {
           double sasai = (LCPOparam[i][1]*S1+LCPOparam[i][2]*Aij+LCPOparam[i][3]*Ajk+LCPOparam[i][4]*Aijk);
 
           if (AtomResidueName[0][i] == "N" || AtomResidueName[0][i] == "CA"  || AtomResidueName[0][i] == "C" || AtomResidueName[0][i] == "O") {
-            if (sasai > 0 ) sasa += (sasai/MaxSurf[i][0]*DeltaG[natoms][0]);
+            if (sasai > 0 ) {
+              sasa += (sasai/MaxSurf[i][0]*DeltaG[natoms][0]);
+            }
             derivatives[i][0] += ((dAijdc_2[0]*LCPOparam[i][2]+dAijdc_4[0]*LCPOparam[i][4])/MaxSurf[i][0]*DeltaG[natoms][0])*10;
             derivatives[i][1] += ((dAijdc_2[1]*LCPOparam[i][2]+dAijdc_4[1]*LCPOparam[i][4])/MaxSurf[i][0]*DeltaG[natoms][0])*10;
             derivatives[i][2] += ((dAijdc_2[2]*LCPOparam[i][2]+dAijdc_4[2]*LCPOparam[i][4])/MaxSurf[i][0]*DeltaG[natoms][0])*10;
           }
 
           if (AtomResidueName[0][i] != "N" && AtomResidueName[0][i] != "CA"  && AtomResidueName[0][i] != "C" && AtomResidueName[0][i] != "O") {
-            if (sasai > 0. ) sasa += (sasai/MaxSurf[i][1]*DeltaG[i][0]);
+            if (sasai > 0. ) {
+              sasa += (sasai/MaxSurf[i][1]*DeltaG[i][0]);
+            }
             derivatives[i][0] += ((dAijdc_2[0]*LCPOparam[i][2]+dAijdc_4[0]*LCPOparam[i][4])/MaxSurf[i][1]*DeltaG[i][0])*10;
             derivatives[i][1] += ((dAijdc_2[1]*LCPOparam[i][2]+dAijdc_4[1]*LCPOparam[i][4])/MaxSurf[i][1]*DeltaG[i][0])*10;
             derivatives[i][2] += ((dAijdc_2[2]*LCPOparam[i][2]+dAijdc_4[2]*LCPOparam[i][4])/MaxSurf[i][1]*DeltaG[i][0])*10;
@@ -1066,7 +1093,9 @@ void SASA_LCPO::calculate() {
   }
 
 
-  for(unsigned i=0; i<natoms; i++) { setAtomsDerivatives(i,derivatives[i]);}
+  for(unsigned i=0; i<natoms; i++) {
+    setAtomsDerivatives(i,derivatives[i]);
+  }
   setBoxDerivatives(virial);
   setValue(sasa);
   firstStepFlag = 1;
diff --git a/src/secondarystructure/AlphaRMSD.cpp b/src/secondarystructure/AlphaRMSD.cpp
index b0286a967d..5fa823f51f 100644
--- a/src/secondarystructure/AlphaRMSD.cpp
+++ b/src/secondarystructure/AlphaRMSD.cpp
@@ -95,29 +95,47 @@ PLUMED_REGISTER_ACTION(AlphaRMSD,"ALPHARMSD")
 
 void AlphaRMSD::registerKeywords( Keywords& keys ) {
   SecondaryStructureRMSD::registerKeywords( keys );
-  keys.remove("ATOMS"); keys.remove("SEGMENT"); keys.remove("BONDLENGTH"); keys.remove("CUTOFF_ATOMS");
-  keys.remove("NO_ACTION_LOG"); keys.remove("STRANDS_CUTOFF"); keys.remove("STRUCTURE");
+  keys.remove("ATOMS");
+  keys.remove("SEGMENT");
+  keys.remove("BONDLENGTH");
+  keys.remove("CUTOFF_ATOMS");
+  keys.remove("NO_ACTION_LOG");
+  keys.remove("STRANDS_CUTOFF");
+  keys.remove("STRUCTURE");
 }
 
 AlphaRMSD::AlphaRMSD(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in the input and create a string that describes how to compute the less than
-  std::string ltmap; bool uselessthan=SecondaryStructureRMSD::readShortcutWords( ltmap, this );
+  std::string ltmap;
+  bool uselessthan=SecondaryStructureRMSD::readShortcutWords( ltmap, this );
   // read in the backbone atoms
-  std::vector<unsigned> chains; std::string atoms; SecondaryStructureRMSD::readBackboneAtoms( this, plumed, "protein", chains, atoms );
+  std::vector<unsigned> chains;
+  std::string atoms;
+  SecondaryStructureRMSD::readBackboneAtoms( this, plumed, "protein", chains, atoms );
 
   // This constructs all conceivable sections of alpha helix in the backbone of the chains
-  unsigned nprevious=0, segno=1; std::string seglist;
+  unsigned nprevious=0, segno=1;
+  std::string seglist;
   for(unsigned i=0; i<chains.size(); ++i) {
-    if( chains[i]<30 ) error("segment of backbone defined is not long enough to form an alpha helix. Each backbone fragment must contain a minimum of 6 residues");
+    if( chains[i]<30 ) {
+      error("segment of backbone defined is not long enough to form an alpha helix. Each backbone fragment must contain a minimum of 6 residues");
+    }
     unsigned nres=chains[i]/5;
-    if( chains[i]%5!=0 ) error("backbone segment received does not contain a multiple of five residues");
+    if( chains[i]%5!=0 ) {
+      error("backbone segment received does not contain a multiple of five residues");
+    }
     for(unsigned ires=0; ires<nres-5; ires++) {
-      unsigned accum=nprevious + 5*ires; std::string strval, num; Tools::convert( segno, num );
-      Tools::convert( accum, strval ); seglist += " SEGMENT" + num + "=" + strval;
-      for(unsigned k=1; k<30; ++k) { Tools::convert( accum+k, strval ); seglist += "," + strval; }
+      unsigned accum=nprevious + 5*ires;
+      std::string strval, num;
+      Tools::convert( segno, num );
+      Tools::convert( accum, strval );
+      seglist += " SEGMENT" + num + "=" + strval;
+      for(unsigned k=1; k<30; ++k) {
+        Tools::convert( accum+k, strval );
+        seglist += "," + strval;
+      }
       segno++;
     }
     nprevious+=chains[i];
@@ -161,14 +179,29 @@ AlphaRMSD::AlphaRMSD(const ActionOptions&ao):
   Tools::convert(  reference[0][2], ref2 );
   std::string structure=" STRUCTURE1=" + ref0 + "," + ref1 + "," + ref2;
   for(unsigned i=1; i<30; ++i) {
-    for(unsigned k=0; k<3; ++k) { Tools::convert( reference[i][k], ref0 ); structure += "," + ref0; }
+    for(unsigned k=0; k<3; ++k) {
+      Tools::convert( reference[i][k], ref0 );
+      structure += "," + ref0;
+    }
   }
 
-  std::string type; parse("TYPE",type); std::string lab = getShortcutLabel() + "_rmsd"; if( uselessthan ) lab = getShortcutLabel();
-  std::string nopbcstr=""; bool nopbc; parseFlag("NOPBC",nopbc); if( nopbc ) nopbcstr = " NOPBC";
+  std::string type;
+  parse("TYPE",type);
+  std::string lab = getShortcutLabel() + "_rmsd";
+  if( uselessthan ) {
+    lab = getShortcutLabel();
+  }
+  std::string nopbcstr="";
+  bool nopbc;
+  parseFlag("NOPBC",nopbc);
+  if( nopbc ) {
+    nopbcstr = " NOPBC";
+  }
   readInputLine( lab + ": SECONDARY_STRUCTURE_RMSD BONDLENGTH=0.17" + seglist + structure + " " + atoms + " TYPE=" + type + nopbcstr );
   // Create the less than object
-  if( ltmap.length()>0 ) SecondaryStructureRMSD::expandShortcut( uselessthan, getShortcutLabel(), lab, ltmap, this );
+  if( ltmap.length()>0 ) {
+    SecondaryStructureRMSD::expandShortcut( uselessthan, getShortcutLabel(), lab, ltmap, this );
+  }
 }
 
 }
diff --git a/src/secondarystructure/AntibetaRMSD.cpp b/src/secondarystructure/AntibetaRMSD.cpp
index 3ed1d4d0ef..79bece5c0f 100644
--- a/src/secondarystructure/AntibetaRMSD.cpp
+++ b/src/secondarystructure/AntibetaRMSD.cpp
@@ -96,8 +96,12 @@ PLUMED_REGISTER_ACTION(AntibetaRMSD,"ANTIBETARMSD")
 
 void AntibetaRMSD::registerKeywords( Keywords& keys ) {
   SecondaryStructureRMSD::registerKeywords( keys );
-  keys.remove("ATOMS"); keys.remove("SEGMENT"); keys.remove("BONDLENGTH");
-  keys.remove("NO_ACTION_LOG"); keys.remove("CUTOFF_ATOMS"); keys.remove("STRUCTURE");
+  keys.remove("ATOMS");
+  keys.remove("SEGMENT");
+  keys.remove("BONDLENGTH");
+  keys.remove("NO_ACTION_LOG");
+  keys.remove("CUTOFF_ATOMS");
+  keys.remove("STRUCTURE");
   keys.add("compulsory","STYLE","all","Antiparallel beta sheets can either form in a single chain or from a pair of chains. If STYLE=all all "
            "chain configuration with the appropriate geometry are counted.  If STYLE=inter "
            "only sheet-like configurations involving two chains are counted, while if STYLE=intra "
@@ -106,34 +110,46 @@ void AntibetaRMSD::registerKeywords( Keywords& keys ) {
 
 AntibetaRMSD::AntibetaRMSD(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in the input and create a string that describes how to compute the less than
-  std::string ltmap; bool uselessthan=SecondaryStructureRMSD::readShortcutWords( ltmap, this );
+  std::string ltmap;
+  bool uselessthan=SecondaryStructureRMSD::readShortcutWords( ltmap, this );
   // read in the backbone atoms
-  std::vector<unsigned> chains; std::string atoms; SecondaryStructureRMSD::readBackboneAtoms( this, plumed, "protein", chains, atoms );
+  std::vector<unsigned> chains;
+  std::string atoms;
+  SecondaryStructureRMSD::readBackboneAtoms( this, plumed, "protein", chains, atoms );
 
   bool intra_chain(false), inter_chain(false);
-  std::string style; parse("STYLE",style);
+  std::string style;
+  parse("STYLE",style);
   if( Tools::caseInSensStringCompare(style, "all") ) {
-    intra_chain=true; inter_chain=true;
+    intra_chain=true;
+    inter_chain=true;
   } else if( Tools::caseInSensStringCompare(style, "inter") ) {
-    intra_chain=false; inter_chain=true;
+    intra_chain=false;
+    inter_chain=true;
   } else if( Tools::caseInSensStringCompare(style, "intra") ) {
-    intra_chain=true; inter_chain=false;
+    intra_chain=true;
+    inter_chain=false;
   } else {
     error( style + " is not a valid directive for the STYLE keyword");
   }
 
   // This constructs all conceivable sections of antibeta sheet in the backbone of the chains
-  std::string seglist; unsigned k=1;
+  std::string seglist;
+  unsigned k=1;
   if( intra_chain ) {
-    unsigned nprevious=0; std::vector<unsigned> nlist(30);
+    unsigned nprevious=0;
+    std::vector<unsigned> nlist(30);
     for(unsigned i=0; i<chains.size(); ++i) {
-      if( chains[i]<40 ) error("segment of backbone is not long enough to form an antiparallel beta hairpin. Each backbone fragment must contain a minimum of 8 residues");
+      if( chains[i]<40 ) {
+        error("segment of backbone is not long enough to form an antiparallel beta hairpin. Each backbone fragment must contain a minimum of 8 residues");
+      }
       // Loop over all possible triples in each 8 residue segment of protein
       unsigned nres=chains[i]/5;
-      if( chains[i]%5!=0 ) error("backbone segment received does not contain a multiple of five residues");
+      if( chains[i]%5!=0 ) {
+        error("backbone segment received does not contain a multiple of five residues");
+      }
       for(unsigned ires=0; ires<nres-7; ires++) {
         for(unsigned jres=ires+7; jres<nres; jres++) {
           for(unsigned k=0; k<15; ++k) {
@@ -142,26 +158,42 @@ AntibetaRMSD::AntibetaRMSD(const ActionOptions&ao):
           }
           std::string nlstr, num;
           Tools::convert( nlist[0], nlstr );
-          Tools::convert(k, num); k++;
+          Tools::convert(k, num);
+          k++;
           seglist += " SEGMENT" + num + "=" + nlstr;
-          for(unsigned kk=1; kk<nlist.size(); ++kk ) { Tools::convert( nlist[kk], nlstr ); seglist += "," + nlstr; }
+          for(unsigned kk=1; kk<nlist.size(); ++kk ) {
+            Tools::convert( nlist[kk], nlstr );
+            seglist += "," + nlstr;
+          }
         }
       }
       nprevious+=chains[i];
     }
   }
   if( inter_chain ) {
-    if( chains.size()==1 && style!="all" ) error("there is only one chain defined so cannot use inter_chain option");
+    if( chains.size()==1 && style!="all" ) {
+      error("there is only one chain defined so cannot use inter_chain option");
+    }
     std::vector<unsigned> nlist(30);
     for(unsigned ichain=1; ichain<chains.size(); ++ichain) {
-      unsigned iprev=0; for(unsigned i=0; i<ichain; ++i) iprev+=chains[i];
+      unsigned iprev=0;
+      for(unsigned i=0; i<ichain; ++i) {
+        iprev+=chains[i];
+      }
       unsigned inres=chains[ichain]/5;
-      if( chains[ichain]%5!=0 ) error("backbone segment received does not contain a multiple of five residues");
+      if( chains[ichain]%5!=0 ) {
+        error("backbone segment received does not contain a multiple of five residues");
+      }
       for(unsigned ires=0; ires<inres-2; ++ires) {
         for(unsigned jchain=0; jchain<ichain; ++jchain) {
-          unsigned jprev=0; for(unsigned i=0; i<jchain; ++i) jprev+=chains[i];
+          unsigned jprev=0;
+          for(unsigned i=0; i<jchain; ++i) {
+            jprev+=chains[i];
+          }
           unsigned jnres=chains[jchain]/5;
-          if( chains[jchain]%5!=0 ) error("backbone segment received does not contain a multiple of five residues");
+          if( chains[jchain]%5!=0 ) {
+            error("backbone segment received does not contain a multiple of five residues");
+          }
           for(unsigned jres=0; jres<jnres-2; ++jres) {
             for(unsigned k=0; k<15; ++k) {
               nlist[k]=iprev+ ires*5+k;
@@ -169,9 +201,13 @@ AntibetaRMSD::AntibetaRMSD(const ActionOptions&ao):
             }
             std::string nlstr, num;
             Tools::convert( nlist[0], nlstr );
-            Tools::convert(k, num); k++;
+            Tools::convert(k, num);
+            k++;
             seglist += " SEGMENT" + num + "=" + nlstr;
-            for(unsigned kk=1; kk<nlist.size(); ++kk ) { Tools::convert( nlist[kk], nlstr ); seglist += "," + nlstr; }
+            for(unsigned kk=1; kk<nlist.size(); ++kk ) {
+              Tools::convert( nlist[kk], nlstr );
+              seglist += "," + nlstr;
+            }
           }
         }
       }
@@ -216,16 +252,34 @@ AntibetaRMSD::AntibetaRMSD(const ActionOptions&ao):
   Tools::convert(  reference[0][2], ref2 );
   std::string structure=" STRUCTURE1=" + ref0 + "," + ref1 + "," + ref2;
   for(unsigned i=1; i<30; ++i) {
-    for(unsigned k=0; k<3; ++k) { Tools::convert( reference[i][k], ref0 ); structure += "," + ref0; }
+    for(unsigned k=0; k<3; ++k) {
+      Tools::convert( reference[i][k], ref0 );
+      structure += "," + ref0;
+    }
   }
 
-  std::string strands_cutoff; parse("STRANDS_CUTOFF",strands_cutoff);
-  if( strands_cutoff.length()>0 ) strands_cutoff=" CUTOFF_ATOMS=6,21 STRANDS_CUTOFF="+strands_cutoff;
-  std::string type; parse("TYPE",type); std::string lab = getShortcutLabel() + "_rmsd"; if( uselessthan ) lab = getShortcutLabel();
-  std::string nopbcstr=""; bool nopbc; parseFlag("NOPBC",nopbc); if( nopbc ) nopbcstr = " NOPBC";
+  std::string strands_cutoff;
+  parse("STRANDS_CUTOFF",strands_cutoff);
+  if( strands_cutoff.length()>0 ) {
+    strands_cutoff=" CUTOFF_ATOMS=6,21 STRANDS_CUTOFF="+strands_cutoff;
+  }
+  std::string type;
+  parse("TYPE",type);
+  std::string lab = getShortcutLabel() + "_rmsd";
+  if( uselessthan ) {
+    lab = getShortcutLabel();
+  }
+  std::string nopbcstr="";
+  bool nopbc;
+  parseFlag("NOPBC",nopbc);
+  if( nopbc ) {
+    nopbcstr = " NOPBC";
+  }
   readInputLine( lab + ": SECONDARY_STRUCTURE_RMSD BONDLENGTH=0.17" + seglist + structure + " " + atoms + " TYPE=" + type + strands_cutoff + nopbcstr );
   // Create the less than object
-  if( ltmap.length()>0 ) SecondaryStructureRMSD::expandShortcut( uselessthan, getShortcutLabel(), lab, ltmap, this );
+  if( ltmap.length()>0 ) {
+    SecondaryStructureRMSD::expandShortcut( uselessthan, getShortcutLabel(), lab, ltmap, this );
+  }
 }
 
 }
diff --git a/src/secondarystructure/ParabetaRMSD.cpp b/src/secondarystructure/ParabetaRMSD.cpp
index cb2a35a786..cf88f2fb6b 100644
--- a/src/secondarystructure/ParabetaRMSD.cpp
+++ b/src/secondarystructure/ParabetaRMSD.cpp
@@ -97,8 +97,12 @@ PLUMED_REGISTER_ACTION(ParabetaRMSD,"PARABETARMSD")
 
 void ParabetaRMSD::registerKeywords( Keywords& keys ) {
   SecondaryStructureRMSD::registerKeywords( keys );
-  keys.remove("ATOMS"); keys.remove("SEGMENT"); keys.remove("BONDLENGTH");
-  keys.remove("NO_ACTION_LOG"); keys.remove("CUTOFF_ATOMS"); keys.remove("STRUCTURE");
+  keys.remove("ATOMS");
+  keys.remove("SEGMENT");
+  keys.remove("BONDLENGTH");
+  keys.remove("NO_ACTION_LOG");
+  keys.remove("CUTOFF_ATOMS");
+  keys.remove("STRUCTURE");
   keys.add("compulsory","STYLE","all","Parallel beta sheets can either form in a single chain or from a pair of chains. If STYLE=all all "
            "chain configuration with the appropriate geometry are counted.  If STYLE=inter "
            "only sheet-like configurations involving two chains are counted, while if STYLE=intra "
@@ -108,33 +112,46 @@ void ParabetaRMSD::registerKeywords( Keywords& keys ) {
 
 ParabetaRMSD::ParabetaRMSD(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in the input and create a string that describes how to compute the less than
-  std::string ltmap; bool uselessthan=SecondaryStructureRMSD::readShortcutWords( ltmap, this );
+  std::string ltmap;
+  bool uselessthan=SecondaryStructureRMSD::readShortcutWords( ltmap, this );
   // read in the backbone atoms
-  std::vector<unsigned> chains; std::string atoms; SecondaryStructureRMSD::readBackboneAtoms( this, plumed, "protein", chains, atoms );
+  std::vector<unsigned> chains;
+  std::string atoms;
+  SecondaryStructureRMSD::readBackboneAtoms( this, plumed, "protein", chains, atoms );
 
-  bool intra_chain(false), inter_chain(false); std::string seglist;
-  std::string style; parse("STYLE",style); unsigned jjkk=1;
+  bool intra_chain(false), inter_chain(false);
+  std::string seglist;
+  std::string style;
+  parse("STYLE",style);
+  unsigned jjkk=1;
   if( Tools::caseInSensStringCompare(style, "all") ) {
-    intra_chain=true; inter_chain=true;
+    intra_chain=true;
+    inter_chain=true;
   } else if( Tools::caseInSensStringCompare(style, "inter") ) {
-    intra_chain=false; inter_chain=true;
+    intra_chain=false;
+    inter_chain=true;
   } else if( Tools::caseInSensStringCompare(style, "intra") ) {
-    intra_chain=true; inter_chain=false;
+    intra_chain=true;
+    inter_chain=false;
   } else {
     error( style + " is not a valid directive for the STYLE keyword");
   }
 
   // This constructs all conceivable sections of antibeta sheet in the backbone of the chains
   if( intra_chain ) {
-    unsigned nprevious=0; std::vector<unsigned> nlist(30);
+    unsigned nprevious=0;
+    std::vector<unsigned> nlist(30);
     for(unsigned i=0; i<chains.size(); ++i) {
-      if( chains[i]<40 ) error("segment of backbone is not long enough to form an antiparallel beta hairpin. Each backbone fragment must contain a minimum of 8 residues");
+      if( chains[i]<40 ) {
+        error("segment of backbone is not long enough to form an antiparallel beta hairpin. Each backbone fragment must contain a minimum of 8 residues");
+      }
       // Loop over all possible triples in each 8 residue segment of protein
       unsigned nres=chains[i]/5;
-      if( chains[i]%5!=0 ) error("backbone segment received does not contain a multiple of five residues");
+      if( chains[i]%5!=0 ) {
+        error("backbone segment received does not contain a multiple of five residues");
+      }
       for(unsigned ires=0; ires<nres-8; ires++) {
         for(unsigned jres=ires+6; jres<nres-2; jres++) {
           for(unsigned k=0; k<15; ++k) {
@@ -143,9 +160,13 @@ ParabetaRMSD::ParabetaRMSD(const ActionOptions&ao):
           }
           std::string nlstr, num;
           Tools::convert( nlist[0], nlstr );
-          Tools::convert(jjkk, num); jjkk++;
+          Tools::convert(jjkk, num);
+          jjkk++;
           seglist += " SEGMENT" + num + "=" + nlstr;
-          for(unsigned kk=1; kk<nlist.size(); ++kk ) { Tools::convert( nlist[kk], nlstr ); seglist += "," + nlstr; }
+          for(unsigned kk=1; kk<nlist.size(); ++kk ) {
+            Tools::convert( nlist[kk], nlstr );
+            seglist += "," + nlstr;
+          }
         }
       }
       nprevious+=chains[i];
@@ -153,17 +174,29 @@ ParabetaRMSD::ParabetaRMSD(const ActionOptions&ao):
   }
   // This constructs all conceivable sections of antibeta sheet that form between chains
   if( inter_chain ) {
-    if( chains.size()==1 && !Tools::caseInSensStringCompare(style, "all") ) error("there is only one chain defined so cannot use inter_chain option");
+    if( chains.size()==1 && !Tools::caseInSensStringCompare(style, "all") ) {
+      error("there is only one chain defined so cannot use inter_chain option");
+    }
     std::vector<unsigned> nlist(30);
     for(unsigned ichain=1; ichain<chains.size(); ++ichain) {
-      unsigned iprev=0; for(unsigned i=0; i<ichain; ++i) iprev+=chains[i];
+      unsigned iprev=0;
+      for(unsigned i=0; i<ichain; ++i) {
+        iprev+=chains[i];
+      }
       unsigned inres=chains[ichain]/5;
-      if( chains[ichain]%5!=0 ) error("backbone segment received does not contain a multiple of five residues");
+      if( chains[ichain]%5!=0 ) {
+        error("backbone segment received does not contain a multiple of five residues");
+      }
       for(unsigned ires=0; ires<inres-2; ++ires) {
         for(unsigned jchain=0; jchain<ichain; ++jchain) {
-          unsigned jprev=0; for(unsigned i=0; i<jchain; ++i) jprev+=chains[i];
+          unsigned jprev=0;
+          for(unsigned i=0; i<jchain; ++i) {
+            jprev+=chains[i];
+          }
           unsigned jnres=chains[jchain]/5;
-          if( chains[jchain]%5!=0 ) error("backbone segment received does not contain a multiple of five residues");
+          if( chains[jchain]%5!=0 ) {
+            error("backbone segment received does not contain a multiple of five residues");
+          }
           for(unsigned jres=0; jres<jnres-2; ++jres) {
             for(unsigned k=0; k<15; ++k) {
               nlist[k]=iprev + ires*5+k;
@@ -171,9 +204,13 @@ ParabetaRMSD::ParabetaRMSD(const ActionOptions&ao):
             }
             std::string nlstr, num;
             Tools::convert( nlist[0], nlstr );
-            Tools::convert(jjkk, num); jjkk++;
+            Tools::convert(jjkk, num);
+            jjkk++;
             seglist += " SEGMENT" + num + "=" + nlstr;
-            for(unsigned kk=1; kk<nlist.size(); ++kk ) { Tools::convert( nlist[kk], nlstr ); seglist += "," + nlstr; }
+            for(unsigned kk=1; kk<nlist.size(); ++kk ) {
+              Tools::convert( nlist[kk], nlstr );
+              seglist += "," + nlstr;
+            }
           }
         }
       }
@@ -219,7 +256,10 @@ ParabetaRMSD::ParabetaRMSD(const ActionOptions&ao):
   Tools::convert(  reference[0][2], ref2 );
   std::string structure=" STRUCTURE1=" + ref0 + "," + ref1 + "," + ref2;
   for(unsigned i=1; i<30; ++i) {
-    for(unsigned k=0; k<3; ++k) { Tools::convert( reference[i][k], ref0 ); structure += "," + ref0; }
+    for(unsigned k=0; k<3; ++k) {
+      Tools::convert( reference[i][k], ref0 );
+      structure += "," + ref0;
+    }
   }
 
   reference[0]=Vector(-1.439, -5.122, -1.144); // N    i
@@ -258,13 +298,29 @@ ParabetaRMSD::ParabetaRMSD(const ActionOptions&ao):
   Tools::convert(  reference[0][2], ref2 );
   structure +=" STRUCTURE2=" + ref0 + "," + ref1 + "," + ref2;
   for(unsigned i=1; i<30; ++i) {
-    for(unsigned k=0; k<3; ++k) { Tools::convert( reference[i][k], ref0 ); structure += "," + ref0; }
+    for(unsigned k=0; k<3; ++k) {
+      Tools::convert( reference[i][k], ref0 );
+      structure += "," + ref0;
+    }
   }
 
-  std::string strands_cutoff; parse("STRANDS_CUTOFF",strands_cutoff);
-  std::string nopbcstr=""; bool nopbc; parseFlag("NOPBC",nopbc); if( nopbc ) nopbcstr = " NOPBC";
-  if( strands_cutoff.length()>0 ) strands_cutoff=" CUTOFF_ATOMS=6,21 STRANDS_CUTOFF="+strands_cutoff;
-  std::string type; parse("TYPE",type); std::string lab = getShortcutLabel() + "_low"; if( uselessthan ) lab = getShortcutLabel();
+  std::string strands_cutoff;
+  parse("STRANDS_CUTOFF",strands_cutoff);
+  std::string nopbcstr="";
+  bool nopbc;
+  parseFlag("NOPBC",nopbc);
+  if( nopbc ) {
+    nopbcstr = " NOPBC";
+  }
+  if( strands_cutoff.length()>0 ) {
+    strands_cutoff=" CUTOFF_ATOMS=6,21 STRANDS_CUTOFF="+strands_cutoff;
+  }
+  std::string type;
+  parse("TYPE",type);
+  std::string lab = getShortcutLabel() + "_low";
+  if( uselessthan ) {
+    lab = getShortcutLabel();
+  }
   readInputLine( getShortcutLabel() + "_both: SECONDARY_STRUCTURE_RMSD BONDLENGTH=0.17" + seglist + structure + " " + atoms + " TYPE=" + type + strands_cutoff + nopbcstr );
   if( ltmap.length()>0 ) {
     // Create the lowest line
diff --git a/src/secondarystructure/SecondaryStructureRMSD.cpp b/src/secondarystructure/SecondaryStructureRMSD.cpp
index 5265cf2a27..b0071a98ef 100644
--- a/src/secondarystructure/SecondaryStructureRMSD.cpp
+++ b/src/secondarystructure/SecondaryStructureRMSD.cpp
@@ -43,9 +43,14 @@ PLUMED_REGISTER_ACTION(SecondaryStructureRMSD,"SECONDARY_STRUCTURE_RMSD");
 bool SecondaryStructureRMSD::readShortcutWords( std::string& ltmap, ActionShortcut* action ) {
   action->parse("LESS_THAN",ltmap);
   if( ltmap.length()==0 ) {
-    std::string nn, mm, d_0, r_0; action->parse("R_0",r_0);
-    if( r_0.length()==0 ) r_0="0.08";
-    action->parse("NN",nn); action->parse("D_0",d_0); action->parse("MM",mm);
+    std::string nn, mm, d_0, r_0;
+    action->parse("R_0",r_0);
+    if( r_0.length()==0 ) {
+      r_0="0.08";
+    }
+    action->parse("NN",nn);
+    action->parse("D_0",d_0);
+    action->parse("MM",mm);
     ltmap = "RATIONAL R_0=" + r_0 + " D_0=" + d_0 + " NN=" + nn + " MM=" + mm;
     return false;
   }
@@ -54,8 +59,11 @@ bool SecondaryStructureRMSD::readShortcutWords( std::string& ltmap, ActionShortc
 
 void SecondaryStructureRMSD::expandShortcut( const bool& uselessthan, const std::string& labout, const std::string& labin, const std::string& ltmap, ActionShortcut* action ) {
   action->readInputLine( labout + "_lt: LESS_THAN ARG=" + labin + " SWITCH={" + ltmap  +"}");
-  if( uselessthan ) action->readInputLine( labout + "_lessthan: SUM ARG=" + labout + "_lt PERIODIC=NO");
-  else action->readInputLine( labout + ": SUM ARG=" + labout + "_lt PERIODIC=NO");
+  if( uselessthan ) {
+    action->readInputLine( labout + "_lessthan: SUM ARG=" + labout + "_lt PERIODIC=NO");
+  } else {
+    action->readInputLine( labout + ": SUM ARG=" + labout + "_lt PERIODIC=NO");
+  }
 }
 
 void SecondaryStructureRMSD::registerKeywords( Keywords& keys ) {
@@ -90,21 +98,29 @@ void SecondaryStructureRMSD::registerKeywords( Keywords& keys ) {
   keys.add("hidden","NO_ACTION_LOG","suppresses printing from action on the log");
   keys.addOutputComponent("struct","default","the vectors containing the rmsd distances between the residues and each of the reference structures");
   keys.addOutputComponent("lessthan","default","the number blocks of residues that have an RMSD from the secondary structure that is less than the threshold");
-  keys.needsAction("SECONDARY_STRUCTURE_RMSD"); keys.needsAction("LESS_THAN"); keys.needsAction("SUM");
+  keys.needsAction("SECONDARY_STRUCTURE_RMSD");
+  keys.needsAction("LESS_THAN");
+  keys.needsAction("SUM");
 }
 
 void SecondaryStructureRMSD::readBackboneAtoms( ActionShortcut* action, PlumedMain& plumed, const std::string& moltype, std::vector<unsigned>& chain_lengths, std::string& all_atoms ) {
   auto* moldat=plumed.getActionSet().selectLatest<GenericMolInfo*>(action);
-  if( ! moldat ) action->error("Unable to find MOLINFO in input");
+  if( ! moldat ) {
+    action->error("Unable to find MOLINFO in input");
+  }
 
-  std::vector<std::string> resstrings; action->parseVector( "RESIDUES", resstrings );
-  if(resstrings.size()==0) action->error("residues are not defined, check the keyword RESIDUES");
-  else if( Tools::caseInSensStringCompare(resstrings[0], "all") ) {
+  std::vector<std::string> resstrings;
+  action->parseVector( "RESIDUES", resstrings );
+  if(resstrings.size()==0) {
+    action->error("residues are not defined, check the keyword RESIDUES");
+  } else if( Tools::caseInSensStringCompare(resstrings[0], "all") ) {
     resstrings[0]="all";
     action->log.printf("  examining all possible secondary structure combinations\n");
   } else {
     action->log.printf("  examining secondary structure in residue positions : %s ",resstrings[0].c_str() );
-    for(unsigned i=1; i<resstrings.size(); ++i) action->log.printf(", %s",resstrings[i].c_str() );
+    for(unsigned i=1; i<resstrings.size(); ++i) {
+      action->log.printf(", %s",resstrings[i].c_str() );
+    }
     action->log.printf("\n");
   }
   std::vector< std::vector<AtomNumber> > backatoms;
@@ -114,9 +130,13 @@ void SecondaryStructureRMSD::readBackboneAtoms( ActionShortcut* action, PlumedMa
   for(unsigned i=0; i<backatoms.size(); ++i) {
     chain_lengths[i]=backatoms[i].size();
     for(unsigned j=0; j<backatoms[i].size(); ++j) {
-      std::string bat_str; Tools::convert( backatoms[i][j].serial(), bat_str );
-      if( i==0 && j==0 ) all_atoms = "ATOMS=" + bat_str;
-      else all_atoms += "," + bat_str;
+      std::string bat_str;
+      Tools::convert( backatoms[i][j].serial(), bat_str );
+      if( i==0 && j==0 ) {
+        all_atoms = "ATOMS=" + bat_str;
+      } else {
+        all_atoms += "," + bat_str;
+      }
     }
   }
 }
@@ -129,98 +149,138 @@ SecondaryStructureRMSD::SecondaryStructureRMSD(const ActionOptions&ao):
   align_strands(false),
   s_cutoff2(0),
   align_atom_1(0),
-  align_atom_2(0)
-{
-  if( plumed.usingNaturalUnits() ) error("cannot use this collective variable when using natural units");
+  align_atom_2(0) {
+  if( plumed.usingNaturalUnits() ) {
+    error("cannot use this collective variable when using natural units");
+  }
 
-  parse("TYPE",alignType); parseFlag("NOPBC",nopbc);
+  parse("TYPE",alignType);
+  parseFlag("NOPBC",nopbc);
   log.printf("  distances from secondary structure elements are calculated using %s algorithm\n",alignType.c_str() );
-  log<<"  Bibliography "<<plumed.cite("Pietrucci and Laio, J. Chem. Theory Comput. 5, 2197 (2009)"); log<<"\n";
+  log<<"  Bibliography "<<plumed.cite("Pietrucci and Laio, J. Chem. Theory Comput. 5, 2197 (2009)");
+  log<<"\n";
 
   parseFlag("VERBOSE",verbose_output);
 
   if( keywords.exists("STRANDS_CUTOFF") ) {
     double s_cutoff = 0;
-    parse("STRANDS_CUTOFF",s_cutoff); align_strands=true;
+    parse("STRANDS_CUTOFF",s_cutoff);
+    align_strands=true;
     if( s_cutoff>0) {
       log.printf("  ignoring contributions from strands that are more than %f apart\n",s_cutoff);
-      std::vector<unsigned> cutatoms; parseVector("CUTOFF_ATOMS",cutatoms);
+      std::vector<unsigned> cutatoms;
+      parseVector("CUTOFF_ATOMS",cutatoms);
       if( cutatoms.size()==2 ) {
-        align_atom_1=cutatoms[0]; align_atom_2=cutatoms[1];
-      } else error("did not find CUTOFF_ATOMS in input");
+        align_atom_1=cutatoms[0];
+        align_atom_2=cutatoms[1];
+      } else {
+        error("did not find CUTOFF_ATOMS in input");
+      }
     }
     s_cutoff2=s_cutoff*s_cutoff;
   }
 
   // Read in the atoms
-  std::vector<AtomNumber> all_atoms; parseAtomList("ATOMS",all_atoms); requestAtoms( all_atoms );
+  std::vector<AtomNumber> all_atoms;
+  parseAtomList("ATOMS",all_atoms);
+  requestAtoms( all_atoms );
 
   for(unsigned i=1;; ++i) {
     std::vector<unsigned> newatoms;
-    if( !parseNumberedVector("SEGMENT",i,newatoms) ) break;
+    if( !parseNumberedVector("SEGMENT",i,newatoms) ) {
+      break;
+    }
     if( verbose_output ) {
       log.printf("  Secondary structure segment %u contains atoms : ", static_cast<unsigned>(colvar_atoms.size()+1));
-      for(unsigned i=0; i<newatoms.size(); ++i) log.printf("%d ",all_atoms[newatoms[i]].serial() );
+      for(unsigned i=0; i<newatoms.size(); ++i) {
+        log.printf("%d ",all_atoms[newatoms[i]].serial() );
+      }
       log.printf("\n");
     }
     colvar_atoms.push_back( newatoms );
   }
 
-  double bondlength; parse("BONDLENGTH",bondlength); bondlength=bondlength/getUnits().getLength();
+  double bondlength;
+  parse("BONDLENGTH",bondlength);
+  bondlength=bondlength/getUnits().getLength();
 
   // Read in the reference structure
   for(unsigned ii=1;; ++ii) {
     std::vector<double> cstruct;
-    if( !parseNumberedVector("STRUCTURE",ii,cstruct) ) break ;
+    if( !parseNumberedVector("STRUCTURE",ii,cstruct) ) {
+      break ;
+    }
     plumed_assert( cstruct.size()%3==0 && cstruct.size()/3==colvar_atoms[0].size() );
     std::vector<Vector> structure( cstruct.size()/3 );
     for(unsigned i=0; i<structure.size(); ++i) {
-      for(unsigned j=0; j<3; ++j) structure[i][j] = 0.1*cstruct[3*i+j]/getUnits().getLength();
+      for(unsigned j=0; j<3; ++j) {
+        structure[i][j] = 0.1*cstruct[3*i+j]/getUnits().getLength();
+      }
     }
     if( alignType=="DRMSD" ) {
       std::map<std::pair<unsigned,unsigned>, double> targets;
       for(unsigned i=0; i<structure.size()-1; ++i) {
         for(unsigned j=i+1; j<structure.size(); ++j) {
           double distance = delta( structure[i], structure[j] ).modulo();
-          if(distance > bondlength) targets[std::make_pair(i,j)] = distance;
+          if(distance > bondlength) {
+            targets[std::make_pair(i,j)] = distance;
+          }
         }
       }
       drmsd_targets.push_back( targets );
     } else {
-      Vector center; std::vector<double> align( structure.size(), 1.0 ), displace( structure.size(), 1.0 );
-      for(unsigned i=0; i<structure.size(); ++i) center+=structure[i]*align[i];
-      for(unsigned i=0; i<structure.size(); ++i) structure[i] -= center;
-      RMSD newrmsd; newrmsd.clear();
+      Vector center;
+      std::vector<double> align( structure.size(), 1.0 ), displace( structure.size(), 1.0 );
+      for(unsigned i=0; i<structure.size(); ++i) {
+        center+=structure[i]*align[i];
+      }
+      for(unsigned i=0; i<structure.size(); ++i) {
+        structure[i] -= center;
+      }
+      RMSD newrmsd;
+      newrmsd.clear();
       newrmsd.set(align,displace,structure,alignType,true,true);
       myrmsd.push_back( newrmsd );
     }
   }
 
   // And create values to hold everything
-  unsigned nref = myrmsd.size(); if( alignType=="DRMSD" ) nref=drmsd_targets.size();
+  unsigned nref = myrmsd.size();
+  if( alignType=="DRMSD" ) {
+    nref=drmsd_targets.size();
+  }
   plumed_assert( nref>0 );
-  std::vector<unsigned> shape(1); shape[0]=colvar_atoms.size();
-  if( nref==1 ) { addValue( shape ); setNotPeriodic(); }
-  else {
+  std::vector<unsigned> shape(1);
+  shape[0]=colvar_atoms.size();
+  if( nref==1 ) {
+    addValue( shape );
+    setNotPeriodic();
+  } else {
     std::string num;
     for(unsigned i=0; i<nref; ++i) {
-      Tools::convert( i+1, num ); addComponent( "struct-" + num, shape );
+      Tools::convert( i+1, num );
+      addComponent( "struct-" + num, shape );
       componentIsNotPeriodic( "struct-" + num );
     }
   }
 }
 
 void SecondaryStructureRMSD::areAllTasksRequired( std::vector<ActionWithVector*>& task_reducing_actions ) {
-  if( s_cutoff2>0 ) task_reducing_actions.push_back(this);
+  if( s_cutoff2>0 ) {
+    task_reducing_actions.push_back(this);
+  }
 }
 
 int SecondaryStructureRMSD::checkTaskStatus( const unsigned& taskno, int& flag ) const {
   if( s_cutoff2>0 ) {
     Vector distance=pbcDistance( ActionAtomistic::getPosition( getAtomIndex(taskno,align_atom_1) ),
                                  ActionAtomistic::getPosition( getAtomIndex(taskno,align_atom_2) ) );
-    if( distance.modulo2()<s_cutoff2 ) return 1;
+    if( distance.modulo2()<s_cutoff2 ) {
+      return 1;
+    }
     return 0;
-  } return flag;
+  }
+  return flag;
 }
 
 void SecondaryStructureRMSD::calculate() {
@@ -230,16 +290,21 @@ void SecondaryStructureRMSD::calculate() {
 void SecondaryStructureRMSD::performTask( const unsigned& current, MultiValue& myvals ) const {
   // Resize the derivatives if need be
   unsigned nderi = 3*getNumberOfAtoms()+9;
-  if( myvals.getNumberOfDerivatives()!=nderi ) myvals.resize( myvals.getNumberOfValues(), nderi, 0, 0 );
+  if( myvals.getNumberOfDerivatives()!=nderi ) {
+    myvals.resize( myvals.getNumberOfValues(), nderi, 0, 0 );
+  }
   // Retrieve the positions
   const unsigned natoms = colvar_atoms[current].size();
   std::vector<Vector> pos( natoms ), deriv( natoms );
-  for(unsigned i=0; i<natoms; ++i) pos[i]=ActionAtomistic::getPosition( getAtomIndex(current,i) );
+  for(unsigned i=0; i<natoms; ++i) {
+    pos[i]=ActionAtomistic::getPosition( getAtomIndex(current,i) );
+  }
 
   // This aligns the two strands if this is required
   Vector distance=pbcDistance( pos[align_atom_1],pos[align_atom_2] );
   if( align_strands ) {
-    Vector origin_old, origin_new; origin_old=pos[align_atom_2];
+    Vector origin_old, origin_new;
+    origin_old=pos[align_atom_2];
     origin_new=pos[align_atom_1]+distance;
     for(unsigned i=15; i<30; ++i) {
       pos[i]+=( origin_new - origin_old );
@@ -256,8 +321,13 @@ void SecondaryStructureRMSD::performTask( const unsigned& current, MultiValue& m
     // And now calculate the DRMSD
     const unsigned rs = drmsd_targets.size();
     for(unsigned i=0; i<rs; ++i) {
-      double drmsd=0; Vector distance; Tensor vir; vir.zero();
-      for(unsigned j=0; j<natoms; ++j) deriv[j].zero();
+      double drmsd=0;
+      Vector distance;
+      Tensor vir;
+      vir.zero();
+      for(unsigned j=0; j<natoms; ++j) {
+        deriv[j].zero();
+      }
       for(const auto & it : drmsd_targets[i] ) {
         const unsigned k=it.first.first;
         const unsigned j=it.first.second;
@@ -269,22 +339,27 @@ void SecondaryStructureRMSD::performTask( const unsigned& current, MultiValue& m
         drmsd += diff*diff;
 
         if( !doNotCalculateDerivatives() ) {
-          deriv[k] += -der*distance; deriv[j] += der*distance;
+          deriv[k] += -der*distance;
+          deriv[j] += der*distance;
           vir += -der*Tensor(distance,distance);
         }
       }
 
       const double inpairs = 1./static_cast<double>(drmsd_targets[i].size());
       unsigned ostrn = getConstPntrToComponent(i)->getPositionInStream();
-      drmsd = sqrt(inpairs*drmsd); myvals.setValue( ostrn, drmsd );
+      drmsd = sqrt(inpairs*drmsd);
+      myvals.setValue( ostrn, drmsd );
 
       if( !doNotCalculateDerivatives() ) {
         double scalef = inpairs / drmsd;
         for(unsigned j=0; j<natoms; ++j) {
           const unsigned ja = getAtomIndex( current, j );
-          myvals.addDerivative( ostrn, 3*ja + 0, scalef*deriv[j][0] ); myvals.updateIndex( ostrn, 3*ja+0 );
-          myvals.addDerivative( ostrn, 3*ja + 1, scalef*deriv[j][1] ); myvals.updateIndex( ostrn, 3*ja+1 );
-          myvals.addDerivative( ostrn, 3*ja + 2, scalef*deriv[j][2] ); myvals.updateIndex( ostrn, 3*ja+2 );
+          myvals.addDerivative( ostrn, 3*ja + 0, scalef*deriv[j][0] );
+          myvals.updateIndex( ostrn, 3*ja+0 );
+          myvals.addDerivative( ostrn, 3*ja + 1, scalef*deriv[j][1] );
+          myvals.updateIndex( ostrn, 3*ja+1 );
+          myvals.addDerivative( ostrn, 3*ja + 2, scalef*deriv[j][2] );
+          myvals.updateIndex( ostrn, 3*ja+2 );
         }
         unsigned nbase = myvals.getNumberOfDerivatives() - 9;
         for(unsigned k=0; k<3; ++k) {
@@ -303,12 +378,16 @@ void SecondaryStructureRMSD::performTask( const unsigned& current, MultiValue& m
       myvals.setValue( ostrn, nr );
 
       if( !doNotCalculateDerivatives() ) {
-        Tensor vir; vir.zero();
+        Tensor vir;
+        vir.zero();
         for(unsigned j=0; j<natoms; ++j) {
           const unsigned ja = getAtomIndex( current, j );
-          myvals.addDerivative( ostrn, 3*ja + 0, deriv[j][0] ); myvals.updateIndex( ostrn, 3*colvar_atoms[current][j]+0 );
-          myvals.addDerivative( ostrn, 3*ja + 1, deriv[j][1] ); myvals.updateIndex( ostrn, 3*colvar_atoms[current][j]+1 );
-          myvals.addDerivative( ostrn, 3*ja + 2, deriv[j][2] ); myvals.updateIndex( ostrn, 3*colvar_atoms[current][j]+2 );
+          myvals.addDerivative( ostrn, 3*ja + 0, deriv[j][0] );
+          myvals.updateIndex( ostrn, 3*colvar_atoms[current][j]+0 );
+          myvals.addDerivative( ostrn, 3*ja + 1, deriv[j][1] );
+          myvals.updateIndex( ostrn, 3*colvar_atoms[current][j]+1 );
+          myvals.addDerivative( ostrn, 3*ja + 2, deriv[j][2] );
+          myvals.updateIndex( ostrn, 3*colvar_atoms[current][j]+2 );
           vir+=(-1.0*Tensor( pos[j], deriv[j] ));
         }
         unsigned nbase = myvals.getNumberOfDerivatives() - 9;
diff --git a/src/setup/Load.cpp b/src/setup/Load.cpp
index fcf58a049c..c66f272b80 100644
--- a/src/setup/Load.cpp
+++ b/src/setup/Load.cpp
@@ -117,8 +117,7 @@ the other objects.
 //+ENDPLUMEDOC
 
 class Load :
-  public virtual ActionAnyorder
-{
+  public virtual ActionAnyorder {
 public:
   static void registerKeywords( Keywords& keys );
   explicit Load(const ActionOptions&ao);
@@ -133,8 +132,7 @@ void Load::registerKeywords( Keywords& keys ) {
 
 Load::Load(const ActionOptions&ao):
   Action(ao),
-  ActionAnyorder(ao)
-{
+  ActionAnyorder(ao) {
   std::string f;
   parse("FILE",f);
   checkRead();
diff --git a/src/setup/Restart.cpp b/src/setup/Restart.cpp
index 560dca57d2..9f65d7a8d3 100644
--- a/src/setup/Restart.cpp
+++ b/src/setup/Restart.cpp
@@ -88,8 +88,7 @@ PRINT ARG=d1 FILE=out1
 //+ENDPLUMEDOC
 
 class Restart :
-  public virtual ActionSetup
-{
+  public virtual ActionSetup {
 public:
   static void registerKeywords( Keywords& keys );
   explicit Restart(const ActionOptions&ao);
@@ -104,18 +103,21 @@ void Restart::registerKeywords( Keywords& keys ) {
 
 Restart::Restart(const ActionOptions&ao):
   Action(ao),
-  ActionSetup(ao)
-{
+  ActionSetup(ao) {
   bool no=false;
   parseFlag("NO",no);
   bool md=plumed.getRestart();
   log<<"  MD code "<<(md?"did":"didn't")<<" require restart\n";
   if(no) {
-    if(md) log<<"  Switching off restart\n";
+    if(md) {
+      log<<"  Switching off restart\n";
+    }
     plumed.setRestart(false);
     log<<"  Not restarting simulation: files will be backed up\n";
   } else {
-    if(!md) log<<"  Switching on restart\n";
+    if(!md) {
+      log<<"  Switching on restart\n";
+    }
     plumed.setRestart(true);
     log<<"  Restarting simulation: files will be appended\n";
   }
diff --git a/src/setup/Units.cpp b/src/setup/Units.cpp
index 39261032bd..f7f8a74847 100644
--- a/src/setup/Units.cpp
+++ b/src/setup/Units.cpp
@@ -87,8 +87,7 @@ UNITS LENGTH=0.1 TIME=0.001
 //+ENDPLUMEDOC
 
 class Units :
-  public virtual ActionSetup
-{
+  public virtual ActionSetup {
 public:
   static void registerKeywords( Keywords& keys );
   explicit Units(const ActionOptions&ao);
@@ -108,74 +107,73 @@ void Units::registerKeywords( Keywords& keys ) {
 
 Units::Units(const ActionOptions&ao):
   Action(ao),
-  ActionSetup(ao)
-{
+  ActionSetup(ao) {
   PLMD::Units u;
 
   std::string s;
 
   s="";
   parse("LENGTH",s);
-  if(s.length()>0) u.setLength(s);
+  if(s.length()>0) {
+    u.setLength(s);
+  }
   if(u.getLengthString().length()>0 && u.getLengthString()=="nm") {
     log.printf("  length: %s\n",u.getLengthString().c_str());
-  }
-  else if(u.getLengthString().length()>0 && u.getLengthString()!="nm") {
+  } else if(u.getLengthString().length()>0 && u.getLengthString()!="nm") {
     log.printf("  length: %s = %g nm\n",u.getLengthString().c_str(),u.getLength());
-  }
-  else {
+  } else {
     log.printf("  length: %g nm\n",u.getLength());
   }
 
   s="";
   parse("ENERGY",s);
-  if(s.length()>0) u.setEnergy(s);
+  if(s.length()>0) {
+    u.setEnergy(s);
+  }
   if(u.getEnergyString().length()>0 && u.getEnergyString()=="kj/mol") {
     log.printf("  energy: %s\n",u.getEnergyString().c_str());
-  }
-  else if(u.getEnergyString().length()>0 && u.getEnergyString()!="kj/mol") {
+  } else if(u.getEnergyString().length()>0 && u.getEnergyString()!="kj/mol") {
     log.printf("  energy: %s = %g kj/mol\n",u.getEnergyString().c_str(),u.getEnergy());
-  }
-  else {
+  } else {
     log.printf("  energy: %g kj/mol\n",u.getEnergy());
   }
 
   s="";
   parse("TIME",s);
-  if(s.length()>0) u.setTime(s);
+  if(s.length()>0) {
+    u.setTime(s);
+  }
   if(u.getTimeString().length()>0 && u.getTimeString()=="ps") {
     log.printf("  time: %s\n",u.getTimeString().c_str());
-  }
-  else if(u.getTimeString().length()>0 && u.getTimeString()!="ps") {
+  } else if(u.getTimeString().length()>0 && u.getTimeString()!="ps") {
     log.printf("  time: %s = %g ps\n",u.getTimeString().c_str(),u.getTime());
-  }
-  else {
+  } else {
     log.printf("  time: %g ps\n",u.getTime());
   }
 
   s="";
   parse("CHARGE",s);
-  if(s.length()>0) u.setCharge(s);
+  if(s.length()>0) {
+    u.setCharge(s);
+  }
   if(u.getChargeString().length()>0 && u.getChargeString()=="e") {
     log.printf("  charge: %s\n",u.getChargeString().c_str());
-  }
-  else if(u.getChargeString().length()>0 && u.getChargeString()!="e") {
+  } else if(u.getChargeString().length()>0 && u.getChargeString()!="e") {
     log.printf("  charge: %s = %g e\n",u.getChargeString().c_str(),u.getCharge());
-  }
-  else {
+  } else {
     log.printf("  charge: %g e\n",u.getCharge());
   }
 
   s="";
   parse("MASS",s);
-  if(s.length()>0) u.setMass(s);
+  if(s.length()>0) {
+    u.setMass(s);
+  }
   if(u.getMassString().length()>0 && u.getMassString()=="amu") {
     log.printf("  mass: %s\n",u.getMassString().c_str());
-  }
-  else if(u.getMassString().length()>0 && u.getMassString()!="amu") {
+  } else if(u.getMassString().length()>0 && u.getMassString()!="amu") {
     log.printf("  mass: %s = %g amu\n",u.getMassString().c_str(),u.getMass());
-  }
-  else {
+  } else {
     log.printf("  mass: %g amu\n",u.getMass());
   }
 
diff --git a/src/sizeshape/mahadist.cpp b/src/sizeshape/mahadist.cpp
index 67ac27914f..68b6befd40 100644
--- a/src/sizeshape/mahadist.cpp
+++ b/src/sizeshape/mahadist.cpp
@@ -103,8 +103,7 @@ position_maha_dist::position_maha_dist(const ActionOptions&ao):
   squared(false),
   dist(0),
   prec_f_name(""),
-  ref_f_name("")    // Note! no comma here in the last line.
-{
+  ref_f_name("") {  // Note! no comma here in the last line.
   parseAtomList("GROUP",atom_list);
   parse("REFERENCE", ref_f_name);
   parse("PRECISION", prec_f_name);
@@ -121,12 +120,18 @@ position_maha_dist::position_maha_dist(const ActionOptions&ao):
     log.printf("  %d", atom_list[i].serial());
   }
 
-  if(squared)log.printf("\n chosen to use SQUARED option for SIZESHAPE_POSITION_MAHA_DIST\n");
+  if(squared) {
+    log.printf("\n chosen to use SQUARED option for SIZESHAPE_POSITION_MAHA_DIST\n");
+  }
 
-  if(pbc) log.printf("\n using periodic boundary conditions\n");
-  else log.printf("\n without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("\n using periodic boundary conditions\n");
+  } else {
+    log.printf("\n without periodic boundary conditions\n");
+  }
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
 
   requestAtoms(atom_list);
 
@@ -136,25 +141,28 @@ position_maha_dist::position_maha_dist(const ActionOptions&ao):
 }
 
 // read inputs function
-void position_maha_dist::readinputs()
-{
+void position_maha_dist::readinputs() {
   unsigned N=getNumberOfAtoms();
   // read ref coords
   in_.open(ref_f_name);
 
-  ref_str.resize(N,3); prec.resize(N,N);
+  ref_str.resize(N,3);
+  prec.resize(N,N);
 
   std::string line_, val_;
   unsigned c_=0;
 
-  while (c_ < N)
-  {
+  while (c_ < N) {
     in_.getline(line_);
     std::vector<std::string> items_;
     std::stringstream check_(line_);
 
-    while(std::getline(check_, val_, ' ')) { items_.push_back(val_); }
-    for(int i=0; i<3; ++i) { ref_str(c_,i) = std::stold(items_[i]); }
+    while(std::getline(check_, val_, ' ')) {
+      items_.push_back(val_);
+    }
+    for(int i=0; i<3; ++i) {
+      ref_str(c_,i) = std::stold(items_[i]);
+    }
     c_ += 1;
   }
   in_.close();
@@ -165,8 +173,7 @@ void position_maha_dist::readinputs()
   std::string line, val;
   unsigned int c = 0;
 
-  while(c < N)
-  {
+  while(c < N) {
     in_.getline(line);
 
     // vector for storing the objects
@@ -175,13 +182,11 @@ void position_maha_dist::readinputs()
     // stringstream helps to treat a string like an ifstream!
     std::stringstream check(line);
 
-    while (std::getline(check, val, ' '))
-    {
+    while (std::getline(check, val, ' ')) {
       items.push_back(val);
     }
 
-    for(unsigned int i=0; i<N; ++i)
-    {
+    for(unsigned int i=0; i<N; ++i) {
       prec(c, i) = std::stold(items[i]);
     }
 
@@ -192,13 +197,14 @@ void position_maha_dist::readinputs()
 }
 
 
-double position_maha_dist::determinant(int n, const std::vector<std::vector<double>>* B)
-{
+double position_maha_dist::determinant(int n, const std::vector<std::vector<double>>* B) {
 
   std::vector<std::vector<double>> A(n, std::vector<double>(n, 0));
   // make a copy first!
   for(int i=0; i<n; ++i) {
-    for(int j=0; j<n; ++j) {A[i][j] = (*B)[i][j];}
+    for(int j=0; j<n; ++j) {
+      A[i][j] = (*B)[i][j];
+    }
   }
 
 
@@ -207,34 +213,35 @@ double position_maha_dist::determinant(int n, const std::vector<std::vector<doub
   double det = 1;
 
   // Row operations for i = 0, ,,,, n - 2 (n-1 not needed)
-  for ( int i = 0; i < n - 1; i++ )
-  {
+  for ( int i = 0; i < n - 1; i++ ) {
     // Partial pivot: find row r below with largest element in column i
     int r = i;
     double maxA = std::abs( A[i][i] );
-    for ( int k = i + 1; k < n; k++ )
-    {
+    for ( int k = i + 1; k < n; k++ ) {
       double val = std::abs( A[k][i] );
-      if ( val > maxA )
-      {
+      if ( val > maxA ) {
         r = k;
         maxA = val;
       }
     }
-    if ( r != i )
-    {
-      for ( int j = i; j < n; j++ ) std::swap( A[i][j], A[r][j] );
+    if ( r != i ) {
+      for ( int j = i; j < n; j++ ) {
+        std::swap( A[i][j], A[r][j] );
+      }
       det = -det;
     }
 
     // Row operations to make upper-triangular
     double pivot = A[i][i];
-    if (std::abs( pivot ) < SMALL ) return 0.0;              // Singular matrix
+    if (std::abs( pivot ) < SMALL ) {
+      return 0.0;  // Singular matrix
+    }
 
-    for ( int r = i + 1; r < n; r++ )                    // On lower rows
-    {
+    for ( int r = i + 1; r < n; r++ ) {                  // On lower rows
       double multiple = A[r][i] / pivot;                // Multiple of row i to clear element in ith column
-      for ( int j = i; j < n; j++ ) A[r][j] -= multiple * A[i][j];
+      for ( int j = i; j < n; j++ ) {
+        A[r][j] -= multiple * A[i][j];
+      }
     }
     det *= pivot;                                        // Determinant is product of diagonal
   }
@@ -269,10 +276,17 @@ void position_maha_dist::kabsch_rot_mat() {
   unsigned k=0;
 
   // Transfer the matrix to the local array
-  for (int i=0; i<cl; ++i) for (int j=0; j<rw; ++j) da[k++]=static_cast<double>( correlation(j,i) ); // note! its [j][i] not [i][j]
+  for (int i=0; i<cl; ++i)
+    for (int j=0; j<rw; ++j) {
+      da[k++]=static_cast<double>( correlation(j,i) );  // note! its [j][i] not [i][j]
+    }
 
   int nsv, info, nrows=rw, ncols=cl;
-  if(rw>cl) {nsv=cl;} else {nsv=rw;}
+  if(rw>cl) {
+    nsv=cl;
+  } else {
+    nsv=rw;
+  }
 
   // Create some containers for stuff from single value decomposition
   std::vector<double> S(nsv);
@@ -285,15 +299,20 @@ void position_maha_dist::kabsch_rot_mat() {
   std::vector<double> work(1);
   plumed_lapack_dgesdd( "A", &nrows, &ncols, da.data(), &nrows, S.data(), U.data(), &nrows, VT.data(), &ncols, work.data(), &lwork, iwork.data(), &info );
   //if(info!=0) return info;
-  if(info!=0) log.printf("info:", info);
+  if(info!=0) {
+    log.printf("info:", info);
+  }
 
   // Retrieve correct sizes for work and rellocate
-  lwork=(int) work[0]; work.resize(lwork);
+  lwork=(int) work[0];
+  work.resize(lwork);
 
   // This does the singular value decomposition
   plumed_lapack_dgesdd( "A", &nrows, &ncols, da.data(), &nrows, S.data(), U.data(), &nrows, VT.data(), &ncols, work.data(), &lwork, iwork.data(), &info );
   //if(info!=0) return info;
-  if(info!=0) log.printf("info:", info);
+  if(info!=0) {
+    log.printf("info:", info);
+  }
 
 
   // get U and VT in form of 2D vector (U_, VT_)
@@ -302,8 +321,20 @@ void position_maha_dist::kabsch_rot_mat() {
 
   int  c=0;
 
-  for(int i=0; i<nrows; ++i) { for(int j=0; j<nrows; ++j) { U_[j][i] = U[c]; c += 1;} } c = 0; // note! its [j][i] not [i][j]
-  for(int i=0; i<ncols; ++i) { for(int j=0; j<ncols; ++j) { VT_[j][i] = VT[c]; c += 1;} } c=0; // note! its [j][i] not [i][j]
+  for(int i=0; i<nrows; ++i) {
+    for(int j=0; j<nrows; ++j) {
+      U_[j][i] = U[c];
+      c += 1;
+    }
+  }
+  c = 0; // note! its [j][i] not [i][j]
+  for(int i=0; i<ncols; ++i) {
+    for(int j=0; j<ncols; ++j) {
+      VT_[j][i] = VT[c];
+      c += 1;
+    }
+  }
+  c=0; // note! its [j][i] not [i][j]
 
 
   // calculate determinants
@@ -311,13 +342,22 @@ void position_maha_dist::kabsch_rot_mat() {
   double det_vt = determinant(ncols, &VT_);
 
   // check!
-  if (det_u * det_vt < 0.0) { for(int i=0; i<nrows; ++i) {U_[i][nrows-1] *= -1;} }
+  if (det_u * det_vt < 0.0) {
+    for(int i=0; i<nrows; ++i) {
+      U_[i][nrows-1] *= -1;
+    }
+  }
 
 
   //Matrix<double> rotation(3,3);
   rotation.resize(3,3);
   Matrix<double> u(3,3), vt(3,3);
-  for(int i=0; i<3; ++i) { for(int j=0; j<3; ++j) { u(i,j)=U_[i][j]; vt(i,j)=VT_[i][j]; } }
+  for(int i=0; i<3; ++i) {
+    for(int j=0; j<3; ++j) {
+      u(i,j)=U_[i][j];
+      vt(i,j)=VT_[i][j];
+    }
+  }
 
   // get rotation matrix
   mult(u, vt, rotation);
@@ -336,7 +376,11 @@ double position_maha_dist::cal_maha_dist() {
 
   // compute the displacement
   Matrix<double> disp(N,3);
-  for(unsigned int i=0; i<N; ++i) { for(unsigned int j=0; j<3; ++j) { disp(i,j) = (rotated_obj(i,j)-ref_str(i,j)); } }
+  for(unsigned int i=0; i<N; ++i) {
+    for(unsigned int j=0; j<3; ++j) {
+      disp(i,j) = (rotated_obj(i,j)-ref_str(i,j));
+    }
+  }
 
   Matrix<double> prec_dot_disp(N,3);
   Matrix<double> disp_T(3,N);
@@ -349,9 +393,13 @@ double position_maha_dist::cal_maha_dist() {
 
 
   double maha_d=0.0;
-  for(int i=0; i<3; ++i) { maha_d += out(i,i);}
+  for(int i=0; i<3; ++i) {
+    maha_d += out(i,i);
+  }
 
-  if (!squared) maha_d = std::sqrt(maha_d);
+  if (!squared) {
+    maha_d = std::sqrt(maha_d);
+  }
 
   return maha_d;
 }
@@ -370,12 +418,24 @@ void position_maha_dist::grad_maha(double d) {
   transpose(rotation, rot_T);
   mult(ref_str, rot_T, ref_str_rot_T);
 
-  for(unsigned i=0; i<N; ++i) { for(unsigned j=0; j<3; ++j) { diff_(i,j) = mobile_str(i,j) - ref_str_rot_T(i,j); } }
+  for(unsigned i=0; i<N; ++i) {
+    for(unsigned j=0; j<3; ++j) {
+      diff_(i,j) = mobile_str(i,j) - ref_str_rot_T(i,j);
+    }
+  }
 
   mult(prec, diff_, derv_);
 
   //for(unsigned i=0; i<N; ++i){ for(unsigned j=0; j<3; ++j) {derv_(i,j) /= (N*d);} }  // dividing by N here!
-  for(unsigned i=0; i<N; ++i) { for(unsigned j=0; j<3; ++j) { if (!squared) {derv_(i,j) /= d;} else {derv_(i,j) *= 2.0;}}}
+  for(unsigned i=0; i<N; ++i) {
+    for(unsigned j=0; j<3; ++j) {
+      if (!squared) {
+        derv_(i,j) /= d;
+      } else {
+        derv_(i,j) *= 2.0;
+      }
+    }
+  }
 
 
 }
@@ -402,7 +462,9 @@ void position_maha_dist::numeric_maha() {
 // calculator
 void position_maha_dist::calculate() {
 
-  if(pbc) makeWhole();
+  if(pbc) {
+    makeWhole();
+  }
   unsigned N=getNumberOfAtoms();
 
   mobile_str.resize(N,3);
@@ -418,14 +480,16 @@ void position_maha_dist::calculate() {
   // translating the structure to center of geometry
   double center_of_geometry[3]= {0.0, 0.0, 0.0};
 
-  for(unsigned int i=0; i<N; ++i)
-  {
-    center_of_geometry[0] += mobile_str(i,0); center_of_geometry[1] += mobile_str(i,1); center_of_geometry[2] += mobile_str(i,2);
+  for(unsigned int i=0; i<N; ++i) {
+    center_of_geometry[0] += mobile_str(i,0);
+    center_of_geometry[1] += mobile_str(i,1);
+    center_of_geometry[2] += mobile_str(i,2);
   }
 
-  for(unsigned int i=0; i<N; ++i)
-  {
-    for(unsigned int j=0; j<3; ++j) { mobile_str(i,j) -= (center_of_geometry[j]/N); }
+  for(unsigned int i=0; i<N; ++i) {
+    for(unsigned int j=0; j<3; ++j) {
+      mobile_str(i,j) -= (center_of_geometry[j]/N);
+    }
   }
 
   kabsch_rot_mat();
diff --git a/src/sizeshape/pos_proj.cpp b/src/sizeshape/pos_proj.cpp
index 2aa0ae44cf..102492622a 100644
--- a/src/sizeshape/pos_proj.cpp
+++ b/src/sizeshape/pos_proj.cpp
@@ -117,8 +117,7 @@ position_linear_proj::position_linear_proj(const ActionOptions&ao):
   proj(0),
   prec_f_name(""),
   ref_f_name(""),
-  coeffs_f_name("")   // Note! no comma here in the last line.
-{
+  coeffs_f_name("") { // Note! no comma here in the last line.
   parseFlag("SERIAL",serial);
   parseAtomList("GROUP",atom_list);
   parse("REFERENCE", ref_f_name);
@@ -135,10 +134,14 @@ position_linear_proj::position_linear_proj(const ActionOptions&ao):
     log.printf("  %d", atom_list[i].serial());
   }
 
-  if(pbc) log.printf("\n using periodic boundary conditions\n");
-  else log.printf("\n without periodic boundary conditions\n");
+  if(pbc) {
+    log.printf("\n using periodic boundary conditions\n");
+  } else {
+    log.printf("\n without periodic boundary conditions\n");
+  }
 
-  addValueWithDerivatives(); setNotPeriodic();
+  addValueWithDerivatives();
+  setNotPeriodic();
 
   requestAtoms(atom_list);
 
@@ -148,26 +151,29 @@ position_linear_proj::position_linear_proj(const ActionOptions&ao):
 }
 
 // read inputs function
-void position_linear_proj::readinputs()
-{
+void position_linear_proj::readinputs() {
   unsigned N=getNumberOfAtoms();
   // read ref coords
   in_.open(ref_f_name);
 
-  ref_str.resize(N,3); prec.resize(N,N);
+  ref_str.resize(N,3);
+  prec.resize(N,N);
   derv_numeric.resize(N,3);
 
   std::string line_, val_;
   unsigned c_=0;
 
-  while (c_ < N)
-  {
+  while (c_ < N) {
     in_.getline(line_);
     std::vector<std::string> items_;
     std::stringstream check_(line_);
 
-    while(std::getline(check_, val_, ' ')) { items_.push_back(val_); }
-    for(int i=0; i<3; ++i) { ref_str(c_,i) = std::stold(items_[i]); }
+    while(std::getline(check_, val_, ' ')) {
+      items_.push_back(val_);
+    }
+    for(int i=0; i<3; ++i) {
+      ref_str(c_,i) = std::stold(items_[i]);
+    }
     c_ += 1;
   }
   in_.close();
@@ -178,8 +184,7 @@ void position_linear_proj::readinputs()
   std::string line, val;
   unsigned int c = 0;
 
-  while(c < N)
-  {
+  while(c < N) {
     in_.getline(line);
 
     // vector for storing the objects
@@ -188,13 +193,11 @@ void position_linear_proj::readinputs()
     // stringstream helps to treat a string like an ifstream!
     std::stringstream check(line);
 
-    while (std::getline(check, val, ' '))
-    {
+    while (std::getline(check, val, ' ')) {
       items.push_back(val);
     }
 
-    for(unsigned int i=0; i<N; ++i)
-    {
+    for(unsigned int i=0; i<N; ++i) {
       prec(c, i) = std::stold(items[i]);
     }
 
@@ -207,7 +210,11 @@ void position_linear_proj::readinputs()
   in_.open(coeffs_f_name);
   unsigned n_=0;
   std::string l_;
-  while (n_ < N*3) { in_.getline(l_); linear_coeffs.push_back(std::stod(l_)); n_ += 1; }
+  while (n_ < N*3) {
+    in_.getline(l_);
+    linear_coeffs.push_back(std::stod(l_));
+    n_ += 1;
+  }
   linear_coeffs.resize(N*3);
 
   in_.close();
@@ -216,13 +223,14 @@ void position_linear_proj::readinputs()
 
 
 
-double position_linear_proj::determinant(int n, const std::vector<std::vector<double>>* B)
-{
+double position_linear_proj::determinant(int n, const std::vector<std::vector<double>>* B) {
 
   std::vector<std::vector<double>> A(n, std::vector<double>(n, 0));
   // make a copy first!
   for(int i=0; i<n; ++i) {
-    for(int j=0; j<n; ++j) {A[i][j] = (*B)[i][j];}
+    for(int j=0; j<n; ++j) {
+      A[i][j] = (*B)[i][j];
+    }
   }
 
 
@@ -231,34 +239,35 @@ double position_linear_proj::determinant(int n, const std::vector<std::vector<do
   double det = 1;
 
   // Row operations for i = 0, ,,,, n - 2 (n-1 not needed)
-  for ( int i = 0; i < n - 1; i++ )
-  {
+  for ( int i = 0; i < n - 1; i++ ) {
     // Partial pivot: find row r below with largest element in column i
     int r = i;
     double maxA = std::abs( A[i][i] );
-    for ( int k = i + 1; k < n; k++ )
-    {
+    for ( int k = i + 1; k < n; k++ ) {
       double val = std::abs( A[k][i] );
-      if ( val > maxA )
-      {
+      if ( val > maxA ) {
         r = k;
         maxA = val;
       }
     }
-    if ( r != i )
-    {
-      for ( int j = i; j < n; j++ ) std::swap( A[i][j], A[r][j] );
+    if ( r != i ) {
+      for ( int j = i; j < n; j++ ) {
+        std::swap( A[i][j], A[r][j] );
+      }
       det = -det;
     }
 
     // Row operations to make upper-triangular
     double pivot = A[i][i];
-    if (std::abs( pivot ) < SMALL ) return 0.0;              // Singular matrix
+    if (std::abs( pivot ) < SMALL ) {
+      return 0.0;  // Singular matrix
+    }
 
-    for ( int r = i + 1; r < n; r++ )                    // On lower rows
-    {
+    for ( int r = i + 1; r < n; r++ ) {                  // On lower rows
       double multiple = A[r][i] / pivot;                // Multiple of row i to clear element in ith column
-      for ( int j = i; j < n; j++ ) A[r][j] -= multiple * A[i][j];
+      for ( int j = i; j < n; j++ ) {
+        A[r][j] -= multiple * A[i][j];
+      }
     }
     det *= pivot;                                        // Determinant is product of diagonal
   }
@@ -293,10 +302,17 @@ void position_linear_proj::kabsch_rot_mat() {
   unsigned k=0;
 
   // Transfer the matrix to the local array
-  for (int i=0; i<cl; ++i) for (int j=0; j<rw; ++j) da[k++]=static_cast<double>( correlation(j,i) ); // note! its [j][i] not [i][j]
+  for (int i=0; i<cl; ++i)
+    for (int j=0; j<rw; ++j) {
+      da[k++]=static_cast<double>( correlation(j,i) );  // note! its [j][i] not [i][j]
+    }
 
   int nsv, info, nrows=rw, ncols=cl;
-  if(rw>cl) {nsv=cl;} else {nsv=rw;}
+  if(rw>cl) {
+    nsv=cl;
+  } else {
+    nsv=rw;
+  }
 
   // Create some containers for stuff from single value decomposition
   std::vector<double> S(nsv);
@@ -309,15 +325,20 @@ void position_linear_proj::kabsch_rot_mat() {
   std::vector<double> work(1);
   plumed_lapack_dgesdd( "A", &nrows, &ncols, da.data(), &nrows, S.data(), U.data(), &nrows, VT.data(), &ncols, work.data(), &lwork, iwork.data(), &info );
   //if(info!=0) return info;
-  if(info!=0) log.printf("info:", info);
+  if(info!=0) {
+    log.printf("info:", info);
+  }
 
   // Retrieve correct sizes for work and rellocate
-  lwork=(int) work[0]; work.resize(lwork);
+  lwork=(int) work[0];
+  work.resize(lwork);
 
   // This does the singular value decomposition
   plumed_lapack_dgesdd( "A", &nrows, &ncols, da.data(), &nrows, S.data(), U.data(), &nrows, VT.data(), &ncols, work.data(), &lwork, iwork.data(), &info );
   //if(info!=0) return info;
-  if(info!=0) log.printf("info:", info);
+  if(info!=0) {
+    log.printf("info:", info);
+  }
 
 
   // get U and VT in form of 2D vector (U_, VT_)
@@ -326,8 +347,20 @@ void position_linear_proj::kabsch_rot_mat() {
 
   int  c=0;
 
-  for(int i=0; i<nrows; ++i) { for(int j=0; j<nrows; ++j) { U_[j][i] = U[c]; c += 1;} } c = 0; // note! its [j][i] not [i][j]
-  for(int i=0; i<ncols; ++i) { for(int j=0; j<ncols; ++j) { VT_[j][i] = VT[c]; c += 1;} } c=0; // note! its [j][i] not [i][j]
+  for(int i=0; i<nrows; ++i) {
+    for(int j=0; j<nrows; ++j) {
+      U_[j][i] = U[c];
+      c += 1;
+    }
+  }
+  c = 0; // note! its [j][i] not [i][j]
+  for(int i=0; i<ncols; ++i) {
+    for(int j=0; j<ncols; ++j) {
+      VT_[j][i] = VT[c];
+      c += 1;
+    }
+  }
+  c=0; // note! its [j][i] not [i][j]
 
 
   // calculate determinants
@@ -335,13 +368,22 @@ void position_linear_proj::kabsch_rot_mat() {
   double det_vt = determinant(ncols, &VT_);
 
   // check!
-  if (det_u * det_vt < 0.0) { for(int i=0; i<nrows; ++i) {U_[i][nrows-1] *= -1;} }
+  if (det_u * det_vt < 0.0) {
+    for(int i=0; i<nrows; ++i) {
+      U_[i][nrows-1] *= -1;
+    }
+  }
 
 
   //Matrix<double> rotation(3,3);
   rotation.resize(3,3);
   Matrix<double> u(3,3), vt(3,3);
-  for(int i=0; i<3; ++i) { for(int j=0; j<3; ++j) { u(i,j)=U_[i][j]; vt(i,j)=VT_[i][j]; } }
+  for(int i=0; i<3; ++i) {
+    for(int j=0; j<3; ++j) {
+      u(i,j)=U_[i][j];
+      vt(i,j)=VT_[i][j];
+    }
+  }
 
   // get rotation matrix
   mult(u, vt, rotation);
@@ -361,11 +403,18 @@ double position_linear_proj::cal_position_linear_proj() {
   // compute the displacement
   std::vector<double> disp(N*3);
   unsigned c=0;
-  for(unsigned int i=0; i<N; ++i) { for(int j=0; j<3; ++j) { disp[c] = (rotated_obj(i,j)-ref_str(i,j)); c+=1;} }
+  for(unsigned int i=0; i<N; ++i) {
+    for(int j=0; j<3; ++j) {
+      disp[c] = (rotated_obj(i,j)-ref_str(i,j));
+      c+=1;
+    }
+  }
 
   //double proj_val = dotProduct(disp, linear_coeffs);
   double proj_val = 0.0;
-  for(unsigned int i=0; i<N*3; ++i) { proj_val += (linear_coeffs[i]*disp[i]);}
+  for(unsigned int i=0; i<N*3; ++i) {
+    proj_val += (linear_coeffs[i]*disp[i]);
+  }
 
   return proj_val;
 }
@@ -399,7 +448,9 @@ void position_linear_proj::numeric_grad() {
   }
 
   if(!serial) {
-    if(!derv_numeric.getVector().empty()) comm.Sum(&derv_numeric(0,0), derv_numeric.getVector().size());
+    if(!derv_numeric.getVector().empty()) {
+      comm.Sum(&derv_numeric(0,0), derv_numeric.getVector().size());
+    }
   }
 
 
@@ -416,7 +467,9 @@ void position_linear_proj::numeric_grad() {
 // calculator
 void position_linear_proj::calculate() {
 
-  if(pbc) makeWhole();
+  if(pbc) {
+    makeWhole();
+  }
   unsigned N=getNumberOfAtoms();
 
   mobile_str.resize(N,3);
@@ -432,14 +485,16 @@ void position_linear_proj::calculate() {
   // translating the structure to center of geometry
   double center_of_geometry[3]= {0.0, 0.0, 0.0};
 
-  for(unsigned int i=0; i<N; ++i)
-  {
-    center_of_geometry[0] += mobile_str(i,0); center_of_geometry[1] += mobile_str(i,1); center_of_geometry[2] += mobile_str(i,2);
+  for(unsigned int i=0; i<N; ++i) {
+    center_of_geometry[0] += mobile_str(i,0);
+    center_of_geometry[1] += mobile_str(i,1);
+    center_of_geometry[2] += mobile_str(i,2);
   }
 
-  for(unsigned int i=0; i<N; ++i)
-  {
-    for(int j=0; j<3; ++j) { mobile_str(i,j) -= (center_of_geometry[j]/N); }
+  for(unsigned int i=0; i<N; ++i) {
+    for(int j=0; j<3; ++j) {
+      mobile_str(i,j) -= (center_of_geometry[j]/N);
+    }
   }
 
   kabsch_rot_mat();
diff --git a/src/small_vector/small_vector.h b/src/small_vector/small_vector.h
index 82d029b3d4..b004e0284d 100644
--- a/src/small_vector/small_vector.h
+++ b/src/small_vector/small_vector.h
@@ -318,13 +318,11 @@
 #endif
 
 namespace PLMD {
-namespace gch
-{
+namespace gch {
 
 #ifdef PLUMED_GCH_LIB_CONCEPTS
 
-namespace concepts
-{
+namespace concepts {
 
 template <typename T>
 concept Complete = requires { sizeof (T); };
@@ -352,17 +350,18 @@ concept NoThrowConstructibleFrom = std::is_nothrow_constructible<T, Args...>::va
 template <typename From, typename To>
 concept ConvertibleTo =
   std::is_convertible<From, To>::value
-  &&  requires (typename std::add_rvalue_reference<From>::type (&f) (void))
-{
+&&  requires (typename std::add_rvalue_reference<From>::type (&f) (void)) {
   static_cast<To> (f ());
 };
 
 template <typename From, typename To>
 concept NoThrowConvertibleTo =
   std::is_nothrow_convertible<From, To>::value
-  &&  requires (typename std::add_rvalue_reference<From>::type (&f) (void) noexcept)
-{
-  { static_cast<To> (f ()) } noexcept;
+&&  requires (typename std::add_rvalue_reference<From>::type (&f) (void) noexcept) {
+  {
+    static_cast<To> (f ())
+  }
+  noexcept;
 };
 
 // Note: std::default_initializable requires std::destructible.
@@ -426,12 +425,10 @@ concept EmplaceConstructible =
   &&  (  (  requires { typename X::allocator_type; } // only perform this check if X is
             &&  std::same_as<typename X::allocator_type, // allocator-aware
             typename std::allocator_traits<A>::template rebind_alloc<T>>
-            &&  (  requires (A m, T *p, Args&&... args)
-{
+&&  (  requires (A m, T *p, Args&&... args) {
   m.construct (p, std::forward<Args> (args)...);
 }
-||  requires (T *p, Args&&... args)
-{
+||  requires (T *p, Args&&... args) {
 #if __cplusplus >= 202002L // c++20 fully featured
   { std::construct_at (p, std::forward<Args> (args)...) } -> std::same_as<T *>;
 #else
@@ -439,8 +436,7 @@ concept EmplaceConstructible =
 #endif
 }))
 ||  (! requires { typename X::allocator_type; }
-     &&  requires (T *p, Args&&... args)
-{
+&&  requires (T *p, Args&&... args) {
 #if __cplusplus >= 202002L // c++20 fully featured
   { std::construct_at (p, std::forward<Args> (args)...) } -> std::same_as<T *>;
 #else
@@ -478,8 +474,7 @@ typename A = typename std::conditional<requires { typename X::allocator_type; },
            &&  (  (  requires { typename X::allocator_type; } // if X is allocator aware
                      &&  std::same_as<typename X::allocator_type,
                      typename std::allocator_traits<A>::template rebind_alloc<T>>
-                  &&  (  requires (A m, T *p)
-{
+&&  (  requires (A m, T *p) {
   m.destroy (p);
 }
 ||   std::is_destructible<T>::value))
@@ -502,15 +497,32 @@ EqualityComparable<T>
 &&  Destructible<T>
 &&  ConstructibleFrom<T, std::nullptr_t>
 &&  ConvertibleTo<std::nullptr_t, T>
-&&  requires (T p, T q, std::nullptr_t np)
-{
+&&  requires (T p, T q, std::nullptr_t np) {
   T (np);
-  { p = np   } -> std::same_as<T&>;
-  { p  != q  } -> ContextuallyConvertibleToBool;
-  { p  == np } -> ContextuallyConvertibleToBool;
-  { np == p  } -> ContextuallyConvertibleToBool;
-  { p  != np } -> ContextuallyConvertibleToBool;
-  { np != p  } -> ContextuallyConvertibleToBool;
+  {
+    p = np
+  }
+  -> std::same_as<T&>;
+  {
+    p  != q
+  }
+  -> ContextuallyConvertibleToBool;
+  {
+    p  == np
+  }
+  -> ContextuallyConvertibleToBool;
+  {
+    np == p
+  }
+  -> ContextuallyConvertibleToBool;
+  {
+    p  != np
+  }
+  -> ContextuallyConvertibleToBool;
+  {
+    np != p
+  }
+  -> ContextuallyConvertibleToBool;
 };
 
 static_assert (  NullablePointer<int *>);
@@ -527,8 +539,7 @@ NoThrowCopyConstructible<A>
               typename std::allocator_traits<A>::void_pointer vp,
               typename std::allocator_traits<A>::const_void_pointer cvp,
               typename std::allocator_traits<A>::value_type& r,
-              typename std::allocator_traits<A>::size_type n)
-{
+              typename std::allocator_traits<A>::size_type n) {
   /** Inner types **/
   // A::pointer
   requires NullablePointer<            typename std::allocator_traits<A>::pointer>;
@@ -581,46 +592,64 @@ NoThrowCopyConstructible<A>
 
   // A::template rebind<U>::other [optional]
   requires ! requires { typename A::template rebind<U>::other; }
-  ||  requires
-  {
+  ||  requires {
     requires std::same_as<decltype (b), typename A::template rebind<U>::other>;
     requires std::same_as<A, typename decltype (b)::template rebind<T>::other>;
   };
 
   /** Operations on pointers **/
-  { *p  } -> std::same_as<typename A::value_type&>;
-  { *cp } -> std::same_as<const typename A::value_type&>;
+  {
+    *p
+  }
+  -> std::same_as<typename A::value_type&>;
+  {
+    *cp
+  }
+  -> std::same_as<const typename A::value_type&>;
 
   // Language in the standard implies that `decltype (p)` must either
   // be a raw pointer or implement `operator->`. There is no mention
   // of `std::to_address` or `std::pointer_traits<Ptr>::to_address`.
   requires std::same_as<decltype (p), typename A::value_type *>
-  ||  requires
-  {
+  ||  requires {
     { p.operator-> () } -> std::same_as<typename A::value_type *>;
   };
 
   requires std::same_as<decltype (cp), const typename A::value_type *>
-  ||  requires
-  {
+  ||  requires {
     { cp.operator-> () } -> std::same_as<const typename A::value_type *>;
   };
 
-  { static_cast<decltype (p)> (vp)   } -> std::same_as<decltype (p)>;
-  { static_cast<decltype (cp)> (cvp) } -> std::same_as<decltype (cp)>;
+  {
+    static_cast<decltype (p)> (vp)
+  }
+  -> std::same_as<decltype (p)>;
+  {
+    static_cast<decltype (cp)> (cvp)
+  }
+  -> std::same_as<decltype (cp)>;
 
-  { std::pointer_traits<decltype (p)>::pointer_to (r) } -> std::same_as<decltype (p)>;
+  {
+    std::pointer_traits<decltype (p)>::pointer_to (r)
+  }
+  -> std::same_as<decltype (p)>;
 
   /** Storage and lifetime operations **/
   // a.allocate (n)
-  { a.allocate (n) } -> std::same_as<decltype (p)>;
+  {
+    a.allocate (n)
+  }
+  -> std::same_as<decltype (p)>;
 
   // a.allocate (n, cvp) [optional]
   requires ! requires { a.allocate (n, cvp); }
   ||  requires { { a.allocate (n, cvp) } -> std::same_as<decltype (p)>; };
 
   // a.deallocate (p, n)
-  { a.deallocate (p, n) } -> std::convertible_to<void>;
+  {
+    a.deallocate (p, n)
+  }
+  -> std::convertible_to<void>;
 
   // a.max_size () [optional]
   requires ! requires { a.max_size (); }
@@ -643,8 +672,7 @@ NoThrowCopyConstructible<A>
   /** Influence on container operations **/
   // a.select_on_container_copy_construction () [optional]
   requires ! requires { a.select_on_container_copy_construction (); }
-  ||  requires
-  {
+  ||  requires {
     { a.select_on_container_copy_construction () } -> std::same_as<A>;
   };
 
@@ -657,13 +685,24 @@ NoThrowCopyConstructible<A>
   requires BoolConstant<
   typename std::allocator_traits<A>::propagate_on_container_swap>;
 
-  { a == b } -> std::same_as<bool>;
-  { a != b } -> std::same_as<bool>;
+  {
+    a == b
+  }
+  -> std::same_as<bool>;
+  {
+    a != b
+  }
+  -> std::same_as<bool>;
 }
-&&  requires (A a1, A a2)
-{
-  { a1 == a2 } -> std::same_as<bool>;
-  { a1 != a2 } -> std::same_as<bool>;
+&&  requires (A a1, A a2) {
+  {
+    a1 == a2
+  }
+  -> std::same_as<bool>;
+  {
+    a1 != a2
+  }
+  -> std::same_as<bool>;
 };
 
 static_assert (AllocatorFor<std::allocator<int>, int>,
@@ -672,8 +711,7 @@ static_assert (AllocatorFor<std::allocator<int>, int>,
 template <typename A>
 concept Allocator = AllocatorFor<A, typename A::value_type>;
 
-namespace small_vector
-{
+namespace small_vector {
 
 // Basically, these shut off the concepts if we have an incomplete type.
 // This namespace is only needed because of issues on Clang
@@ -754,18 +792,17 @@ template <typename Allocator>
 #ifdef PLUMED_GCH_LIB_CONCEPTS
 requires concepts::small_vector::Allocator<Allocator>
 #endif
-struct default_buffer_size
-{
+struct default_buffer_size {
 private:
   template <typename, typename Enable = void>
   struct is_complete
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename U>
   struct is_complete<U, decltype (static_cast<void> (sizeof (U)))>
-: std::true_type
-  { };
+: std::true_type {
+  };
 
 public:
   using allocator_type     = Allocator;
@@ -817,8 +854,7 @@ default_buffer_size_v = default_buffer_size<Allocator>::value;
 #endif
 
 template <typename Pointer, typename DifferenceType>
-class small_vector_iterator
-{
+class small_vector_iterator {
 public:
   using difference_type   = DifferenceType;
   using value_type        = typename std::iterator_traits<Pointer>::value_type;
@@ -859,68 +895,59 @@ class small_vector_iterator
 
   PLUMED_GCH_CPP14_CONSTEXPR
   small_vector_iterator&
-  operator++ (void) noexcept
-  {
+  operator++ (void) noexcept {
     ++m_ptr;
     return *this;
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   small_vector_iterator
-  operator++ (int) noexcept
-  {
+  operator++ (int) noexcept {
     return small_vector_iterator (m_ptr++);
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   small_vector_iterator&
-  operator-- (void) noexcept
-  {
+  operator-- (void) noexcept {
     --m_ptr;
     return *this;
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   small_vector_iterator
-  operator-- (int) noexcept
-  {
+  operator-- (int) noexcept {
     return small_vector_iterator (m_ptr--);
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   small_vector_iterator&
-  operator+= (difference_type n) noexcept
-  {
+  operator+= (difference_type n) noexcept {
     m_ptr += n;
     return *this;
   }
 
   constexpr
   small_vector_iterator
-  operator+ (difference_type n) const noexcept
-  {
+  operator+ (difference_type n) const noexcept {
     return small_vector_iterator (m_ptr + n);
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   small_vector_iterator&
-  operator-= (difference_type n) noexcept
-  {
+  operator-= (difference_type n) noexcept {
     m_ptr -= n;
     return *this;
   }
 
   constexpr
   small_vector_iterator
-  operator- (difference_type n) const noexcept
-  {
+  operator- (difference_type n) const noexcept {
     return small_vector_iterator (m_ptr - n);
   }
 
   constexpr
   reference
-  operator* (void) const noexcept
-  {
+  operator* (void) const noexcept {
 #ifdef PLUMED_GCH_LIB_LAUNDER
     return launder_and_dereference (m_ptr);
 #else
@@ -930,15 +957,13 @@ class small_vector_iterator
 
   constexpr
   pointer
-  operator-> (void) const noexcept
-  {
+  operator-> (void) const noexcept {
     return get_pointer (m_ptr);
   }
 
   constexpr
   reference
-  operator[] (difference_type n) const noexcept
-  {
+  operator[] (difference_type n) const noexcept {
 #ifdef PLUMED_GCH_LIB_LAUNDER
     return launder_and_dereference (m_ptr + n);
 #else
@@ -948,8 +973,7 @@ class small_vector_iterator
 
   constexpr
   const Pointer&
-  base (void) const noexcept
-  {
+  base (void) const noexcept {
     return m_ptr;
   }
 
@@ -958,8 +982,7 @@ class small_vector_iterator
             typename std::enable_if<std::is_pointer<Ptr>::value, bool>::type = true>
   static constexpr
   pointer
-  get_pointer (Pointer ptr) noexcept
-  {
+  get_pointer (Pointer ptr) noexcept {
     return ptr;
   }
 
@@ -967,8 +990,7 @@ class small_vector_iterator
             typename std::enable_if<! std::is_pointer<Ptr>::value, bool>::type = false>
   static constexpr
   pointer
-  get_pointer (Pointer ptr) noexcept
-  {
+  get_pointer (Pointer ptr) noexcept {
     // Given the requirements for Allocator, Pointer must either be a raw pointer, or
     // have a defined operator-> which returns a raw pointer.
     return ptr.operator-> ();
@@ -980,8 +1002,7 @@ class small_vector_iterator
             typename std::enable_if<std::is_pointer<Ptr>::value, bool>::type = true>
   static constexpr
   reference
-  launder_and_dereference (Pointer ptr) noexcept
-  {
+  launder_and_dereference (Pointer ptr) noexcept {
     return *std::launder (ptr);
   }
 
@@ -989,8 +1010,7 @@ class small_vector_iterator
             typename std::enable_if<! std::is_pointer<Ptr>::value, bool>::type = false>
   static constexpr
   reference
-  launder_and_dereference (Pointer ptr) noexcept
-  {
+  launder_and_dereference (Pointer ptr) noexcept {
     return *ptr;
   }
 
@@ -1008,8 +1028,7 @@ bool
 operator== (const small_vector_iterator<PointerLHS, DifferenceTypeLHS>& lhs,
             const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs)
 noexcept (noexcept (lhs.base () == rhs.base ()))
-requires requires { { lhs.base () == rhs.base () } -> std::convertible_to<bool>; }
-{
+requires requires { { lhs.base () == rhs.base () } -> std::convertible_to<bool>; } {
   return lhs.base () == rhs.base ();
 }
 
@@ -1019,8 +1038,7 @@ bool
 operator== (const small_vector_iterator<Pointer, DifferenceType>& lhs,
             const small_vector_iterator<Pointer, DifferenceType>& rhs)
 noexcept (noexcept (lhs.base () == rhs.base ()))
-requires requires { { lhs.base () == rhs.base () } -> std::convertible_to<bool>; }
-{
+requires requires { { lhs.base () == rhs.base () } -> std::convertible_to<bool>; } {
   return lhs.base () == rhs.base ();
 }
 
@@ -1031,8 +1049,7 @@ constexpr
 auto
 operator<=> (const small_vector_iterator<PointerLHS, DifferenceTypeLHS>& lhs,
              const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs)
-noexcept (noexcept (lhs.base () <=> rhs.base ()))
-{
+noexcept (noexcept (lhs.base () <=> rhs.base ())) {
   return lhs.base () <=> rhs.base ();
 }
 
@@ -1042,8 +1059,7 @@ constexpr
 auto
 operator<=> (const small_vector_iterator<Pointer, DifferenceType>& lhs,
              const small_vector_iterator<Pointer, DifferenceType>& rhs)
-noexcept (noexcept (lhs.base () <=> rhs.base ()))
-{
+noexcept (noexcept (lhs.base () <=> rhs.base ())) {
   return lhs.base () <=> rhs.base ();
 }
 
@@ -1053,8 +1069,7 @@ constexpr
 auto
 operator<=> (const small_vector_iterator<PointerLHS, DifferenceTypeLHS>& lhs,
              const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs)
-noexcept (noexcept (lhs.base () < rhs.base ()) && noexcept (rhs.base () < lhs.base ()))
-{
+noexcept (noexcept (lhs.base () < rhs.base ()) && noexcept (rhs.base () < lhs.base ())) {
   using ordering = std::weak_ordering;
   return (lhs.base () < rhs.base ()) ? ordering::less
          : (rhs.base () < lhs.base ()) ? ordering::greater
@@ -1066,8 +1081,7 @@ constexpr
 auto
 operator<=> (const small_vector_iterator<Pointer, DifferenceType>& lhs,
              const small_vector_iterator<Pointer, DifferenceType>& rhs)
-noexcept (noexcept (lhs.base () < rhs.base ()) && noexcept (rhs.base () < lhs.base ()))
-{
+noexcept (noexcept (lhs.base () < rhs.base ()) && noexcept (rhs.base () < lhs.base ())) {
   using ordering = std::weak_ordering;
   return (lhs.base () < rhs.base ()) ? ordering::less
          : (rhs.base () < lhs.base ()) ? ordering::greater
@@ -1087,8 +1101,7 @@ template <typename PointerLHS, typename DifferenceTypeLHS,
 constexpr
 bool
 operator== (const small_vector_iterator<PointerLHS, DifferenceTypeLHS>& lhs,
-            const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept
-{
+            const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept {
   return lhs.base () == rhs.base ();
 }
 
@@ -1096,8 +1109,7 @@ template <typename Pointer, typename DifferenceType>
 constexpr
 bool
 operator== (const small_vector_iterator<Pointer, DifferenceType>& lhs,
-            const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept
-{
+            const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept {
   return lhs.base () == rhs.base ();
 }
 
@@ -1106,8 +1118,7 @@ template <typename PointerLHS, typename DifferenceTypeLHS,
 constexpr
 bool
 operator!= (const small_vector_iterator<PointerLHS, DifferenceTypeLHS>& lhs,
-            const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept
-{
+            const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept {
   return lhs.base () != rhs.base ();
 }
 
@@ -1115,8 +1126,7 @@ template <typename Pointer, typename DifferenceType>
 constexpr
 bool
 operator!= (const small_vector_iterator<Pointer, DifferenceType>& lhs,
-            const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept
-{
+            const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept {
   return lhs.base () != rhs.base ();
 }
 
@@ -1125,8 +1135,7 @@ template <typename PointerLHS, typename DifferenceTypeLHS,
 constexpr
 bool
 operator< (const small_vector_iterator<PointerLHS, DifferenceTypeLHS>& lhs,
-           const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept
-{
+const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept {
   return lhs.base () < rhs.base ();
 }
 
@@ -1134,8 +1143,7 @@ template <typename Pointer, typename DifferenceType>
 constexpr
 bool
 operator< (const small_vector_iterator<Pointer, DifferenceType>& lhs,
-           const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept
-{
+const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept {
   return lhs.base () < rhs.base ();
 }
 
@@ -1144,8 +1152,7 @@ template <typename PointerLHS, typename DifferenceTypeLHS,
 constexpr
 bool
 operator>= (const small_vector_iterator<PointerLHS, DifferenceTypeLHS>& lhs,
-            const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept
-{
+            const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept {
   return lhs.base () >= rhs.base ();
 }
 
@@ -1153,8 +1160,7 @@ template <typename Pointer, typename DifferenceType>
 constexpr
 bool
 operator>= (const small_vector_iterator<Pointer, DifferenceType>& lhs,
-            const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept
-{
+            const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept {
   return lhs.base () >= rhs.base ();
 }
 
@@ -1163,8 +1169,7 @@ template <typename PointerLHS, typename DifferenceTypeLHS,
 constexpr
 bool
 operator> (const small_vector_iterator<PointerLHS, DifferenceTypeLHS>& lhs,
-           const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept
-{
+           const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept {
   return lhs.base () > rhs.base ();
 }
 
@@ -1172,8 +1177,7 @@ template <typename Pointer, typename DifferenceType>
 constexpr
 bool
 operator> (const small_vector_iterator<Pointer, DifferenceType>& lhs,
-           const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept
-{
+           const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept {
   return lhs.base () > rhs.base ();
 }
 
@@ -1182,8 +1186,7 @@ template <typename PointerLHS, typename DifferenceTypeLHS,
 constexpr
 bool
 operator<= (const small_vector_iterator<PointerLHS, DifferenceTypeLHS>& lhs,
-            const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept
-{
+const small_vector_iterator<PointerRHS, DifferenceTypeRHS>& rhs) noexcept {
   return lhs.base () <= rhs.base ();
 }
 
@@ -1191,8 +1194,7 @@ template <typename Pointer, typename DifferenceType>
 constexpr
 bool
 operator<= (const small_vector_iterator<Pointer, DifferenceType>& lhs,
-            const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept
-{
+const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept {
   return lhs.base () <= rhs.base ();
 }
 
@@ -1202,8 +1204,7 @@ template <typename PointerLHS, typename PointerRHS, typename DifferenceType>
 constexpr
 DifferenceType
 operator- (const small_vector_iterator<PointerLHS, DifferenceType>& lhs,
-           const small_vector_iterator<PointerRHS, DifferenceType>& rhs) noexcept
-{
+           const small_vector_iterator<PointerRHS, DifferenceType>& rhs) noexcept {
   return static_cast<DifferenceType> (lhs.base () - rhs.base ());
 }
 
@@ -1211,46 +1212,41 @@ template <typename Pointer, typename DifferenceType>
 constexpr
 DifferenceType
 operator- (const small_vector_iterator<Pointer, DifferenceType>& lhs,
-           const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept
-{
+           const small_vector_iterator<Pointer, DifferenceType>& rhs) noexcept {
   return static_cast<DifferenceType> (lhs.base () - rhs.base ());
 }
 
 template <typename Pointer, typename DifferenceType>
 constexpr
 small_vector_iterator<Pointer, DifferenceType>
-operator+ (DifferenceType n, const small_vector_iterator<Pointer, DifferenceType>& it) noexcept
-{
+operator+ (DifferenceType n, const small_vector_iterator<Pointer, DifferenceType>& it) noexcept {
   return it + n;
 }
 
-namespace detail
-{
+namespace detail {
 
 #ifndef PLUMED_GCH_LIB_IS_SWAPPABLE
 
-namespace small_vector_adl
-{
+namespace small_vector_adl {
 
 using std::swap;
 
 template <typename T, typename Enable = void>
 struct is_nothrow_swappable
-: std::false_type
-{ };
+: std::false_type {
+};
 
 template <typename T>
 struct is_nothrow_swappable<T, decltype (swap (std::declval<T&> (), std::declval<T&> ()))>
-: std::integral_constant<bool, noexcept (swap (std::declval<T&> (), std::declval<T&> ()))>
-{ };
+: std::integral_constant<bool, noexcept (swap (std::declval<T&> (), std::declval<T&> ()))> {
+};
 
 }
 
 #endif
 
 template <typename T, unsigned InlineCapacity>
-class inline_storage
-{
+class inline_storage {
 public:
   using value_ty = T;
 
@@ -1263,43 +1259,37 @@ class inline_storage
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR
   value_ty *
-  get_inline_ptr (void) noexcept
-  {
+  get_inline_ptr (void) noexcept {
     return static_cast<value_ty *> (static_cast<void *> (std::addressof (*m_data)));
   }
 
   PLUMED_GCH_NODISCARD constexpr
   const value_ty *
-  get_inline_ptr (void) const noexcept
-  {
+  get_inline_ptr (void) const noexcept {
     return static_cast<const value_ty *> (static_cast<const void *> (std::addressof (*m_data)));
   }
 
   static constexpr
   std::size_t
-  element_size (void) noexcept
-  {
+  element_size (void) noexcept {
     return sizeof (value_ty);
   }
 
   static constexpr
   std::size_t
-  alignment (void) noexcept
-  {
+  alignment (void) noexcept {
     return alignof (value_ty);
   }
 
   static constexpr
   unsigned
-  num_elements (void) noexcept
-  {
+  num_elements (void) noexcept {
     return InlineCapacity;
   }
 
   static constexpr
   std::size_t
-  num_bytes (void) noexcept
-  {
+  num_bytes (void) noexcept {
     return num_elements () * element_size ();
   }
 
@@ -1308,8 +1298,7 @@ class inline_storage
 };
 
 template <typename T>
-class PLUMED_GCH_EMPTY_BASE inline_storage<T, 0>
-{
+class PLUMED_GCH_EMPTY_BASE inline_storage<T, 0> {
 public:
   using value_ty = T;
 
@@ -1322,43 +1311,37 @@ class PLUMED_GCH_EMPTY_BASE inline_storage<T, 0>
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR
   value_ty *
-  get_inline_ptr (void) noexcept
-  {
+  get_inline_ptr (void) noexcept {
     return nullptr;
   }
 
   PLUMED_GCH_NODISCARD constexpr
   const value_ty *
-  get_inline_ptr (void) const noexcept
-  {
+  get_inline_ptr (void) const noexcept {
     return nullptr;
   }
 
   static constexpr
   std::size_t
-  element_size (void) noexcept
-  {
+  element_size (void) noexcept {
     return sizeof (value_ty);
   }
 
   static constexpr
   std::size_t
-  alignment (void) noexcept
-  {
+  alignment (void) noexcept {
     return alignof (value_ty);
   }
 
   static constexpr
   unsigned
-  num_elements (void) noexcept
-  {
+  num_elements (void) noexcept {
     return 0;
   }
 
   static constexpr
   std::size_t
-  num_bytes (void) noexcept
-  {
+  num_bytes (void) noexcept {
     return 0;
   }
 };
@@ -1372,8 +1355,7 @@ class allocator_inliner;
 
 template <typename Allocator>
 class PLUMED_GCH_EMPTY_BASE allocator_inliner<Allocator, true>
-: private Allocator
-{
+: private Allocator {
   using alloc_traits = std::allocator_traits<Allocator>;
 
   static constexpr
@@ -1399,8 +1381,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_inliner<Allocator, true>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
   maybe_assign (const allocator_inliner& other)
-  noexcept (noexcept (std::declval<Allocator&> ().operator= (other)))
-  {
+  noexcept (noexcept (std::declval<Allocator&> ().operator= (other))) {
     Allocator::operator= (other);
   }
 
@@ -1415,8 +1396,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_inliner<Allocator, true>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
   maybe_assign (allocator_inliner&& other)
-  noexcept (noexcept (std::declval<Allocator&> ().operator= (std::move (other))))
-  {
+  noexcept (noexcept (std::declval<Allocator&> ().operator= (std::move (other)))) {
     Allocator::operator= (std::move (other));
   }
 
@@ -1436,8 +1416,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_inliner<Allocator, true>
   PLUMED_GCH_CPP20_CONSTEXPR
   allocator_inliner&
   operator= (const allocator_inliner& other)
-  noexcept (noexcept (std::declval<allocator_inliner&> ().maybe_assign (other)))
-  {
+  noexcept (noexcept (std::declval<allocator_inliner&> ().maybe_assign (other))) {
     assert (&other != this
             &&  "`allocator_inliner` should not participate in self-copy-assignment.");
     maybe_assign (other);
@@ -1447,8 +1426,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_inliner<Allocator, true>
   PLUMED_GCH_CPP20_CONSTEXPR
   allocator_inliner&
   operator= (allocator_inliner&& other)
-  noexcept (noexcept (std::declval<allocator_inliner&> ().maybe_assign (std::move (other))))
-  {
+  noexcept (noexcept (std::declval<allocator_inliner&> ().maybe_assign (std::move (other)))) {
     assert (&other != this
             &&  "`allocator_inliner` should not participate in self-move-assignment.");
     maybe_assign (std::move (other));
@@ -1457,15 +1435,13 @@ class PLUMED_GCH_EMPTY_BASE allocator_inliner<Allocator, true>
 
   PLUMED_GCH_CPP14_CONSTEXPR
   Allocator&
-  allocator_ref (void) noexcept
-  {
+  allocator_ref (void) noexcept {
     return *this;
   }
 
   constexpr
   const Allocator&
-  allocator_ref (void) const noexcept
-  {
+  allocator_ref (void) const noexcept {
     return *this;
   }
 
@@ -1480,16 +1456,14 @@ class PLUMED_GCH_EMPTY_BASE allocator_inliner<Allocator, true>
             typename std::enable_if<! IsNoOp, bool>::type = false>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap (allocator_inliner& other)
-  {
+  swap (allocator_inliner& other) {
     using std::swap;
     swap (static_cast<Allocator&> (*this), static_cast<Allocator&> (other));
   }
 };
 
 template <typename Allocator>
-class allocator_inliner<Allocator, false>
-{
+class allocator_inliner<Allocator, false> {
   using alloc_traits = std::allocator_traits<Allocator>;
 
   static constexpr
@@ -1515,8 +1489,7 @@ class allocator_inliner<Allocator, false>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
   maybe_assign (const allocator_inliner& other)
-  noexcept (noexcept (std::declval<decltype (other.m_alloc)&> () = other.m_alloc))
-  {
+  noexcept (noexcept (std::declval<decltype (other.m_alloc)&> () = other.m_alloc)) {
     m_alloc = other.m_alloc;
   }
 
@@ -1531,8 +1504,7 @@ class allocator_inliner<Allocator, false>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
   maybe_assign (allocator_inliner&& other)
-  noexcept (noexcept (std::declval<decltype (other.m_alloc)&> () = std::move (other.m_alloc)))
-  {
+  noexcept (noexcept (std::declval<decltype (other.m_alloc)&> () = std::move (other.m_alloc))) {
     m_alloc = std::move (other.m_alloc);
   }
 
@@ -1552,8 +1524,7 @@ class allocator_inliner<Allocator, false>
   PLUMED_GCH_CPP20_CONSTEXPR
   allocator_inliner&
   operator= (const allocator_inliner& other)
-  noexcept (noexcept (std::declval<allocator_inliner&> ().maybe_assign (other)))
-  {
+  noexcept (noexcept (std::declval<allocator_inliner&> ().maybe_assign (other))) {
     assert (&other != this
             &&  "`allocator_inliner` should not participate in self-copy-assignment.");
     maybe_assign (other);
@@ -1563,8 +1534,7 @@ class allocator_inliner<Allocator, false>
   PLUMED_GCH_CPP20_CONSTEXPR
   allocator_inliner&
   operator= (allocator_inliner&& other)
-  noexcept (noexcept (std::declval<allocator_inliner&> ().maybe_assign (std::move (other))))
-  {
+  noexcept (noexcept (std::declval<allocator_inliner&> ().maybe_assign (std::move (other)))) {
     assert (&other != this
             &&  "`allocator_inliner` should not participate in self-move-assignment.");
     maybe_assign (std::move (other));
@@ -1573,15 +1543,13 @@ class allocator_inliner<Allocator, false>
 
   PLUMED_GCH_CPP14_CONSTEXPR
   Allocator&
-  allocator_ref (void) noexcept
-  {
+  allocator_ref (void) noexcept {
     return m_alloc;
   }
 
   constexpr
   const Allocator&
-  allocator_ref (void) const noexcept
-  {
+  allocator_ref (void) const noexcept {
     return m_alloc;
   }
 
@@ -1596,8 +1564,7 @@ class allocator_inliner<Allocator, false>
             typename std::enable_if<! IsNoOp, bool>::type = false>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap (allocator_inliner& other)
-  {
+  swap (allocator_inliner& other) {
     using std::swap;
     swap (m_alloc, other.m_alloc);
   }
@@ -1608,18 +1575,17 @@ class allocator_inliner<Allocator, false>
 
 template <typename Allocator>
 class PLUMED_GCH_EMPTY_BASE allocator_interface
-: public allocator_inliner<Allocator>
-{
+: public allocator_inliner<Allocator> {
 public:
   template <typename, typename = void>
   struct is_complete
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename U>
   struct is_complete<U, decltype (static_cast<void> (sizeof (U)))>
-: std::true_type
-  { };
+: std::true_type {
+  };
 
   using size_type = typename std::allocator_traits<Allocator>::size_type;
 
@@ -1698,118 +1664,117 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
 
   template <typename V, typename Enable = void>
   struct is_trivially_destructible
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename V>
   struct is_trivially_destructible<V, typename std::enable_if<is_complete<V>::value>::type>
-: std::is_trivially_destructible<V>
-  { };
+: std::is_trivially_destructible<V> {
+  };
 
   template <typename Void, typename T, typename ...Args>
   struct is_trivially_constructible_impl
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename V, typename ...Args>
   struct is_trivially_constructible_impl<
     typename std::enable_if<is_complete<V>::value>::type,
     V, Args...>
-: std::is_trivially_constructible<V, Args...>
-  { };
+: std::is_trivially_constructible<V, Args...> {
+  };
 
   template <typename V, typename ...Args>
   struct is_trivially_constructible
-: is_trivially_constructible_impl<void, V, Args...>
-  { };
+: is_trivially_constructible_impl<void, V, Args...> {
+  };
 
   template <typename T, typename Enable = void>
-  struct underlying_if_enum
-  {
+  struct underlying_if_enum {
     using type = T;
   };
 
   template <typename T>
   struct underlying_if_enum<T, typename std::enable_if<std::is_enum<T>::value>::type>
-: std::underlying_type<T>
-  { };
+: std::underlying_type<T> {
+  };
 
   template <typename T>
   using underlying_if_enum_t = typename underlying_if_enum<T>::type;
 
   template <typename, typename = void>
   struct has_ptr_traits_to_address
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename P>
   struct has_ptr_traits_to_address<P,
                                    void_t<decltype (std::pointer_traits<P>::to_address (std::declval<P> ()))>>
-: std::true_type
-  { };
+: std::true_type {
+  };
 
   template <typename Void, typename A, typename V, typename ...Args>
   struct has_alloc_construct_check
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename A, typename V, typename ...Args>
   struct has_alloc_construct_check<
     void_t<decltype (std::declval<A&> ().construct (std::declval<V *> (),
                      std::declval<Args> ()...))>,
     A, V, Args...>
-: std::true_type
-  { };
+: std::true_type {
+  };
 
   template <typename Void, typename A, typename V, typename ...Args>
   struct has_alloc_construct_impl
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename A, typename V, typename ...Args>
   struct has_alloc_construct_impl<typename std::enable_if<is_complete<V>::value>::type,
                                   A, V, Args...>
-: has_alloc_construct_check<void, A, V, Args...>
-  { };
+: has_alloc_construct_check<void, A, V, Args...> {
+  };
 
   template <typename A, typename V, typename ...Args>
   struct has_alloc_construct
-: has_alloc_construct_impl<void, A, V, Args...>
-  { };
+: has_alloc_construct_impl<void, A, V, Args...> {
+  };
 
   template <typename A, typename V, typename ...Args>
   struct must_use_alloc_construct
 : bool_constant<! std::is_same<A, std::allocator<V>>::value
-                  &&  has_alloc_construct<A, V, Args...>::value>
-  { };
+                  &&  has_alloc_construct<A, V, Args...>::value> {
+                  };
 
   template <typename Void, typename A, typename V>
   struct has_alloc_destroy_impl
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename A, typename V>
   struct has_alloc_destroy_impl<
     void_t<decltype (std::declval<A&> ().destroy (std::declval<V *> ()))>,
     A, V>
-: std::true_type
-  { };
+: std::true_type {
+  };
 
   template <typename A, typename V, typename Enable = void>
   struct has_alloc_destroy
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename A, typename V>
   struct has_alloc_destroy<A, V, typename std::enable_if<is_complete<V>::value>::type>
-: has_alloc_destroy_impl<void, A, V>
-  { };
+: has_alloc_destroy_impl<void, A, V> {
+  };
 
   template <typename A, typename V>
   struct must_use_alloc_destroy
 : bool_constant<! std::is_same<A, std::allocator<V>>::value
-                  &&  has_alloc_destroy<A, V>::value>
-  { };
+                  &&  has_alloc_destroy<A, V>::value> {
+                  };
 
 public:
   allocator_interface (void)                           = default;
@@ -1844,62 +1809,59 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
 
   template <typename, typename, typename = void>
   struct is_memcpyable_integral
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename From, typename To>
   struct is_memcpyable_integral<From, To,
-                                typename std::enable_if<is_complete<From>::value>::type>
-  {
-    using from = underlying_if_enum_t<From>;
-    using to   = underlying_if_enum_t<To>;
-
-    static constexpr
-    bool
-    value = (sizeof (from) == sizeof (to))
-    &&  (std::is_same<bool, from>::value == std::is_same<bool, to>::value)
-    &&  std::is_integral<from>::value
-    &&  std::is_integral<to>::value;
-                        };
+                                typename std::enable_if<is_complete<From>::value>::type> {
+                                  using from = underlying_if_enum_t<From>;
+                                  using to   = underlying_if_enum_t<To>;
+
+                                  static constexpr
+                                  bool
+                                  value = (sizeof (from) == sizeof (to))
+                                  &&  (std::is_same<bool, from>::value == std::is_same<bool, to>::value)
+                                  &&  std::is_integral<from>::value
+                                  &&  std::is_integral<to>::value;
+                                                      };
 
   template <typename From, typename To>
   struct is_convertible_pointer
 : bool_constant<std::is_pointer<From>::value
                   &&  std::is_pointer<To>::value
-                  &&  std::is_convertible<From, To>::value>
-  { };
+                  &&  std::is_convertible<From, To>::value> {
+                  };
 
   // Memcpyable assignment.
   template <typename QualifiedFrom, typename QualifiedTo = value_ty, typename Enable = void>
   struct is_memcpyable
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename QualifiedFrom, typename QualifiedTo>
   struct is_memcpyable<QualifiedFrom, QualifiedTo,
-                       typename std::enable_if<is_complete<QualifiedFrom>::value>::type>
-  {
-    static_assert (! std::is_reference<QualifiedTo>::value,
-                   "QualifiedTo must not be a reference.");
+                       typename std::enable_if<is_complete<QualifiedFrom>::value>::type> {
+                         static_assert (! std::is_reference<QualifiedTo>::value,
+                                        "QualifiedTo must not be a reference.");
 
-    using from = typename std::remove_reference<
-      typename std::remove_cv<QualifiedFrom>::type>::type;
+                         using from = typename std::remove_reference<
+                           typename std::remove_cv<QualifiedFrom>::type>::type;
 
-    using to = typename std::remove_cv<QualifiedTo>::type;
+                         using to = typename std::remove_cv<QualifiedTo>::type;
 
-    static constexpr
-    bool
-    value = std::is_trivially_assignable<QualifiedTo&, QualifiedFrom>::value
-    &&  std::is_trivially_copyable<to>::value
-    &&  (  std::is_same<typename std::remove_cv<from>::type, to>::value
-           ||  is_memcpyable_integral<from, to>::value
-           ||  is_convertible_pointer<from, to>::value);
-                                     };
+                         static constexpr
+                         bool
+                         value = std::is_trivially_assignable<QualifiedTo&, QualifiedFrom>::value
+                         &&  std::is_trivially_copyable<to>::value
+                         &&  (  std::is_same<typename std::remove_cv<from>::type, to>::value
+                                ||  is_memcpyable_integral<from, to>::value
+                                ||  is_convertible_pointer<from, to>::value);
+                                                          };
 
   // Memcpyable construction.
   template <typename QualifiedFrom, typename QualifiedTo>
-  struct is_uninitialized_memcpyable_impl
-  {
+  struct is_uninitialized_memcpyable_impl {
     static_assert (! std::is_reference<QualifiedTo>::value,
                    "QualifiedTo must not be a reference.");
 
@@ -1921,23 +1883,23 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
 
   template <typename To, typename ...Args>
   struct is_uninitialized_memcpyable
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename To, typename From>
   struct is_uninitialized_memcpyable<To, From>
-: is_uninitialized_memcpyable_impl<From, To>
-  { };
+: is_uninitialized_memcpyable_impl<From, To> {
+  };
 
   template <typename Iterator>
   struct is_small_vector_iterator
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename ...Ts>
   struct is_small_vector_iterator<small_vector_iterator<Ts...>>
-: std::true_type
-  { };
+: std::true_type {
+  };
 
   template <typename InputIt>
   struct is_contiguous_iterator
@@ -1960,38 +1922,37 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
     ||  std::is_same<InputIt,
                      decltype (std::begin (std::declval<const std::valarray<value_ty>&> ()))>::value
 #endif
-    >
-  { };
+    > {
+    };
 
   template <typename InputIt>
   struct is_memcpyable_iterator
 : bool_constant<is_memcpyable<decltype (*std::declval<InputIt> ())>::value
-                  &&  is_contiguous_iterator<InputIt>::value>
-  { };
+                  &&  is_contiguous_iterator<InputIt>::value> {
+                  };
 
   // Unwrap `move_iterator`s.
   template <typename InputIt>
   struct is_memcpyable_iterator<std::move_iterator<InputIt>>
-: is_memcpyable_iterator<InputIt>
-  { };
+: is_memcpyable_iterator<InputIt> {
+  };
 
   template <typename InputIt, typename V = value_ty>
   struct is_uninitialized_memcpyable_iterator
 : bool_constant<is_uninitialized_memcpyable<V, decltype (*std::declval<InputIt> ())>::value
-                  &&  is_contiguous_iterator<InputIt>::value>
-  { };
+                  &&  is_contiguous_iterator<InputIt>::value> {
+                  };
 
   // unwrap move_iterators
   template <typename U, typename V>
   struct is_uninitialized_memcpyable_iterator<std::move_iterator<U>, V>
-: is_uninitialized_memcpyable_iterator<U, V>
-  { };
+: is_uninitialized_memcpyable_iterator<U, V> {
+  };
 
   PLUMED_GCH_NORETURN
   static PLUMED_GCH_CPP20_CONSTEXPR
   void
-  throw_range_length_error (void)
-  {
+  throw_range_length_error (void) {
 #ifdef PLUMED_GCH_EXCEPTIONS
     throw std::length_error ("The specified range is too long.");
 #else
@@ -2002,16 +1963,14 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
 
   static constexpr
   value_ty *
-  to_address (value_ty *p) noexcept
-  {
+  to_address (value_ty *p) noexcept {
     static_assert (! std::is_function<value_ty>::value, "value_ty is a function pointer.");
     return p;
   }
 
   static constexpr
   const value_ty *
-  to_address (const value_ty *p) noexcept
-  {
+  to_address (const value_ty *p) noexcept {
     static_assert (! std::is_function<value_ty>::value, "value_ty is a function pointer.");
     return p;
   }
@@ -2021,8 +1980,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   static constexpr
   auto
   to_address (const Pointer& p) noexcept
-  -> decltype (std::pointer_traits<Pointer>::to_address (p))
-  {
+  -> decltype (std::pointer_traits<Pointer>::to_address (p)) {
     return std::pointer_traits<Pointer>::to_address (p);
   }
 
@@ -2031,8 +1989,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   static constexpr
   auto
   to_address (const Pointer& p) noexcept
-  -> decltype (to_address (p.operator-> ()))
-  {
+  -> decltype (to_address (p.operator-> ())) {
     return to_address (p.operator-> ());
   }
 
@@ -2040,8 +1997,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   PLUMED_GCH_NODISCARD
   static PLUMED_GCH_CONSTEVAL
   std::size_t
-  numeric_max (void) noexcept
-  {
+  numeric_max (void) noexcept {
     static_assert (0 <= (std::numeric_limits<Integer>::max) (), "Integer is nonpositive.");
     return static_cast<std::size_t> ((std::numeric_limits<Integer>::max) ());
   }
@@ -2049,8 +2005,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   PLUMED_GCH_NODISCARD
   static PLUMED_GCH_CPP17_CONSTEXPR
   size_ty
-  internal_range_length (cptr first, cptr last) noexcept
-  {
+  internal_range_length (cptr first, cptr last) noexcept {
     // This is guaranteed to be less than or equal to max size_ty.
     return static_cast<size_ty> (last - first);
   }
@@ -2059,13 +2014,13 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   PLUMED_GCH_NODISCARD
   static PLUMED_GCH_CPP17_CONSTEXPR
   size_ty
-  external_range_length_impl (RandomIt first, RandomIt last, std::random_access_iterator_tag)
-  {
+  external_range_length_impl (RandomIt first, RandomIt last, std::random_access_iterator_tag) {
     assert (0 <= (last - first) && "Invalid range.");
     const auto len = static_cast<std::size_t> (last - first);
 #ifndef NDEBUG
-    if (numeric_max<size_ty> () < len)
+    if (numeric_max<size_ty> () < len) {
       throw_range_length_error ();
+    }
 #endif
     return static_cast<size_ty> (len);
   }
@@ -2074,15 +2029,14 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   PLUMED_GCH_NODISCARD
   static PLUMED_GCH_CPP17_CONSTEXPR
   size_ty
-  external_range_length_impl (ForwardIt first, ForwardIt last, std::forward_iterator_tag)
-  {
+  external_range_length_impl (ForwardIt first, ForwardIt last, std::forward_iterator_tag) {
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-    if (std::is_constant_evaluated ())
-    {
+    if (std::is_constant_evaluated ()) {
       // Make sure constexpr doesn't get broken by `using namespace std::rel_ops`.
       typename std::iterator_traits<ForwardIt>::difference_type len = 0;
-      for (; ! (first == last); ++first)
+      for (; ! (first == last); ++first) {
         ++len;
+      }
       assert (static_cast<std::size_t> (len) <= numeric_max<size_ty> ());
       return static_cast<size_ty> (len);
     }
@@ -2090,8 +2044,9 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
 
     const auto len = static_cast<std::size_t> (std::distance (first, last));
 #ifndef NDEBUG
-    if (numeric_max<size_ty> () < len)
+    if (numeric_max<size_ty> () < len) {
       throw_range_length_error ();
+    }
 #endif
     return static_cast<size_ty> (len);
   }
@@ -2103,8 +2058,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
             PLUMED_GCH_NODISCARD
             static PLUMED_GCH_CPP17_CONSTEXPR
             size_ty
-            external_range_length (ForwardIt first, ForwardIt last)
-  {
+  external_range_length (ForwardIt first, ForwardIt last) {
     using iterator_cat = typename std::iterator_traits<ForwardIt>::iterator_category;
     return external_range_length_impl (first, last, iterator_cat { });
   }
@@ -2116,15 +2070,14 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
             PLUMED_GCH_NODISCARD
             static PLUMED_GCH_CPP17_CONSTEXPR
             size_ty
-            external_range_length (ForwardIt first, ForwardIt last) noexcept
-  {
+  external_range_length (ForwardIt first, ForwardIt last) noexcept {
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-    if (std::is_constant_evaluated ())
-    {
+    if (std::is_constant_evaluated ()) {
       // Make sure constexpr doesn't get broken by `using namespace std::rel_ops`.
       size_ty len = 0;
-      for (; ! (first == last); ++first)
+      for (; ! (first == last); ++first) {
         ++len;
+      }
       return len;
     }
 #endif
@@ -2138,8 +2091,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   PLUMED_GCH_NODISCARD
   static PLUMED_GCH_CPP17_CONSTEXPR
   Iterator
-  unchecked_next (Iterator pos, Integer n = 1) noexcept
-  {
+  unchecked_next (Iterator pos, Integer n = 1) noexcept {
     unchecked_advance (pos, static_cast<IteratorDiffT> (n));
     return pos;
   }
@@ -2150,8 +2102,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   PLUMED_GCH_NODISCARD
   static PLUMED_GCH_CPP17_CONSTEXPR
   Iterator
-  unchecked_prev (Iterator pos, Integer n = 1) noexcept
-  {
+  unchecked_prev (Iterator pos, Integer n = 1) noexcept {
     unchecked_advance (pos, -static_cast<IteratorDiffT> (n));
     return pos;
   }
@@ -2161,15 +2112,13 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
             typename Integer = IteratorDiffT>
   static PLUMED_GCH_CPP17_CONSTEXPR
   void
-  unchecked_advance (Iterator& pos, Integer n) noexcept
-  {
+  unchecked_advance (Iterator& pos, Integer n) noexcept {
     std::advance (pos, static_cast<IteratorDiffT> (n));
   }
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR
   size_ty
-  get_max_size (void) const noexcept
-  {
+  get_max_size (void) const noexcept {
     // This is protected from max/min macros.
     return (std::min) (static_cast<size_ty> (alloc_traits::max_size (allocator_ref ())),
                        static_cast<size_ty> (numeric_max<difference_type> ()));
@@ -2177,22 +2126,19 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  allocate (size_ty n)
-  {
+  allocate (size_ty n) {
     return alloc_traits::allocate (allocator_ref (), static_cast<size_type> (n));
   }
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  allocate_with_hint (size_ty n, cptr hint)
-  {
+  allocate_with_hint (size_ty n, cptr hint) {
     return alloc_traits::allocate (allocator_ref (), static_cast<size_type> (n), hint);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  deallocate (ptr p, size_ty n)
-  {
+  deallocate (ptr p, size_ty n) {
     alloc_traits::deallocate (allocator_ref (), to_address (p),
                               static_cast<size_type> (n));
   }
@@ -2202,11 +2148,9 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
               is_uninitialized_memcpyable<value_ty, U>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  construct (ptr p, U&& val) noexcept
-  {
+  construct (ptr p, U&& val) noexcept {
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-    if (std::is_constant_evaluated ())
-    {
+    if (std::is_constant_evaluated ()) {
       alloc_traits::construct (allocator_ref (), to_address (p), std::forward<U> (val));
       return;
     }
@@ -2225,8 +2169,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   construct (ptr p, Args&&... args)
   noexcept (noexcept (alloc_traits::construct (std::declval<alloc_ty&> (),
                       std::declval<value_ty *> (),
-                      std::forward<Args> (args)...)))
-  {
+                      std::forward<Args> (args)...))) {
     alloc_traits::construct (allocator_ref (), to_address (p), std::forward<Args> (args)...);
   }
 
@@ -2239,8 +2182,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   PLUMED_GCH_CPP20_CONSTEXPR
   void
   construct (ptr p, Args&&... args)
-  noexcept (noexcept (::new (std::declval<void *> ()) value_ty (std::declval<Args> ()...)))
-  {
+  noexcept (noexcept (::new (std::declval<void *> ()) value_ty (std::declval<Args> ()...))) {
     construct_at (to_address (p), std::forward<Args> (args)...);
   }
 
@@ -2258,8 +2200,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
                                     &&  has_alloc_destroy<A, V>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  destroy (ptr p) noexcept
-  {
+  destroy (ptr p) noexcept {
     alloc_traits::destroy (allocator_ref (), to_address (p));
   }
 
@@ -2270,8 +2211,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
                                     &&! has_alloc_destroy<A, V>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  destroy (ptr p) noexcept
-  {
+  destroy (ptr p) noexcept {
     destroy_at (to_address (p));
   }
 
@@ -2288,10 +2228,10 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
                                     ||  must_use_alloc_destroy<A, V>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  destroy_range (ptr first, ptr last) noexcept
-  {
-    for (; ! (first == last); ++first)
+  destroy_range (ptr first, ptr last) noexcept {
+    for (; ! (first == last); ++first) {
       destroy (first);
+    }
   }
 
   // allowed if trivially copyable and we use the standard allocator
@@ -2301,19 +2241,20 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
               is_uninitialized_memcpyable_iterator<ForwardIt>::value, bool>::type = true>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  uninitialized_copy (ForwardIt first, ForwardIt last, ptr dest) noexcept
-  {
+  uninitialized_copy (ForwardIt first, ForwardIt last, ptr dest) noexcept {
     static_assert (std::is_constructible<value_ty, decltype (*first)>::value,
                    "`value_type` must be copy constructible.");
 
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-    if (std::is_constant_evaluated ())
+    if (std::is_constant_evaluated ()) {
       return default_uninitialized_copy (first, last, dest);
+    }
 #endif
 
     const size_ty num_copy = external_range_length (first, last);
-    if (num_copy != 0)
+    if (num_copy != 0) {
       std::memcpy (to_address (dest), to_address (first), num_copy * sizeof (value_ty));
+    }
     return unchecked_next (dest, num_copy);
   }
 
@@ -2324,8 +2265,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   ptr
   uninitialized_copy (std::move_iterator<ForwardIt> first,
                       std::move_iterator<ForwardIt> last,
-                      ptr dest) noexcept
-  {
+                      ptr dest) noexcept {
     return uninitialized_copy (first.base (), last.base (), dest);
   }
 
@@ -2334,26 +2274,23 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
               ! is_uninitialized_memcpyable_iterator<InputIt>::value, bool>::type = false>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  uninitialized_copy (InputIt first, InputIt last, ptr d_first)
-  {
+  uninitialized_copy (InputIt first, InputIt last, ptr d_first) {
     return default_uninitialized_copy (first, last, d_first);
   }
 
   template <typename InputIt>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  default_uninitialized_copy (InputIt first, InputIt last, ptr d_first)
-  {
+  default_uninitialized_copy (InputIt first, InputIt last, ptr d_first) {
     ptr d_last = d_first;
-    PLUMED_GCH_TRY
-    {
+    PLUMED_GCH_TRY {
       // Note: Not != because `using namespace std::rel_ops` can break constexpr.
-      for (; ! (first == last); ++first, static_cast<void> (++d_last))
+      for (; ! (first == last); ++first, static_cast<void> (++d_last)) {
         construct (d_last, *first);
+      }
       return d_last;
     }
-    PLUMED_GCH_CATCH (...)
-    {
+    PLUMED_GCH_CATCH (...) {
       destroy_range (d_first, d_last);
       PLUMED_GCH_THROW;
     }
@@ -2364,11 +2301,11 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
                                     &&! must_use_alloc_construct<A, V>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  uninitialized_value_construct (ptr first, ptr last)
-  {
+  uninitialized_value_construct (ptr first, ptr last) {
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-    if (std::is_constant_evaluated ())
+    if (std::is_constant_evaluated ()) {
       return default_uninitialized_value_construct (first, last);
+    }
 #endif
     std::fill (first, last, value_ty ());
     return last;
@@ -2379,24 +2316,21 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
                                     ||  must_use_alloc_construct<A, V>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  uninitialized_value_construct (ptr first, ptr last)
-  {
+  uninitialized_value_construct (ptr first, ptr last) {
     return default_uninitialized_value_construct (first, last);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  default_uninitialized_value_construct (ptr first, ptr last)
-  {
+  default_uninitialized_value_construct (ptr first, ptr last) {
     ptr curr = first;
-    PLUMED_GCH_TRY
-    {
-      for (; ! (curr == last); ++curr)
+    PLUMED_GCH_TRY {
+      for (; ! (curr == last); ++curr) {
         construct (curr);
+      }
       return curr;
     }
-    PLUMED_GCH_CATCH (...)
-    {
+    PLUMED_GCH_CATCH (...) {
       destroy_range (first, curr);
       PLUMED_GCH_THROW;
     }
@@ -2404,24 +2338,21 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  uninitialized_fill (ptr first, ptr last)
-  {
+  uninitialized_fill (ptr first, ptr last) {
     return uninitialized_value_construct (first, last);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  uninitialized_fill (ptr first, ptr last, const value_ty& val)
-  {
+  uninitialized_fill (ptr first, ptr last, const value_ty& val) {
     ptr curr = first;
-    PLUMED_GCH_TRY
-    {
-      for (; ! (curr == last); ++curr)
+    PLUMED_GCH_TRY {
+      for (; ! (curr == last); ++curr) {
         construct (curr, val);
+      }
       return curr;
     }
-    PLUMED_GCH_CATCH (...)
-    {
+    PLUMED_GCH_CATCH (...) {
       destroy_range (first, curr);
       PLUMED_GCH_THROW;
     }
@@ -2435,18 +2366,17 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
             typename std::enable_if<std::is_array<V>::value, bool>::type = true>
   static PLUMED_GCH_CPP20_CONSTEXPR
   void
-  destroy_at (value_ty *p) noexcept
-  {
-    for (auto& e : *p)
+  destroy_at (value_ty *p) noexcept {
+    for (auto& e : *p) {
       destroy_at (std::addressof (e));
+    }
   }
 
   template <typename V = value_ty,
             typename std::enable_if<! std::is_array<V>::value, bool>::type = false>
   static PLUMED_GCH_CPP20_CONSTEXPR
   void
-  destroy_at (value_ty *p) noexcept
-  {
+  destroy_at (value_ty *p) noexcept {
     p->~value_ty ();
   }
 
@@ -2455,11 +2385,11 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
   auto
   construct_at (value_ty *p, Args&&... args)
   noexcept (noexcept (::new (std::declval<void *> ()) V (std::declval<Args> ()...)))
-  -> decltype (::new (std::declval<void *> ()) V (std::declval<Args> ()...))
-  {
+  -> decltype (::new (std::declval<void *> ()) V (std::declval<Args> ()...)) {
 #if defined (PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED) && defined (PLUMED_GCH_LIB_CONSTEXPR_MEMORY)
-    if (std::is_constant_evaluated ())
+    if (std::is_constant_evaluated ()) {
       return std::construct_at (p, std::forward<Args> (args)...);
+    }
 #endif
     void *vp = const_cast<void *> (static_cast<const volatile void *> (p));
     return ::new (vp) value_ty (std::forward<Args>(args)...);
@@ -2467,8 +2397,7 @@ class PLUMED_GCH_EMPTY_BASE allocator_interface
 };
 
 template <typename Pointer, typename SizeT>
-class small_vector_data_base
-{
+class small_vector_data_base {
 public:
   using ptr     = Pointer;
   using size_ty = SizeT;
@@ -2480,18 +2409,29 @@ class small_vector_data_base
   small_vector_data_base& operator= (small_vector_data_base&&) noexcept = default;
   ~small_vector_data_base           (void)                              = default;
 
-  constexpr ptr     data_ptr (void) const noexcept { return m_data_ptr; }
-  constexpr size_ty capacity (void) const noexcept { return m_capacity; }
-  constexpr size_ty size     (void) const noexcept { return m_size; }
+  constexpr ptr     data_ptr (void) const noexcept {
+    return m_data_ptr;
+  }
+  constexpr size_ty capacity (void) const noexcept {
+    return m_capacity;
+  }
+  constexpr size_ty size     (void) const noexcept {
+    return m_size;
+  }
 
-  PLUMED_GCH_CPP20_CONSTEXPR void set_data_ptr (ptr     data_ptr) noexcept { m_data_ptr = data_ptr; }
-  PLUMED_GCH_CPP20_CONSTEXPR void set_capacity (size_ty capacity) noexcept { m_capacity = capacity; }
-  PLUMED_GCH_CPP20_CONSTEXPR void set_size     (size_ty size)     noexcept { m_size     = size;     }
+  PLUMED_GCH_CPP20_CONSTEXPR void set_data_ptr (ptr     data_ptr) noexcept {
+    m_data_ptr = data_ptr;
+  }
+  PLUMED_GCH_CPP20_CONSTEXPR void set_capacity (size_ty capacity) noexcept {
+    m_capacity = capacity;
+  }
+  PLUMED_GCH_CPP20_CONSTEXPR void set_size     (size_ty size)     noexcept {
+    m_size     = size;
+  }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  set (ptr data_ptr, size_ty capacity, size_ty size)
-  {
+  set (ptr data_ptr, size_ty capacity, size_ty size) {
     m_data_ptr = data_ptr;
     m_capacity = capacity;
     m_size     = size;
@@ -2499,32 +2439,28 @@ class small_vector_data_base
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap_data_ptr (small_vector_data_base& other) noexcept
-  {
+  swap_data_ptr (small_vector_data_base& other) noexcept {
     using std::swap;
     swap (m_data_ptr, other.m_data_ptr);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap_capacity (small_vector_data_base& other) noexcept
-  {
+  swap_capacity (small_vector_data_base& other) noexcept {
     using std::swap;
     swap (m_capacity, other.m_capacity);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap_size (small_vector_data_base& other) noexcept
-  {
+  swap_size (small_vector_data_base& other) noexcept {
     using std::swap;
     swap (m_size, other.m_size);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap (small_vector_data_base& other) noexcept
-  {
+  swap (small_vector_data_base& other) noexcept {
     using std::swap;
     swap (m_data_ptr, other.m_data_ptr);
     swap (m_capacity, other.m_capacity);
@@ -2539,8 +2475,7 @@ class small_vector_data_base
 
 template <typename Pointer, typename SizeT, typename T, unsigned InlineCapacity>
 class small_vector_data
-: public small_vector_data_base<Pointer, SizeT>
-{
+: public small_vector_data_base<Pointer, SizeT> {
 public:
   using value_ty = T;
 
@@ -2553,15 +2488,13 @@ class small_vector_data
 
   PLUMED_GCH_CPP14_CONSTEXPR
   value_ty *
-  storage (void) noexcept
-  {
+  storage (void) noexcept {
     return m_storage.get_inline_ptr ();
   }
 
   constexpr
   const value_ty *
-  storage (void) const noexcept
-  {
+  storage (void) const noexcept {
     return m_storage.get_inline_ptr ();
   }
 
@@ -2572,8 +2505,7 @@ class small_vector_data
 template <typename Pointer, typename SizeT, typename T>
 class PLUMED_GCH_EMPTY_BASE small_vector_data<Pointer, SizeT, T, 0>
 : public  small_vector_data_base<Pointer, SizeT>,
-private inline_storage<T, 0>
-{
+private inline_storage<T, 0> {
   using base = inline_storage<T, 0>;
 
 public:
@@ -2588,23 +2520,20 @@ private inline_storage<T, 0>
 
   PLUMED_GCH_CPP14_CONSTEXPR
   value_ty *
-  storage (void) noexcept
-  {
+  storage (void) noexcept {
     return base::get_inline_ptr ();
   }
 
   constexpr
   const value_ty *
-  storage (void) const noexcept
-  {
+  storage (void) const noexcept {
     return base::get_inline_ptr ();
   }
 };
 
 template <typename Allocator, unsigned InlineCapacity>
 class small_vector_base
-: public allocator_interface<Allocator>
-{
+: public allocator_interface<Allocator> {
 public:
   using size_type       = typename allocator_interface<Allocator>::size_type;
   using difference_type = typename allocator_interface<Allocator>::difference_type;
@@ -2650,16 +2579,14 @@ class small_vector_base
   PLUMED_GCH_NODISCARD
   static PLUMED_GCH_CONSTEVAL
   std::size_t
-  numeric_max (void) noexcept
-  {
+  numeric_max (void) noexcept {
     return alloc_interface::template numeric_max<Integer> ();
   }
 
   PLUMED_GCH_NODISCARD
   static PLUMED_GCH_CONSTEVAL
   size_ty
-  get_inline_capacity (void) noexcept
-  {
+  get_inline_capacity (void) noexcept {
     return static_cast<size_ty> (InlineCapacity);
   }
 
@@ -2671,8 +2598,7 @@ class small_vector_base
 
   template <typename Void, typename AI, typename V, typename ...Args>
   struct is_emplace_constructible_impl
-: std::false_type
-  {
+: std::false_type {
     using nothrow = std::false_type;
   };
 
@@ -2682,8 +2608,7 @@ class small_vector_base
            decltype (std::declval<AI&> ().construct (std::declval<V *> (),
                      std::declval<Args> ()...))>,
     AI, V, Args...>
-: std::true_type
-  {
+: std::true_type {
     using nothrow =
     bool_constant<noexcept (std::declval<AI&> ().construct (std::declval<V *> (),
                             std::declval<Args> ()...))>;
@@ -2691,46 +2616,46 @@ class small_vector_base
 
   template <typename ...Args>
   struct is_emplace_constructible
-: is_emplace_constructible_impl<void, alloc_interface, value_ty, Args...>
-  { };
+: is_emplace_constructible_impl<void, alloc_interface, value_ty, Args...> {
+  };
 
   template <typename ...Args>
   struct is_nothrow_emplace_constructible
-: is_emplace_constructible_impl<void, alloc_interface, value_ty, Args...>::nothrow
-  { };
+: is_emplace_constructible_impl<void, alloc_interface, value_ty, Args...>::nothrow {
+  };
 
   template <typename V = value_ty>
   struct is_explicitly_move_insertable
-: is_emplace_constructible<V&&>
-  { };
+: is_emplace_constructible<V&&> {
+  };
 
   template <typename V = value_ty>
   struct is_explicitly_nothrow_move_insertable
-: is_nothrow_emplace_constructible<V&&>
-  { };
+: is_nothrow_emplace_constructible<V&&> {
+  };
 
   template <typename V = value_ty>
   struct is_explicitly_copy_insertable
 : std::integral_constant<bool, is_emplace_constructible<V&>::value
-                           &&  is_emplace_constructible<const V&>::value>
-  { };
+                           &&  is_emplace_constructible<const V&>::value> {
+                           };
 
   template <typename V = value_ty>
   struct is_explicitly_nothrow_copy_insertable
 : std::integral_constant<bool, is_nothrow_emplace_constructible<V&>::value
-                           &&  is_nothrow_emplace_constructible<const V&>::value>
-  { };
+                           &&  is_nothrow_emplace_constructible<const V&>::value> {
+                           };
 
   template <typename AI, typename Enable = void>
   struct is_eraseable
-: std::false_type
-  { };
+: std::false_type {
+  };
 
   template <typename AI>
   struct is_eraseable<AI,
                       void_t<decltype (std::declval<AI&> ().destroy (std::declval<value_ty *> ()))>>
-: std::true_type
-  { };
+: std::true_type {
+  };
 
   template <typename V>
   struct relocate_with_move
@@ -2749,8 +2674,8 @@ class small_vector_base
 #ifdef PLUMED_GCH_LIB_IS_ALWAYS_EQUAL
                   ||  std::allocator_traits<A>::is_always_equal::value
 #endif
-                  >
-  { };
+                  > {
+                  };
 
   template <typename A>
   struct allocations_are_swappable
@@ -2759,8 +2684,8 @@ class small_vector_base
 #ifdef PLUMED_GCH_LIB_IS_ALWAYS_EQUAL
                   ||  std::allocator_traits<A>::is_always_equal::value
 #endif
-                  >
-  { };
+                  > {
+                  };
 
   template <typename ...Args>
   using is_memcpyable = typename alloc_interface::template is_memcpyable<Args...>;
@@ -2772,8 +2697,7 @@ class small_vector_base
   PLUMED_GCH_NORETURN
   static PLUMED_GCH_CPP20_CONSTEXPR
   void
-  throw_overflow_error (void)
-  {
+  throw_overflow_error (void) {
 #ifdef PLUMED_GCH_EXCEPTIONS
     throw std::overflow_error ("The requested conversion would overflow.");
 #else
@@ -2785,8 +2709,7 @@ class small_vector_base
   PLUMED_GCH_NORETURN
   static PLUMED_GCH_CPP20_CONSTEXPR
   void
-  throw_index_error (void)
-  {
+  throw_index_error (void) {
 #ifdef PLUMED_GCH_EXCEPTIONS
     throw std::out_of_range ("The requested index was out of range.");
 #else
@@ -2798,8 +2721,7 @@ class small_vector_base
   PLUMED_GCH_NORETURN
   static PLUMED_GCH_CPP20_CONSTEXPR
   void
-  throw_increment_error (void)
-  {
+  throw_increment_error (void) {
 #ifdef PLUMED_GCH_EXCEPTIONS
     throw std::domain_error ("The requested increment was outside of the allowed range.");
 #else
@@ -2813,8 +2735,7 @@ class small_vector_base
   PLUMED_GCH_NORETURN
   static PLUMED_GCH_CPP20_CONSTEXPR
   void
-  throw_allocation_size_error (void)
-  {
+  throw_allocation_size_error (void) {
 #ifdef PLUMED_GCH_EXCEPTIONS
     throw std::length_error ("The required allocation exceeds the maximum size.");
 #else
@@ -2827,14 +2748,12 @@ class small_vector_base
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR
   ptr
-  ptr_cast (const small_vector_iterator<cptr, diff_ty>& it) noexcept
-  {
+  ptr_cast (const small_vector_iterator<cptr, diff_ty>& it) noexcept {
     return unchecked_next (begin_ptr (), it.base () - begin_ptr ());
   }
 
 private:
-  class stack_temporary
-  {
+  class stack_temporary {
   public:
     stack_temporary            (void)                       = delete;
     stack_temporary            (const stack_temporary&)     = delete;
@@ -2846,43 +2765,37 @@ class small_vector_base
     template <typename ...Args>
     PLUMED_GCH_CPP20_CONSTEXPR explicit
     stack_temporary (alloc_interface& alloc_iface, Args&&... args)
-      : m_interface (alloc_iface)
-    {
+      : m_interface (alloc_iface) {
       m_interface.construct (get_pointer (), std::forward<Args> (args)...);
     }
 
     PLUMED_GCH_CPP20_CONSTEXPR
-    ~stack_temporary (void)
-    {
+    ~stack_temporary (void) {
       m_interface.destroy (get_pointer ());
     }
 
     PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR
     const value_ty&
-    get (void) const noexcept
-    {
+    get (void) const noexcept {
       return *get_pointer ();
     }
 
     PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR
     value_ty&&
-    release (void) noexcept
-    {
+    release (void) noexcept {
       return std::move (*get_pointer ());
     }
 
   private:
     PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR
     cptr
-    get_pointer (void) const noexcept
-    {
+    get_pointer (void) const noexcept {
       return static_cast<cptr> (static_cast<const void *> (std::addressof (m_data)));
     }
 
     PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR
     ptr
-    get_pointer (void) noexcept
-    {
+    get_pointer (void) noexcept {
       return static_cast<ptr> (static_cast<void *> (std::addressof (m_data)));
     }
 
@@ -2892,8 +2805,7 @@ class small_vector_base
 
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
 
-  class heap_temporary
-  {
+  class heap_temporary {
   public:
     heap_temporary            (void)                      = delete;
     heap_temporary            (const heap_temporary&)     = delete;
@@ -2906,37 +2818,31 @@ class small_vector_base
     PLUMED_GCH_CPP20_CONSTEXPR explicit
     heap_temporary (alloc_interface& alloc_iface, Args&&... args)
       : m_interface (alloc_iface),
-        m_data_ptr  (alloc_iface.allocate (sizeof (value_ty)))
-    {
-      PLUMED_GCH_TRY
-      {
+        m_data_ptr  (alloc_iface.allocate (sizeof (value_ty))) {
+      PLUMED_GCH_TRY {
         m_interface.construct (m_data_ptr, std::forward<Args> (args)...);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         m_interface.deallocate (m_data_ptr, sizeof (value_ty));
         PLUMED_GCH_THROW;
       }
     }
 
     PLUMED_GCH_CPP20_CONSTEXPR
-    ~heap_temporary (void)
-    {
+    ~heap_temporary (void) {
       m_interface.destroy (m_data_ptr);
       m_interface.deallocate (m_data_ptr, sizeof (value_ty));
     }
 
     PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR
     const value_ty&
-    get (void) const noexcept
-    {
+    get (void) const noexcept {
       return *m_data_ptr;
     }
 
     PLUMED_GCH_NODISCARD PLUMED_GCH_CPP20_CONSTEXPR
     value_ty&&
-    release (void) noexcept
-    {
+    release (void) noexcept {
       return std::move (*m_data_ptr);
     }
 
@@ -2949,182 +2855,161 @@ class small_vector_base
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  wipe (void)
-  {
+  wipe (void) {
     destroy_range (begin_ptr (), end_ptr ());
-    if (has_allocation ())
+    if (has_allocation ()) {
       deallocate (data_ptr (), get_capacity ());
+    }
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  set_data_ptr (ptr data_ptr) noexcept
-  {
+  set_data_ptr (ptr data_ptr) noexcept {
     m_data.set_data_ptr (data_ptr);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  set_capacity (size_ty capacity) noexcept
-  {
+  set_capacity (size_ty capacity) noexcept {
     m_data.set_capacity (static_cast<size_type> (capacity));
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  set_size (size_ty size) noexcept
-  {
+  set_size (size_ty size) noexcept {
     m_data.set_size (static_cast<size_type> (size));
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  set_data (ptr data_ptr, size_ty capacity, size_ty size) noexcept
-  {
+  set_data (ptr data_ptr, size_ty capacity, size_ty size) noexcept {
     m_data.set (data_ptr, static_cast<size_type> (capacity), static_cast<size_type> (size));
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap_data_ptr (small_vector_base& other) noexcept
-  {
+  swap_data_ptr (small_vector_base& other) noexcept {
     m_data.swap_data_ptr (other.m_data);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap_capacity (small_vector_base& other) noexcept
-  {
+  swap_capacity (small_vector_base& other) noexcept {
     m_data.swap_capacity (other.m_data);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap_size (small_vector_base& other) noexcept
-  {
+  swap_size (small_vector_base& other) noexcept {
     m_data.swap_size (other.m_data);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap_allocation (small_vector_base& other) noexcept
-  {
+  swap_allocation (small_vector_base& other) noexcept {
     m_data.swap (other.m_data);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  reset_data (ptr data_ptr, size_ty capacity, size_ty size)
-  {
+  reset_data (ptr data_ptr, size_ty capacity, size_ty size) {
     wipe ();
     m_data.set (data_ptr, static_cast<size_type> (capacity), static_cast<size_type> (size));
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  increase_size (size_ty n) noexcept
-  {
+  increase_size (size_ty n) noexcept {
     m_data.set_size (get_size () + n);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  decrease_size (size_ty n) noexcept
-  {
+  decrease_size (size_ty n) noexcept {
     m_data.set_size (get_size () - n);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  unchecked_allocate (size_ty n)
-  {
+  unchecked_allocate (size_ty n) {
     assert (InlineCapacity < n && "Allocated capacity should be greater than InlineCapacity.");
     return alloc_interface::allocate (n);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  unchecked_allocate (size_ty n, cptr hint)
-  {
+  unchecked_allocate (size_ty n, cptr hint) {
     assert (InlineCapacity < n && "Allocated capacity should be greater than InlineCapacity.");
     return alloc_interface::allocate_with_hint (n, hint);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  checked_allocate (size_ty n)
-  {
-    if (get_max_size () < n)
+  checked_allocate (size_ty n) {
+    if (get_max_size () < n) {
       throw_allocation_size_error ();
+    }
     return unchecked_allocate (n);
   }
 
 protected:
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR
   size_ty
-  unchecked_calculate_new_capacity (const size_ty minimum_required_capacity) const noexcept
-  {
+  unchecked_calculate_new_capacity (const size_ty minimum_required_capacity) const noexcept {
     const size_ty current_capacity = get_capacity ();
 
     assert (current_capacity < minimum_required_capacity);
 
-    if (get_max_size () - current_capacity <= current_capacity)
+    if (get_max_size () - current_capacity <= current_capacity) {
       return get_max_size ();
+    }
 
     // Note: This growth factor might be theoretically superior, but in testing it falls flat:
     // size_ty new_capacity = current_capacity + (current_capacity / 2);
 
     const size_ty new_capacity = 2 * current_capacity;
-    if (new_capacity < minimum_required_capacity)
+    if (new_capacity < minimum_required_capacity) {
       return minimum_required_capacity;
+    }
     return new_capacity;
   }
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR
   size_ty
-  checked_calculate_new_capacity (const size_ty minimum_required_capacity) const
-  {
-    if (get_max_size () < minimum_required_capacity)
+  checked_calculate_new_capacity (const size_ty minimum_required_capacity) const {
+    if (get_max_size () < minimum_required_capacity) {
       throw_allocation_size_error ();
+    }
     return unchecked_calculate_new_capacity (minimum_required_capacity);
   }
 
   template <unsigned I>
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base&
-  copy_assign_default (const small_vector_base<Allocator, I>& other)
-  {
-    if (get_capacity () < other.get_size ())
-    {
+  copy_assign_default (const small_vector_base<Allocator, I>& other) {
+    if (get_capacity () < other.get_size ()) {
       // Reallocate.
       size_ty new_capacity = unchecked_calculate_new_capacity (other.get_size ());
       ptr     new_data_ptr = unchecked_allocate (new_capacity, other.allocation_end_ptr ());
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_copy (other.begin_ptr (), other.end_ptr (), new_data_ptr);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         deallocate (new_data_ptr, new_capacity);
         PLUMED_GCH_THROW;
       }
 
       reset_data (new_data_ptr, new_capacity, other.get_size ());
-    }
-    else
-    {
-      if (get_size () < other.get_size ())
-      {
+    } else {
+      if (get_size () < other.get_size ()) {
         // No reallocation, partially in uninitialized space.
         std::copy_n (other.begin_ptr (), get_size (), begin_ptr ());
         uninitialized_copy (
           unchecked_next (other.begin_ptr (), get_size ()),
           other.end_ptr (),
           end_ptr ());
-      }
-      else
-      {
+      } else {
         destroy_range (copy_range (other.begin_ptr (), other.end_ptr (), begin_ptr ()),
                        end_ptr ());
       }
@@ -3145,13 +3030,12 @@ class small_vector_base
                                     >::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base&
-  copy_assign (const small_vector_base<Allocator, I>& other)
-  {
-    if (other.allocator_ref () == allocator_ref ())
+  copy_assign (const small_vector_base<Allocator, I>& other) {
+    if (other.allocator_ref () == allocator_ref ()) {
       return copy_assign_default (other);
+    }
 
-    if (InlineCapacity < other.get_size ())
-    {
+    if (InlineCapacity < other.get_size ()) {
       alloc_interface new_alloc (other);
 
       const size_ty new_capacity = other.get_size ();
@@ -3159,32 +3043,26 @@ class small_vector_base
                                  new_capacity,
                                  other.allocation_end_ptr ());
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_copy (other.begin_ptr (), other.end_ptr (), new_data_ptr);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         new_alloc.deallocate (new_data_ptr, new_capacity);
         PLUMED_GCH_THROW;
       }
 
       reset_data (new_data_ptr, new_capacity, other.get_size ());
       alloc_interface::operator= (new_alloc);
-    }
-    else
-    {
-      if (has_allocation ())
-      {
+    } else {
+      if (has_allocation ()) {
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
         ptr new_data_ptr;
-        if (std::is_constant_evaluated ())
-        {
+        if (std::is_constant_evaluated ()) {
           alloc_interface new_alloc (other);
           new_data_ptr = new_alloc.allocate (InlineCapacity);
-        }
-        else
+        } else {
           new_data_ptr = storage_ptr ();
+        }
 #else
         const ptr new_data_ptr = storage_ptr ();
 #endif
@@ -3194,17 +3072,13 @@ class small_vector_base
         deallocate (data_ptr (), get_capacity ());
         set_data_ptr (new_data_ptr);
         set_capacity (InlineCapacity);
-      }
-      else if (get_size () < other.get_size ())
-      {
+      } else if (get_size () < other.get_size ()) {
         std::copy_n (other.begin_ptr (), get_size (), begin_ptr ());
         uninitialized_copy (
           unchecked_next (other.begin_ptr (), get_size ()),
           other.end_ptr (),
           end_ptr ());
-      }
-      else
-      {
+      } else {
         destroy_range (copy_range (other.begin_ptr (), other.end_ptr (), begin_ptr ()),
                        end_ptr ());
       }
@@ -3223,16 +3097,14 @@ class small_vector_base
                                     >::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base&
-  copy_assign (const small_vector_base<Allocator, I>& other)
-  {
+  copy_assign (const small_vector_base<Allocator, I>& other) {
     return copy_assign_default (other);
   }
 
   template <unsigned I>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  move_allocation_pointer (small_vector_base<alloc_ty, I>&& other) noexcept
-  {
+  move_allocation_pointer (small_vector_base<alloc_ty, I>&& other) noexcept {
     reset_data (other.data_ptr (), other.get_capacity (), other.get_size ());
     other.set_default ();
   }
@@ -3240,8 +3112,7 @@ class small_vector_base
   template <unsigned N = InlineCapacity, typename std::enable_if<N == 0>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base&
-  move_assign_default (small_vector_base&& other) noexcept
-  {
+  move_assign_default (small_vector_base&& other) noexcept {
     move_allocation_pointer (std::move (other));
     alloc_interface::operator= (std::move (other));
     return *this;
@@ -3253,24 +3124,22 @@ class small_vector_base
             small_vector_base&
             move_assign_default (small_vector_base<Allocator, LessEqualI>&& other)
             noexcept (std::is_nothrow_move_assignable<value_ty>::value
-                      &&  std::is_nothrow_move_constructible<value_ty>::value)
-  {
+  &&  std::is_nothrow_move_constructible<value_ty>::value) {
     // We only move the allocation pointer over if it has strictly greater capacity than
     // the inline capacity of `*this` because allocations can never have a smaller capacity
     // than the inline capacity.
-    if (InlineCapacity < other.get_capacity ())
-          move_allocation_pointer (std::move (other));
-    else
-    {
+    if (InlineCapacity < other.get_capacity ()) {
+      move_allocation_pointer (std::move (other));
+    } else {
       // We are guaranteed to have sufficient capacity to store the elements.
-      if (InlineCapacity < get_capacity ())
-      {
+      if (InlineCapacity < get_capacity ()) {
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
         ptr new_data_ptr;
-        if (std::is_constant_evaluated ())
+        if (std::is_constant_evaluated ()) {
           new_data_ptr = other.allocate (InlineCapacity);
-        else
+        } else {
           new_data_ptr = storage_ptr ();
+        }
 #else
         const ptr new_data_ptr = storage_ptr ();
 #endif
@@ -3280,17 +3149,13 @@ class small_vector_base
         deallocate (data_ptr (), get_capacity ());
         set_data_ptr (new_data_ptr);
         set_capacity (InlineCapacity);
-      }
-      else if (get_size () < other.get_size ())
-      {
+      } else if (get_size () < other.get_size ()) {
         // There are more elements in `other`.
         // Overwrite the existing range and uninitialized move the rest.
         ptr other_pivot = unchecked_next (other.begin_ptr (), get_size ());
         std::move (other.begin_ptr (), other_pivot, begin_ptr ());
         uninitialized_move (other_pivot, other.end_ptr (), end_ptr ());
-      }
-      else
-      {
+      } else {
         // There are the same number or fewer elements in `other`.
         // Overwrite part of the existing range and destroy the rest.
         ptr new_end = std::move (other.begin_ptr (), other.end_ptr (), begin_ptr ());
@@ -3312,13 +3177,11 @@ class small_vector_base
             typename std::enable_if<(InlineCapacity < GreaterI)>::type * = nullptr>
             PLUMED_GCH_CPP20_CONSTEXPR
             small_vector_base&
-            move_assign_default (small_vector_base<Allocator, GreaterI>&& other)
-  {
-    if (other.has_allocation ())
+  move_assign_default (small_vector_base<Allocator, GreaterI>&& other) {
+    if (other.has_allocation ()) {
       move_allocation_pointer (std::move (other));
-    else if (get_capacity () < other.get_size ()
-             ||  (has_allocation () && ! (other.allocator_ref () == allocator_ref ())))
-    {
+    } else if (get_capacity () < other.get_size ()
+               ||  (has_allocation () && ! (other.allocator_ref () == allocator_ref ()))) {
       // Reallocate.
 
       // The compiler should be able to optimize this.
@@ -3329,30 +3192,23 @@ class small_vector_base
 
       ptr new_data_ptr = other.allocate_with_hint (new_capacity, other.allocation_end_ptr ());
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_move (other.begin_ptr (), other.end_ptr (), new_data_ptr);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         other.deallocate (new_data_ptr, new_capacity);
         PLUMED_GCH_THROW;
       }
 
       reset_data (new_data_ptr, new_capacity, other.get_size ());
-    }
-    else
-    {
-      if (get_size () < other.get_size ())
-      {
+    } else {
+      if (get_size () < other.get_size ()) {
         // There are more elements in `other`.
         // Overwrite the existing range and uninitialized move the rest.
         ptr other_pivot = unchecked_next (other.begin_ptr (), get_size ());
         std::move (other.begin_ptr (), other_pivot, begin_ptr ());
         uninitialized_move (other_pivot, other.end_ptr (), end_ptr ());
-      }
-      else
-      {
+      } else {
         // fewer elements in other
         // overwrite part of the existing range and destroy the rest
         ptr new_end = std::move (other.begin_ptr (), other.end_ptr (), begin_ptr ());
@@ -3370,38 +3226,29 @@ class small_vector_base
   template <unsigned I>
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base&
-  move_assign_unequal_no_propagate (small_vector_base<Allocator, I>&& other)
-  {
-    if (get_capacity () < other.get_size ())
-    {
+  move_assign_unequal_no_propagate (small_vector_base<Allocator, I>&& other) {
+    if (get_capacity () < other.get_size ()) {
       // Reallocate.
       size_ty new_capacity = unchecked_calculate_new_capacity (other.get_size ());
       ptr     new_data_ptr = unchecked_allocate (new_capacity, other.allocation_end_ptr ());
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_move (other.begin_ptr (), other.end_ptr (), new_data_ptr);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         deallocate (new_data_ptr, new_capacity);
         PLUMED_GCH_THROW;
       }
 
       reset_data (new_data_ptr, new_capacity, other.get_size ());
-    }
-    else
-    {
-      if (get_size () < other.get_size ())
-      {
+    } else {
+      if (get_size () < other.get_size ()) {
         // There are more elements in `other`.
         // Overwrite the existing range and uninitialized move the rest.
         ptr other_pivot = unchecked_next (other.begin_ptr (), get_size ());
         std::move (other.begin_ptr (), other_pivot, begin_ptr ());
         uninitialized_move (other_pivot, other.end_ptr (), end_ptr ());
-      }
-      else
-      {
+      } else {
         // There are fewer elements in `other`.
         // Overwrite part of the existing range and destroy the rest.
         destroy_range (
@@ -3423,8 +3270,7 @@ class small_vector_base
   small_vector_base&
   move_assign (small_vector_base<Allocator, I>&& other)
   noexcept (noexcept (
-              std::declval<small_vector_base&> ().move_assign_default (std::move (other))))
-  {
+              std::declval<small_vector_base&> ().move_assign_default (std::move (other)))) {
     return move_assign_default (std::move (other));
   }
 
@@ -3432,10 +3278,10 @@ class small_vector_base
             typename std::enable_if<! allocations_are_movable<A>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base&
-  move_assign (small_vector_base<Allocator, I>&& other)
-  {
-    if (other.allocator_ref () == allocator_ref ())
+  move_assign (small_vector_base<Allocator, I>&& other) {
+    if (other.allocator_ref () == allocator_ref ()) {
       return move_assign_default (std::move (other));
+    }
     return move_assign_unequal_no_propagate (std::move (other));
   }
 
@@ -3443,8 +3289,7 @@ class small_vector_base
             typename std::enable_if<I == 0>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  move_initialize (small_vector_base&& other) noexcept
-  {
+  move_initialize (small_vector_base&& other) noexcept {
     set_data (other.data_ptr (), other.get_capacity (), other.get_size ());
     other.set_default ();
   }
@@ -3454,15 +3299,11 @@ class small_vector_base
             PLUMED_GCH_CPP20_CONSTEXPR
             void
             move_initialize (small_vector_base<Allocator, LessEqualI>&& other)
-            noexcept (std::is_nothrow_move_constructible<value_ty>::value)
-  {
-    if (InlineCapacity < other.get_capacity ())
-    {
+  noexcept (std::is_nothrow_move_constructible<value_ty>::value) {
+    if (InlineCapacity < other.get_capacity ()) {
       set_data (other.data_ptr (), other.get_capacity (), other.get_size ());
       other.set_default ();
-    }
-    else
-    {
+    } else {
       set_to_inline_storage ();
       uninitialized_move (other.begin_ptr (), other.end_ptr (), data_ptr ());
       set_size (other.get_size ());
@@ -3473,33 +3314,24 @@ class small_vector_base
             typename std::enable_if<(InlineCapacity < GreaterI)>::type * = nullptr>
             PLUMED_GCH_CPP20_CONSTEXPR
             void
-            move_initialize (small_vector_base<Allocator, GreaterI>&& other)
-  {
-    if (other.has_allocation ())
-    {
+  move_initialize (small_vector_base<Allocator, GreaterI>&& other) {
+    if (other.has_allocation ()) {
       set_data (other.data_ptr (), other.get_capacity (), other.get_size ());
       other.set_default ();
-    }
-    else
-    {
-      if (InlineCapacity < other.get_size ())
-      {
+    } else {
+      if (InlineCapacity < other.get_size ()) {
         // We may throw in this case.
         set_data_ptr (unchecked_allocate (other.get_size (), other.allocation_end_ptr ()));
         set_capacity (other.get_size ());
 
-        PLUMED_GCH_TRY
-        {
+        PLUMED_GCH_TRY {
           uninitialized_move (other.begin_ptr (), other.end_ptr (), data_ptr ());
         }
-        PLUMED_GCH_CATCH (...)
-        {
+        PLUMED_GCH_CATCH (...) {
           deallocate (data_ptr (), get_capacity ());
           PLUMED_GCH_THROW;
         }
-      }
-      else
-      {
+      } else {
         set_to_inline_storage ();
         uninitialized_move (other.begin_ptr (), other.end_ptr (), data_ptr ());
       }
@@ -3517,8 +3349,7 @@ class small_vector_base
 //    ~small_vector_base           (void)                         = impl;
 
   PLUMED_GCH_CPP20_CONSTEXPR
-  small_vector_base (void) noexcept
-  {
+  small_vector_base (void) noexcept {
     set_default ();
   }
 
@@ -3529,25 +3360,19 @@ class small_vector_base
   small_vector_base (bypass_tag,
                      const small_vector_base<Allocator, I>& other,
                      const MaybeAlloc&... alloc)
-    : alloc_interface (other, alloc...)
-  {
-    if (InlineCapacity < other.get_size ())
-    {
+    : alloc_interface (other, alloc...) {
+    if (InlineCapacity < other.get_size ()) {
       set_data_ptr (unchecked_allocate (other.get_size (), other.allocation_end_ptr ()));
       set_capacity (other.get_size ());
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_copy (other.begin_ptr (), other.end_ptr (), data_ptr ());
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         deallocate (data_ptr (), get_capacity ());
         PLUMED_GCH_THROW;
       }
-    }
-    else
-    {
+    } else {
       set_to_inline_storage ();
       uninitialized_copy (other.begin_ptr (), other.end_ptr (), data_ptr ());
     }
@@ -3560,8 +3385,7 @@ class small_vector_base
   small_vector_base (bypass_tag, small_vector_base<Allocator, I>&& other)
   noexcept (std::is_nothrow_move_constructible<value_ty>::value
             ||  (I == 0 && I == InlineCapacity))
-    : alloc_interface (std::move (other))
-  {
+    : alloc_interface (std::move (other)) {
     move_initialize (std::move (other));
   }
 
@@ -3585,32 +3409,25 @@ class small_vector_base
                                                                 )>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base (bypass_tag, small_vector_base<Allocator, I>&& other, const alloc_ty& alloc)
-    : alloc_interface (alloc)
-  {
-    if (other.allocator_ref () == alloc)
-    {
+    : alloc_interface (alloc) {
+    if (other.allocator_ref () == alloc) {
       move_initialize (std::move (other));
       return;
     }
 
-    if (InlineCapacity < other.get_size ())
-    {
+    if (InlineCapacity < other.get_size ()) {
       // We may throw in this case.
       set_data_ptr (unchecked_allocate (other.get_size (), other.allocation_end_ptr ()));
       set_capacity (other.get_size ());
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_move (other.begin_ptr (), other.end_ptr (), data_ptr ());
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         deallocate (data_ptr (), get_capacity ());
         PLUMED_GCH_THROW;
       }
-    }
-    else
-    {
+    } else {
       set_to_inline_storage ();
       uninitialized_move (other.begin_ptr (), other.end_ptr (), data_ptr ());
     }
@@ -3620,31 +3437,27 @@ class small_vector_base
 
   PLUMED_GCH_CPP20_CONSTEXPR explicit
   small_vector_base (const alloc_ty& alloc) noexcept
-    : alloc_interface (alloc)
-  {
+    : alloc_interface (alloc) {
     set_default ();
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base (size_ty count, const alloc_ty& alloc)
-    : alloc_interface (alloc)
-  {
-    if (InlineCapacity < count)
-    {
+    : alloc_interface (alloc) {
+    if (InlineCapacity < count) {
       set_data_ptr (checked_allocate (count));
       set_capacity (count);
-    }
-    else
+    } else {
       set_to_inline_storage ();
+    }
 
-    PLUMED_GCH_TRY
-    {
+    PLUMED_GCH_TRY {
       uninitialized_value_construct (begin_ptr (), unchecked_next (begin_ptr (), count));
     }
-    PLUMED_GCH_CATCH (...)
-    {
-      if (has_allocation ())
+    PLUMED_GCH_CATCH (...) {
+      if (has_allocation ()) {
         deallocate (data_ptr (), get_capacity ());
+      }
       PLUMED_GCH_THROW;
     }
     set_size (count);
@@ -3652,24 +3465,21 @@ class small_vector_base
 
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base (size_ty count, const value_ty& val, const alloc_ty& alloc)
-    : alloc_interface (alloc)
-  {
-    if (InlineCapacity < count)
-    {
+    : alloc_interface (alloc) {
+    if (InlineCapacity < count) {
       set_data_ptr (checked_allocate (count));
       set_capacity (count);
-    }
-    else
+    } else {
       set_to_inline_storage ();
+    }
 
-    PLUMED_GCH_TRY
-    {
+    PLUMED_GCH_TRY {
       uninitialized_fill (begin_ptr (), unchecked_next (begin_ptr (), count), val);
     }
-    PLUMED_GCH_CATCH (...)
-    {
-      if (has_allocation ())
+    PLUMED_GCH_CATCH (...) {
+      if (has_allocation ()) {
         deallocate (data_ptr (), get_capacity ());
+      }
       PLUMED_GCH_THROW;
     }
     set_size (count);
@@ -3678,28 +3488,26 @@ class small_vector_base
   template <typename Generator>
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base (size_ty count, Generator& g, const alloc_ty& alloc)
-    : alloc_interface (alloc)
-  {
-    if (InlineCapacity < count)
-    {
+    : alloc_interface (alloc) {
+    if (InlineCapacity < count) {
       set_data_ptr (checked_allocate (count));
       set_capacity (count);
-    }
-    else
+    } else {
       set_to_inline_storage ();
+    }
 
     ptr curr = begin_ptr ();
     const ptr new_end = unchecked_next (begin_ptr (), count);
-    PLUMED_GCH_TRY
-    {
-      for (; ! (curr == new_end); ++curr)
+    PLUMED_GCH_TRY {
+      for (; ! (curr == new_end); ++curr) {
         construct (curr, g ());
+      }
     }
-    PLUMED_GCH_CATCH (...)
-    {
+    PLUMED_GCH_CATCH (...) {
       destroy_range (begin_ptr (), curr);
-      if (has_allocation ())
+      if (has_allocation ()) {
         deallocate (data_ptr (), get_capacity ());
+      }
       PLUMED_GCH_THROW;
     }
     set_size (count);
@@ -3713,8 +3521,7 @@ class small_vector_base
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base (InputIt first, InputIt last, std::input_iterator_tag,
                      const alloc_ty& alloc)
-    : small_vector_base (alloc)
-  {
+    : small_vector_base (alloc) {
     using iterator_cat = typename std::iterator_traits<InputIt>::iterator_category;
     append_range (first, last, iterator_cat { });
   }
@@ -3727,25 +3534,19 @@ class small_vector_base
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector_base (ForwardIt first, ForwardIt last, std::forward_iterator_tag,
                      const alloc_ty& alloc)
-    : alloc_interface (alloc)
-  {
+    : alloc_interface (alloc) {
     size_ty count = external_range_length (first, last);
-    if (InlineCapacity < count)
-    {
+    if (InlineCapacity < count) {
       set_data_ptr (unchecked_allocate (count));
       set_capacity (count);
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_copy (first, last, begin_ptr ());
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         deallocate (data_ptr (), get_capacity ());
         PLUMED_GCH_THROW;
       }
-    }
-    else
-    {
+    } else {
       set_to_inline_storage ();
       uninitialized_copy (first, last, begin_ptr ());
     }
@@ -3754,8 +3555,7 @@ class small_vector_base
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
-  ~small_vector_base (void) noexcept
-  {
+  ~small_vector_base (void) noexcept {
     assert (InlineCapacity <= get_capacity () && "Invalid capacity.");
     wipe ();
   }
@@ -3764,45 +3564,39 @@ class small_vector_base
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  set_to_inline_storage (void)
-  {
+  set_to_inline_storage (void) {
     set_capacity (InlineCapacity);
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-    if (std::is_constant_evaluated ())
+    if (std::is_constant_evaluated ()) {
       return set_data_ptr (alloc_interface::allocate (InlineCapacity));
+    }
 #endif
     set_data_ptr (storage_ptr ());
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  assign_with_copies (size_ty count, const value_ty& val)
-  {
-    if (get_capacity () < count)
-    {
+  assign_with_copies (size_ty count, const value_ty& val) {
+    if (get_capacity () < count) {
       size_ty new_capacity = checked_calculate_new_capacity (count);
       ptr     new_begin    = unchecked_allocate (new_capacity);
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_fill (new_begin, unchecked_next (new_begin, count), val);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         deallocate (new_begin, new_capacity);
         PLUMED_GCH_THROW;
       }
 
       reset_data (new_begin, new_capacity, count);
-    }
-    else if (get_size () < count)
-    {
+    } else if (get_size () < count) {
       std::fill (begin_ptr (), end_ptr (), val);
       uninitialized_fill (end_ptr (), unchecked_next (begin_ptr (), count), val);
       set_size (count);
-    }
-    else
+    } else {
       erase_range (std::fill_n (begin_ptr (), count, val), end_ptr ());
+    }
   }
 
   template <typename InputIt,
@@ -3811,17 +3605,17 @@ class small_vector_base
                                       decltype (*std::declval<InputIt> ())>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  assign_with_range (InputIt first, InputIt last, std::input_iterator_tag)
-  {
+  assign_with_range (InputIt first, InputIt last, std::input_iterator_tag) {
     using iterator_cat = typename std::iterator_traits<InputIt>::iterator_category;
 
     ptr curr = begin_ptr ();
-    for (; ! (end_ptr () == curr || first == last); ++curr, static_cast<void> (++first))
+    for (; ! (end_ptr () == curr || first == last); ++curr, static_cast<void> (++first)) {
       *curr = *first;
+    }
 
-    if (first == last)
+    if (first == last) {
       erase_to_end (curr);
-    else
+    } else
       append_range (first, last, iterator_cat { });
   }
 
@@ -3831,34 +3625,28 @@ class small_vector_base
                                       decltype (*std::declval<ForwardIt> ())>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  assign_with_range (ForwardIt first, ForwardIt last, std::forward_iterator_tag)
-  {
+  assign_with_range (ForwardIt first, ForwardIt last, std::forward_iterator_tag) {
     const size_ty count = external_range_length (first, last);
-    if (get_capacity () < count)
-    {
+    if (get_capacity () < count) {
       size_ty new_capacity = checked_calculate_new_capacity (count);
       ptr     new_begin    = unchecked_allocate (new_capacity);
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_copy (first, last, new_begin);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         deallocate (new_begin, new_capacity);
         PLUMED_GCH_THROW;
       }
 
       reset_data (new_begin, new_capacity, count);
-    }
-    else if (get_size () < count)
-    {
+    } else if (get_size () < count) {
       ForwardIt pivot = copy_n_return_in (first, get_size (), begin_ptr ());
       uninitialized_copy (pivot, last, end_ptr ());
       set_size (count);
-    }
-    else
+    } else {
       erase_range (copy_range (first, last, begin_ptr ()), end_ptr ());
+    }
   }
 
   template <typename InputIt,
@@ -3867,8 +3655,7 @@ class small_vector_base
                                       decltype (*std::declval<InputIt> ())>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  assign_with_range (InputIt first, InputIt last, std::input_iterator_tag)
-  {
+  assign_with_range (InputIt first, InputIt last, std::input_iterator_tag) {
     using iterator_cat = typename std::iterator_traits<InputIt>::iterator_category;
 
     // If not assignable then destroy all elements and append.
@@ -3877,8 +3664,8 @@ class small_vector_base
   }
 
   // Ie. move-if-noexcept.
-  struct strong_exception_policy
-  { };
+  struct strong_exception_policy {
+  };
 
   template <typename Policy = void, typename V = value_ty,
             typename std::enable_if<is_explicitly_move_insertable<V>::value
@@ -3888,8 +3675,7 @@ class small_vector_base
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
   uninitialized_move (ptr first, ptr last, ptr d_first)
-  noexcept (std::is_nothrow_move_constructible<value_ty>::value)
-  {
+  noexcept (std::is_nothrow_move_constructible<value_ty>::value) {
     return uninitialized_copy (std::make_move_iterator (first),
                                std::make_move_iterator (last),
                                d_first);
@@ -3903,15 +3689,13 @@ class small_vector_base
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
   uninitialized_move (ptr first, ptr last, ptr d_first)
-  noexcept (alloc_interface::template is_uninitialized_memcpyable_iterator<ptr>::value)
-  {
+  noexcept (alloc_interface::template is_uninitialized_memcpyable_iterator<ptr>::value) {
     return uninitialized_copy (first, last, d_first);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  shift_into_uninitialized (ptr pos, size_ty n_shift)
-  {
+  shift_into_uninitialized (ptr pos, size_ty n_shift) {
     // Shift elements over to the right into uninitialized space.
     // Returns the start of the shifted range.
     // Precondition: shift < end_ptr () - pos
@@ -3928,22 +3712,21 @@ class small_vector_base
   template <typename ...Args>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  append_element (Args&&... args)
-  {
-    if (get_size () < get_capacity ())
-          return emplace_into_current_end (std::forward<Args> (args)...);
+  append_element (Args&&... args) {
+    if (get_size () < get_capacity ()) {
+      return emplace_into_current_end (std::forward<Args> (args)...);
+    }
     return emplace_into_reallocation_end (std::forward<Args> (args)...);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  append_copies (size_ty count, const value_ty& val)
-  {
-    if (num_uninitialized () < count)
-    {
+  append_copies (size_ty count, const value_ty& val) {
+    if (num_uninitialized () < count) {
       // Reallocate.
-      if (get_max_size () - get_size () < count)
+      if (get_max_size () - get_size () < count) {
         throw_allocation_size_error ();
+      }
 
       size_ty original_size = get_size ();
       size_ty new_size      = get_size () + count;
@@ -3953,13 +3736,11 @@ class small_vector_base
       ptr     new_data_ptr = unchecked_allocate (new_capacity, allocation_end_ptr ());
       ptr     new_last     = unchecked_next (new_data_ptr, original_size);
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         new_last = uninitialized_fill (new_last, unchecked_next (new_last, count), val);
         uninitialized_move (begin_ptr (), end_ptr (), new_data_ptr);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         destroy_range (unchecked_next (new_data_ptr, original_size), new_last);
         deallocate (new_data_ptr, new_capacity);
         PLUMED_GCH_THROW;
@@ -3967,9 +3748,7 @@ class small_vector_base
 
       reset_data (new_data_ptr, new_capacity, new_size);
       return unchecked_next (new_data_ptr, original_size);
-    }
-    else
-    {
+    } else {
       const ptr ret = end_ptr ();
       uninitialized_fill (ret, unchecked_next (ret, count), val);
       increase_size (count);
@@ -3982,18 +3761,14 @@ class small_vector_base
               std::is_same<MovePolicy, strong_exception_policy>::value, bool>::type = true>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  append_range (InputIt first, InputIt last, std::input_iterator_tag)
-  {
+  append_range (InputIt first, InputIt last, std::input_iterator_tag) {
     // Append with a strong exception guarantee.
     size_ty original_size = get_size ();
-    for (; ! (first == last); ++first)
-    {
-      PLUMED_GCH_TRY
-      {
+    for (; ! (first == last); ++first) {
+      PLUMED_GCH_TRY {
         append_element (*first);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         erase_range (unchecked_next (begin_ptr (), original_size), end_ptr ());
         PLUMED_GCH_THROW;
       }
@@ -4006,26 +3781,25 @@ class small_vector_base
               ! std::is_same<MovePolicy, strong_exception_policy>::value, bool>::type = false>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  append_range (InputIt first, InputIt last, std::input_iterator_tag)
-  {
+  append_range (InputIt first, InputIt last, std::input_iterator_tag) {
     size_ty original_size = get_size ();
-    for (; ! (first == last); ++first)
+    for (; ! (first == last); ++first) {
       append_element (*first);
+    }
     return unchecked_next (begin_ptr (), original_size);
   }
 
   template <typename MovePolicy = void, typename ForwardIt>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  append_range (ForwardIt first, ForwardIt last, std::forward_iterator_tag)
-  {
+  append_range (ForwardIt first, ForwardIt last, std::forward_iterator_tag) {
     const size_ty num_insert = external_range_length (first, last);
 
-    if (num_uninitialized () < num_insert)
-    {
+    if (num_uninitialized () < num_insert) {
       // Reallocate.
-      if (get_max_size () - get_size () < num_insert)
+      if (get_max_size () - get_size () < num_insert) {
         throw_allocation_size_error ();
+      }
 
       size_ty original_size = get_size ();
       size_ty new_size      = get_size () + num_insert;
@@ -4035,13 +3809,11 @@ class small_vector_base
       ptr     new_data_ptr = unchecked_allocate (new_capacity, allocation_end_ptr ());
       ptr     new_last     = unchecked_next (new_data_ptr, original_size);
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         new_last = uninitialized_copy (first, last, new_last);
         uninitialized_move<MovePolicy> (begin_ptr (), end_ptr (), new_data_ptr);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         destroy_range (unchecked_next (new_data_ptr, original_size), new_last);
         deallocate (new_data_ptr, new_capacity);
         PLUMED_GCH_THROW;
@@ -4049,9 +3821,7 @@ class small_vector_base
 
       reset_data (new_data_ptr, new_capacity, new_size);
       return unchecked_next (new_data_ptr, original_size);
-    }
-    else
-    {
+    } else {
       ptr ret = end_ptr ();
       uninitialized_copy (first, last, ret);
       increase_size (num_insert);
@@ -4062,34 +3832,34 @@ class small_vector_base
   template <typename ...Args>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  emplace_at (ptr pos, Args&&... args)
-  {
+  emplace_at (ptr pos, Args&&... args) {
     assert (get_size () <= get_capacity () && "size was greater than capacity");
 
-    if (get_size () < get_capacity ())
+    if (get_size () < get_capacity ()) {
       return emplace_into_current (pos, std::forward<Args> (args)...);
+    }
     return emplace_into_reallocation (pos, std::forward<Args> (args)...);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  insert_copies (ptr pos, size_ty count, const value_ty& val)
-  {
-    if (0 == count)
+  insert_copies (ptr pos, size_ty count, const value_ty& val) {
+    if (0 == count) {
       return pos;
+    }
 
-    if (end_ptr () == pos)
-    {
-      if (1 == count)
+    if (end_ptr () == pos) {
+      if (1 == count) {
         return append_element (val);
+      }
       return append_copies (count, val);
     }
 
-    if (num_uninitialized () < count)
-    {
+    if (num_uninitialized () < count) {
       // Reallocate.
-      if (get_max_size () - get_size () < count)
+      if (get_max_size () - get_size () < count) {
         throw_allocation_size_error ();
+      }
 
       const size_ty offset = internal_range_length (begin_ptr (), pos);
 
@@ -4101,8 +3871,7 @@ class small_vector_base
       ptr new_first              = unchecked_next (new_data_ptr, offset);
       ptr new_last               = new_first;
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_fill (new_first, unchecked_next (new_first, count), val);
         unchecked_advance  (new_last, count);
 
@@ -4110,8 +3879,7 @@ class small_vector_base
         new_first = new_data_ptr;
         uninitialized_move (pos, end_ptr (), new_last);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         destroy_range (new_first, new_last);
         deallocate (new_data_ptr, new_capacity);
         PLUMED_GCH_THROW;
@@ -4119,15 +3887,12 @@ class small_vector_base
 
       reset_data (new_data_ptr, new_capacity, new_size);
       return unchecked_next (begin_ptr (), offset);
-    }
-    else
-    {
+    } else {
       // If we have fewer to insert than tailing elements after `pos`, we shift into
       // uninitialized and then copy over.
 
       const size_ty tail_size = internal_range_length (pos, end_ptr ());
-      if (tail_size < count)
-      {
+      if (tail_size < count) {
         // The number inserted is larger than the number after `pos`,
         // so part of the input will be used to construct new elements,
         // and another part of it will assign existing ones.
@@ -4142,8 +3907,7 @@ class small_vector_base
         size_ty num_val_tail = count - tail_size;
 
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-        if (std::is_constant_evaluated ())
-        {
+        if (std::is_constant_evaluated ()) {
           uninitialized_fill (end_ptr (), unchecked_next (end_ptr (), num_val_tail), val);
           increase_size (num_val_tail);
 
@@ -4161,8 +3925,7 @@ class small_vector_base
         uninitialized_fill (end_ptr (), unchecked_next (end_ptr (), num_val_tail), val);
         increase_size (num_val_tail);
 
-        PLUMED_GCH_TRY
-        {
+        PLUMED_GCH_TRY {
           // We need to handle possible aliasing here.
           const stack_temporary tmp (*this, val);
 
@@ -4175,8 +3938,7 @@ class small_vector_base
             // Finally, try to copy the rest of the elements over.
             std::fill_n (pos, tail_size, tmp.get ());
           }
-          PLUMED_GCH_CATCH (...)
-          {
+          PLUMED_GCH_CATCH (...) {
             // Attempt to roll back and destroy the tail if we fail.
             ptr inserted_end = unchecked_prev (end_ptr (), tail_size);
             move_left (inserted_end, end_ptr (), pos);
@@ -4185,19 +3947,15 @@ class small_vector_base
             PLUMED_GCH_THROW;
           }
         }
-        PLUMED_GCH_CATCH (...)
-        {
+        PLUMED_GCH_CATCH (...) {
           // Destroy the elements constructed from the input.
           destroy_range (original_end, end_ptr ());
           decrease_size (internal_range_length (original_end, end_ptr ()));
           PLUMED_GCH_THROW;
         }
-      }
-      else
-      {
+      } else {
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-        if (std::is_constant_evaluated ())
-        {
+        if (std::is_constant_evaluated ()) {
           const heap_temporary tmp (*this, val);
 
           ptr inserted_end = shift_into_uninitialized (pos, count);
@@ -4212,12 +3970,10 @@ class small_vector_base
 
         // Attempt to copy over the elements.
         // If we fail we'll attempt a full roll-back.
-        PLUMED_GCH_TRY
-        {
+        PLUMED_GCH_TRY {
           std::fill (pos, inserted_end, tmp.get ());
         }
-        PLUMED_GCH_CATCH (...)
-        {
+        PLUMED_GCH_CATCH (...) {
           ptr original_end = move_left (inserted_end, end_ptr (), pos);
           destroy_range (original_end, end_ptr ());
           decrease_size (count);
@@ -4231,17 +3987,16 @@ class small_vector_base
   template <typename ForwardIt>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  insert_range_helper (ptr pos, ForwardIt first, ForwardIt last)
-  {
+  insert_range_helper (ptr pos, ForwardIt first, ForwardIt last) {
     assert (! (first == last) && "The range should not be empty.");
     assert (! (end_ptr () == pos) && "`pos` should not be at the end.");
 
     const size_ty num_insert = external_range_length (first, last);
-    if (num_uninitialized () < num_insert)
-    {
+    if (num_uninitialized () < num_insert) {
       // Reallocate.
-      if (get_max_size () - get_size () < num_insert)
+      if (get_max_size () - get_size () < num_insert) {
         throw_allocation_size_error ();
+      }
 
       const size_ty offset   = internal_range_length (begin_ptr (), pos);
       const size_ty new_size = get_size () + num_insert;
@@ -4252,8 +4007,7 @@ class small_vector_base
       ptr           new_first    = unchecked_next (new_data_ptr, offset);
       ptr           new_last     = new_first;
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_copy (first, last, new_first);
         unchecked_advance  (new_last, num_insert);
 
@@ -4261,8 +4015,7 @@ class small_vector_base
         new_first = new_data_ptr;
         uninitialized_move (pos, end_ptr (), new_last);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         destroy_range (new_first, new_last);
         deallocate (new_data_ptr, new_capacity);
         PLUMED_GCH_THROW;
@@ -4270,14 +4023,11 @@ class small_vector_base
 
       reset_data (new_data_ptr, new_capacity, new_size);
       return unchecked_next (begin_ptr (), offset);
-    }
-    else
-    {
+    } else {
       // if we have fewer to insert than tailing elements after
       // `pos` we shift into uninitialized and then copy over
       const size_ty tail_size = internal_range_length (pos, end_ptr ());
-      if (tail_size < num_insert)
-      {
+      if (tail_size < num_insert) {
         // Use the same method as insert_copies.
         ptr original_end = end_ptr ();
         ForwardIt pivot  = unchecked_next (first, tail_size);
@@ -4286,8 +4036,7 @@ class small_vector_base
         uninitialized_copy (pivot, last, end_ptr ());
         increase_size (num_insert - tail_size);
 
-        PLUMED_GCH_TRY
-        {
+        PLUMED_GCH_TRY {
           // Now move the tail to the end.
           uninitialized_move (pos, original_end, end_ptr ());
           increase_size (tail_size);
@@ -4297,8 +4046,7 @@ class small_vector_base
             // Finally, try to copy the rest of the elements over.
             copy_range (first, pivot, pos);
           }
-          PLUMED_GCH_CATCH (...)
-          {
+          PLUMED_GCH_CATCH (...) {
             // Attempt to roll back and destroy the tail if we fail.
             ptr inserted_end = unchecked_prev (end_ptr (), tail_size);
             move_left (inserted_end, end_ptr (), pos);
@@ -4307,26 +4055,21 @@ class small_vector_base
             PLUMED_GCH_THROW;
           }
         }
-        PLUMED_GCH_CATCH (...)
-        {
+        PLUMED_GCH_CATCH (...) {
           // If we throw, destroy the first copy we made.
           destroy_range (original_end, end_ptr ());
           decrease_size (internal_range_length (original_end, end_ptr ()));
           PLUMED_GCH_THROW;
         }
-      }
-      else
-      {
+      } else {
         shift_into_uninitialized (pos, num_insert);
 
         // Attempt to copy over the elements.
         // If we fail we'll attempt a full roll-back.
-        PLUMED_GCH_TRY
-        {
+        PLUMED_GCH_TRY {
           copy_range (first, last, pos);
         }
-        PLUMED_GCH_CATCH (...)
-        {
+        PLUMED_GCH_CATCH (...) {
           ptr inserted_end = unchecked_next (pos, num_insert);
           ptr original_end = move_left (inserted_end, end_ptr (), pos);
           destroy_range (original_end, end_ptr ());
@@ -4341,8 +4084,7 @@ class small_vector_base
   template <typename InputIt>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  insert_range (ptr pos, InputIt first, InputIt last, std::input_iterator_tag)
-  {
+  insert_range (ptr pos, InputIt first, InputIt last, std::input_iterator_tag) {
     assert (! (first == last) && "The range should not be empty.");
 
     // Ensure we use this specific overload to give a strong exception guarantee for 1 element.
@@ -4361,13 +4103,14 @@ class small_vector_base
   template <typename ForwardIt>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  insert_range (ptr pos, ForwardIt first, ForwardIt last, std::forward_iterator_tag)
-  {
-    if (! (end_ptr () == pos))
+  insert_range (ptr pos, ForwardIt first, ForwardIt last, std::forward_iterator_tag) {
+    if (! (end_ptr () == pos)) {
       return insert_range_helper (pos, first, last);
+    }
 
-    if (unchecked_next (first) == last)
+    if (unchecked_next (first) == last) {
       return append_element (*first);
+    }
 
     using iterator_cat = typename std::iterator_traits<ForwardIt>::iterator_category;
     return append_range (first, last, iterator_cat { });
@@ -4376,8 +4119,7 @@ class small_vector_base
   template <typename ...Args>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  emplace_into_current_end (Args&&... args)
-  {
+  emplace_into_current_end (Args&&... args) {
     construct (end_ptr (), std::forward<Args> (args)...);
     increase_size (1);
     return unchecked_prev (end_ptr ());
@@ -4388,10 +4130,10 @@ class small_vector_base
               std::is_nothrow_move_constructible<V>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  emplace_into_current (ptr pos, value_ty&& val)
-  {
-    if (pos == end_ptr ())
+  emplace_into_current (ptr pos, value_ty&& val) {
+    if (pos == end_ptr ()) {
       return emplace_into_current_end (std::move (val));
+    }
 
     // In the special case of value_ty&& we don't make a copy because behavior is unspecified
     // when it is an internal element. Hence, we'll take the opportunity to optimize and assume
@@ -4405,14 +4147,13 @@ class small_vector_base
   template <typename ...Args>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  emplace_into_current (ptr pos, Args&&... args)
-  {
-    if (pos == end_ptr ())
+  emplace_into_current (ptr pos, Args&&... args) {
+    if (pos == end_ptr ()) {
       return emplace_into_current_end (std::forward<Args> (args)...);
+    }
 
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-    if (std::is_constant_evaluated ())
-    {
+    if (std::is_constant_evaluated ()) {
       heap_temporary tmp (*this, std::forward<Args> (args)...);
       shift_into_uninitialized (pos, 1);
       *pos = tmp.release ();
@@ -4430,11 +4171,11 @@ class small_vector_base
   template <typename ...Args>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  emplace_into_reallocation_end (Args&&... args)
-  {
+  emplace_into_reallocation_end (Args&&... args) {
     // Appending; strong exception guarantee.
-    if (get_max_size () == get_size ())
+    if (get_max_size () == get_size ()) {
       throw_allocation_size_error ();
+    }
 
     const size_ty new_size = get_size () + 1;
 
@@ -4443,21 +4184,18 @@ class small_vector_base
     const ptr     new_data_ptr = unchecked_allocate (new_capacity, allocation_end_ptr ());
     const ptr     emplace_pos  = unchecked_next (new_data_ptr, get_size ());
 
-    PLUMED_GCH_TRY
-    {
+    PLUMED_GCH_TRY {
       construct (emplace_pos, std::forward<Args> (args)...);
       PLUMED_GCH_TRY
       {
         uninitialized_move<strong_exception_policy> (begin_ptr (), end_ptr (), new_data_ptr);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         destroy (emplace_pos);
         PLUMED_GCH_THROW;
       }
     }
-    PLUMED_GCH_CATCH (...)
-    {
+    PLUMED_GCH_CATCH (...) {
       deallocate (new_data_ptr, new_capacity);
       PLUMED_GCH_THROW;
     }
@@ -4469,14 +4207,15 @@ class small_vector_base
   template <typename ...Args>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  emplace_into_reallocation (ptr pos, Args&&... args)
-  {
+  emplace_into_reallocation (ptr pos, Args&&... args) {
     const size_ty offset = internal_range_length (begin_ptr (), pos);
-    if (offset == get_size ())
+    if (offset == get_size ()) {
       return emplace_into_reallocation_end (std::forward<Args> (args)...);
+    }
 
-    if (get_max_size () == get_size ())
+    if (get_max_size () == get_size ()) {
       throw_allocation_size_error ();
+    }
 
     const size_ty new_size = get_size () + 1;
 
@@ -4486,8 +4225,7 @@ class small_vector_base
     ptr           new_first    = unchecked_next (new_data_ptr, offset);
     ptr           new_last     = new_first;
 
-    PLUMED_GCH_TRY
-    {
+    PLUMED_GCH_TRY {
       construct (new_first, std::forward<Args> (args)...);
       unchecked_advance (new_last, 1);
 
@@ -4495,8 +4233,7 @@ class small_vector_base
       new_first = new_data_ptr;
       uninitialized_move (pos, end_ptr (), new_last);
     }
-    PLUMED_GCH_CATCH (...)
-    {
+    PLUMED_GCH_CATCH (...) {
       destroy_range (new_first, new_last);
       deallocate (new_data_ptr, new_capacity);
       PLUMED_GCH_THROW;
@@ -4508,30 +4245,28 @@ class small_vector_base
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  shrink_to_size (void)
-  {
-    if (! has_allocation () || get_size () == get_capacity ())
+  shrink_to_size (void) {
+    if (! has_allocation () || get_size () == get_capacity ()) {
       return begin_ptr ();
+    }
 
     // The rest runs only if allocated.
 
     size_ty new_capacity;
     ptr     new_data_ptr;
 
-    if (InlineCapacity < get_size ())
-    {
+    if (InlineCapacity < get_size ()) {
       new_capacity = get_size ();
       new_data_ptr = unchecked_allocate (new_capacity, allocation_end_ptr ());
-    }
-    else
-    {
+    } else {
       // We move to inline storage.
       new_capacity = InlineCapacity;
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-      if (std::is_constant_evaluated ())
+      if (std::is_constant_evaluated ()) {
         new_data_ptr = alloc_interface::allocate (InlineCapacity);
-      else
+      } else {
         new_data_ptr = storage_ptr ();
+      }
 #else
       new_data_ptr = storage_ptr ();
 #endif
@@ -4551,19 +4286,19 @@ class small_vector_base
   template <typename ...ValueT>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  resize_with (size_ty new_size, const ValueT&... val)
-  {
+  resize_with (size_ty new_size, const ValueT&... val) {
     // ValueT... should either be value_ty or empty.
 
-    if (new_size == 0)
+    if (new_size == 0) {
       erase_all ();
+    }
 
-    if (get_capacity () < new_size)
-    {
+    if (get_capacity () < new_size) {
       // Reallocate.
 
-      if (get_max_size () < new_size)
+      if (get_max_size () < new_size) {
         throw_allocation_size_error ();
+      }
 
       const size_ty original_size = get_size ();
 
@@ -4572,8 +4307,7 @@ class small_vector_base
       ptr           new_data_ptr = unchecked_allocate (new_capacity, allocation_end_ptr ());
       ptr           new_last     = unchecked_next (new_data_ptr, original_size);
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         new_last = uninitialized_fill (
           new_last,
           unchecked_next (new_data_ptr, new_size),
@@ -4582,43 +4316,38 @@ class small_vector_base
         // Strong exception guarantee.
         uninitialized_move<strong_exception_policy> (begin_ptr (), end_ptr (), new_data_ptr);
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         destroy_range (unchecked_next (new_data_ptr, original_size), new_last);
         deallocate (new_data_ptr, new_capacity);
         PLUMED_GCH_THROW;
       }
 
       reset_data (new_data_ptr, new_capacity, new_size);
-    }
-    else if (get_size () < new_size)
-    {
+    } else if (get_size () < new_size) {
       // Construct in the uninitialized section.
       uninitialized_fill (end_ptr (), unchecked_next (begin_ptr (), new_size), val...);
       set_size (new_size);
-    }
-    else
+    } else {
       erase_range (unchecked_next (begin_ptr (), new_size), end_ptr ());
+    }
 
     // Do nothing if the count is the same as the current size.
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  request_capacity (size_ty request)
-  {
-    if (request <= get_capacity ())
+  request_capacity (size_ty request) {
+    if (request <= get_capacity ()) {
       return;
+    }
 
     size_ty new_capacity = checked_calculate_new_capacity (request);
     ptr     new_begin    = unchecked_allocate (new_capacity);
 
-    PLUMED_GCH_TRY
-    {
+    PLUMED_GCH_TRY {
       uninitialized_move<strong_exception_policy> (begin_ptr (), end_ptr (), new_begin);
     }
-    PLUMED_GCH_CATCH (...)
-    {
+    PLUMED_GCH_CATCH (...) {
       deallocate (new_begin, new_capacity);
       PLUMED_GCH_THROW;
     }
@@ -4631,8 +4360,7 @@ class small_vector_base
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  erase_at (ptr pos)
-  {
+  erase_at (ptr pos) {
     move_left (unchecked_next (pos), end_ptr (), pos);
     erase_last ();
     return pos;
@@ -4640,8 +4368,7 @@ class small_vector_base
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  erase_last (void)
-  {
+  erase_last (void) {
     decrease_size (1);
 
     // The element located at end_ptr is still alive since the size decreased.
@@ -4650,20 +4377,18 @@ class small_vector_base
 
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  erase_range (ptr first, ptr last)
-  {
-    if (! (first == last))
+  erase_range (ptr first, ptr last) {
+    if (! (first == last)) {
       erase_to_end (move_left (last, end_ptr (), first));
+    }
     return first;
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  erase_to_end (ptr pos)
-  {
+  erase_to_end (ptr pos) {
     assert (0 <= (end_ptr () - pos) && "`pos` was in the uninitialized range");
-    if (size_ty change = internal_range_length (pos, end_ptr ()))
-    {
+    if (size_ty change = internal_range_length (pos, end_ptr ())) {
       decrease_size (change);
       destroy_range (pos, unchecked_next (pos, change));
     }
@@ -4671,8 +4396,7 @@ class small_vector_base
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  erase_all (void)
-  {
+  erase_all (void) {
     ptr curr_end = end_ptr ();
     set_size (0);
     destroy_range (begin_ptr (), curr_end);
@@ -4687,8 +4411,7 @@ class small_vector_base
 #else
             &&  detail::small_vector_adl::is_nothrow_swappable<value_ty>::value
 #endif
-           )
-  {
+           ) {
     assert (get_size () <= other.get_size ());
 
     const ptr other_tail = std::swap_ranges (begin_ptr (), end_ptr (), other.begin_ptr ());
@@ -4707,8 +4430,7 @@ class small_vector_base
 #else
             &&  detail::small_vector_adl::is_nothrow_swappable<value_ty>::value
 #endif
-           )
-  {
+           ) {
     // This function is used when:
     //   We are using the standard allocator.
     //   The allocators propagate and are equal.
@@ -4721,10 +4443,9 @@ class small_vector_base
 
     assert (get_capacity () <= other.get_capacity ());
 
-    if (has_allocation ()) // Implies that `other` also has an allocation.
+    if (has_allocation ()) { // Implies that `other` also has an allocation.
       swap_allocation (other);
-    else if (other.has_allocation ())
-    {
+    } else if (other.has_allocation ()) {
       // Note: This will never be constant evaluated because both are always allocated.
       uninitialized_move (begin_ptr (), end_ptr (), other.storage_ptr ());
       destroy_range (begin_ptr (), end_ptr ());
@@ -4736,30 +4457,27 @@ class small_vector_base
       other.set_capacity (InlineCapacity);
 
       swap_size (other);
-    }
-    else if (get_size () < other.get_size ())
+    } else if (get_size () < other.get_size ()) {
       swap_elements (other);
-    else
+    } else {
       other.swap_elements (*this);
+    }
 
     alloc_interface::swap (other);
   }
 
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap_unequal_no_propagate (small_vector_base& other)
-  {
+  swap_unequal_no_propagate (small_vector_base& other) {
     assert (get_capacity () <= other.get_capacity ());
 
-    if (get_capacity () < other.get_size ())
-    {
+    if (get_capacity () < other.get_size ()) {
       // Reallocation required.
       // We should always be able to reuse the allocation of `other`.
       const size_ty new_capacity = unchecked_calculate_new_capacity (other.get_size ());
       const ptr     new_data_ptr = unchecked_allocate (new_capacity, end_ptr ());
 
-      PLUMED_GCH_TRY
-      {
+      PLUMED_GCH_TRY {
         uninitialized_move (other.begin_ptr (), other.end_ptr (), new_data_ptr);
         PLUMED_GCH_TRY
         {
@@ -4767,30 +4485,29 @@ class small_vector_base
             std::move (begin_ptr (), end_ptr (), other.begin_ptr ()),
             other.end_ptr ());
         }
-        PLUMED_GCH_CATCH (...)
-        {
+        PLUMED_GCH_CATCH (...) {
           destroy_range (new_data_ptr, unchecked_next (new_data_ptr, other.get_size ()));
           PLUMED_GCH_THROW;
         }
       }
-      PLUMED_GCH_CATCH (...)
-      {
+      PLUMED_GCH_CATCH (...) {
         deallocate (new_data_ptr, new_capacity);
         PLUMED_GCH_THROW;
       }
 
       destroy_range (begin_ptr (), end_ptr ());
-      if (has_allocation ())
+      if (has_allocation ()) {
         deallocate (data_ptr (), get_capacity ());
+      }
 
       set_data_ptr (new_data_ptr);
       set_capacity (new_capacity);
       swap_size (other);
-    }
-    else if (get_size () < other.get_size ())
+    } else if (get_size () < other.get_size ()) {
       swap_elements (other);
-    else
+    } else {
       other.swap_elements (*this);
+    }
 
     // This should have no effect.
     alloc_interface::swap (other);
@@ -4801,8 +4518,7 @@ class small_vector_base
                                     &&  InlineCapacity == 0>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap (small_vector_base& other) noexcept
-  {
+  swap (small_vector_base& other) noexcept {
     swap_allocation (other);
     alloc_interface::swap (other);
   }
@@ -4819,33 +4535,31 @@ class small_vector_base
 #else
             &&  detail::small_vector_adl::is_nothrow_swappable<value_ty>::value
 #endif
-                                         )
-  {
-    if (get_capacity () < other.get_capacity ())
-          swap_default (other);
-    else
+                                         ) {
+    if (get_capacity () < other.get_capacity ()) {
+      swap_default (other);
+    } else {
       other.swap_default (*this);
+    }
   }
 
   template <typename A = alloc_ty,
             typename std::enable_if<! allocations_are_swappable<A>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  swap (small_vector_base& other)
-  {
-    if (get_capacity () < other.get_capacity ())
-    {
-      if (other.allocator_ref () == allocator_ref ())
+  swap (small_vector_base& other) {
+    if (get_capacity () < other.get_capacity ()) {
+      if (other.allocator_ref () == allocator_ref ()) {
         swap_default (other);
-      else
+      } else {
         swap_unequal_no_propagate (other);
-    }
-    else
-    {
-      if (other.allocator_ref () == allocator_ref ())
+      }
+    } else {
+      if (other.allocator_ref () == allocator_ref ()) {
         other.swap_default (*this);
-      else
+      } else {
         other.swap_unequal_no_propagate (*this);
+      }
     }
   }
 
@@ -4857,8 +4571,7 @@ class small_vector_base
   template <typename InputIt>
   static PLUMED_GCH_CPP20_CONSTEXPR
   InputIt
-  unmove_iterator (InputIt it)
-  {
+  unmove_iterator (InputIt it) {
     return it;
   }
 
@@ -4866,8 +4579,7 @@ class small_vector_base
   static PLUMED_GCH_CPP20_CONSTEXPR
   auto
   unmove_iterator (std::move_iterator<InputIt> it)
-  -> decltype (unmove_iterator (it.base ()))
-  {
+  -> decltype (unmove_iterator (it.base ())) {
     return unmove_iterator (it.base ());
   }
 
@@ -4875,8 +4587,7 @@ class small_vector_base
   static PLUMED_GCH_CPP20_CONSTEXPR
   auto
   unmove_iterator (std::reverse_iterator<InputIt> it)
-  -> std::reverse_iterator<decltype (unmove_iterator (it.base ()))>
-  {
+  -> std::reverse_iterator<decltype (unmove_iterator (it.base ()))> {
     return std::reverse_iterator<decltype (unmove_iterator (it.base ()))> (
       unmove_iterator (it.base ()));
                                 }
@@ -4886,13 +4597,11 @@ class small_vector_base
   template <typename InputIt>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  copy_range (InputIt first, InputIt last, ptr dest)
-  {
+  copy_range (InputIt first, InputIt last, ptr dest) {
 #if defined (PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED) && defined (__GLIBCXX__)
     if (    std::is_constant_evaluated ()
             &&! std::is_same<decltype (unmove_iterator (std::declval<InputIt> ())),
-                             InputIt>::value)
-    {
+                             InputIt>::value) {
       return std::move (unmove_iterator (first), unmove_iterator (last), dest);
     }
 #endif
@@ -4905,18 +4614,17 @@ class small_vector_base
               is_memcpyable_iterator<InputIt>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   InputIt
-  copy_n_return_in (InputIt first, size_ty count, ptr dest) noexcept
-  {
+  copy_n_return_in (InputIt first, size_ty count, ptr dest) noexcept {
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-    if (std::is_constant_evaluated ())
-    {
+    if (std::is_constant_evaluated ()) {
       std::copy_n (first, count, dest);
       return unchecked_next (first, count);
     }
 #endif
 
-    if (count != 0)
+    if (count != 0) {
       std::memcpy (to_address (dest), to_address (first), count * sizeof (value_ty));
+    }
     // Note: The unsafe cast here should be proven to be safe in the caller function.
     return unchecked_next (first, count);
   }
@@ -4926,8 +4634,7 @@ class small_vector_base
               is_memcpyable_iterator<InputIt>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   std::move_iterator<InputIt>
-  copy_n_return_in (std::move_iterator<InputIt> first, size_ty count, ptr dest) noexcept
-  {
+  copy_n_return_in (std::move_iterator<InputIt> first, size_ty count, ptr dest) noexcept {
     return std::move_iterator<InputIt> (copy_n_return_in (first.base (), count, dest));
   }
 
@@ -4939,13 +4646,11 @@ class small_vector_base
               >::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   RandomIt
-  copy_n_return_in (RandomIt first, size_ty count, ptr dest)
-  {
+  copy_n_return_in (RandomIt first, size_ty count, ptr dest) {
 #if defined (PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED) && defined (__GLIBCXX__)
     if (    std::is_constant_evaluated ()
             &&! std::is_same<decltype (unmove_iterator (std::declval<RandomIt> ())),
-                             RandomIt>::value)
-    {
+                             RandomIt>::value) {
       auto bfirst = unmove_iterator (first);
       auto blast  = unchecked_next (bfirst, count);
       std::move (bfirst, blast, dest);
@@ -4966,11 +4671,11 @@ class small_vector_base
               >::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   InputIt
-  copy_n_return_in (InputIt first, size_ty count, ptr dest)
-  {
+  copy_n_return_in (InputIt first, size_ty count, ptr dest) {
 
-    for (; count != 0; --count, static_cast<void> (++dest), static_cast<void> (++first))
+    for (; count != 0; --count, static_cast<void> (++dest), static_cast<void> (++first)) {
       *dest = *first;
+    }
     return first;
   }
 
@@ -4978,18 +4683,19 @@ class small_vector_base
             typename std::enable_if<is_memcpyable<V>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  move_left (ptr first, ptr last, ptr d_first)
-  {
+  move_left (ptr first, ptr last, ptr d_first) {
     // Shift initialized elements to the left.
 
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-    if (std::is_constant_evaluated ())
+    if (std::is_constant_evaluated ()) {
       return std::move (first, last, d_first);
+    }
 #endif
 
     const size_ty num_moved = internal_range_length (first, last);
-    if (num_moved != 0)
+    if (num_moved != 0) {
       std::memmove (to_address (d_first), to_address (first), num_moved * sizeof (value_ty));
+    }
     return unchecked_next (d_first, num_moved);
   }
 
@@ -4997,8 +4703,7 @@ class small_vector_base
             typename std::enable_if<! is_memcpyable<V>::value>::type * = nullptr>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  move_left (ptr first, ptr last, ptr d_first)
-  {
+  move_left (ptr first, ptr last, ptr d_first) {
     // Shift initialized elements to the left.
     return std::move (first, last, d_first);
   }
@@ -5007,19 +4712,20 @@ class small_vector_base
             typename std::enable_if<is_memcpyable<V>::value, bool>::type = true>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  move_right (ptr first, ptr last, ptr d_last)
-  {
+  move_right (ptr first, ptr last, ptr d_last) {
     // Move initialized elements to the right.
 
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-    if (std::is_constant_evaluated ())
+    if (std::is_constant_evaluated ()) {
       return std::move_backward (first, last, d_last);
+    }
 #endif
 
     const size_ty num_moved = internal_range_length (first, last);
     const ptr     dest      = unchecked_prev (d_last, num_moved);
-    if (num_moved != 0)
+    if (num_moved != 0) {
       std::memmove (to_address (dest), to_address (first), num_moved * sizeof (value_ty));
+    }
     return dest;
   }
 
@@ -5027,8 +4733,7 @@ class small_vector_base
             typename std::enable_if<! is_memcpyable<V>::value, bool>::type = false>
   PLUMED_GCH_CPP20_CONSTEXPR
   ptr
-  move_right (ptr first, ptr last, ptr d_last)
-  {
+  move_right (ptr first, ptr last, ptr d_last) {
     // move initialized elements to the right
     // n should not be 0
     return std::move_backward (first, last, d_last);
@@ -5037,126 +4742,110 @@ class small_vector_base
 public:
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  set_default (void)
-  {
+  set_default (void) {
     set_to_inline_storage ();
     set_size (0);
   }
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR
   ptr
-  data_ptr (void) noexcept
-  {
+  data_ptr (void) noexcept {
     return m_data.data_ptr ();
   }
 
   PLUMED_GCH_NODISCARD constexpr
   cptr
-  data_ptr (void) const noexcept
-  {
+  data_ptr (void) const noexcept {
     return m_data.data_ptr ();
   }
 
   PLUMED_GCH_NODISCARD constexpr
   size_ty
-  get_capacity (void) const noexcept
-  {
+  get_capacity (void) const noexcept {
     return m_data.capacity ();
   }
 
   PLUMED_GCH_NODISCARD constexpr
   size_ty
-  get_size (void) const noexcept
-  {
+  get_size (void) const noexcept {
     return m_data.size ();
   }
 
   PLUMED_GCH_NODISCARD constexpr
   size_ty
-  num_uninitialized (void) const noexcept
-  {
+  num_uninitialized (void) const noexcept {
     return get_capacity () - get_size ();
   }
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR
   ptr
-  begin_ptr (void) noexcept
-  {
+  begin_ptr (void) noexcept {
     return data_ptr ();
   }
 
   PLUMED_GCH_NODISCARD
   constexpr
   cptr
-  begin_ptr (void) const noexcept
-  {
+  begin_ptr (void) const noexcept {
     return data_ptr ();
   }
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR
   ptr
-  end_ptr (void) noexcept
-  {
+  end_ptr (void) noexcept {
     return unchecked_next (begin_ptr (), get_size ());
   }
 
   PLUMED_GCH_NODISCARD constexpr
   cptr
-  end_ptr (void) const noexcept
-  {
+  end_ptr (void) const noexcept {
     return unchecked_next (begin_ptr (), get_size ());
   }
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR
   ptr
-  allocation_end_ptr (void) noexcept
-  {
+  allocation_end_ptr (void) noexcept {
     return unchecked_next (begin_ptr (), get_capacity ());
   }
 
   PLUMED_GCH_NODISCARD constexpr
   cptr
-  allocation_end_ptr (void) const noexcept
-  {
+  allocation_end_ptr (void) const noexcept {
     return unchecked_next (begin_ptr (), get_capacity ());
   }
 
   PLUMED_GCH_NODISCARD constexpr
   alloc_ty
-  copy_allocator (void) const noexcept
-  {
+  copy_allocator (void) const noexcept {
     return alloc_ty (allocator_ref ());
   }
 
   PLUMED_GCH_NODISCARD PLUMED_GCH_CPP14_CONSTEXPR
   ptr
-  storage_ptr (void) noexcept
-  {
+  storage_ptr (void) noexcept {
     return m_data.storage ();
   }
 
   PLUMED_GCH_NODISCARD constexpr
   cptr
-  storage_ptr (void) const noexcept
-  {
+  storage_ptr (void) const noexcept {
     return m_data.storage ();
   }
 
   PLUMED_GCH_NODISCARD constexpr
   bool
-  has_allocation (void) const noexcept
-  {
+  has_allocation (void) const noexcept {
 #ifdef PLUMED_GCH_LIB_IS_CONSTANT_EVALUATED
-    if (std::is_constant_evaluated ())
+    if (std::is_constant_evaluated ()) {
       return true;
+    }
 #endif
     return InlineCapacity < get_capacity ();
   }
 
   PLUMED_GCH_NODISCARD constexpr
   bool
-  is_inlinable (void) const noexcept
-  {
+  is_inlinable (void) const noexcept {
     return get_size () <= InlineCapacity;
   }
 
@@ -5171,8 +4860,7 @@ template <typename T, unsigned InlineCapacity, typename Allocator>
 requires concepts::small_vector::AllocatorFor<Allocator, T>
 #endif
 class small_vector
-: private detail::small_vector_base<Allocator, InlineCapacity>
-{
+: private detail::small_vector_base<Allocator, InlineCapacity> {
   using base = detail::small_vector_base<Allocator, InlineCapacity>;
 
 public:
@@ -5253,8 +4941,7 @@ class small_vector
   Erasable = concepts::small_vector::Erasable<value_type, small_vector, allocator_type>;
 
   template <typename ...Args>
-  struct EmplaceConstructible
-  {
+  struct EmplaceConstructible {
     static constexpr
     bool
     value = concepts::small_vector::EmplaceConstructible<value_type, small_vector,
@@ -5278,7 +4965,8 @@ class small_vector
 #ifdef PLUMED_GCH_LIB_CONCEPTS
   requires CopyInsertable
 #endif
-: base (base::bypass, other)
+:
+  base (base::bypass, other)
   { }
 
   PLUMED_GCH_CPP20_CONSTEXPR
@@ -5287,7 +4975,8 @@ class small_vector
 #ifdef PLUMED_GCH_LIB_CONCEPTS
   requires MoveInsertable
 #endif
-: base (base::bypass, std::move (other))
+:
+  base (base::bypass, std::move (other))
   { }
 
   PLUMED_GCH_CPP20_CONSTEXPR explicit
@@ -5300,7 +4989,8 @@ class small_vector
 #ifdef PLUMED_GCH_LIB_CONCEPTS
   requires CopyInsertable
 #endif
-: base (base::bypass, other, alloc)
+:
+  base (base::bypass, other, alloc)
   { }
 
   PLUMED_GCH_CPP20_CONSTEXPR
@@ -5308,7 +4998,8 @@ class small_vector
 #ifdef PLUMED_GCH_LIB_CONCEPTS
   requires MoveInsertable
 #endif
-: base (base::bypass, std::move (other), alloc)
+:
+  base (base::bypass, std::move (other), alloc)
   { }
 
   PLUMED_GCH_CPP20_CONSTEXPR explicit
@@ -5316,7 +5007,8 @@ class small_vector
 #ifdef PLUMED_GCH_LIB_CONCEPTS
   requires DefaultInsertable
 #endif
-: base (count, alloc)
+:
+  base (count, alloc)
   { }
 
   PLUMED_GCH_CPP20_CONSTEXPR
@@ -5325,7 +5017,8 @@ class small_vector
 #ifdef PLUMED_GCH_LIB_CONCEPTS
   requires CopyInsertable
 #endif
-: base (count, value, alloc)
+:
+  base (count, value, alloc)
   { }
 
 #ifdef PLUMED_GCH_LIB_CONCEPTS
@@ -5365,7 +5058,8 @@ class small_vector
 #ifdef PLUMED_GCH_LIB_CONCEPTS
   requires EmplaceConstructible<const_reference>::value
 #endif
-: small_vector (init.begin (), init.end (), alloc)
+:
+  small_vector (init.begin (), init.end (), alloc)
   { }
 
   template <unsigned I>
@@ -5484,8 +5178,7 @@ class small_vector
 #endif
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  assign (InputIt first, InputIt last)
-  {
+  assign (InputIt first, InputIt last) {
     using iterator_cat = typename std::iterator_traits<InputIt>::iterator_category;
     base::assign_with_range (first, last, iterator_cat { });
   }
@@ -5507,8 +5200,9 @@ class small_vector
   requires CopyInsertable && CopyAssignable
 #endif
   {
-    if (&other != this)
+    if (&other != this) {
       base::copy_assign (other);
+    }
   }
 
   template <unsigned I>
@@ -5517,8 +5211,7 @@ class small_vector
 #endif
   PLUMED_GCH_CPP20_CONSTEXPR
   void
-  assign (const small_vector<T, I, Allocator>& other)
-  {
+  assign (const small_vector<T, I, Allocator>& other) {
     base::copy_assign (other);
   }
 
@@ -5541,8 +5234,9 @@ class small_vector
   requires MoveInsertable && MoveAssignable
 #endif
   {
-    if (&other != this)
+    if (&other != this) {
       base::move_assign (std::move (other));
+    }
   }
 
   template <unsigned I>
@@ -5561,8 +5255,7 @@ class small_vector
                                                  )
                  &&  std::is_nothrow_move_assignable<value_type>::value
                  &&  std::is_nothrow_move_constructible<value_type>::value
-                                                       )
-  {
+  ) {
     base::move_assign (std::move (other));
   }
 
@@ -5622,200 +5315,179 @@ class small_vector
 
   PLUMED_GCH_CPP14_CONSTEXPR
   iterator
-  begin (void) noexcept
-  {
+  begin (void) noexcept {
     return iterator { base::begin_ptr () };
   }
 
   constexpr
   const_iterator
-  begin (void) const noexcept
-  {
+  begin (void) const noexcept {
     return const_iterator { base::begin_ptr () };
   }
 
   constexpr
   const_iterator
-  cbegin (void) const noexcept
-  {
+  cbegin (void) const noexcept {
     return begin ();
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   iterator
-  end (void) noexcept
-  {
+  end (void) noexcept {
     return iterator { base::end_ptr () };
   }
 
   constexpr
   const_iterator
-  end (void) const noexcept
-  {
+  end (void) const noexcept {
     return const_iterator { base::end_ptr () };
   }
 
   constexpr
   const_iterator
-  cend (void) const noexcept
-  {
+  cend (void) const noexcept {
     return end ();
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   reverse_iterator
-  rbegin (void) noexcept
-  {
+  rbegin (void) noexcept {
     return reverse_iterator { end () };
   }
 
   constexpr
   const_reverse_iterator
-  rbegin (void) const noexcept
-  {
+  rbegin (void) const noexcept {
     return const_reverse_iterator { end () };
   }
 
   constexpr
   const_reverse_iterator
-  crbegin (void) const noexcept
-  {
+  crbegin (void) const noexcept {
     return rbegin ();
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   reverse_iterator
-  rend (void) noexcept
-  {
+  rend (void) noexcept {
     return reverse_iterator { begin () };
   }
 
   constexpr
   const_reverse_iterator
-  rend (void) const noexcept
-  {
+  rend (void) const noexcept {
     return const_reverse_iterator { begin () };
   }
 
   constexpr
   const_reverse_iterator
-  crend (void) const noexcept
-  {
+  crend (void) const noexcept {
     return rend ();
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   reference
-  at (size_type pos)
-  {
-    if (size () <= pos)
+  at (size_type pos) {
+    if (size () <= pos) {
       base::throw_index_error ();
+    }
     return begin ()[static_cast<difference_type> (pos)];
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   const_reference
-  at (size_type pos) const
-  {
-    if (size () <= pos)
+  at (size_type pos) const {
+    if (size () <= pos) {
       base::throw_index_error ();
+    }
     return begin ()[static_cast<difference_type> (pos)];
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   reference
-  operator[] (size_type pos)
-  {
+  operator[] (size_type pos) {
 #ifdef _GLIBCXX_DEBUG
-    if (size () <= pos) base::throw_index_error ();
+    if (size () <= pos) {
+      base::throw_index_error ();
+    }
 #endif
     return begin ()[static_cast<difference_type> (pos)];
   }
 
   constexpr
   const_reference
-  operator[] (size_type pos) const
-  {
+  operator[] (size_type pos) const {
 #ifdef _GLIBCXX_DEBUG
-    if (size () <= pos) base::throw_index_error ();
+    if (size () <= pos) {
+      base::throw_index_error ();
+    }
 #endif
     return begin ()[static_cast<difference_type> (pos)];
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   reference
-  front (void)
-  {
+  front (void) {
     return (*this)[0];
   }
 
   constexpr
   const_reference
-  front (void) const
-  {
+  front (void) const {
     return (*this)[0];
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   reference
-  back (void)
-  {
+  back (void) {
     return (*this)[size () - 1];
   }
 
   constexpr
   const_reference
-  back (void) const
-  {
+  back (void) const {
     return (*this)[size () - 1];
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   pointer
-  data (void) noexcept
-  {
+  data (void) noexcept {
     return base::begin_ptr ();
   }
 
   constexpr
   const_pointer
-  data (void) const noexcept
-  {
+  data (void) const noexcept {
     return base::begin_ptr ();
   }
 
   constexpr
   size_type
-  size (void) const noexcept
-  {
+  size (void) const noexcept {
     return static_cast<size_type> (base::get_size ());
   }
 
   PLUMED_GCH_NODISCARD constexpr
   bool
-  empty (void) const noexcept
-  {
+  empty (void) const noexcept {
     return size () == 0;
   }
 
   PLUMED_GCH_CPP14_CONSTEXPR
   size_type
-  max_size (void) const noexcept
-  {
+  max_size (void) const noexcept {
     return static_cast<size_type> (base::get_max_size ());
   }
 
   constexpr
   size_type
-  capacity (void) const noexcept
-  {
+  capacity (void) const noexcept {
     return static_cast<size_type> (base::get_capacity ());
   }
 
   constexpr
   allocator_type
-  get_allocator (void) const noexcept
-  {
+  get_allocator (void) const noexcept {
     return base::copy_allocator ();
   }
 
@@ -5866,10 +5538,10 @@ class small_vector
 #endif
   PLUMED_GCH_CPP20_CONSTEXPR
   iterator
-  insert (const_iterator pos, InputIt first, InputIt last)
-  {
-    if (first == last)
+  insert (const_iterator pos, InputIt first, InputIt last) {
+    if (first == last) {
       return iterator (base::ptr_cast (pos));
+    }
 
     using iterator_cat = typename std::iterator_traits<InputIt>::iterator_category;
     return iterator (base::insert_range (base::ptr_cast (pos), first, last, iterator_cat { }));
@@ -5895,8 +5567,7 @@ class small_vector
 #endif
   PLUMED_GCH_CPP20_CONSTEXPR
   iterator
-  emplace (const_iterator pos, Args&&... args)
-  {
+  emplace (const_iterator pos, Args&&... args) {
     return iterator (base::emplace_at (base::ptr_cast (pos), std::forward<Args> (args)...));
   }
 
@@ -5953,8 +5624,7 @@ class small_vector
 #endif
   PLUMED_GCH_CPP20_CONSTEXPR
   reference
-  emplace_back (Args&&... args)
-  {
+  emplace_back (Args&&... args) {
     return *base::append_element (std::forward<Args> (args)...);
   }
 
@@ -6021,23 +5691,20 @@ class small_vector
 
   PLUMED_GCH_NODISCARD constexpr
   bool
-  inlined (void) const noexcept
-  {
+  inlined (void) const noexcept {
     return ! base::has_allocation ();
   }
 
   PLUMED_GCH_NODISCARD constexpr
   bool
-  inlinable (void) const noexcept
-  {
+  inlinable (void) const noexcept {
     return base::is_inlinable ();
   }
 
   PLUMED_GCH_NODISCARD
   static PLUMED_GCH_CONSTEVAL
   size_type
-  inline_capacity (void) noexcept
-  {
+  inline_capacity (void) noexcept {
     return static_cast<size_type> (inline_capacity_v);
   }
 
@@ -6054,8 +5721,7 @@ class small_vector
 #endif
   PLUMED_GCH_CPP20_CONSTEXPR
   small_vector&
-  append (InputIt first, InputIt last)
-  {
+  append (InputIt first, InputIt last) {
     using policy = typename base::strong_exception_policy;
     using iterator_cat = typename std::iterator_traits<InputIt>::iterator_category;
     base::template append_range<policy> (first, last, iterator_cat { });
@@ -6108,8 +5774,7 @@ template <typename T, unsigned InlineCapacityLHS, unsigned InlineCapacityRHS, ty
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator== (const small_vector<T, InlineCapacityLHS, Allocator>& lhs,
-            const small_vector<T, InlineCapacityRHS, Allocator>& rhs)
-{
+            const small_vector<T, InlineCapacityRHS, Allocator>& rhs) {
   return lhs.size () == rhs.size () && std::equal (lhs.begin (), lhs.end (), rhs.begin ());
 }
 
@@ -6117,8 +5782,7 @@ template <typename T, unsigned InlineCapacity, typename Allocator>
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator== (const small_vector<T, InlineCapacity, Allocator>& lhs,
-            const small_vector<T, InlineCapacity, Allocator>& rhs)
-{
+            const small_vector<T, InlineCapacity, Allocator>& rhs) {
   return lhs.size () == rhs.size () && std::equal (lhs.begin (), lhs.end (), rhs.begin ());
 }
 
@@ -6129,8 +5793,7 @@ requires std::three_way_comparable<T>
 constexpr
 auto
 operator<=> (const small_vector<T, InlineCapacityLHS, Allocator>& lhs,
-             const small_vector<T, InlineCapacityRHS, Allocator>& rhs)
-{
+             const small_vector<T, InlineCapacityRHS, Allocator>& rhs) {
   return std::lexicographical_compare_three_way (
     lhs.begin (), lhs.end (),
     rhs.begin (), rhs.end (),
@@ -6142,8 +5805,7 @@ requires std::three_way_comparable<T>
 constexpr
 auto
 operator<=> (const small_vector<T, InlineCapacity, Allocator>& lhs,
-             const small_vector<T, InlineCapacity, Allocator>& rhs)
-{
+             const small_vector<T, InlineCapacity, Allocator>& rhs) {
   return std::lexicographical_compare_three_way (
     lhs.begin (), lhs.end (),
     rhs.begin (), rhs.end (),
@@ -6154,8 +5816,7 @@ template <typename T, unsigned InlineCapacityLHS, unsigned InlineCapacityRHS, ty
 constexpr
 auto
 operator<=> (const small_vector<T, InlineCapacityLHS, Allocator>& lhs,
-             const small_vector<T, InlineCapacityRHS, Allocator>& rhs)
-{
+             const small_vector<T, InlineCapacityRHS, Allocator>& rhs) {
   constexpr auto comparison = [](const T& l, const T& r) {
     return (l < r) ? std::weak_ordering::less
             : (r < l) ? std::weak_ordering::greater
@@ -6172,8 +5833,7 @@ template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 auto
 operator<=> (const small_vector<T, InlineCapacity, Allocator>& lhs,
-             const small_vector<T, InlineCapacity, Allocator>& rhs)
-{
+             const small_vector<T, InlineCapacity, Allocator>& rhs) {
   constexpr auto comparison = [](const T& l, const T& r) {
     return (l < r) ? std::weak_ordering::less
             : (r < l) ? std::weak_ordering::greater
@@ -6192,8 +5852,7 @@ template <typename T, unsigned InlineCapacityLHS, unsigned InlineCapacityRHS, ty
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator!= (const small_vector<T, InlineCapacityLHS, Allocator>& lhs,
-            const small_vector<T, InlineCapacityRHS, Allocator>& rhs)
-{
+            const small_vector<T, InlineCapacityRHS, Allocator>& rhs) {
   return ! (lhs == rhs);
 }
 
@@ -6201,8 +5860,7 @@ template <typename T, unsigned InlineCapacity, typename Allocator>
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator!= (const small_vector<T, InlineCapacity, Allocator>& lhs,
-            const small_vector<T, InlineCapacity, Allocator>& rhs)
-{
+            const small_vector<T, InlineCapacity, Allocator>& rhs) {
   return ! (lhs == rhs);
 }
 
@@ -6210,8 +5868,7 @@ template <typename T, unsigned InlineCapacityLHS, unsigned InlineCapacityRHS, ty
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator<  (const small_vector<T, InlineCapacityLHS, Allocator>& lhs,
-            const small_vector<T, InlineCapacityRHS, Allocator>& rhs)
-{
+const small_vector<T, InlineCapacityRHS, Allocator>& rhs) {
   return std::lexicographical_compare (lhs.begin (), lhs.end (), rhs.begin (), rhs.end ());
 }
 
@@ -6219,8 +5876,7 @@ template <typename T, unsigned InlineCapacity, typename Allocator>
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator<  (const small_vector<T, InlineCapacity, Allocator>& lhs,
-            const small_vector<T, InlineCapacity, Allocator>& rhs)
-{
+const small_vector<T, InlineCapacity, Allocator>& rhs) {
   return std::lexicographical_compare (lhs.begin (), lhs.end (), rhs.begin (), rhs.end ());
 }
 
@@ -6228,8 +5884,7 @@ template <typename T, unsigned InlineCapacityLHS, unsigned InlineCapacityRHS, ty
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator>= (const small_vector<T, InlineCapacityLHS, Allocator>& lhs,
-            const small_vector<T, InlineCapacityRHS, Allocator>& rhs)
-{
+            const small_vector<T, InlineCapacityRHS, Allocator>& rhs) {
   return ! (lhs < rhs);
 }
 
@@ -6237,8 +5892,7 @@ template <typename T, unsigned InlineCapacity, typename Allocator>
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator>= (const small_vector<T, InlineCapacity, Allocator>& lhs,
-            const small_vector<T, InlineCapacity, Allocator>& rhs)
-{
+            const small_vector<T, InlineCapacity, Allocator>& rhs) {
   return ! (lhs < rhs);
 }
 
@@ -6246,8 +5900,7 @@ template <typename T, unsigned InlineCapacityLHS, unsigned InlineCapacityRHS, ty
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator>  (const small_vector<T, InlineCapacityLHS, Allocator>& lhs,
-            const small_vector<T, InlineCapacityRHS, Allocator>& rhs)
-{
+            const small_vector<T, InlineCapacityRHS, Allocator>& rhs) {
   return rhs < lhs;
 }
 
@@ -6255,8 +5908,7 @@ template <typename T, unsigned InlineCapacity, typename Allocator>
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator>  (const small_vector<T, InlineCapacity, Allocator>& lhs,
-            const small_vector<T, InlineCapacity, Allocator>& rhs)
-{
+            const small_vector<T, InlineCapacity, Allocator>& rhs) {
   return rhs < lhs;
 }
 
@@ -6264,8 +5916,7 @@ template <typename T, unsigned InlineCapacityLHS, unsigned InlineCapacityRHS, ty
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator<= (const small_vector<T, InlineCapacityLHS, Allocator>& lhs,
-            const small_vector<T, InlineCapacityRHS, Allocator>& rhs)
-{
+const small_vector<T, InlineCapacityRHS, Allocator>& rhs) {
   return rhs >= lhs;
 }
 
@@ -6273,8 +5924,7 @@ template <typename T, unsigned InlineCapacity, typename Allocator>
 inline PLUMED_GCH_CPP20_CONSTEXPR
 bool
 operator<= (const small_vector<T, InlineCapacity, Allocator>& lhs,
-            const small_vector<T, InlineCapacity, Allocator>& rhs)
-{
+const small_vector<T, InlineCapacity, Allocator>& rhs) {
   return rhs >= lhs;
 }
 
@@ -6306,8 +5956,7 @@ requires concepts::MoveInsertable<T, small_vector<T, InlineCapacity, Allocator>,
 template <typename T, unsigned InlineCapacity, typename Allocator, typename U>
 inline PLUMED_GCH_CPP20_CONSTEXPR
 typename small_vector<T, InlineCapacity, Allocator>::size_type
-erase (small_vector<T, InlineCapacity, Allocator>& v, const U& value)
-{
+erase (small_vector<T, InlineCapacity, Allocator>& v, const U& value) {
   const auto original_size = v.size ();
   v.erase (std::remove (v.begin (), v.end (), value), v.end ());
   return original_size - v.size ();
@@ -6316,8 +5965,7 @@ erase (small_vector<T, InlineCapacity, Allocator>& v, const U& value)
 template <typename T, unsigned InlineCapacity, typename Allocator, typename Pred>
 inline PLUMED_GCH_CPP20_CONSTEXPR
 typename small_vector<T, InlineCapacity, Allocator>::size_type
-erase_if (small_vector<T, InlineCapacity, Allocator>& v, Pred pred)
-{
+erase_if (small_vector<T, InlineCapacity, Allocator>& v, Pred pred) {
   const auto original_size = v.size ();
   v.erase (std::remove_if (v.begin (), v.end (), pred), v.end ());
   return original_size - v.size ();
@@ -6326,104 +5974,91 @@ erase_if (small_vector<T, InlineCapacity, Allocator>& v, Pred pred)
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::iterator
-begin (small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+begin (small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.begin ();
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::const_iterator
-begin (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+begin (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.begin ();
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::const_iterator
-cbegin (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+cbegin (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return begin (v);
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::iterator
-end (small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+end (small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.end ();
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::const_iterator
-end (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+end (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.end ();
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::const_iterator
-cend (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+cend (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return end (v);
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::reverse_iterator
-rbegin (small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+rbegin (small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.rbegin ();
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::const_reverse_iterator
-rbegin (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+rbegin (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.rbegin ();
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::const_reverse_iterator
-crbegin (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+crbegin (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return rbegin (v);
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::reverse_iterator
-rend (small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+rend (small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.rend ();
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::const_reverse_iterator
-rend (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+rend (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.rend ();
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::const_reverse_iterator
-crend (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+crend (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return rend (v);
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::size_type
-size (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+size (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.size ();
 }
 
@@ -6433,8 +6068,7 @@ typename std::common_type<
   std::ptrdiff_t,
   typename std::make_signed<
     typename small_vector<T, InlineCapacity, Allocator>::size_type>::type>::type
-ssize (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+ssize (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   using ret_type = typename std::common_type<
     std::ptrdiff_t,
     typename std::make_signed<decltype (v.size ())>::type>::type;
@@ -6444,24 +6078,21 @@ ssize (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
 template <typename T, unsigned InlineCapacity, typename Allocator>
 PLUMED_GCH_NODISCARD constexpr
 bool
-empty (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+empty (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.empty ();
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::pointer
-data (small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+data (small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.data ();
 }
 
 template <typename T, unsigned InlineCapacity, typename Allocator>
 constexpr
 typename small_vector<T, InlineCapacity, Allocator>::const_pointer
-data (const small_vector<T, InlineCapacity, Allocator>& v) noexcept
-{
+data (const small_vector<T, InlineCapacity, Allocator>& v) noexcept {
   return v.data ();
 }
 
diff --git a/src/sprint/Sprint.cpp b/src/sprint/Sprint.cpp
index 89d01e5f1b..33ddc9fb9e 100644
--- a/src/sprint/Sprint.cpp
+++ b/src/sprint/Sprint.cpp
@@ -94,46 +94,65 @@ void Sprint::registerKeywords(Keywords& keys) {
   keys.add("optional","MATRIX","the matrix that you would like to perform SPRINT on");
   keys.add("numbered","GROUP","specifies the list of atoms that should be assumed indistinguishable");
   keys.add("numbered","SWITCH","specify the switching function to use between two sets of indistinguishable atoms");
-  keys.needsAction("CONTACT_MATRIX"); keys.needsAction("DIAGONALIZE"); keys.needsAction("CUSTOM");
-  keys.needsAction("SELECT_COMPONENTS"); keys.needsAction("SORT"); keys.needsAction("COMBINE");
+  keys.needsAction("CONTACT_MATRIX");
+  keys.needsAction("DIAGONALIZE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("SELECT_COMPONENTS");
+  keys.needsAction("SORT");
+  keys.needsAction("COMBINE");
   keys.addOutputComponent("coord","default","the sprint coordinates");
 }
 
 Sprint::Sprint(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string matinp; parse("MATRIX",matinp);
+  ActionShortcut(ao) {
+  std::string matinp;
+  parse("MATRIX",matinp);
   if( matinp.length()==0 ) {
     readInputLine( getShortcutLabel() + "_jmat: CONTACT_MATRIX " + convertInputLineToString() );
     matinp = getShortcutLabel() + "_jmat";
   }
-  std::vector<unsigned> nin_group; unsigned ntot_atoms=0;
+  std::vector<unsigned> nin_group;
+  unsigned ntot_atoms=0;
   for(unsigned i=1;; ++i) {
-    std::string inum; Tools::convert( i, inum );
+    std::string inum;
+    Tools::convert( i, inum );
     ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( matinp + inum + inum );
-    if( !av ) break ;
-    unsigned natoms = (av->copyOutput(0))->getShape()[0]; nin_group.push_back( natoms ); ntot_atoms += natoms;
+    if( !av ) {
+      break ;
+    }
+    unsigned natoms = (av->copyOutput(0))->getShape()[0];
+    nin_group.push_back( natoms );
+    ntot_atoms += natoms;
   }
 
   // Diagonalization
   readInputLine( getShortcutLabel() + "_diag: DIAGONALIZE ARG=" + matinp + " VECTORS=1");
   // Compute sprint coordinates as product of eigenvalue and eigenvector times square root of number of atoms in all groups
-  std::string str_natoms; Tools::convert( ntot_atoms, str_natoms );
+  std::string str_natoms;
+  Tools::convert( ntot_atoms, str_natoms );
   readInputLine( getShortcutLabel() + "_sp: CUSTOM ARG=" + getShortcutLabel() + "_diag.vals-1," + getShortcutLabel() +
                  "_diag.vecs-1 FUNC=sqrt(" + str_natoms + ")*x*y PERIODIC=NO");
   // Sort sprint coordinates for each group of atoms
   unsigned k=0, kk=0;
   for(unsigned j=0; j<nin_group.size(); ++j) {
-    std::string jnum, knum; Tools::convert( j+1, jnum ); Tools::convert(k+1, knum); k++;
+    std::string jnum, knum;
+    Tools::convert( j+1, jnum );
+    Tools::convert(k+1, knum);
+    k++;
     std::string sort_act = getShortcutLabel() + "_selection" + jnum + ": SELECT_COMPONENTS ARG=" + getShortcutLabel() + "_sp COMPONENTS=" + knum;
     for(unsigned n=1; n<nin_group[j]; ++n) {
-      Tools::convert( k+1, knum ); sort_act += ","+ knum; k++;
+      Tools::convert( k+1, knum );
+      sort_act += ","+ knum;
+      k++;
     }
     readInputLine( sort_act );
     readInputLine( getShortcutLabel() + jnum + ": SORT ARG=" + getShortcutLabel() + "_selection" + jnum );
     for(unsigned n=0; n<nin_group[j]; ++n) {
-      std::string knum, nnum; Tools::convert( kk, knum ); Tools::convert( n+1, nnum ); kk++;
+      std::string knum, nnum;
+      Tools::convert( kk, knum );
+      Tools::convert( n+1, nnum );
+      kk++;
       readInputLine( getShortcutLabel() + "_coord-" + knum + ": COMBINE ARG=" + getShortcutLabel() + jnum + "." + nnum + " PERIODIC=NO" );
     }
   }
diff --git a/src/symfunc/AngularTetra.cpp b/src/symfunc/AngularTetra.cpp
index d326b7ccc7..10d33a50d5 100644
--- a/src/symfunc/AngularTetra.cpp
+++ b/src/symfunc/AngularTetra.cpp
@@ -48,25 +48,42 @@ void AngularTetra::registerKeywords( Keywords& keys ) {
   CoordinationNumbers::shortcutKeywords( keys );
   keys.addFlag("NOPBC",false,"ignore the periodic boundary conditions when calculating distances");
   keys.add("compulsory","CUTOFF","-1","ignore distances that have a value larger than this cutoff");
-  keys.remove("NN"); keys.remove("MM"); keys.remove("D_0"); keys.remove("R_0"); keys.remove("SWITCH");
-  keys.needsAction("DISTANCE_MATRIX"); keys.needsAction("NEIGHBORS");
-  keys.needsAction("GSYMFUNC_THREEBODY"); keys.needsAction("CUSTOM");
+  keys.remove("NN");
+  keys.remove("MM");
+  keys.remove("D_0");
+  keys.remove("R_0");
+  keys.remove("SWITCH");
+  keys.needsAction("DISTANCE_MATRIX");
+  keys.needsAction("NEIGHBORS");
+  keys.needsAction("GSYMFUNC_THREEBODY");
+  keys.needsAction("CUSTOM");
 }
 
 AngularTetra::AngularTetra( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  bool nopbc; parseFlag("NOPBC",nopbc);
-  std::string pbcstr=""; if( nopbc ) pbcstr = " NOPBC";
+  ActionShortcut(ao) {
+  bool nopbc;
+  parseFlag("NOPBC",nopbc);
+  std::string pbcstr="";
+  if( nopbc ) {
+    pbcstr = " NOPBC";
+  }
   // Read species input and create the matrix
-  std::string sp_str, rcut; parse("SPECIES",sp_str); parse("CUTOFF",rcut);
+  std::string sp_str, rcut;
+  parse("SPECIES",sp_str);
+  parse("CUTOFF",rcut);
   if( sp_str.length()>0 ) {
     readInputLine( getShortcutLabel() + "_mat: DISTANCE_MATRIX COMPONENTS GROUP=" + sp_str + " CUTOFF=" + rcut + pbcstr );
   } else {
-    std::string specA, specB; parse("SPECIESA",specA); parse("SPECIESB",specB);
-    if( specA.length()==0 ) error("missing input atoms");
-    if( specB.length()==0 ) error("missing SPECIESB keyword");
+    std::string specA, specB;
+    parse("SPECIESA",specA);
+    parse("SPECIESB",specB);
+    if( specA.length()==0 ) {
+      error("missing input atoms");
+    }
+    if( specB.length()==0 ) {
+      error("missing SPECIESB keyword");
+    }
     readInputLine( getShortcutLabel() + "_mat: DISTANCE_MATRIX COMPONENTS GROUPA=" + specA + " GROUPB=" + specB + " CUTOFF=" + rcut + pbcstr );
   }
   // Get the neighbors matrix
@@ -77,7 +94,8 @@ AngularTetra::AngularTetra( const ActionOptions& ao):
   // Now evaluate the actual per atom CV
   readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_g8.g8 FUNC=(1-(3*x/8)) PERIODIC=NO");
   // And get the things to do with the quantities we have computed
-  std::map<std::string,std::string> keymap; multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
+  std::map<std::string,std::string> keymap;
+  multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
   multicolvar::MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel(), "", keymap, this );
 }
 
diff --git a/src/symfunc/AtomicSMAC.cpp b/src/symfunc/AtomicSMAC.cpp
index 6a937c52b3..3ace1070d1 100644
--- a/src/symfunc/AtomicSMAC.cpp
+++ b/src/symfunc/AtomicSMAC.cpp
@@ -58,35 +58,51 @@ void AtomicSMAC::registerKeywords(Keywords& keys) {
   keys.add("optional","SWITCH_COORD","This keyword is used to define the coordination switching function.");
   keys.reset_style("KERNEL","optional");
   multicolvar::MultiColvarShortcuts::shortcutKeywords( keys );
-  keys.needsAction("CONTACT_MATRIX"); keys.needsAction("GSYMFUNC_THREEBODY"); keys.needsAction("ONES");
+  keys.needsAction("CONTACT_MATRIX");
+  keys.needsAction("GSYMFUNC_THREEBODY");
+  keys.needsAction("ONES");
   keys.needsAction("MATRIX_VECTOR_PRODUCT");
 }
 
 AtomicSMAC::AtomicSMAC(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Create the matrices
-  std::string sw_input; parse("SWITCH",sw_input);
-  std::string sp_lab, sp_laba; parse("SPECIES",sp_lab); parse("SPECIESA",sp_laba);
+  std::string sw_input;
+  parse("SWITCH",sw_input);
+  std::string sp_lab, sp_laba;
+  parse("SPECIES",sp_lab);
+  parse("SPECIESA",sp_laba);
   std::string cmap_input = getShortcutLabel() + "_cmap: CONTACT_MATRIX";
   if( sp_lab.length()>0 ) {
     readInputLine( getShortcutLabel() + "_cmap: CONTACT_MATRIX GROUP=" + sp_lab + " COMPONENTS SWITCH={" + sw_input + "}");
   } else if( sp_laba.length()>0 ) {
-    std::string sp_labb; parse("SPECIESB",sp_labb);
+    std::string sp_labb;
+    parse("SPECIESB",sp_labb);
     readInputLine( getShortcutLabel() + "_cmap: CONTACT_MATRIX GROUPA=" + sp_laba + " GROUPB=" + sp_labb + " COMPONENTS SWITCH={" + sw_input + "}");
   }
   // Now need the Gaussians
   std::string mykernels;
   for(unsigned i=1;; ++i) {
-    std::string kstr_inpt, istr, kern_str; Tools::convert( i, istr );
-    if( !parseNumbered("KERNEL",i,kstr_inpt ) ) { break; }
+    std::string kstr_inpt, istr, kern_str;
+    Tools::convert( i, istr );
+    if( !parseNumbered("KERNEL",i,kstr_inpt ) ) {
+      break;
+    }
     std::vector<std::string> words = Tools::getWords(kstr_inpt);
-    if( words[0]=="GAUSSIAN" ) kern_str="gaussian";
-    else error("unknown kernel type");
-    std::string center, var; Tools::parse(words,"CENTER",center); Tools::parse(words,"SIGMA",var);
-    if( mykernels.length()==0 ) mykernels = "exp(-(ajik-" + center + ")^2/(2*" + var + "*" + var + "))";
-    else mykernels = mykernels + "+exp(-(ajik-" + center + ")^2/(2*" + var + "*" + var + "))";
+    if( words[0]=="GAUSSIAN" ) {
+      kern_str="gaussian";
+    } else {
+      error("unknown kernel type");
+    }
+    std::string center, var;
+    Tools::parse(words,"CENTER",center);
+    Tools::parse(words,"SIGMA",var);
+    if( mykernels.length()==0 ) {
+      mykernels = "exp(-(ajik-" + center + ")^2/(2*" + var + "*" + var + "))";
+    } else {
+      mykernels = mykernels + "+exp(-(ajik-" + center + ")^2/(2*" + var + "*" + var + "))";
+    }
   }
   // Hard coded switching function on minimum distance here -- should be improved
   readInputLine( getShortcutLabel() + "_ksum: GSYMFUNC_THREEBODY WEIGHT=" + getShortcutLabel() + "_cmap.w " +
@@ -95,11 +111,13 @@ AtomicSMAC::AtomicSMAC(const ActionOptions& ao):
   // And just the sum of the coordination numbers
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_cmap");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   readInputLine( getShortcutLabel() + "_denom: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_cmap.w," + getShortcutLabel() + "_ones");
   // And the transformed switching functions
-  std::string swcoord_str; parse("SWITCH_COORD",swcoord_str);
+  std::string swcoord_str;
+  parse("SWITCH_COORD",swcoord_str);
   readInputLine( getShortcutLabel() + "_mtdenom: MORE_THAN ARG=" + getShortcutLabel() + "_denom SWITCH={" + swcoord_str +"}");
   // And matheval to get the final quantity
   readInputLine( getShortcutLabel() + "_smac: CUSTOM ARG=" + getShortcutLabel() + "_ksum.n," + getShortcutLabel() + "_mtdenom," + getShortcutLabel() + "_ksum.d FUNC=x*y/z PERIODIC=NO");
diff --git a/src/symfunc/CoordShellVectorFunction.cpp b/src/symfunc/CoordShellVectorFunction.cpp
index 8c0d92ef6c..684dd292d1 100644
--- a/src/symfunc/CoordShellVectorFunction.cpp
+++ b/src/symfunc/CoordShellVectorFunction.cpp
@@ -152,23 +152,37 @@ void CoordShellVectorFunction::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","PSI","0.0","The Euler rotational angle psi");
   keys.add("compulsory","ALPHA","3.0","The alpha parameter of the angular function that is used for FCCUBIC");
   keys.addFlag("LOWMEM",false,"this flag does nothing and is present only to ensure back-compatibility");
-  keys.needsAction("CONTACT_MATRIX"); keys.needsAction("FCCUBIC_FUNC"); keys.needsAction("CUSTOM");
-  keys.needsAction("ONES"); keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("CONTACT_MATRIX");
+  keys.needsAction("FCCUBIC_FUNC");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("ONES");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
 }
 
 CoordShellVectorFunction::CoordShellVectorFunction(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string matlab, sp_str, specA, specB; bool lowmem; parseFlag("LOWMEM",lowmem);
-  if( lowmem ) warning("LOWMEM flag is deprecated and is no longer required for this action");
-  parse("SPECIES",sp_str); parse("SPECIESA",specA); parse("SPECIESB",specB);
+  ActionShortcut(ao) {
+  std::string matlab, sp_str, specA, specB;
+  bool lowmem;
+  parseFlag("LOWMEM",lowmem);
+  if( lowmem ) {
+    warning("LOWMEM flag is deprecated and is no longer required for this action");
+  }
+  parse("SPECIES",sp_str);
+  parse("SPECIESA",specA);
+  parse("SPECIESB",specB);
   if( sp_str.length()>0 || specA.length()>0 ) {
     matlab = getShortcutLabel() + "_mat";
     CoordinationNumbers::expandMatrix( true, getShortcutLabel(),  sp_str, specA, specB, this );
-  } else error("found no input atoms use SPECIES/SPECIESA");
-  double phi, theta, psi; parse("PHI",phi); parse("THETA",theta); parse("PSI",psi);
-  std::vector<std::string> rotelements(9); std::string xvec = matlab + ".x", yvec = matlab + ".y", zvec = matlab + ".z";
+  } else {
+    error("found no input atoms use SPECIES/SPECIESA");
+  }
+  double phi, theta, psi;
+  parse("PHI",phi);
+  parse("THETA",theta);
+  parse("PSI",psi);
+  std::vector<std::string> rotelements(9);
+  std::string xvec = matlab + ".x", yvec = matlab + ".y", zvec = matlab + ".z";
   if( phi!=0 || theta!=0 || psi!=0 ) {
     Tools::convert( std::cos(psi)*std::cos(phi)-std::cos(theta)*std::sin(phi)*std::sin(psi), rotelements[0] );
     Tools::convert( std::cos(psi)*std::sin(phi)+std::cos(theta)*std::cos(phi)*std::sin(psi), rotelements[1] );
@@ -187,7 +201,8 @@ CoordShellVectorFunction::CoordShellVectorFunction(const ActionOptions& ao):
   }
   // Calculate FCC cubic function from bond vectors
   if( getName()=="FCCUBIC" ) {
-    std::string alpha; parse("ALPHA",alpha);
+    std::string alpha;
+    parse("ALPHA",alpha);
     readInputLine( getShortcutLabel() + "_vfunc: FCCUBIC_FUNC ARG=" + xvec + "," + yvec + "," + zvec+ " ALPHA=" + alpha);
   } else if( getName()=="TETRAHEDRAL" ) {
     readInputLine( getShortcutLabel() + "_r: CUSTOM ARG=" + xvec + "," + yvec + "," + zvec + " PERIODIC=NO FUNC=sqrt(x*x+y*y+z*z)");
@@ -198,18 +213,22 @@ CoordShellVectorFunction::CoordShellVectorFunction(const ActionOptions& ao):
     readInputLine( getShortcutLabel() + "_vfunc: CUSTOM ARG=" + xvec + "," + yvec + "," + zvec + "," + getShortcutLabel() + "_r"
                    + " VAR=x,y,z,r PERIODIC=NO FUNC=(x^4+y^4+z^4)/(r^4)" );
   } else {
-    std::string myfunc; parse("FUNCTION",myfunc);
+    std::string myfunc;
+    parse("FUNCTION",myfunc);
     if( myfunc.find("r")!=std::string::npos ) {
       readInputLine( getShortcutLabel() + "_r: CUSTOM ARG=" + xvec + "," + yvec + "," + zvec + " PERIODIC=NO FUNC=sqrt(x*x+y*y+z*z)");
       readInputLine( getShortcutLabel() + "_vfunc: CUSTOM ARG=" + xvec + "," + yvec + "," + zvec + "," + getShortcutLabel() + "_r VAR=x,y,z,r PERIODIC=NO FUNC=" + myfunc );
-    } else readInputLine( getShortcutLabel() + "_vfunc: CUSTOM ARG=" + xvec + "," + yvec + "," + zvec + " PERIODIC=NO FUNC=" + myfunc );
+    } else {
+      readInputLine( getShortcutLabel() + "_vfunc: CUSTOM ARG=" + xvec + "," + yvec + "," + zvec + " PERIODIC=NO FUNC=" + myfunc );
+    }
   }
   // Hadamard product of function above and weights
   readInputLine( getShortcutLabel() + "_wvfunc: CUSTOM ARG=" + getShortcutLabel() + "_vfunc," + matlab + ".w FUNC=x*y PERIODIC=NO");
   // And coordination numbers
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_mat");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   readInputLine( getShortcutLabel() + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_wvfunc," + getShortcutLabel() + "_ones");
   std::string olab=getShortcutLabel();
@@ -221,7 +240,8 @@ CoordShellVectorFunction::CoordShellVectorFunction(const ActionOptions& ao):
     readInputLine( getShortcutLabel() + "_n: CUSTOM ARG=" + getShortcutLabel() + "," + getShortcutLabel() + "_denom FUNC=x/y PERIODIC=NO");
   }
   // And expand the functions
-  std::map<std::string,std::string> keymap; multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
+  std::map<std::string,std::string> keymap;
+  multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
   multicolvar::MultiColvarShortcuts::expandFunctions( getShortcutLabel(), olab, "", keymap, this );
 }
 
diff --git a/src/symfunc/CoordinationNumbers.cpp b/src/symfunc/CoordinationNumbers.cpp
index 39271e71e2..abc1497958 100644
--- a/src/symfunc/CoordinationNumbers.cpp
+++ b/src/symfunc/CoordinationNumbers.cpp
@@ -111,12 +111,15 @@ void CoordinationNumbers::shortcutKeywords( Keywords& keys ) {
   keys.add("compulsory","R_0","The r_0 parameter of the switching function");
   keys.add("optional","SWITCH","the switching function that it used in the construction of the contact matrix");
   multicolvar::MultiColvarShortcuts::shortcutKeywords( keys );
-  keys.needsAction("CONTACT_MATRIX"); keys.needsAction("GROUP");
+  keys.needsAction("CONTACT_MATRIX");
+  keys.needsAction("GROUP");
 }
 
 void CoordinationNumbers::expandMatrix( const bool& components, const std::string& lab, const std::string& sp_str,
                                         const std::string& spa_str, const std::string& spb_str, ActionShortcut* action ) {
-  if( sp_str.length()==0 && spa_str.length()==0 ) return;
+  if( sp_str.length()==0 && spa_str.length()==0 ) {
+    return;
+  }
 
   std::string matinp = lab  + "_mat: CONTACT_MATRIX";
   if( sp_str.length()>0 ) {
@@ -127,16 +130,27 @@ void CoordinationNumbers::expandMatrix( const bool& components, const std::strin
     action->readInputLine( lab + "_grp: GROUP ATOMS=" + spa_str );
   }
 
-  std::string sw_str; action->parse("SWITCH",sw_str);
+  std::string sw_str;
+  action->parse("SWITCH",sw_str);
   if( sw_str.length()>0 ) {
     matinp += " SWITCH={" + sw_str + "}";
   } else {
-    std::string r0; action->parse("R_0",r0); std::string d0; action->parse("D_0",d0);
-    if( r0.length()==0 ) action->error("missing switching function parameters use SWITCH/R_0");
-    std::string nn; action->parse("NN",nn); std::string mm; action->parse("MM",mm);
+    std::string r0;
+    action->parse("R_0",r0);
+    std::string d0;
+    action->parse("D_0",d0);
+    if( r0.length()==0 ) {
+      action->error("missing switching function parameters use SWITCH/R_0");
+    }
+    std::string nn;
+    action->parse("NN",nn);
+    std::string mm;
+    action->parse("MM",mm);
     matinp += " R_0=" + r0 + " D_0=" + d0 + " NN=" + nn + " MM=" + mm;
   }
-  if( components ) matinp += " COMPONENTS";
+  if( components ) {
+    matinp += " COMPONENTS";
+  }
   action->readInputLine( matinp );
 }
 
@@ -146,47 +160,68 @@ void CoordinationNumbers::registerKeywords( Keywords& keys ) {
   keys.addFlag("LOWMEM",false,"this flag does nothing and is present only to ensure back-compatibility");
   keys.add("optional","MOMENTS","the list of moments that you would like to calculate");
   keys.addOutputComponent("moment","MOMENTS","the moments of the distribution");
-  keys.needsAction("MATRIX_VECTOR_PRODUCT"); keys.needsAction("ONES"); keys.needsAction("MOMENTS");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("ONES");
+  keys.needsAction("MOMENTS");
 }
 
 CoordinationNumbers::CoordinationNumbers(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  bool lowmem; parseFlag("LOWMEM",lowmem);
-  if( lowmem ) warning("LOWMEM flag is deprecated and is no longer required for this action");
+  ActionShortcut(ao) {
+  bool lowmem;
+  parseFlag("LOWMEM",lowmem);
+  if( lowmem ) {
+    warning("LOWMEM flag is deprecated and is no longer required for this action");
+  }
   // Setup the contract matrix if that is what is needed
   std::string matlab, sp_str, specA, specB;
-  parse("SPECIES",sp_str); parse("SPECIESA",specA); parse("SPECIESB",specB);
+  parse("SPECIES",sp_str);
+  parse("SPECIESA",specA);
+  parse("SPECIESB",specB);
   if( sp_str.length()>0 || specA.length()>0 ) {
-    matlab = getShortcutLabel() + "_mat"; bool comp=false;
-    if( getName()=="COORDINATION_MOMENTS" ) { comp=true; matlab = getShortcutLabel() + "_mat"; }
+    matlab = getShortcutLabel() + "_mat";
+    bool comp=false;
+    if( getName()=="COORDINATION_MOMENTS" ) {
+      comp=true;
+      matlab = getShortcutLabel() + "_mat";
+    }
     expandMatrix( comp, getShortcutLabel(), sp_str, specA, specB, this );
-  } else error("missing atoms input use SPECIES or SPECIESA/SPECIESB");
+  } else {
+    error("missing atoms input use SPECIES or SPECIESA/SPECIESB");
+  }
   ActionWithValue* mb=plumed.getActionSet().selectWithLabel<ActionWithValue*>( matlab );
-  if( !mb ) error("could not find action with name " + matlab );
+  if( !mb ) {
+    error("could not find action with name " + matlab );
+  }
   Value*  arg=mb->copyOutput(0);
-  if( arg->getRank()!=2 || arg->hasDerivatives() ) error("the input to this action should be a matrix or scalar");
+  if( arg->getRank()!=2 || arg->hasDerivatives() ) {
+    error("the input to this action should be a matrix or scalar");
+  }
   // Create vector of ones to multiply input matrix by
-  std::string nones; Tools::convert( arg->getShape()[1], nones );
+  std::string nones;
+  Tools::convert( arg->getShape()[1], nones );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + nones );
   if( getName()=="COORDINATION_MOMENTS" ) {
     // Calculate the lengths of the vectors
-    std::string r_power; parse("R_POWER",r_power);
+    std::string r_power;
+    parse("R_POWER",r_power);
     readInputLine( getShortcutLabel() + "_pow: CUSTOM ARG=" + matlab + ".x," + matlab + ".y," + matlab + ".z," + matlab + ".w VAR=x,y,z,w "
                    + "PERIODIC=NO FUNC=w*(sqrt(x*x+y*y+z*z)^" + r_power +")");
     matlab = getShortcutLabel() + "_pow";
   }
   // Calcualte coordination numbers as matrix vector times vector of ones
   readInputLine( getShortcutLabel() + ": MATRIX_VECTOR_PRODUCT  ARG=" + matlab + "," + getShortcutLabel() + "_ones");
-  std::vector<std::string> moments; parseVector("MOMENTS",moments); Tools::interpretRanges( moments );
+  std::vector<std::string> moments;
+  parseVector("MOMENTS",moments);
+  Tools::interpretRanges( moments );
   readInputLine( getShortcutLabel() + "_caverage: MEAN ARG=" + getShortcutLabel() + " PERIODIC=NO");
   for(unsigned i=0; i<moments.size(); ++i) {
     readInputLine( getShortcutLabel() + "_diffpow-" + moments[i] + ": CUSTOM ARG=" + getShortcutLabel() + "," + getShortcutLabel() + "_caverage PERIODIC=NO FUNC=(x-y)^" + moments[i] );
     readInputLine( getShortcutLabel() + "_moment-" + moments[i] + ": MEAN ARG=" + getShortcutLabel() + "_diffpow-" + moments[i] + " PERIODIC=NO");
   }
   // Read in all the shortcut stuff
-  std::map<std::string,std::string> keymap; multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
+  std::map<std::string,std::string> keymap;
+  multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
   multicolvar::MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel(), "", keymap, this );
 }
 
diff --git a/src/symfunc/CylindricalHarmonic.cpp b/src/symfunc/CylindricalHarmonic.cpp
index 727f4cbcc6..ea5cd5b471 100644
--- a/src/symfunc/CylindricalHarmonic.cpp
+++ b/src/symfunc/CylindricalHarmonic.cpp
@@ -74,22 +74,39 @@ void CylindricalHarmonic::registerKeywords( Keywords& keys ) {
 void CylindricalHarmonic::read( ActionWithArguments* action ) {
   parse(action,"DEGREE",tmom);
   action->log.printf("  calculating %dth order cylindrical harmonic with %s and %s as input \n", tmom, action->getPntrToArgument(0)->getName().c_str(), action->getPntrToArgument(1)->getName().c_str() );
-  if( action->getNumberOfArguments()==3 ) action->log.printf("  multiplying cylindrical harmonic by weight from %s \n", action->getPntrToArgument(2)->getName().c_str() );
+  if( action->getNumberOfArguments()==3 ) {
+    action->log.printf("  multiplying cylindrical harmonic by weight from %s \n", action->getPntrToArgument(2)->getName().c_str() );
+  }
 }
 
 void CylindricalHarmonic::setPeriodicityForOutputs( ActionWithValue* action ) {
-  action->componentIsNotPeriodic("rm"); action->componentIsNotPeriodic("im");
+  action->componentIsNotPeriodic("rm");
+  action->componentIsNotPeriodic("im");
 }
 
 void CylindricalHarmonic::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
-  double dlen2 = args[0]*args[0] + args[1]*args[1]; double dlen = sqrt( dlen2 ); double dlen3 = dlen2*dlen;
-  std::complex<double> com1( args[0]/dlen,args[1]/dlen ); double weight=1; if( args.size()==3 ) weight=args[2];
-  std::complex<double> ppp = pow( com1, tmom-1 ), ii( 0, 1 ); double real_z = real( ppp*com1 ), imag_z = imag( ppp*com1 );
+  double dlen2 = args[0]*args[0] + args[1]*args[1];
+  double dlen = sqrt( dlen2 );
+  double dlen3 = dlen2*dlen;
+  std::complex<double> com1( args[0]/dlen,args[1]/dlen );
+  double weight=1;
+  if( args.size()==3 ) {
+    weight=args[2];
+  }
+  std::complex<double> ppp = pow( com1, tmom-1 ), ii( 0, 1 );
+  double real_z = real( ppp*com1 ), imag_z = imag( ppp*com1 );
   std::complex<double> dp_x = static_cast<double>(tmom)*ppp*( (1.0/dlen)-(args[0]*args[0])/dlen3-ii*(args[0]*args[1])/dlen3 );
   std::complex<double> dp_y = static_cast<double>(tmom)*ppp*( ii*(1.0/dlen)-(args[0]*args[1])/dlen3-ii*(args[1]*args[1])/dlen3 );
-  vals[0] = weight*real_z; derivatives(0,0) = weight*real(dp_x); derivatives(0,1) = weight*real(dp_y);
-  vals[1] = weight*imag_z; derivatives(1,0) = weight*imag(dp_x); derivatives(1,1) = weight*imag(dp_y);
-  if( args.size()==3 ) { derivatives(0,2) = real_z; derivatives(1,2) = imag_z; }
+  vals[0] = weight*real_z;
+  derivatives(0,0) = weight*real(dp_x);
+  derivatives(0,1) = weight*real(dp_y);
+  vals[1] = weight*imag_z;
+  derivatives(1,0) = weight*imag(dp_x);
+  derivatives(1,1) = weight*imag(dp_y);
+  if( args.size()==3 ) {
+    derivatives(0,2) = real_z;
+    derivatives(1,2) = imag_z;
+  }
 }
 
 }
diff --git a/src/symfunc/Fccubic.cpp b/src/symfunc/Fccubic.cpp
index b680e62a8d..b5f90ee048 100644
--- a/src/symfunc/Fccubic.cpp
+++ b/src/symfunc/Fccubic.cpp
@@ -112,7 +112,8 @@ void Fccubic::read( ActionWithArguments* action ) {
   // Scaling factors such that '1' corresponds to fcc lattice
   // and '0' corresponds to isotropic (liquid)
   parse(action,"ALPHA",alpha);
-  a1 = 80080. / (2717. + 16*alpha); b1 = 16.*(alpha-143)/(2717+16*alpha);
+  a1 = 80080. / (2717. + 16*alpha);
+  b1 = 16.*(alpha-143)/(2717+16*alpha);
   action->log.printf("  setting alpha paramter equal to %f \n",alpha);
 }
 
diff --git a/src/symfunc/HexaticParameter.cpp b/src/symfunc/HexaticParameter.cpp
index 904e4d4d8f..f2c021ad56 100644
--- a/src/symfunc/HexaticParameter.cpp
+++ b/src/symfunc/HexaticParameter.cpp
@@ -62,29 +62,39 @@ void HexacticParameter::registerKeywords( Keywords& keys ) {
   keys.addOutputComponent("_vmean","VMEAN","the norm of the mean vector");
   keys.addFlag("VSUM",false,"calculate the norm of the sum of all the vectors");
   keys.addOutputComponent("_vsum","VSUM","the norm of the mean vector");
-  keys.needsAction("CYLINDRICAL_HARMONIC_MATRIX"); keys.needsAction("ONES");
-  keys.needsAction("MATRIX_VECTOR_PRODUCT"); keys.needsAction("CUSTOM");
-  keys.needsAction("MEAN"); keys.needsAction("SUM"); keys.needsAction("COMBINE");
+  keys.needsAction("CYLINDRICAL_HARMONIC_MATRIX");
+  keys.needsAction("ONES");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("MEAN");
+  keys.needsAction("SUM");
+  keys.needsAction("COMBINE");
 }
 
 HexacticParameter::HexacticParameter( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string sp_str, specA, specB; parse("SPECIES",sp_str); parse("SPECIESA",specA); parse("SPECIESB",specB);
+  ActionShortcut(ao) {
+  std::string sp_str, specA, specB;
+  parse("SPECIES",sp_str);
+  parse("SPECIESA",specA);
+  parse("SPECIESB",specB);
   CoordinationNumbers::expandMatrix( true, getShortcutLabel(), sp_str, specA, specB, this );
-  std::string myplane; parse("PLANE",myplane);
+  std::string myplane;
+  parse("PLANE",myplane);
   if( myplane=="xy" ) {
     readInputLine( getShortcutLabel() + ": CYLINDRICAL_HARMONIC_MATRIX DEGREE=6 ARG=" + getShortcutLabel() + "_mat.x," + getShortcutLabel() + "_mat.y," + getShortcutLabel() + "_mat.w" );
   } else if( myplane=="xz" ) {
     readInputLine( getShortcutLabel() + ": CYLINDRICAL_HARMONIC_MATRIX DEGREE=6 ARG=" + getShortcutLabel() + "_mat.x," + getShortcutLabel() + "_mat.z," + getShortcutLabel() + "_mat.w" );
   } else if( myplane=="yz" ) {
     readInputLine( getShortcutLabel() + ": CYLINDRICAL_HARMONIC_MATRIX DEGREE=6 ARG=" + getShortcutLabel() + "_mat.y," + getShortcutLabel() + "_mat.z," + getShortcutLabel() + "_mat.w" );
-  } else error("invalid input for plane -- should be xy, xz or yz");
+  } else {
+    error("invalid input for plane -- should be xy, xz or yz");
+  }
   // And coordination number
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_mat");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   readInputLine( getShortcutLabel() + "_rm: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + ".rm," + getShortcutLabel() + "_ones");
   readInputLine( getShortcutLabel() + "_im: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + ".im," + getShortcutLabel() + "_ones");
@@ -96,7 +106,8 @@ HexacticParameter::HexacticParameter( const ActionOptions& ao):
   readInputLine( getShortcutLabel() + "_imn: CUSTOM ARG=" + getShortcutLabel() + "_im," + getShortcutLabel() + "_denom FUNC=x/y PERIODIC=NO");
 
   // If we are doing VMEAN determine sum of vector components
-  bool do_vmean; parseFlag("VMEAN",do_vmean);
+  bool do_vmean;
+  parseFlag("VMEAN",do_vmean);
   if( do_vmean ) {
     // Real part
     readInputLine( getShortcutLabel() + "_rms: MEAN ARG=" + getShortcutLabel() + "_rmn PERIODIC=NO");
@@ -105,7 +116,8 @@ HexacticParameter::HexacticParameter( const ActionOptions& ao):
     // Now calculate the total length of the vector
     createVectorNormInput( getShortcutLabel(), getShortcutLabel() + "_vmean", "ms" );
   }
-  bool do_vsum; parseFlag("VSUM",do_vsum);
+  bool do_vsum;
+  parseFlag("VSUM",do_vsum);
   if( do_vsum ) {
     // Real part
     readInputLine( getShortcutLabel() + "_rmz: SUM ARG=" + getShortcutLabel() + "_rmn PERIODIC=NO");
diff --git a/src/symfunc/LocalAverage.cpp b/src/symfunc/LocalAverage.cpp
index 6c52ff3f4e..7ca8e1b31f 100644
--- a/src/symfunc/LocalAverage.cpp
+++ b/src/symfunc/LocalAverage.cpp
@@ -98,30 +98,43 @@ PLUMED_REGISTER_ACTION(LocalAverage,"LOCAL_AVERAGE")
 
 void LocalAverage::registerKeywords( Keywords& keys ) {
   CoordinationNumbers::shortcutKeywords( keys );
-  keys.needsAction("ONES"); keys.needsAction("MATRIX_VECTOR_PRODUCT");
-  keys.needsAction("VSTACK"); keys.needsAction("CUSTOM"); keys.needsAction("OUTER_PRODUCT");
+  keys.needsAction("ONES");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("VSTACK");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("OUTER_PRODUCT");
 }
 
 LocalAverage::LocalAverage(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string sp_str, specA, specB; parse("SPECIES",sp_str); parse("SPECIESA",specA); parse("SPECIESB",specB);
+  ActionShortcut(ao) {
+  std::string sp_str, specA, specB;
+  parse("SPECIES",sp_str);
+  parse("SPECIESA",specA);
+  parse("SPECIESB",specB);
   CoordinationNumbers::expandMatrix( false, getShortcutLabel(), sp_str, specA, specB, this );
-  std::map<std::string,std::string> keymap; multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
-  if( sp_str.length()>0 ) specA=specB=sp_str;
+  std::map<std::string,std::string> keymap;
+  multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
+  if( sp_str.length()>0 ) {
+    specA=specB=sp_str;
+  }
   // Calculate the coordination numbers
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_mat");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   readInputLine( getShortcutLabel() + "_coord: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_mat," + getShortcutLabel() + "_ones" );
 
-  int l=-1; std::vector<ActionShortcut*> shortcuts=plumed.getActionSet().select<ActionShortcut*>();
+  int l=-1;
+  std::vector<ActionShortcut*> shortcuts=plumed.getActionSet().select<ActionShortcut*>();
   for(unsigned i=0; i<shortcuts.size(); ++i) {
     if( specA==shortcuts[i]->getShortcutLabel() ) {
       std::string sname = shortcuts[i]->getName();
-      if( sname=="Q1" || sname=="Q3" || sname=="Q4" || sname=="Q6" ) { Tools::convert( sname.substr(1), l ); break; }
+      if( sname=="Q1" || sname=="Q3" || sname=="Q4" || sname=="Q6" ) {
+        Tools::convert( sname.substr(1), l );
+        break;
+      }
     }
   }
 
@@ -135,14 +148,21 @@ LocalAverage::LocalAverage(const ActionOptions&ao):
       if( !plumed.getActionSet().selectWithLabel<ActionWithValue*>(specB + "_imn-" + num) ) {
         readInputLine( specB  + "_imn-" + num + ": CUSTOM ARG=" + specB + "_sp.im-" + num + "," + specB  + "_denom FUNC=x/y PERIODIC=NO");
       }
-      if( i==-l ) { vargs = "ARG=" + specB + "_rmn-" + num + "," + specB + "_imn-" + num; svargs = "ARG=" + getShortcutLabel() + "_prod." + specB + "_rmn-" + num + "," + getShortcutLabel() + "_prod." + specB + "_imn-" + num; }
-      else { vargs += "," +  specB + "_rmn-" + num + "," + specB + "_imn-" + num; svargs += "," + getShortcutLabel() + "_prod." + specB + "_rmn-" + num + "," + getShortcutLabel() + "_prod." + specB + "_imn-" + num; }
+      if( i==-l ) {
+        vargs = "ARG=" + specB + "_rmn-" + num + "," + specB + "_imn-" + num;
+        svargs = "ARG=" + getShortcutLabel() + "_prod." + specB + "_rmn-" + num + "," + getShortcutLabel() + "_prod." + specB + "_imn-" + num;
+      } else {
+        vargs += "," +  specB + "_rmn-" + num + "," + specB + "_imn-" + num;
+        svargs += "," + getShortcutLabel() + "_prod." + specB + "_rmn-" + num + "," + getShortcutLabel() + "_prod." + specB + "_imn-" + num;
+      }
       sargs += "," + specB + "_rmn-" + num + "," + specB  + "_imn-" + num;
     }
     readInputLine( getShortcutLabel() + "_vstack: VSTACK " + vargs );
     readInputLine( getShortcutLabel() + "_prod: MATRIX_VECTOR_PRODUCT " + sargs );
     readInputLine( getShortcutLabel() + "_vpstack: VSTACK " + svargs );
-    std::string twolplusone; Tools::convert( 2*(2*l+1), twolplusone ); readInputLine( getShortcutLabel() + "_lones: ONES SIZE=" + twolplusone );
+    std::string twolplusone;
+    Tools::convert( 2*(2*l+1), twolplusone );
+    readInputLine( getShortcutLabel() + "_lones: ONES SIZE=" + twolplusone );
     readInputLine( getShortcutLabel() + "_unorm: OUTER_PRODUCT ARG=" + getShortcutLabel() + "_coord," + getShortcutLabel() + "_lones" );
     readInputLine( getShortcutLabel() + "_av: CUSTOM ARG=" + getShortcutLabel() + "_vpstack," + getShortcutLabel() + "_vstack," + getShortcutLabel() + "_unorm FUNC=(x+y)/(1+z) PERIODIC=NO");
     readInputLine( getShortcutLabel() + "_av2: CUSTOM ARG=" + getShortcutLabel() + "_av FUNC=x*x PERIODIC=NO");
@@ -157,10 +177,12 @@ LocalAverage::LocalAverage(const ActionOptions&ao):
 
 std::string LocalAverage::getMomentumSymbol( const int& m ) const {
   if( m<0 ) {
-    std::string num; Tools::convert( -1*m, num );
+    std::string num;
+    Tools::convert( -1*m, num );
     return "n" + num;
   } else if( m>0 ) {
-    std::string num; Tools::convert( m, num );
+    std::string num;
+    Tools::convert( m, num );
     return "p" + num;
   }
   return "0";
diff --git a/src/symfunc/LocalCrystalinity.cpp b/src/symfunc/LocalCrystalinity.cpp
index a06d7b6433..88761a5d8f 100644
--- a/src/symfunc/LocalCrystalinity.cpp
+++ b/src/symfunc/LocalCrystalinity.cpp
@@ -54,29 +54,40 @@ PLUMED_REGISTER_ACTION(LocalCrystallinity,"LOCAL_CRYSTALINITY")
 void LocalCrystallinity::registerKeywords( Keywords& keys ) {
   CoordinationNumbers::shortcutKeywords( keys );
   keys.add("numbered","GVECTOR","the coefficients of the linear combinations to compute for the CV");
-  keys.needsAction("ONES"); keys.needsAction("MATRIX_VECTOR_PRODUCT");
-  keys.needsAction("COMBINE"); keys.needsAction("CUSTOM");
+  keys.needsAction("ONES");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CUSTOM");
 }
 
 LocalCrystallinity::LocalCrystallinity( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // This builds an adjacency matrix
-  std::string sp_str, specA, specB; parse("SPECIES",sp_str); parse("SPECIESA",specA); parse("SPECIESB",specB);
+  std::string sp_str, specA, specB;
+  parse("SPECIES",sp_str);
+  parse("SPECIESA",specA);
+  parse("SPECIESB",specB);
   CoordinationNumbers::expandMatrix( true, getShortcutLabel(), sp_str, specA, specB, this );
   // Input for denominator (coord)
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_mat");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   readInputLine( getShortcutLabel() + "_denom: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_mat.w," + getShortcutLabel() + "_ones");
   // Input for numerator
   std::string finput = "";
   for(unsigned i=1;; ++i) {
-    std::vector<std::string> gvec; std::string istr; Tools::convert( i, istr );
-    if( !parseNumberedVector("GVECTOR",i,gvec) ) { break; }
-    if( gvec.size()!=3 ) error("gvectors should have size 3");
+    std::vector<std::string> gvec;
+    std::string istr;
+    Tools::convert( i, istr );
+    if( !parseNumberedVector("GVECTOR",i,gvec) ) {
+      break;
+    }
+    if( gvec.size()!=3 ) {
+      error("gvectors should have size 3");
+    }
     // This is the dot product between the input gvector and the bond vector
     readInputLine( getShortcutLabel() + "_dot" + istr + ": COMBINE ARG=" + getShortcutLabel() + "_mat.x," + getShortcutLabel() + "_mat.y," + getShortcutLabel() + "_mat.z "
                    "PERIODIC=NO COEFFICIENTS=" + gvec[0] + "," + gvec[1] + "," + gvec[2] );
@@ -92,7 +103,9 @@ LocalCrystallinity::LocalCrystallinity( const ActionOptions& ao):
     // And work out the square modulus of this complex number
     readInputLine( getShortcutLabel() + "_" + istr + ": CUSTOM FUNC=x*x+y*y PERIODIC=NO ARG=" + getShortcutLabel() + "_cosmean" + istr + "," + getShortcutLabel() + "_sinmean" + istr);
     // These are all the kvectors that we are adding together in the final combine for the final CV
-    if( i>1 ) finput += ",";
+    if( i>1 ) {
+      finput += ",";
+    }
     finput += getShortcutLabel() + "_" + istr;
   }
   // This computes the final CV
diff --git a/src/symfunc/LocalSteinhardt.cpp b/src/symfunc/LocalSteinhardt.cpp
index 06e1800eb3..779f455696 100644
--- a/src/symfunc/LocalSteinhardt.cpp
+++ b/src/symfunc/LocalSteinhardt.cpp
@@ -293,25 +293,34 @@ void LocalSteinhardt::registerKeywords( Keywords& keys ) {
            "When this keyword is present you no longer need the NN, MM, D_0 and R_0 keywords.");
   keys.addFlag("LOWMEM",false,"this flag does nothing and is present only to ensure back-compatibility");
   multicolvar::MultiColvarShortcuts::shortcutKeywords( keys );
-  keys.needsAction("CONTACT_MATRIX"); keys.needsAction("MATRIX_PRODUCT"); keys.needsAction("GROUP");
-  keys.needsAction("ONES"); keys.needsAction("OUTER_PRODUCT"); keys.needsAction("VSTACK");
-  keys.needsAction("CONCATENATE"); keys.needsAction("CUSTOM"); keys.needsAction("TRANSPOSE");
+  keys.needsAction("CONTACT_MATRIX");
+  keys.needsAction("MATRIX_PRODUCT");
+  keys.needsAction("GROUP");
+  keys.needsAction("ONES");
+  keys.needsAction("OUTER_PRODUCT");
+  keys.needsAction("VSTACK");
+  keys.needsAction("CONCATENATE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("TRANSPOSE");
   keys.needsAction("MATRIX_VECTOR_PRODUCT");
 }
 
 std::string LocalSteinhardt::getSymbol( const int& m ) const {
   if( m<0 ) {
-    std::string num; Tools::convert( -1*m, num );
+    std::string num;
+    Tools::convert( -1*m, num );
     return "n" + num;
   } else if( m>0 ) {
-    std::string num; Tools::convert( m, num );
+    std::string num;
+    Tools::convert( m, num );
     return "p" + num;
   }
   return "0";
 }
 
 std::string LocalSteinhardt::getArgsForStack( const int& l, const std::string& sp_lab ) const {
-  std::string numstr; Tools::convert( l, numstr );
+  std::string numstr;
+  Tools::convert( l, numstr );
   std::string data_mat = " ARG=" + sp_lab + "_sp.rm-n" + numstr + "," + sp_lab + "_sp.im-n" + numstr;
   for(int i=-l+1; i<=l; ++i) {
     numstr = getSymbol( i );
@@ -322,18 +331,24 @@ std::string LocalSteinhardt::getArgsForStack( const int& l, const std::string& s
 
 LocalSteinhardt::LocalSteinhardt(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  bool lowmem; parseFlag("LOWMEM",lowmem);
-  if( lowmem ) warning("LOWMEM flag is deprecated and is no longer required for this action");
+  ActionShortcut(ao) {
+  bool lowmem;
+  parseFlag("LOWMEM",lowmem);
+  if( lowmem ) {
+    warning("LOWMEM flag is deprecated and is no longer required for this action");
+  }
   // Get the Q value
-  int l; Tools::convert( getName().substr(7), l);
+  int l;
+  Tools::convert( getName().substr(7), l);
   // Create a vector filled with ones
-  std::string twolplusone; Tools::convert( 2*(2*l+1), twolplusone );
+  std::string twolplusone;
+  Tools::convert( 2*(2*l+1), twolplusone );
   readInputLine( getShortcutLabel() + "_uvec: ONES SIZE=" + twolplusone );
   // Read in species keyword
-  std::string sp_str; parse("SPECIES",sp_str);
-  std::string spa_str; parse("SPECIESA",spa_str);
+  std::string sp_str;
+  parse("SPECIES",sp_str);
+  std::string spa_str;
+  parse("SPECIESA",spa_str);
   if( sp_str.length()>0 ) {
     // Create a group with these atoms
     readInputLine( getShortcutLabel() + "_grp: GROUP ATOMS=" + sp_str );
@@ -346,12 +361,15 @@ LocalSteinhardt::LocalSteinhardt(const ActionOptions& ao):
       readInputLine( getShortcutLabel() + "_uvecs: VSTACK" + getArgsForStack( l, sp_lab[0] ) );
     } else {
       std::string len_vec = getShortcutLabel() + "_mags: CONCATENATE ARG=" + sp_lab[0] + "_norm";
-      for(unsigned i=1; i<sp_lab.size(); ++i) len_vec += "," + sp_lab[i] + "_norm";
+      for(unsigned i=1; i<sp_lab.size(); ++i) {
+        len_vec += "," + sp_lab[i] + "_norm";
+      }
       // This is the vector that contains all the magnitudes
       readInputLine( len_vec );
       std::string concat_str = getShortcutLabel() + "_uvecs: CONCATENATE";
       for(unsigned i=0; i<sp_lab.size(); ++i) {
-        std::string snum; Tools::convert( i+1, snum );
+        std::string snum;
+        Tools::convert( i+1, snum );
         concat_str += " MATRIX" + snum + "1=" + getShortcutLabel() + "_uvecs" + snum;
         readInputLine( getShortcutLabel() + "_uvecs" + snum + ": VSTACK" + getArgsForStack( l, sp_lab[i] ) );
       }
@@ -364,14 +382,19 @@ LocalSteinhardt::LocalSteinhardt(const ActionOptions& ao):
     readInputLine( getShortcutLabel() + "_vecs: CUSTOM ARG=" + getShortcutLabel() + "_uvecs," + getShortcutLabel() + "_nmat FUNC=x/y PERIODIC=NO");
     // And transpose the matrix
     readInputLine( getShortcutLabel() + "_vecsT: TRANSPOSE ARG=" + getShortcutLabel() + "_vecs" );
-    std::string sw_str; parse("SWITCH",sw_str); readInputLine( getShortcutLabel() + "_cmap: CONTACT_MATRIX GROUP=" + sp_str + " SWITCH={" + sw_str + "}");
+    std::string sw_str;
+    parse("SWITCH",sw_str);
+    readInputLine( getShortcutLabel() + "_cmap: CONTACT_MATRIX GROUP=" + sp_str + " SWITCH={" + sw_str + "}");
     // And the matrix of dot products
     readInputLine( getShortcutLabel() + "_dpmat: MATRIX_PRODUCT ARG=" + getShortcutLabel() + "_vecs," + getShortcutLabel() + "_vecsT" );
   } else if( spa_str.length()>0 ) {
     // Create a group with these atoms
     readInputLine( getShortcutLabel() + "_grp: GROUP ATOMS=" + spa_str );
-    std::string spb_str; parse("SPECIESB",spb_str);
-    if( spb_str.length()==0 ) plumed_merror("need both SPECIESA and SPECIESB in input");
+    std::string spb_str;
+    parse("SPECIESB",spb_str);
+    if( spb_str.length()==0 ) {
+      plumed_merror("need both SPECIESA and SPECIESB in input");
+    }
     std::vector<std::string> sp_laba = Tools::getWords(spa_str, "\t\n ,");
     std::vector<std::string> sp_labb = Tools::getWords(spb_str, "\t\n ,");
     if( sp_laba.size()==1 ) {
@@ -381,12 +404,15 @@ LocalSteinhardt::LocalSteinhardt(const ActionOptions& ao):
       readInputLine( getShortcutLabel() + "_uvecsA: VSTACK" + getArgsForStack( l, sp_laba[0] ) );
     } else {
       std::string len_vec = getShortcutLabel() + "_magsA: CONCATENATE ARG=" + sp_laba[0] + "_norm";
-      for(unsigned i=1; i<sp_laba.size(); ++i) len_vec += "," + sp_laba[i] + "_norm";
+      for(unsigned i=1; i<sp_laba.size(); ++i) {
+        len_vec += "," + sp_laba[i] + "_norm";
+      }
       //  This is the vector that contains all the magnitudes
       readInputLine( len_vec );
       std::string concat_str = getShortcutLabel() + "_uvecsA: CONCATENATE";
       for(unsigned i=0; i<sp_laba.size(); ++i) {
-        std::string snum; Tools::convert( i+1, snum );
+        std::string snum;
+        Tools::convert( i+1, snum );
         concat_str += " MATRIX" + snum + "1=" + getShortcutLabel() + "_uvecsA" + snum;
         readInputLine( getShortcutLabel() + "_uvecsA" + snum + ": VSTACK" + getArgsForStack( l, sp_laba[i] ) );
       }
@@ -404,12 +430,15 @@ LocalSteinhardt::LocalSteinhardt(const ActionOptions& ao):
       readInputLine( getShortcutLabel() + "_uvecsB: TRANSPOSE ARG=" + getShortcutLabel() + "_uvecsBT");
     } else {
       std::string len_vec = getShortcutLabel() + "_magsB: CONCATENATE ARG=" +  sp_labb[0] + "_norm";
-      for(unsigned i=1; i<sp_labb.size(); ++i) len_vec += "," + sp_labb[i] + "_norm";
+      for(unsigned i=1; i<sp_labb.size(); ++i) {
+        len_vec += "," + sp_labb[i] + "_norm";
+      }
       //  This is the vector that contains all the magnitudes
       readInputLine( len_vec );
       std::string concat_str = getShortcutLabel() + "_uvecsB: CONCATENATE";
       for(unsigned i=0; i<sp_labb.size(); ++i) {
-        std::string snum; Tools::convert( i+1, snum );
+        std::string snum;
+        Tools::convert( i+1, snum );
         concat_str += " MATRIX1" + snum + "=" + getShortcutLabel() + "_uvecsB" + snum;
         readInputLine( getShortcutLabel() + "_uvecsBT" + snum + ": VSTACK" + getArgsForStack( l, sp_labb[i] ) );
         readInputLine( getShortcutLabel() + "_uvecsB" + snum + ": TRANSPOSE ARG=" + getShortcutLabel() + "_uvecsBT" + snum );
@@ -421,7 +450,9 @@ LocalSteinhardt::LocalSteinhardt(const ActionOptions& ao):
     }
     // Now normalise all the vectors by doing Hadammard "product" with normalising matrix
     readInputLine( getShortcutLabel() + "_vecsB: CUSTOM ARG=" + getShortcutLabel() + "_uvecsB," + getShortcutLabel() + "_nmatB FUNC=x/y PERIODIC=NO");
-    std::string sw_str; parse("SWITCH",sw_str); readInputLine( getShortcutLabel() + "_cmap: CONTACT_MATRIX GROUPA=" + spa_str + " GROUPB=" + spb_str + " SWITCH={" + sw_str + "}");
+    std::string sw_str;
+    parse("SWITCH",sw_str);
+    readInputLine( getShortcutLabel() + "_cmap: CONTACT_MATRIX GROUPA=" + spa_str + " GROUPB=" + spb_str + " SWITCH={" + sw_str + "}");
     readInputLine( getShortcutLabel() + "_dpmat: MATRIX_PRODUCT ARG=" + getShortcutLabel() + "_vecsA," + getShortcutLabel() + "_vecsB" );
   }
 
@@ -430,7 +461,8 @@ LocalSteinhardt::LocalSteinhardt(const ActionOptions& ao):
   // Now the sum of coordination numbers times the switching functions
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_cmap");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   readInputLine( getShortcutLabel() + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() +"_prod," + getShortcutLabel() +"_ones");
   // And just the sum of the coordination numbers
diff --git a/src/symfunc/RadialTetra.cpp b/src/symfunc/RadialTetra.cpp
index 8b7b386474..5b23ae7ae2 100644
--- a/src/symfunc/RadialTetra.cpp
+++ b/src/symfunc/RadialTetra.cpp
@@ -51,26 +51,43 @@ void RadialTetra::registerKeywords( Keywords& keys ) {
   CoordinationNumbers::shortcutKeywords( keys );
   keys.addFlag("NOPBC",false,"ignore the periodic boundary conditions when calculating distances");
   keys.add("compulsory","CUTOFF","-1","ignore distances that have a value larger than this cutoff");
-  keys.remove("NN"); keys.remove("MM"); keys.remove("D_0"); keys.remove("R_0"); keys.remove("SWITCH");
-  keys.needsAction("DISTANCE_MATRIX"); keys.needsAction("NEIGHBORS");
-  keys.needsAction("CUSTOM"); keys.needsAction("ONES");
+  keys.remove("NN");
+  keys.remove("MM");
+  keys.remove("D_0");
+  keys.remove("R_0");
+  keys.remove("SWITCH");
+  keys.needsAction("DISTANCE_MATRIX");
+  keys.needsAction("NEIGHBORS");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("ONES");
   keys.needsAction("MATRIX_VECTOR_PRODUCT");
 }
 
 RadialTetra::RadialTetra( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read species input and create the matrix
-  bool nopbc; parseFlag("NOPBC",nopbc);
-  std::string pbcstr=""; if( nopbc ) pbcstr = " NOPBC";
-  std::string sp_str, rcut; parse("SPECIES",sp_str); parse("CUTOFF",rcut);
+  bool nopbc;
+  parseFlag("NOPBC",nopbc);
+  std::string pbcstr="";
+  if( nopbc ) {
+    pbcstr = " NOPBC";
+  }
+  std::string sp_str, rcut;
+  parse("SPECIES",sp_str);
+  parse("CUTOFF",rcut);
   if( sp_str.length()>0 ) {
     readInputLine( getShortcutLabel() + "_mat: DISTANCE_MATRIX GROUP=" + sp_str + " CUTOFF=" + rcut + pbcstr );
   } else {
-    std::string specA, specB; parse("SPECIESA",specA); parse("SPECIESB",specB);
-    if( specA.length()==0 ) error("missing input atoms");
-    if( specB.length()==0 ) error("missing SPECIESB keyword");
+    std::string specA, specB;
+    parse("SPECIESA",specA);
+    parse("SPECIESB",specB);
+    if( specA.length()==0 ) {
+      error("missing input atoms");
+    }
+    if( specB.length()==0 ) {
+      error("missing SPECIESB keyword");
+    }
     readInputLine( getShortcutLabel() + "_mat: DISTANCE_MATRIX GROUPA=" + specA + " GROUPB=" + specB + " CUTOFF=" + rcut + pbcstr);
   }
   // Get the neighbors matrix
@@ -80,7 +97,8 @@ RadialTetra::RadialTetra( const ActionOptions& ao):
   //Now compute sum of four nearest distances
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_mat");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   readInputLine( getShortcutLabel() + "_sum4: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_near4," + getShortcutLabel() + "_ones");
   // Now compute squares of four nearest distance
@@ -93,7 +111,8 @@ RadialTetra::RadialTetra( const ActionOptions& ao):
   readInputLine( getShortcutLabel() + ": CUSTOM ARG=" + getShortcutLabel() + "_sum4," + getShortcutLabel() + "_sum4_2," + getShortcutLabel() + "_meanr " +
                  "FUNC=(1-(y-x*z)/(12*z*z)) PERIODIC=NO");
   // And get the things to do with the quantities we have computed
-  std::map<std::string,std::string> keymap; multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
+  std::map<std::string,std::string> keymap;
+  multicolvar::MultiColvarShortcuts::readShortcutKeywords( keymap, this );
   multicolvar::MultiColvarShortcuts::expandFunctions( getShortcutLabel(), getShortcutLabel(), "", keymap, this );
 }
 
diff --git a/src/symfunc/SMAC.cpp b/src/symfunc/SMAC.cpp
index f988afffb5..ee89f47282 100644
--- a/src/symfunc/SMAC.cpp
+++ b/src/symfunc/SMAC.cpp
@@ -59,25 +59,34 @@ void SMAC::registerKeywords(Keywords& keys) {
   keys.add("optional","SWITCH_COORD","This keyword is used to define the coordination switching function.");
   keys.reset_style("KERNEL","optional");
   multicolvar::MultiColvarShortcuts::shortcutKeywords( keys );
-  keys.needsAction("VSTACK"); keys.needsAction("TRANSPOSE"); keys.needsAction("CONTACT_MATRIX");
-  keys.needsAction("TORSIONS_MATRIX"); keys.needsAction("COMBINE"); keys.needsAction("CUSTOM");
-  keys.needsAction("ONES"); keys.needsAction("MATRIX_VECTOR_PRODUCT"); keys.needsAction("MORE_THAN");
+  keys.needsAction("VSTACK");
+  keys.needsAction("TRANSPOSE");
+  keys.needsAction("CONTACT_MATRIX");
+  keys.needsAction("TORSIONS_MATRIX");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("ONES");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("MORE_THAN");
 }
 
 SMAC::SMAC(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Create the matrices
-  std::string sw_input; parse("SWITCH",sw_input);
-  std::string sp_lab, sp_laba; parse("SPECIES",sp_lab); parse("SPECIESA",sp_laba);
+  std::string sw_input;
+  parse("SWITCH",sw_input);
+  std::string sp_lab, sp_laba;
+  parse("SPECIES",sp_lab);
+  parse("SPECIESA",sp_laba);
   if( sp_lab.length()>0 ) {
     readInputLine( getShortcutLabel() + "_vecs: VSTACK ARG=" + sp_lab + ".x," + sp_lab + ".y," + sp_lab + ".z" );
     readInputLine( getShortcutLabel() + "_vecsT: TRANSPOSE ARG=" + getShortcutLabel() + "_vecs" );
     readInputLine( getShortcutLabel() + "_cmap: CONTACT_MATRIX GROUP=" + sp_lab + " SWITCH={" + sw_input + "}");
     readInputLine( getShortcutLabel() + "_tpmat: TORSIONS_MATRIX ARG=" + getShortcutLabel() + "_vecs," + getShortcutLabel() + "_vecsT POSITIONS1=" + sp_lab + " POSITIONS2=" + sp_lab );
   } else if( sp_laba.length()>0 ) {
-    std::string sp_labb; parse("SPECIESB",sp_labb);
+    std::string sp_labb;
+    parse("SPECIESB",sp_labb);
     readInputLine( getShortcutLabel() + "_vecsa: VSTACK ARG=" + sp_laba + ".x," + sp_laba + ".y," + sp_laba + ".z" );
     readInputLine( getShortcutLabel() + "_vecsb: VSTACK ARG=" + sp_labb + ".x," + sp_labb + ".y," + sp_labb + ".z" );
     readInputLine( getShortcutLabel() + "_vecsbT: TRANSPOSE ARG=" + getShortcutLabel() + "_vecsb" );
@@ -87,17 +96,32 @@ SMAC::SMAC(const ActionOptions& ao):
   // Now need the Gaussians
   std::string kmap_input= getShortcutLabel() + "_ksum: COMBINE PERIODIC=NO";
   for(unsigned i=1;; ++i) {
-    std::string kstr_inpt, istr; Tools::convert( i, istr );
-    if( !parseNumbered("KERNEL",i,kstr_inpt ) ) { break; }
+    std::string kstr_inpt, istr;
+    Tools::convert( i, istr );
+    if( !parseNumbered("KERNEL",i,kstr_inpt ) ) {
+      break;
+    }
     std::vector<std::string> words = Tools::getWords(kstr_inpt);
-    std::string center, var; Tools::parse(words,"CENTER",center); Tools::parse(words,"SIGMA",var);
-    double nsig; Tools::convert( var, nsig ); std::string coeff; Tools::convert( 1/(nsig*nsig), coeff );
+    std::string center, var;
+    Tools::parse(words,"CENTER",center);
+    Tools::parse(words,"SIGMA",var);
+    double nsig;
+    Tools::convert( var, nsig );
+    std::string coeff;
+    Tools::convert( 1/(nsig*nsig), coeff );
     readInputLine( getShortcutLabel() + "_kf" + istr + "_r2: COMBINE PERIODIC=NO ARG=" + getShortcutLabel() + "_tpmat COEFFICIENTS=" + coeff + " PARAMETERS=" + center + " POWERS=2");
-    if( words[0]=="GAUSSIAN" ) readInputLine( getShortcutLabel() + "_kf" + istr + ": CUSTOM PERIODIC=NO FUNC=exp(-x/2) ARG=" +  getShortcutLabel() + "_kf" + istr + "_r2" );
-    else if( words[0]=="TRIANGULAR" ) readInputLine( getShortcutLabel() + "_kf" + istr + ": CUSTOM PERIODIC=NO FUNC=step(1-sqrt(x))*(1-sqrt(x)) ARG=" + getShortcutLabel() + "_kf" + istr + "_r2" );
-    else readInputLine( getShortcutLabel() + "_kf" + istr + ": CUSTOM PERIODIC=NO FUNC=" + words[0] + " ARG=" + getShortcutLabel() + "_kf" + istr + "_r2" );
-    if( i==1 ) kmap_input += " ARG=" + getShortcutLabel() + "_kf" + istr;
-    else kmap_input += "," + getShortcutLabel() + "_kf" + istr;
+    if( words[0]=="GAUSSIAN" ) {
+      readInputLine( getShortcutLabel() + "_kf" + istr + ": CUSTOM PERIODIC=NO FUNC=exp(-x/2) ARG=" +  getShortcutLabel() + "_kf" + istr + "_r2" );
+    } else if( words[0]=="TRIANGULAR" ) {
+      readInputLine( getShortcutLabel() + "_kf" + istr + ": CUSTOM PERIODIC=NO FUNC=step(1-sqrt(x))*(1-sqrt(x)) ARG=" + getShortcutLabel() + "_kf" + istr + "_r2" );
+    } else {
+      readInputLine( getShortcutLabel() + "_kf" + istr + ": CUSTOM PERIODIC=NO FUNC=" + words[0] + " ARG=" + getShortcutLabel() + "_kf" + istr + "_r2" );
+    }
+    if( i==1 ) {
+      kmap_input += " ARG=" + getShortcutLabel() + "_kf" + istr;
+    } else {
+      kmap_input += "," + getShortcutLabel() + "_kf" + istr;
+    }
   }
   readInputLine( kmap_input );
   // Now create the product matrix
@@ -105,13 +129,15 @@ SMAC::SMAC(const ActionOptions& ao):
   // Now the sum of coordination numbers times the switching functions
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_cmap");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_ones: ONES SIZE=" + size );
   readInputLine( getShortcutLabel() + ": MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_prod," + getShortcutLabel() + "_ones");
   // And just the sum of the coordination numbers
   readInputLine( getShortcutLabel() + "_denom: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_cmap," + getShortcutLabel() + "_ones");
   // And the transformed switching functions
-  std::string swcoord_str; parse("SWITCH_COORD",swcoord_str);
+  std::string swcoord_str;
+  parse("SWITCH_COORD",swcoord_str);
   readInputLine( getShortcutLabel() + "_mtdenom: MORE_THAN ARG=" + getShortcutLabel() + "_denom SWITCH={" + swcoord_str +"}");
 // And matheval to get the final quantity
   readInputLine( getShortcutLabel() + "_smac: CUSTOM ARG=" + getShortcutLabel() + "," + getShortcutLabel() + "_mtdenom," + getShortcutLabel() + "_denom FUNC=(x*y)/z PERIODIC=NO");
diff --git a/src/symfunc/SphericalHarmonic.cpp b/src/symfunc/SphericalHarmonic.cpp
index 019ca7a12e..1dfac76468 100644
--- a/src/symfunc/SphericalHarmonic.cpp
+++ b/src/symfunc/SphericalHarmonic.cpp
@@ -83,41 +83,57 @@ unsigned SphericalHarmonic::factorial( const unsigned& n ) const {
 void SphericalHarmonic::read( ActionWithArguments* action ) {
   parse(action,"L",tmom);
   action->log.printf("  calculating %dth order spherical harmonic with %s, %s and %s as input \n", tmom, action->getPntrToArgument(0)->getName().c_str(), action->getPntrToArgument(1)->getName().c_str(), action->getPntrToArgument(2)->getName().c_str() );
-  if( action->getNumberOfArguments()==4 ) action->log.printf("  multiplying cylindrical harmonic by weight from %s \n", action->getPntrToArgument(3)->getName().c_str() );
+  if( action->getNumberOfArguments()==4 ) {
+    action->log.printf("  multiplying cylindrical harmonic by weight from %s \n", action->getPntrToArgument(3)->getName().c_str() );
+  }
 
   normaliz.resize( tmom+1 );
   for(unsigned i=0; i<=tmom; ++i) {
     normaliz[i] = sqrt( (2*tmom+1)*factorial(tmom-i)/(4*pi*factorial(tmom+i)) );
-    if( i%2==1 ) normaliz[i]*=-1;
+    if( i%2==1 ) {
+      normaliz[i]*=-1;
+    }
   }
 
   coeff_poly.resize( tmom+1 );
   if( tmom==1 ) {
     // Legendre polynomial coefficients of order one
-    coeff_poly[0]=0; coeff_poly[1]=1.0;
+    coeff_poly[0]=0;
+    coeff_poly[1]=1.0;
   } else if( tmom==2 ) {
     // Legendre polynomial coefficients of order two
-    coeff_poly[0]=-0.5; coeff_poly[1]=0.0;
+    coeff_poly[0]=-0.5;
+    coeff_poly[1]=0.0;
     coeff_poly[2]=1.5;
   } else if( tmom==3 ) {
     // Legendre polynomial coefficients of order three
-    coeff_poly[0]=0.0; coeff_poly[1]=-1.5;
-    coeff_poly[2]=0.0; coeff_poly[3]=2.5;
+    coeff_poly[0]=0.0;
+    coeff_poly[1]=-1.5;
+    coeff_poly[2]=0.0;
+    coeff_poly[3]=2.5;
   } else if( tmom==4 ) {
     // Legendre polynomial coefficients of order four
-    coeff_poly[0]=0.375; coeff_poly[1]=0.0;
-    coeff_poly[2]=-3.75; coeff_poly[3]=0.0;
+    coeff_poly[0]=0.375;
+    coeff_poly[1]=0.0;
+    coeff_poly[2]=-3.75;
+    coeff_poly[3]=0.0;
     coeff_poly[4]=4.375;
   } else if( tmom==5 ) {
     // Legendre polynomial coefficients of order five
-    coeff_poly[0]=0.0; coeff_poly[1]=1.875;
-    coeff_poly[2]=0.0; coeff_poly[3]=-8.75;
-    coeff_poly[4]=0.0; coeff_poly[5]=7.875;
+    coeff_poly[0]=0.0;
+    coeff_poly[1]=1.875;
+    coeff_poly[2]=0.0;
+    coeff_poly[3]=-8.75;
+    coeff_poly[4]=0.0;
+    coeff_poly[5]=7.875;
   } else if( tmom==6 ) {
     // Legendre polynomial coefficients of order six
-    coeff_poly[0]=-0.3125; coeff_poly[1]=0.0;
-    coeff_poly[2]=6.5625; coeff_poly[3]=0.0;
-    coeff_poly[4]=-19.6875; coeff_poly[5]=0.0;
+    coeff_poly[0]=-0.3125;
+    coeff_poly[1]=0.0;
+    coeff_poly[2]=6.5625;
+    coeff_poly[3]=0.0;
+    coeff_poly[4]=-19.6875;
+    coeff_poly[5]=0.0;
     coeff_poly[6]=14.4375;
   } else {
     action->error("Insert Legendre polynomial coefficients into SphericalHarmonics code");
@@ -125,27 +141,41 @@ void SphericalHarmonic::read( ActionWithArguments* action ) {
 }
 
 std::vector<std::string> SphericalHarmonic::getComponentsPerLabel() const {
-  std::vector<std::string> comp; std::string num;
+  std::vector<std::string> comp;
+  std::string num;
   for(int i=-tmom; i<=tmom; ++i) {
     Tools::convert(fabs(i),num);
-    if( i<0 ) comp.push_back( "-n" + num );
-    else if( i>0 ) comp.push_back( "-p" + num );
-    else comp.push_back( "-0");
+    if( i<0 ) {
+      comp.push_back( "-n" + num );
+    } else if( i>0 ) {
+      comp.push_back( "-p" + num );
+    } else {
+      comp.push_back( "-0");
+    }
   }
   return comp;
 }
 
 void SphericalHarmonic::setPeriodicityForOutputs( ActionWithValue* action ) {
   std::vector<std::string> comp( getComponentsPerLabel() );
-  for(unsigned i=0; i<comp.size(); ++i) { action->componentIsNotPeriodic("rm" + comp[i]); action->componentIsNotPeriodic("im" + comp[i]); }
+  for(unsigned i=0; i<comp.size(); ++i) {
+    action->componentIsNotPeriodic("rm" + comp[i]);
+    action->componentIsNotPeriodic("im" + comp[i]);
+  }
 }
 
 void SphericalHarmonic::calc( const ActionWithArguments* action, const std::vector<double>& args, std::vector<double>& vals, Matrix<double>& derivatives ) const {
-  double weight=1; if( args.size()==4 ) weight = args[3];
-  if( weight<epsilon ) return;
+  double weight=1;
+  if( args.size()==4 ) {
+    weight = args[3];
+  }
+  if( weight<epsilon ) {
+    return;
+  }
 
   double dlen2 = args[0]*args[0]+args[1]*args[1]+args[2]*args[2];
-  double dlen = sqrt( dlen2 ); double dlen3 = dlen2*dlen;
+  double dlen = sqrt( dlen2 );
+  double dlen3 = dlen2*dlen;
   double dpoly_ass, poly_ass=deriv_poly( 0, args[2]/dlen, dpoly_ass );
   // Derivatives of z/r wrt x, y, z
   Vector dz;
@@ -155,11 +185,14 @@ void SphericalHarmonic::calc( const ActionWithArguments* action, const std::vect
   // Accumulate for m=0
   vals[tmom] = weight*poly_ass;
   addVectorDerivatives( tmom, weight*dpoly_ass*dz, derivatives );
-  if( args.size()==4 ) derivatives(tmom, 3) = poly_ass;
+  if( args.size()==4 ) {
+    derivatives(tmom, 3) = poly_ass;
+  }
 
   // The complex number of which we have to take powers
   std::complex<double> com1( args[0]/dlen,args[1]/dlen ), dp_x, dp_y, dp_z;
-  std::complex<double> powered = std::complex<double>(1.0,0.0); std::complex<double> ii( 0.0, 1.0 );
+  std::complex<double> powered = std::complex<double>(1.0,0.0);
+  std::complex<double> ii( 0.0, 1.0 );
   Vector myrealvec, myimagvec, real_dz, imag_dz;
   // Do stuff for all other m values
   for(unsigned m=1; m<=tmom; ++m) {
@@ -179,8 +212,12 @@ void SphericalHarmonic::calc( const ActionWithArguments* action, const std::vect
     dp_z = md*powered*( -(args[0]*args[2])/dlen3-ii*(args[1]*args[2])/dlen3 );
 
     // Derivatives of real and imaginary parts of above
-    real_dz[0] = real( dp_x ); real_dz[1] = real( dp_y ); real_dz[2] = real( dp_z );
-    imag_dz[0] = imag( dp_x ); imag_dz[1] = imag( dp_y ); imag_dz[2] = imag( dp_z );
+    real_dz[0] = real( dp_x );
+    real_dz[1] = real( dp_y );
+    real_dz[2] = real( dp_z );
+    imag_dz[0] = imag( dp_x );
+    imag_dz[1] = imag( dp_y );
+    imag_dz[2] = imag( dp_z );
 
     // Complete derivative of steinhardt parameter
     myrealvec = weight*dpoly_ass*real_z*dz + weight*poly_ass*real_dz;
@@ -203,8 +240,10 @@ void SphericalHarmonic::calc( const ActionWithArguments* action, const std::vect
     vals[3*tmom+1-m] = -pref*weight*itq6;
     addVectorDerivatives( 3*tmom+1-m, -pref*myimagvec, derivatives );
     if( args.size()==4 ) {
-      derivatives(tmom+m,3)=tq6; derivatives(3*tmom+1+m, 3)=itq6;
-      derivatives(tmom-m,3)=pref*tq6; derivatives(3*tmom+1-m, 3)=-pref*itq6;
+      derivatives(tmom+m,3)=tq6;
+      derivatives(3*tmom+1+m, 3)=itq6;
+      derivatives(tmom-m,3)=pref*tq6;
+      derivatives(3*tmom+1-m, 3)=-pref*itq6;
     }
     // Calculate next power of complex number
     powered *= com1;
@@ -213,23 +252,32 @@ void SphericalHarmonic::calc( const ActionWithArguments* action, const std::vect
 
 double SphericalHarmonic::deriv_poly( const unsigned& m, const double& val, double& df ) const {
   double fact=1.0;
-  for(unsigned j=1; j<=m; ++j) fact=fact*j;
+  for(unsigned j=1; j<=m; ++j) {
+    fact=fact*j;
+  }
   double res=coeff_poly[m]*fact;
 
-  double pow=1.0, xi=val, dxi=1.0; df=0.0;
+  double pow=1.0, xi=val, dxi=1.0;
+  df=0.0;
   for(int i=m+1; i<=tmom; ++i) {
     fact=1.0;
-    for(unsigned j=i-m+1; j<=i; ++j) fact=fact*j;
+    for(unsigned j=i-m+1; j<=i; ++j) {
+      fact=fact*j;
+    }
     res=res+coeff_poly[i]*fact*xi;
     df = df + pow*coeff_poly[i]*fact*dxi;
-    xi=xi*val; dxi=dxi*val; pow+=1.0;
+    xi=xi*val;
+    dxi=dxi*val;
+    pow+=1.0;
   }
   df = df*normaliz[m];
   return normaliz[m]*res;
 }
 
 void SphericalHarmonic::addVectorDerivatives( const unsigned& ival, const Vector& der, Matrix<double>& derivatives ) const {
-  for(unsigned j=0; j<3; ++j) derivatives(ival,j) = der[j];
+  for(unsigned j=0; j<3; ++j) {
+    derivatives(ival,j) = der[j];
+  }
 }
 
 }
diff --git a/src/symfunc/Steinhardt.cpp b/src/symfunc/Steinhardt.cpp
index 3366a0f634..3212718e31 100644
--- a/src/symfunc/Steinhardt.cpp
+++ b/src/symfunc/Steinhardt.cpp
@@ -284,28 +284,45 @@ void Steinhardt::registerKeywords( Keywords& keys ) {
   keys.addOutputComponent("_vmean","VMEAN","the norm of the mean vector");
   keys.addFlag("VSUM",false,"calculate the norm of the sum of all the vectors");
   keys.addOutputComponent("_vsum","VSUM","the norm of the mean vector");
-  keys.needsAction("GROUP"); keys.needsAction("CONTACT_MATRIX"); keys.needsAction("SPHERICAL_HARMONIC"); keys.needsAction("ONES");
-  keys.needsAction("MATRIX_VECTOR_PRODUCT"); keys.needsAction("COMBINE"); keys.needsAction("CUSTOM"); keys.needsAction("MEAN"); keys.needsAction("SUM");
+  keys.needsAction("GROUP");
+  keys.needsAction("CONTACT_MATRIX");
+  keys.needsAction("SPHERICAL_HARMONIC");
+  keys.needsAction("ONES");
+  keys.needsAction("MATRIX_VECTOR_PRODUCT");
+  keys.needsAction("COMBINE");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("MEAN");
+  keys.needsAction("SUM");
 }
 
 Steinhardt::Steinhardt( const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  bool lowmem; parseFlag("LOWMEM",lowmem);
-  if( lowmem ) warning("LOWMEM flag is deprecated and is no longer required for this action");
-  std::string sp_str, specA, specB; parse("SPECIES",sp_str); parse("SPECIESA",specA); parse("SPECIESB",specB);
-  CoordinationNumbers::expandMatrix( true, getShortcutLabel(), sp_str, specA, specB, this ); int l;
+  ActionShortcut(ao) {
+  bool lowmem;
+  parseFlag("LOWMEM",lowmem);
+  if( lowmem ) {
+    warning("LOWMEM flag is deprecated and is no longer required for this action");
+  }
+  std::string sp_str, specA, specB;
+  parse("SPECIES",sp_str);
+  parse("SPECIESA",specA);
+  parse("SPECIESB",specB);
+  CoordinationNumbers::expandMatrix( true, getShortcutLabel(), sp_str, specA, specB, this );
+  int l;
   std::string sph_input = getShortcutLabel() + "_sh: SPHERICAL_HARMONIC ARG=" + getShortcutLabel() + "_mat.x," + getShortcutLabel() + "_mat.y," + getShortcutLabel() + "_mat.z," + getShortcutLabel() + "_mat.w";
 
   if( getName()=="Q1" ) {
-    sph_input +=" L=1"; l=1;
+    sph_input +=" L=1";
+    l=1;
   } else if( getName()=="Q3" ) {
-    sph_input += " L=3"; l=3;
+    sph_input += " L=3";
+    l=3;
   } else if( getName()=="Q4" ) {
-    sph_input += " L=4"; l=4;
+    sph_input += " L=4";
+    l=4;
   } else if( getName()=="Q6" ) {
-    sph_input += " L=6"; l=6;
+    sph_input += " L=6";
+    l=6;
   } else {
     plumed_merror("invalid input");
   }
@@ -314,15 +331,18 @@ Steinhardt::Steinhardt( const ActionOptions& ao):
   // Input for denominator (coord)
   ActionWithValue* av = plumed.getActionSet().selectWithLabel<ActionWithValue*>( getShortcutLabel() + "_mat");
   plumed_assert( av && av->getNumberOfComponents()>0 && (av->copyOutput(0))->getRank()==2 );
-  std::string size; Tools::convert( (av->copyOutput(0))->getShape()[1], size );
+  std::string size;
+  Tools::convert( (av->copyOutput(0))->getShape()[1], size );
   readInputLine( getShortcutLabel() + "_denom_ones: ONES SIZE=" + size );
   readInputLine( getShortcutLabel() + "_denom: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_mat.w," + getShortcutLabel() + "_denom_ones" );
   readInputLine( getShortcutLabel() + "_sp: MATRIX_VECTOR_PRODUCT ARG=" + getShortcutLabel() + "_sh.*," + getShortcutLabel() + "_denom_ones");
 
   // If we are doing VMEAN determine sum of vector components
   std::string snum;
-  bool do_vmean; parseFlag("VMEAN",do_vmean);
-  bool do_vsum; parseFlag("VSUM",do_vsum);
+  bool do_vmean;
+  parseFlag("VMEAN",do_vmean);
+  bool do_vsum;
+  parseFlag("VSUM",do_vsum);
   if( do_vmean || do_vsum ) {
     // Divide all components by coordination numbers
     for(int i=-l; i<=l; ++i) {
@@ -365,7 +385,8 @@ Steinhardt::Steinhardt( const ActionOptions& ao):
 }
 
 void Steinhardt::createVectorNormInput( const std::string& ilab, const std::string& olab, const int& l, const std::string& sep, const std::string& vlab ) {
-  std::string arg_inp, norm_input = olab + "2: COMBINE PERIODIC=NO POWERS=2,2"; std::string snum = getSymbol( -l );
+  std::string arg_inp, norm_input = olab + "2: COMBINE PERIODIC=NO POWERS=2,2";
+  std::string snum = getSymbol( -l );
   arg_inp = " ARG=" + ilab + sep + "r" + vlab + "-" + snum +"," + ilab + sep + "i" + vlab + "-" + snum;
   for(int i=-l+1; i<=l; ++i) {
     snum = getSymbol( i );
@@ -378,10 +399,12 @@ void Steinhardt::createVectorNormInput( const std::string& ilab, const std::stri
 
 std::string Steinhardt::getSymbol( const int& m ) const {
   if( m<0 ) {
-    std::string num; Tools::convert( -1*m, num );
+    std::string num;
+    Tools::convert( -1*m, num );
     return "n" + num;
   } else if( m>0 ) {
-    std::string num; Tools::convert( m, num );
+    std::string num;
+    Tools::convert( m, num );
     return "p" + num;
   }
   return "0";
diff --git a/src/symfunc/ThreeBodyGFunctions.cpp b/src/symfunc/ThreeBodyGFunctions.cpp
index 9f6b3f52a0..10b38f6d05 100644
--- a/src/symfunc/ThreeBodyGFunctions.cpp
+++ b/src/symfunc/ThreeBodyGFunctions.cpp
@@ -51,7 +51,8 @@ class ThreeBodyGFunctions : public ActionWithVector {
 PLUMED_REGISTER_ACTION(ThreeBodyGFunctions,"GSYMFUNC_THREEBODY")
 
 void ThreeBodyGFunctions::registerKeywords( Keywords& keys ) {
-  ActionWithVector::registerKeywords( keys ); keys.use("ARG");
+  ActionWithVector::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("compulsory","WEIGHT","the matrix that contains the weights that should be used for each connection");
   keys.add("numbered","FUNCTION","the parameters of the function you would like to compute");
   ActionWithValue::useCustomisableComponents( keys );
@@ -59,39 +60,68 @@ void ThreeBodyGFunctions::registerKeywords( Keywords& keys ) {
 
 ThreeBodyGFunctions::ThreeBodyGFunctions(const ActionOptions&ao):
   Action(ao),
-  ActionWithVector(ao)
-{
-  if( getNumberOfArguments()!=3 ) error("found wrong number of arguments in input");
-  std::vector<Value*> wval; parseArgumentList("WEIGHT",wval);
-  if( wval.size()!=1 ) error("keyword WEIGHT should be provided with the label of a single action");
+  ActionWithVector(ao) {
+  if( getNumberOfArguments()!=3 ) {
+    error("found wrong number of arguments in input");
+  }
+  std::vector<Value*> wval;
+  parseArgumentList("WEIGHT",wval);
+  if( wval.size()!=1 ) {
+    error("keyword WEIGHT should be provided with the label of a single action");
+  }
 
   for(unsigned i=0; i<3; ++i) {
-    if( getPntrToArgument(i)->getRank()!=2 ) error("input argument should be a matrix");
-    if( wval[0]->getShape()[0]!=getPntrToArgument(i)->getShape()[0] || wval[0]->getShape()[1]!=getPntrToArgument(i)->getShape()[1] ) error("mismatched shapes of matrices in input");
+    if( getPntrToArgument(i)->getRank()!=2 ) {
+      error("input argument should be a matrix");
+    }
+    if( wval[0]->getShape()[0]!=getPntrToArgument(i)->getShape()[0] || wval[0]->getShape()[1]!=getPntrToArgument(i)->getShape()[1] ) {
+      error("mismatched shapes of matrices in input");
+    }
   }
   log.printf("  using bond weights from matrix labelled %s \n",wval[0]->getName().c_str() );
   // Rerequest the arguments
-  std::vector<Value*> myargs( getArguments() ); myargs.push_back( wval[0] ); requestArguments( myargs );
-  for(unsigned i=0; i<myargs.size(); ++i) myargs[i]->buildDataStore();
-  std::vector<unsigned> shape(1); shape[0] = getPntrToArgument(0)->getShape()[0];
+  std::vector<Value*> myargs( getArguments() );
+  myargs.push_back( wval[0] );
+  requestArguments( myargs );
+  for(unsigned i=0; i<myargs.size(); ++i) {
+    myargs[i]->buildDataStore();
+  }
+  std::vector<unsigned> shape(1);
+  shape[0] = getPntrToArgument(0)->getShape()[0];
 
   // And now read the functions to compute
   for(int i=1;; i++) {
-    std::string myfunc, mystr, lab, num; Tools::convert(i,num);
-    if( !parseNumbered("FUNCTION",i,mystr ) ) break;
+    std::string myfunc, mystr, lab, num;
+    Tools::convert(i,num);
+    if( !parseNumbered("FUNCTION",i,mystr ) ) {
+      break;
+    }
     std::vector<std::string> data=Tools::getWords(mystr);
-    if( !Tools::parse(data,"LABEL",lab ) ) error("found no LABEL in FUNCTION" + num + " specification");
-    addComponent( lab, shape ); componentIsNotPeriodic( lab );
-    if( !Tools::parse(data,"FUNC",myfunc) ) error("found no FUNC in FUNCTION" + num + " specification");
+    if( !Tools::parse(data,"LABEL",lab ) ) {
+      error("found no LABEL in FUNCTION" + num + " specification");
+    }
+    addComponent( lab, shape );
+    componentIsNotPeriodic( lab );
+    if( !Tools::parse(data,"FUNC",myfunc) ) {
+      error("found no FUNC in FUNCTION" + num + " specification");
+    }
     log.printf("  component labelled %s is computed using %s \n",lab.c_str(), myfunc.c_str() );
-    functions.push_back( LeptonCall() ); std::vector<std::string> argnames(1); argnames[0]="ajik";
-    if( myfunc.find("rij")!=std::string::npos ) argnames.push_back("rij");
+    functions.push_back( LeptonCall() );
+    std::vector<std::string> argnames(1);
+    argnames[0]="ajik";
+    if( myfunc.find("rij")!=std::string::npos ) {
+      argnames.push_back("rij");
+    }
     if( myfunc.find("rik")!=std::string::npos ) {
-      if( argnames.size()<2 ) error("if you have a function of rik it must also be a function of rij -- email gareth.tribello@gmail.com if this is a problem");
+      if( argnames.size()<2 ) {
+        error("if you have a function of rik it must also be a function of rij -- email gareth.tribello@gmail.com if this is a problem");
+      }
       argnames.push_back("rik");
     }
     if( myfunc.find("rjk")!=std::string::npos ) {
-      if( argnames.size()<2 ) error("if you have a function of rjk it must also be a function of rij and rik -- email gareth.tribello@gmail.com if this is a problem");
+      if( argnames.size()<2 ) {
+        error("if you have a function of rjk it must also be a function of rij and rik -- email gareth.tribello@gmail.com if this is a problem");
+      }
       argnames.push_back("rjk");
     }
     functions[i-1].set( myfunc, argnames, this, true );
@@ -102,10 +132,13 @@ ThreeBodyGFunctions::ThreeBodyGFunctions(const ActionOptions&ao):
 std::string ThreeBodyGFunctions::getOutputComponentDescription( const std::string& cname, const Keywords& keys ) const {
   for(unsigned i=0; i<getNumberOfComponents(); ++i) {
     if( getConstPntrToComponent(i)->getName().find(cname)!=std::string::npos ) {
-      std::string num; Tools::convert( i+1, num ); return "the function defined by the FUNCTION" + num + " keyword";
+      std::string num;
+      Tools::convert( i+1, num );
+      return "the function defined by the FUNCTION" + num + " keyword";
     }
   }
-  plumed_error(); return "";
+  plumed_error();
+  return "";
 }
 
 unsigned ThreeBodyGFunctions::getNumberOfDerivatives() {
@@ -121,27 +154,40 @@ void ThreeBodyGFunctions::performTask( const unsigned& task_index, MultiValue& m
   const Value* xval = getPntrToArgument(0);
   const Value* yval = getPntrToArgument(1);
   const Value* zval = getPntrToArgument(2);
-  Angle angle; Vector disti, distj; unsigned matsize = wval->getNumberOfValues();
-  std::vector<double> values(4); std::vector<Vector> der_i(4), der_j(4);
+  Angle angle;
+  Vector disti, distj;
+  unsigned matsize = wval->getNumberOfValues();
+  std::vector<double> values(4);
+  std::vector<Vector> der_i(4), der_j(4);
   unsigned nbonds = wval->getRowLength( task_index ), ncols = wval->getShape()[1];
   for(unsigned i=0; i<nbonds; ++i) {
     unsigned ipos = ncols*task_index + wval->getRowIndex( task_index, i );
     double weighti = wval->get( ipos );
-    if( weighti<epsilon ) continue ;
+    if( weighti<epsilon ) {
+      continue ;
+    }
     disti[0] = xval->get( ipos );
     disti[1] = yval->get( ipos );
     disti[2] = zval->get( ipos );
-    values[1] = disti.modulo2(); der_i[1]=2*disti; der_i[2].zero();
+    values[1] = disti.modulo2();
+    der_i[1]=2*disti;
+    der_i[2].zero();
     for(unsigned j=0; j<i; ++j) {
       unsigned jpos = ncols*task_index + wval->getRowIndex( task_index, j );
       double weightj = wval->get( jpos );
-      if( weightj<epsilon ) continue ;
+      if( weightj<epsilon ) {
+        continue ;
+      }
       distj[0] = xval->get( jpos );
       distj[1] = yval->get( jpos );
       distj[2] = zval->get( jpos );
-      values[2] = distj.modulo2(); der_j[1].zero(); der_j[2]=2*distj;
-      der_i[3] = ( disti - distj ); values[3] = der_i[3].modulo2();
-      der_i[3] = 2*der_i[3]; der_j[3] = -der_i[3];
+      values[2] = distj.modulo2();
+      der_j[1].zero();
+      der_j[2]=2*distj;
+      der_i[3] = ( disti - distj );
+      values[3] = der_i[3].modulo2();
+      der_i[3] = 2*der_i[3];
+      der_j[3] = -der_i[3];
       // Compute angle between bonds
       values[0] = angle.compute( disti, distj, der_i[0], der_j[0] );
       // Compute product of weights
@@ -149,8 +195,11 @@ void ThreeBodyGFunctions::performTask( const unsigned& task_index, MultiValue& m
       // Now compute all symmetry functions
       for(unsigned n=0; n<functions.size(); ++n) {
         unsigned ostrn = getConstPntrToComponent(n)->getPositionInStream();
-        double nonweight = functions[n].evaluate( values ); myvals.addValue( ostrn, nonweight*weightij );
-        if( doNotCalculateDerivatives() ) continue;
+        double nonweight = functions[n].evaluate( values );
+        myvals.addValue( ostrn, nonweight*weightij );
+        if( doNotCalculateDerivatives() ) {
+          continue;
+        }
 
         for(unsigned m=0; m<functions[n].getNumberOfArguments(); ++m) {
           double der = weightij*functions[n].evaluateDeriv( m, values );
@@ -166,19 +215,25 @@ void ThreeBodyGFunctions::performTask( const unsigned& task_index, MultiValue& m
       }
     }
   }
-  if( doNotCalculateDerivatives() ) return ;
+  if( doNotCalculateDerivatives() ) {
+    return ;
+  }
 
   // And update the elements that have derivatives
   // Needs a separate loop here as there may be forces from j
   for(unsigned i=0; i<nbonds; ++i) {
     unsigned ipos = ncols*task_index + wval->getRowIndex( task_index, i );
     double weighti = wval->get( ipos );
-    if( weighti<epsilon ) continue ;
+    if( weighti<epsilon ) {
+      continue ;
+    }
 
     for(unsigned n=0; n<functions.size(); ++n) {
       unsigned ostrn = getConstPntrToComponent(n)->getPositionInStream();
-      myvals.updateIndex( ostrn, ipos ); myvals.updateIndex( ostrn, matsize+ipos );
-      myvals.updateIndex( ostrn, 2*matsize+ipos ); myvals.updateIndex( ostrn, 3*matsize+ipos );
+      myvals.updateIndex( ostrn, ipos );
+      myvals.updateIndex( ostrn, matsize+ipos );
+      myvals.updateIndex( ostrn, 2*matsize+ipos );
+      myvals.updateIndex( ostrn, 3*matsize+ipos );
     }
   }
 }
diff --git a/src/tools/BiasRepresentation.cpp b/src/tools/BiasRepresentation.cpp
index 4e75209cad..2c241812a5 100644
--- a/src/tools/BiasRepresentation.cpp
+++ b/src/tools/BiasRepresentation.cpp
@@ -43,8 +43,7 @@ BiasRepresentation::BiasRepresentation(const std::vector<Value*> & tmpvalues, Co
 
 /// overload the constructor: add the sigma  at constructor time
 BiasRepresentation::BiasRepresentation(const std::vector<Value*> & tmpvalues, Communicator &cc, const std::vector<double> & sigma ):
-  hasgrid(false), rescaledToBias(false), histosigma(sigma),mycomm(cc)
-{
+  hasgrid(false), rescaledToBias(false), histosigma(sigma),mycomm(cc) {
   lowI_=0.0;
   uppI_=0.0;
   doInt_=false;
@@ -58,8 +57,7 @@ BiasRepresentation::BiasRepresentation(const std::vector<Value*> & tmpvalues, Co
 /// overload the constructor: add the grid at constructor time
 BiasRepresentation::BiasRepresentation(const std::vector<Value*> & tmpvalues, Communicator &cc, const std::vector<std::string> & gmin, const std::vector<std::string> & gmax,
                                        const std::vector<unsigned> & nbin, bool doInt, double lowI, double uppI):
-  hasgrid(false), rescaledToBias(false), mycomm(cc)
-{
+  hasgrid(false), rescaledToBias(false), mycomm(cc) {
   ndim=tmpvalues.size();
   for(int i=0; i<ndim; i++) {
     values.push_back(tmpvalues[i]);
@@ -75,8 +73,7 @@ BiasRepresentation::BiasRepresentation(const std::vector<Value*> & tmpvalues, Co
 /// overload the constructor with some external sigmas: needed for histogram
 BiasRepresentation::BiasRepresentation(const std::vector<Value*> & tmpvalues, Communicator &cc, const std::vector<std::string> & gmin, const std::vector<std::string> & gmax,
                                        const std::vector<unsigned> & nbin, const std::vector<double> & sigma):
-  hasgrid(false), rescaledToBias(false),histosigma(sigma),mycomm(cc)
-{
+  hasgrid(false), rescaledToBias(false),histosigma(sigma),mycomm(cc) {
   lowI_=0.0;
   uppI_=0.0;
   doInt_=false;
@@ -92,14 +89,22 @@ BiasRepresentation::BiasRepresentation(const std::vector<Value*> & tmpvalues, Co
 void BiasRepresentation::addGrid(const std::vector<std::string> & gmin, const std::vector<std::string> & gmax, const std::vector<unsigned> & nbin ) {
   plumed_massert(hills.size()==0,"you can set the grid before loading the hills");
   plumed_massert(hasgrid==false,"to build the grid you should not having the grid in this bias representation");
-  std::string ss; ss="file.free";
-  std::vector<Value*> vv; for(unsigned i=0; i<values.size(); i++) vv.push_back(values[i]);
+  std::string ss;
+  ss="file.free";
+  std::vector<Value*> vv;
+  for(unsigned i=0; i<values.size(); i++) {
+    vv.push_back(values[i]);
+  }
   BiasGrid_=Tools::make_unique<Grid>(ss,vv,gmin,gmax,nbin,false,true);
   hasgrid=true;
 }
 
 bool BiasRepresentation::hasSigmaInInput() {
-  if(histosigma.size()==0) {return false;} else {return true;}
+  if(histosigma.size()==0) {
+    return false;
+  } else {
+    return true;
+  }
 }
 
 void BiasRepresentation::setRescaledToBias(bool rescaled) {
@@ -153,14 +158,19 @@ void BiasRepresentation::pushKernel( IFile *ifile ) {
   }
   // the bias factor is not something about the kernels but
   // must be stored to keep the  bias/free energy duality
-  std::string dummy; double dummyd;
+  std::string dummy;
+  double dummyd;
   if(ifile->FieldExist("biasf")) {
     ifile->scanField("biasf",dummy);
     Tools::convert(dummy,dummyd);
-  } else {dummyd=1.0;}
+  } else {
+    dummyd=1.0;
+  }
   biasf.push_back(dummyd);
   // the domain does not pertain to the kernel but to the values here defined
-  std::string mins,maxs,minv,maxv,mini,maxi; mins="min_"; maxs="max_";
+  std::string mins,maxs,minv,maxv,mini,maxi;
+  mins="min_";
+  maxs="max_";
   for(int i=0 ; i<ndim; i++) {
     if(values[i]->isPeriodic()) {
       ifile->scanField(mins+names[i],minv);
@@ -177,24 +187,35 @@ void BiasRepresentation::pushKernel( IFile *ifile ) {
     std::vector<unsigned> nneighb;
     if(doInt_&&(kk->getCenter()[0]+kk->getContinuousSupport()[0] > uppI_ || kk->getCenter()[0]-kk->getContinuousSupport()[0] < lowI_ )) {
       nneighb=BiasGrid_->getNbin();
-    } else nneighb=kk->getSupport(BiasGrid_->getDx());
+    } else {
+      nneighb=kk->getSupport(BiasGrid_->getDx());
+    }
     std::vector<Grid::index_t> neighbors=BiasGrid_->getNeighbors(kk->getCenter(),nneighb);
     std::vector<double> der(ndim);
     std::vector<double> xx(ndim);
     if(mycomm.Get_size()==1) {
       for(unsigned i=0; i<neighbors.size(); ++i) {
         Grid::index_t ineigh=neighbors[i];
-        for(int j=0; j<ndim; ++j) {der[j]=0.0;}
+        for(int j=0; j<ndim; ++j) {
+          der[j]=0.0;
+        }
         BiasGrid_->getPoint(ineigh,xx);
         // assign xx to a new vector of values
-        for(int j=0; j<ndim; ++j) {values[j]->set(xx[j]);}
+        for(int j=0; j<ndim; ++j) {
+          values[j]->set(xx[j]);
+        }
         double bias;
-        if(doInt_) bias=kk->evaluate(values,der,true,doInt_,lowI_,uppI_);
-        else bias=kk->evaluate(values,der,true);
+        if(doInt_) {
+          bias=kk->evaluate(values,der,true,doInt_,lowI_,uppI_);
+        } else {
+          bias=kk->evaluate(values,der,true);
+        }
         if(rescaledToBias) {
           double f=(biasf.back()-1.)/(biasf.back());
           bias*=f;
-          for(int j=0; j<ndim; ++j) {der[j]*=f;}
+          for(int j=0; j<ndim; ++j) {
+            der[j]*=f;
+          }
         }
         BiasGrid_->addValueAndDerivatives(ineigh,bias,der);
       }
@@ -207,23 +228,35 @@ void BiasRepresentation::pushKernel( IFile *ifile ) {
       for(unsigned i=rank; i<neighbors.size(); i+=stride) {
         Grid::index_t ineigh=neighbors[i];
         BiasGrid_->getPoint(ineigh,xx);
-        for(int j=0; j<ndim; ++j) {values[j]->set(xx[j]);}
-        if(doInt_) allbias[i]=kk->evaluate(values,der,true,doInt_,lowI_,uppI_);
-        else allbias[i]=kk->evaluate(values,der,true);
+        for(int j=0; j<ndim; ++j) {
+          values[j]->set(xx[j]);
+        }
+        if(doInt_) {
+          allbias[i]=kk->evaluate(values,der,true,doInt_,lowI_,uppI_);
+        } else {
+          allbias[i]=kk->evaluate(values,der,true);
+        }
         if(rescaledToBias) {
           double f=(biasf.back()-1.)/(biasf.back());
           allbias[i]*=f;
-          for(int j=0; j<ndim; ++j) {tmpder[j]*=f;}
+          for(int j=0; j<ndim; ++j) {
+            tmpder[j]*=f;
+          }
         }
         // this solution with the temporary vector is rather bad, probably better to take
         // a pointer of double as it was in old gaussian
-        for(int j=0; j<ndim; ++j) { allder[ndim*i+j]=tmpder[j]; tmpder[j]=0.;}
+        for(int j=0; j<ndim; ++j) {
+          allder[ndim*i+j]=tmpder[j];
+          tmpder[j]=0.;
+        }
       }
       mycomm.Sum(allbias);
       mycomm.Sum(allder);
       for(unsigned i=0; i<neighbors.size(); ++i) {
         Grid::index_t ineigh=neighbors[i];
-        for(int j=0; j<ndim; ++j) {der[j]=allder[ndim*i+j];}
+        for(int j=0; j<ndim; ++j) {
+          der[j]=allder[ndim*i+j];
+        }
         BiasGrid_->addValueAndDerivatives(ineigh,allbias[i],der);
       }
     }
@@ -242,10 +275,14 @@ Grid* BiasRepresentation::getGridPtr() {
 
 void BiasRepresentation::getMinMaxBin(std::vector<double> &vmin, std::vector<double> &vmax, std::vector<unsigned> &vbin) {
   std::vector<double> ss,cc,binsize;
-  vmin.clear(); vmin.resize(ndim,10.e20);
-  vmax.clear(); vmax.resize(ndim,-10.e20);
-  vbin.clear(); vbin.resize(ndim);
-  binsize.clear(); binsize.resize(ndim,10.e20);
+  vmin.clear();
+  vmin.resize(ndim,10.e20);
+  vmax.clear();
+  vmax.resize(ndim,-10.e20);
+  vbin.clear();
+  vbin.resize(ndim);
+  binsize.clear();
+  binsize.resize(ndim,10.e20);
   int ndiv=10; // adjustable parameter: division per support
   for(unsigned i=0; i<hills.size(); i++) {
     if(histosigma.size()!=0) {
@@ -258,9 +295,15 @@ void BiasRepresentation::getMinMaxBin(std::vector<double> &vmin, std::vector<dou
       double dmin=cc[j]-ss[j];
       double dmax=cc[j]+ss[j];
       double ddiv=ss[j]/double(ndiv);
-      if(dmin<vmin[j])vmin[j]=dmin;
-      if(dmax>vmax[j])vmax[j]=dmax;
-      if(ddiv<binsize[j])binsize[j]=ddiv;
+      if(dmin<vmin[j]) {
+        vmin[j]=dmin;
+      }
+      if(dmax>vmax[j]) {
+        vmax[j]=dmax;
+      }
+      if(ddiv<binsize[j]) {
+        binsize[j]=ddiv;
+      }
     }
   }
   for(int j=0; j<ndim; j++) {
@@ -268,8 +311,12 @@ void BiasRepresentation::getMinMaxBin(std::vector<double> &vmin, std::vector<dou
     if(values[j]->isPeriodic()) {
       double minv,maxv;
       values[j]->getDomain(minv,maxv);
-      if(minv>vmin[j])vmin[j]=minv;
-      if(maxv<vmax[j])vmax[j]=maxv;
+      if(minv>vmin[j]) {
+        vmin[j]=minv;
+      }
+      if(maxv<vmax[j]) {
+        vmax[j]=maxv;
+      }
     }
     vbin[j]=static_cast<unsigned>(std::ceil((vmax[j]-vmin[j])/binsize[j]) );
   }
diff --git a/src/tools/Brent1DRootSearch.h b/src/tools/Brent1DRootSearch.h
index 491b9816a7..15e653e0d1 100644
--- a/src/tools/Brent1DRootSearch.h
+++ b/src/tools/Brent1DRootSearch.h
@@ -68,14 +68,19 @@ Brent1DRootSearch<FCLASS>::Brent1DRootSearch( const FCLASS& pf, const double& t
   EXPAND(1.6),
   ax(0), bx(0),
   fa(0), fb(0),
-  myclass_func(pf)
-{
+  myclass_func(pf) {
 }
 
 template <class FCLASS>
 void Brent1DRootSearch<FCLASS>::bracket( const double& a, const double& b, eng_pointer eng ) {
-  plumed_assert( a!=b ); ax=a; bx=b; fa=(myclass_func.*eng)(a); fb=(myclass_func.*eng)(b);
-  if ((fa > 0.0 && fb > 0.0) || (fa < 0.0 && fb < 0.0)) plumed_merror("input points do not bracket root");
+  plumed_assert( a!=b );
+  ax=a;
+  bx=b;
+  fa=(myclass_func.*eng)(a);
+  fb=(myclass_func.*eng)(b);
+  if ((fa > 0.0 && fb > 0.0) || (fa < 0.0 && fb < 0.0)) {
+    plumed_merror("input points do not bracket root");
+  }
   bracketed=true;
 }
 
@@ -85,31 +90,61 @@ double Brent1DRootSearch<FCLASS>::search( eng_pointer eng ) {
 
   double cx=bx, d, e, min1, min2, fc=fb, p, q, r, s, tol1, xm;
   for(unsigned iter=0; iter<ITMAX; iter++) {
-    if ( (fb>0.0 && fc>0.0) || (fb<0.0 && fc<0.0) ) { cx=ax; fc=fa; e=d=bx-ax; }
-    if( std::fabs(fc) < std::fabs(fb) ) { ax=bx; bx=cx; cx=ax; fa=fb; fb=fc; fc=fa; }
-    tol1=2*EPS*std::fabs(bx)+0.5*tol; xm=0.5*(cx-bx);
-    if( std::fabs(xm) <= tol1 || fb == 0.0 ) return bx;
+    if ( (fb>0.0 && fc>0.0) || (fb<0.0 && fc<0.0) ) {
+      cx=ax;
+      fc=fa;
+      e=d=bx-ax;
+    }
+    if( std::fabs(fc) < std::fabs(fb) ) {
+      ax=bx;
+      bx=cx;
+      cx=ax;
+      fa=fb;
+      fb=fc;
+      fc=fa;
+    }
+    tol1=2*EPS*std::fabs(bx)+0.5*tol;
+    xm=0.5*(cx-bx);
+    if( std::fabs(xm) <= tol1 || fb == 0.0 ) {
+      return bx;
+    }
     if( std::fabs(e) >= tol1 && std::fabs(fa) > std::fabs(fb) ) {
       s=fb/fa;
       if( ax==cx ) {
-        p=2.0*xm*s; q=1.0-s;
+        p=2.0*xm*s;
+        q=1.0-s;
       } else {
-        q=fa/fc; r=fb/fc; p=s*(2.0*xm*q*(q-r)-(bx-ax)*(r-1.0)); q=(q-1.0)*(r-1.0)*(s-1.0);
+        q=fa/fc;
+        r=fb/fc;
+        p=s*(2.0*xm*q*(q-r)-(bx-ax)*(r-1.0));
+        q=(q-1.0)*(r-1.0)*(s-1.0);
       }
-      if (p > 0.0) q = -q;
-      p=std::fabs(p); min1=3.0*xm*q-std::fabs(tol1*q); min2=std::fabs(e*q);
+      if (p > 0.0) {
+        q = -q;
+      }
+      p=std::fabs(p);
+      min1=3.0*xm*q-std::fabs(tol1*q);
+      min2=std::fabs(e*q);
       if (2.0*p < (min1 < min2 ? min1 : min2)) {
-        e=d; d=p/q;
+        e=d;
+        d=p/q;
       } else {
-        d=xm; e=d;
+        d=xm;
+        e=d;
       }
     } else {
-      d=xm; e=d;
+      d=xm;
+      e=d;
+    }
+    ax=bx;
+    fa=fb;
+    if( std::fabs(d) > tol1 ) {
+      bx+=d;
+    } else if(xm<0 ) {
+      bx -= std::fabs(tol1);  // SIGN(tol1,xm);
+    } else {
+      bx += tol1;
     }
-    ax=bx; fa=fb;
-    if( std::fabs(d) > tol1 ) bx+=d;
-    else if(xm<0 ) bx -= std::fabs(tol1); // SIGN(tol1,xm);
-    else bx += tol1;
     fb = (myclass_func.*eng)(bx);
   }
 
diff --git a/src/tools/CheckInRange.cpp b/src/tools/CheckInRange.cpp
index 001fc01c81..4b53280036 100644
--- a/src/tools/CheckInRange.cpp
+++ b/src/tools/CheckInRange.cpp
@@ -25,27 +25,46 @@
 namespace PLMD {
 
 bool CheckInRange::setBounds( const unsigned& n, const std::vector<std::string>& str_lower, const std::vector<std::string>& str_upper, std::string& errors ) {
-  if( str_upper.size()!=n && str_upper.size()>0 ) { errors="wrong number of arguments for LESS_THAN_OR_EQUAL keyword"; return false; }
-  if( str_lower.size()!=n && str_lower.size()>0 ) { errors="wrong number of arguments for GREATER_THAN_OR_EQUAL keyword"; return false; }
+  if( str_upper.size()!=n && str_upper.size()>0 ) {
+    errors="wrong number of arguments for LESS_THAN_OR_EQUAL keyword";
+    return false;
+  }
+  if( str_lower.size()!=n && str_lower.size()>0 ) {
+    errors="wrong number of arguments for GREATER_THAN_OR_EQUAL keyword";
+    return false;
+  }
   if( str_upper.size()>0 && str_lower.size()>0 ) {
-    lower.resize( str_lower.size() ); upper.resize( str_upper.size() );
+    lower.resize( str_lower.size() );
+    upper.resize( str_upper.size() );
     for(unsigned i=0; i<upper.size(); ++i) {
-      if( str_lower[i]=="none" ) lower[i] = -std::numeric_limits<double>::max();
-      else Tools::convert( str_lower[i], lower[i] );
-      if( str_upper[i]=="none" ) upper[i] = std::numeric_limits<double>::max();
-      else Tools::convert( str_upper[i], upper[i] );
+      if( str_lower[i]=="none" ) {
+        lower[i] = -std::numeric_limits<double>::max();
+      } else {
+        Tools::convert( str_lower[i], lower[i] );
+      }
+      if( str_upper[i]=="none" ) {
+        upper[i] = std::numeric_limits<double>::max();
+      } else {
+        Tools::convert( str_upper[i], upper[i] );
+      }
     }
   } else if( str_upper.size()>0 ) {
     upper.resize( str_upper.size() );
     for(unsigned i=0; i<upper.size(); ++i) {
-      if( str_upper[i]=="none" ) upper[i] = std::numeric_limits<double>::max();
-      else Tools::convert( str_upper[i], upper[i] );
+      if( str_upper[i]=="none" ) {
+        upper[i] = std::numeric_limits<double>::max();
+      } else {
+        Tools::convert( str_upper[i], upper[i] );
+      }
     }
   } else if( str_lower.size()>0 ) {
     lower.resize( str_lower.size() );
     for(unsigned i=0; i<lower.size(); ++i) {
-      if( str_lower[i]=="none" ) lower[i] = -std::numeric_limits<double>::max();
-      else Tools::convert( str_lower[i], lower[i] );
+      if( str_lower[i]=="none" ) {
+        lower[i] = -std::numeric_limits<double>::max();
+      } else {
+        Tools::convert( str_lower[i], lower[i] );
+      }
     }
   }
   return true;
@@ -57,30 +76,45 @@ bool CheckInRange::wereSet() const {
 
 std::string CheckInRange::report( const std::vector<std::string>& a ) const {
   if( upper.size()>0 && lower.size()>0 ) {
-    std::string str_l, str_u; Tools::convert( upper[0], str_u ); Tools::convert( lower[0], str_l );
+    std::string str_l, str_u;
+    Tools::convert( upper[0], str_u );
+    Tools::convert( lower[0], str_l );
     std::string out="only printing indices of atoms that have " + str_l + " <= " + a[0] + " <=" + str_u;
     for(unsigned i=1; i<upper.size(); ++i) {
-      Tools::convert( upper[i], str_u ); Tools::convert( lower[i], str_l );
+      Tools::convert( upper[i], str_u );
+      Tools::convert( lower[i], str_l );
       out += " and " + str_l + " <= " + a[i] + " <=" + str_u;
     }
     return out;
   }
   if( upper.size()>0 ) {
-    std::string str_u; Tools::convert( upper[0], str_u );
+    std::string str_u;
+    Tools::convert( upper[0], str_u );
     std::string out="only printing indices of atoms that have " + a[0] + " <= " + str_u;
-    for(unsigned i=1; i<upper.size(); ++i) { Tools::convert( upper[i], str_u ); out += " and " + a[i] + " <= " + str_u; }
+    for(unsigned i=1; i<upper.size(); ++i) {
+      Tools::convert( upper[i], str_u );
+      out += " and " + a[i] + " <= " + str_u;
+    }
     return out;
   }
-  std::string str_l; Tools::convert( lower[0], str_l );
+  std::string str_l;
+  Tools::convert( lower[0], str_l );
   std::string out="only printing indices of atoms that have " + str_l + " <= " + a[0];
-  for(unsigned i=1; i<lower.size(); ++i) { Tools::convert( lower[i], str_l ); out += " and " + str_l + " <= " + a[i]; }
+  for(unsigned i=1; i<lower.size(); ++i) {
+    Tools::convert( lower[i], str_l );
+    out += " and " + str_l + " <= " + a[i];
+  }
   return out;
 }
 
 bool CheckInRange::check( const std::vector<double>& vals ) const {
   for(unsigned j=0; j<vals.size(); ++j) {
-    if( upper.size()>0 && vals[j]>upper[j] ) return false;
-    if( lower.size()>0 && vals[j]<lower[j] ) return false;
+    if( upper.size()>0 && vals[j]>upper[j] ) {
+      return false;
+    }
+    if( lower.size()>0 && vals[j]<lower[j] ) {
+      return false;
+    }
   }
   return true;
 }
diff --git a/src/tools/Citations.cpp b/src/tools/Citations.cpp
index 25f41cf355..2f4a06ca00 100644
--- a/src/tools/Citations.cpp
+++ b/src/tools/Citations.cpp
@@ -28,8 +28,13 @@ namespace PLMD {
 
 std::string Citations::cite(const std::string & item) {
   unsigned i;
-  for(i=0; i<items.size(); ++i) if(items[i]==item) break;
-  if(i==items.size()) items.push_back(item);
+  for(i=0; i<items.size(); ++i)
+    if(items[i]==item) {
+      break;
+    }
+  if(i==items.size()) {
+    items.push_back(item);
+  }
   plumed_assert(i<items.size());
   std::string ret;
   Tools::convert(i+1,ret);
@@ -38,8 +43,9 @@ std::string Citations::cite(const std::string & item) {
 }
 
 std::ostream & operator<<(std::ostream &log,const Citations&cit) {
-  for(unsigned i=0; i<cit.items.size(); ++i)
+  for(unsigned i=0; i<cit.items.size(); ++i) {
     log<<"  ["<<i+1<<"] "<<cit.items[i]<<"\n";
+  }
   return log;
 }
 
diff --git a/src/tools/Communicator.cpp b/src/tools/Communicator.cpp
index b1432938d3..e7ef199baf 100644
--- a/src/tools/Communicator.cpp
+++ b/src/tools/Communicator.cpp
@@ -59,7 +59,9 @@ Communicator& Communicator::operator=(const Communicator&pc) {
 int Communicator::Get_rank()const {
   int r=0;
 #ifdef __PLUMED_HAS_MPI
-  if(initialized()) MPI_Comm_rank(communicator,&r);
+  if(initialized()) {
+    MPI_Comm_rank(communicator,&r);
+  }
 #endif
   return r;
 }
@@ -67,7 +69,9 @@ int Communicator::Get_rank()const {
 int Communicator::Get_size()const {
   int s=1;
 #ifdef __PLUMED_HAS_MPI
-  if(initialized()) MPI_Comm_size(communicator,&s);
+  if(initialized()) {
+    MPI_Comm_size(communicator,&s);
+  }
 #endif
   return s;
 }
@@ -75,8 +79,12 @@ int Communicator::Get_size()const {
 void Communicator::Set_comm(MPI_Comm c) {
 #ifdef __PLUMED_HAS_MPI
   if(initialized()) {
-    if(communicator!=MPI_COMM_SELF && communicator!=MPI_COMM_WORLD) MPI_Comm_free(&communicator);
-    if(c!=MPI_COMM_SELF) MPI_Comm_dup(c,&communicator);
+    if(communicator!=MPI_COMM_SELF && communicator!=MPI_COMM_WORLD) {
+      MPI_Comm_free(&communicator);
+    }
+    if(c!=MPI_COMM_SELF) {
+      MPI_Comm_dup(c,&communicator);
+    }
   }
 #else
   (void) c;
@@ -85,14 +93,18 @@ void Communicator::Set_comm(MPI_Comm c) {
 
 Communicator::~Communicator() {
 #ifdef __PLUMED_HAS_MPI
-  if(initialized() && communicator!=MPI_COMM_SELF && communicator!=MPI_COMM_WORLD) MPI_Comm_free(&communicator);
+  if(initialized() && communicator!=MPI_COMM_SELF && communicator!=MPI_COMM_WORLD) {
+    MPI_Comm_free(&communicator);
+  }
 #endif
 }
 
 void Communicator::Set_comm(const TypesafePtr & val) {
 #ifdef __PLUMED_HAS_MPI
   plumed_massert(initialized(),"you are trying to use an MPI function, but MPI is not initialized");
-  if(val) Set_comm(*(const MPI_Comm*)val.get<const void*>());
+  if(val) {
+    Set_comm(*(const MPI_Comm*)val.get<const void*>());
+  }
 #else
   (void) val;
   plumed_merror("you are trying to use an MPI function, but PLUMED has been compiled without MPI support");
@@ -124,7 +136,9 @@ void Communicator::Abort(int errorcode) {
 
 void Communicator::Bcast(Data data,int root) {
 #if defined(__PLUMED_HAS_MPI)
-  if(initialized()) MPI_Bcast(data.pointer,data.size,data.type,root,communicator);
+  if(initialized()) {
+    MPI_Bcast(data.pointer,data.size,data.type,root,communicator);
+  }
 #else
   (void) data;
   (void) root;
@@ -133,7 +147,9 @@ void Communicator::Bcast(Data data,int root) {
 
 void Communicator::Sum(Data data) {
 #if defined(__PLUMED_HAS_MPI)
-  if(initialized()) MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_SUM,communicator);
+  if(initialized()) {
+    MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_SUM,communicator);
+  }
 #else
   (void) data;
 #endif
@@ -141,7 +157,9 @@ void Communicator::Sum(Data data) {
 
 void Communicator::Prod(Data data) {
 #if defined(__PLUMED_HAS_MPI)
-  if(initialized()) MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_PROD,communicator);
+  if(initialized()) {
+    MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_PROD,communicator);
+  }
 #else
   (void) data;
 #endif
@@ -149,7 +167,9 @@ void Communicator::Prod(Data data) {
 
 void Communicator::Max(Data data) {
 #if defined(__PLUMED_HAS_MPI)
-  if(initialized()) MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_MAX,communicator);
+  if(initialized()) {
+    MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_MAX,communicator);
+  }
 #else
   (void) data;
 #endif
@@ -157,7 +177,9 @@ void Communicator::Max(Data data) {
 
 void Communicator::Min(Data data) {
 #if defined(__PLUMED_HAS_MPI)
-  if(initialized()) MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_MIN,communicator);
+  if(initialized()) {
+    MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_MIN,communicator);
+  }
 #else
   (void) data;
 #endif
@@ -185,7 +207,9 @@ void Communicator::Allgatherv(ConstData in,Data out,const int*recvcounts,const i
   int*di=const_cast<int*>(displs);
 #if defined(__PLUMED_HAS_MPI)
   if(initialized()) {
-    if(s==NULL)s=MPI_IN_PLACE;
+    if(s==NULL) {
+      s=MPI_IN_PLACE;
+    }
     MPI_Allgatherv(s,in.size,in.type,r,rc,di,out.type,communicator);
   } else {
     plumed_assert(in.nbytes==out.nbytes);
@@ -193,7 +217,9 @@ void Communicator::Allgatherv(ConstData in,Data out,const int*recvcounts,const i
     plumed_assert(rc);
     plumed_assert(rc[0]==in.size);
     plumed_assert(di);
-    if(s) std::memcpy(static_cast<char*>(r)+displs[0]*in.nbytes,s,size_t(in.size)*in.nbytes);
+    if(s) {
+      std::memcpy(static_cast<char*>(r)+displs[0]*in.nbytes,s,size_t(in.size)*in.nbytes);
+    }
   }
 #else
   plumed_assert(in.nbytes==out.nbytes);
@@ -201,7 +227,9 @@ void Communicator::Allgatherv(ConstData in,Data out,const int*recvcounts,const i
   plumed_assert(rc);
   plumed_assert(rc[0]==in.size);
   plumed_assert(di);
-  if(s) std::memcpy(static_cast<char*>(r)+displs[0]*in.nbytes,s,size_t(in.size)*in.nbytes);
+  if(s) {
+    std::memcpy(static_cast<char*>(r)+displs[0]*in.nbytes,s,size_t(in.size)*in.nbytes);
+  }
 #endif
 }
 
@@ -210,25 +238,34 @@ void Communicator::Allgather(ConstData in,Data out) {
   void*r=const_cast<void*>((const void*)out.pointer);
 #if defined(__PLUMED_HAS_MPI)
   if(initialized()) {
-    if(s==NULL)s=MPI_IN_PLACE;
+    if(s==NULL) {
+      s=MPI_IN_PLACE;
+    }
     MPI_Allgather(s,in.size,in.type,r,out.size/Get_size(),out.type,communicator);
   } else {
     plumed_assert(in.nbytes==out.nbytes);
     plumed_assert(in.size==out.size);
-    if(s) std::memcpy(r,s,size_t(in.size)*in.nbytes);
+    if(s) {
+      std::memcpy(r,s,size_t(in.size)*in.nbytes);
+    }
   }
 #else
   plumed_assert(in.nbytes==out.nbytes);
   plumed_assert(in.size==out.size);
-  if(s) std::memcpy(r,s,size_t(in.size)*in.nbytes);
+  if(s) {
+    std::memcpy(r,s,size_t(in.size)*in.nbytes);
+  }
 #endif
 }
 
 void Communicator::Recv(Data data,int source,int tag,Status&status) {
 #ifdef __PLUMED_HAS_MPI
   plumed_massert(initialized(),"you are trying to use an MPI function, but MPI is not initialized");
-  if(&status==&StatusIgnore) MPI_Recv(data.pointer,data.size,data.type,source,tag,communicator,MPI_STATUS_IGNORE);
-  else                       MPI_Recv(data.pointer,data.size,data.type,source,tag,communicator,&status.s);
+  if(&status==&StatusIgnore) {
+    MPI_Recv(data.pointer,data.size,data.type,source,tag,communicator,MPI_STATUS_IGNORE);
+  } else {
+    MPI_Recv(data.pointer,data.size,data.type,source,tag,communicator,&status.s);
+  }
 #else
   (void) data;
   (void) source;
@@ -240,7 +277,9 @@ void Communicator::Recv(Data data,int source,int tag,Status&status) {
 
 void Communicator::Barrier()const {
 #ifdef __PLUMED_HAS_MPI
-  if(initialized()) MPI_Barrier(communicator);
+  if(initialized()) {
+    MPI_Barrier(communicator);
+  }
 #endif
 }
 
@@ -252,8 +291,11 @@ bool Communicator::initialized() {
 #if defined(__PLUMED_HAS_MPI)
   int flag=0;
   MPI_Initialized(&flag);
-  if(flag) return true;
-  else return false;
+  if(flag) {
+    return true;
+  } else {
+    return false;
+  }
 #endif
   return false;
 }
@@ -261,8 +303,11 @@ bool Communicator::initialized() {
 void Communicator::Request::wait(Status&s) {
 #ifdef __PLUMED_HAS_MPI
   plumed_massert(initialized(),"you are trying to use an MPI function, but MPI is not initialized");
-  if(&s==&StatusIgnore) MPI_Wait(&r,MPI_STATUS_IGNORE);
-  else MPI_Wait(&r,&s.s);
+  if(&s==&StatusIgnore) {
+    MPI_Wait(&r,MPI_STATUS_IGNORE);
+  } else {
+    MPI_Wait(&r,&s.s);
+  }
 #else
   (void) s;
   plumed_merror("you are trying to use an MPI function, but PLUMED has been compiled without MPI support");
@@ -270,25 +315,61 @@ void Communicator::Request::wait(Status&s) {
 }
 
 #ifdef __PLUMED_HAS_MPI
-template<> MPI_Datatype Communicator::getMPIType<float>() { return MPI_FLOAT;}
-template<> MPI_Datatype Communicator::getMPIType<double>() { return MPI_DOUBLE;}
-template<> MPI_Datatype Communicator::getMPIType<int>()   { return MPI_INT;}
-template<> MPI_Datatype Communicator::getMPIType<char>()   { return MPI_CHAR;}
-template<> MPI_Datatype Communicator::getMPIType<unsigned>()   { return MPI_UNSIGNED;}
-template<> MPI_Datatype Communicator::getMPIType<AtomNumber>()   { return MPI_UNSIGNED;}
-template<> MPI_Datatype Communicator::getMPIType<long unsigned>()   { return MPI_UNSIGNED_LONG;}
-template<> MPI_Datatype Communicator::getMPIType<long long unsigned>() { return MPI_UNSIGNED_LONG_LONG;}
-template<> MPI_Datatype Communicator::getMPIType<long double>()   { return MPI_LONG_DOUBLE;}
+template<> MPI_Datatype Communicator::getMPIType<float>() {
+  return MPI_FLOAT;
+}
+template<> MPI_Datatype Communicator::getMPIType<double>() {
+  return MPI_DOUBLE;
+}
+template<> MPI_Datatype Communicator::getMPIType<int>()   {
+  return MPI_INT;
+}
+template<> MPI_Datatype Communicator::getMPIType<char>()   {
+  return MPI_CHAR;
+}
+template<> MPI_Datatype Communicator::getMPIType<unsigned>()   {
+  return MPI_UNSIGNED;
+}
+template<> MPI_Datatype Communicator::getMPIType<AtomNumber>()   {
+  return MPI_UNSIGNED;
+}
+template<> MPI_Datatype Communicator::getMPIType<long unsigned>()   {
+  return MPI_UNSIGNED_LONG;
+}
+template<> MPI_Datatype Communicator::getMPIType<long long unsigned>() {
+  return MPI_UNSIGNED_LONG_LONG;
+}
+template<> MPI_Datatype Communicator::getMPIType<long double>()   {
+  return MPI_LONG_DOUBLE;
+}
 #else
-template<> MPI_Datatype Communicator::getMPIType<float>() { return MPI_Datatype();}
-template<> MPI_Datatype Communicator::getMPIType<double>() { return MPI_Datatype();}
-template<> MPI_Datatype Communicator::getMPIType<int>() { return MPI_Datatype();}
-template<> MPI_Datatype Communicator::getMPIType<char>() { return MPI_Datatype();}
-template<> MPI_Datatype Communicator::getMPIType<unsigned>() { return MPI_Datatype();}
-template<> MPI_Datatype Communicator::getMPIType<AtomNumber>()   { return MPI_Datatype();}
-template<> MPI_Datatype Communicator::getMPIType<long unsigned>() { return MPI_Datatype();}
-template<> MPI_Datatype Communicator::getMPIType<long long unsigned>() { return MPI_Datatype();}
-template<> MPI_Datatype Communicator::getMPIType<long double>() { return MPI_Datatype();}
+template<> MPI_Datatype Communicator::getMPIType<float>() {
+  return MPI_Datatype();
+}
+template<> MPI_Datatype Communicator::getMPIType<double>() {
+  return MPI_Datatype();
+}
+template<> MPI_Datatype Communicator::getMPIType<int>() {
+  return MPI_Datatype();
+}
+template<> MPI_Datatype Communicator::getMPIType<char>() {
+  return MPI_Datatype();
+}
+template<> MPI_Datatype Communicator::getMPIType<unsigned>() {
+  return MPI_Datatype();
+}
+template<> MPI_Datatype Communicator::getMPIType<AtomNumber>()   {
+  return MPI_Datatype();
+}
+template<> MPI_Datatype Communicator::getMPIType<long unsigned>() {
+  return MPI_Datatype();
+}
+template<> MPI_Datatype Communicator::getMPIType<long long unsigned>() {
+  return MPI_Datatype();
+}
+template<> MPI_Datatype Communicator::getMPIType<long double>() {
+  return MPI_Datatype();
+}
 #endif
 
 void Communicator::Split(int color,int key,Communicator&pc)const {
diff --git a/src/tools/Communicator.h b/src/tools/Communicator.h
index aff4771852..16ef37ddfb 100644
--- a/src/tools/Communicator.h
+++ b/src/tools/Communicator.h
@@ -82,17 +82,34 @@ class Communicator {
     template <unsigned n,unsigned m> explicit Data(TensorGeneric<n,m> &p): pointer(&p), size(n*m), nbytes(sizeof(double)), type(getMPIType<double>()) {}
 /// Init from reference to std::vector
     template <typename T> explicit Data(std::vector<T>&v) {
-      Data d(v.data(),v.size()); pointer=d.pointer; size=d.size; type=d.type;
+      Data d(v.data(),v.size());
+      pointer=d.pointer;
+      size=d.size;
+      type=d.type;
     }
 /// Init from reference to PLMD::Matrix
     template <typename T> explicit Data(Matrix<T>&m ) {
-      if(m.nrows()*m.ncols()>0) { Data d(&m(0,0),m.nrows()*m.ncols()); pointer=d.pointer; size=d.size; type=d.type; }
-      else { pointer=NULL; size=0; }
+      if(m.nrows()*m.ncols()>0) {
+        Data d(&m(0,0),m.nrows()*m.ncols());
+        pointer=d.pointer;
+        size=d.size;
+        type=d.type;
+      } else {
+        pointer=NULL;
+        size=0;
+      }
     }
 /// Init from reference to std::string
     explicit Data(std::string&s) {
-      if(s.size()>0) { Data d(&s[0],s.size()); pointer=d.pointer; size=d.size; type=d.type; }
-      else { pointer=NULL; size=0; }
+      if(s.size()>0) {
+        Data d(&s[0],s.size());
+        pointer=d.pointer;
+        size=d.size;
+        type=d.type;
+      } else {
+        pointer=NULL;
+        size=0;
+      }
     }
   };
 /// Const version of Communicator::Data
@@ -109,15 +126,32 @@ class Communicator {
     template <unsigned n,unsigned m> explicit ConstData(const TensorGeneric<n,m> *p,int s): pointer(p), size(n*m*s), nbytes(sizeof(double)), type(getMPIType<double>()) {}
     template <unsigned n,unsigned m> explicit ConstData(const TensorGeneric<n,m> &p): pointer(&p), size(n*m), nbytes(sizeof(double)), type(getMPIType<double>()) {}
     template <typename T> explicit ConstData(const std::vector<T>&v) {
-      ConstData d(v.data(),v.size()); pointer=d.pointer; size=d.size; type=d.type;
+      ConstData d(v.data(),v.size());
+      pointer=d.pointer;
+      size=d.size;
+      type=d.type;
     }
     template <typename T> explicit ConstData(const Matrix<T>&m ) {
-      if(m.nrows()*m.ncols()>0) { ConstData d(&m(0,0),m.nrows()*m.ncols()); pointer=d.pointer; size=d.size; type=d.type; }
-      else { pointer=NULL; size=0; }
+      if(m.nrows()*m.ncols()>0) {
+        ConstData d(&m(0,0),m.nrows()*m.ncols());
+        pointer=d.pointer;
+        size=d.size;
+        type=d.type;
+      } else {
+        pointer=NULL;
+        size=0;
+      }
     }
     explicit ConstData(const std::string&s) {
-      if(s.size()>0) { ConstData d(&s[0],s.size()); pointer=d.pointer; size=d.size; type=d.type; }
-      else { pointer=NULL; size=0; }
+      if(s.size()>0) {
+        ConstData d(&s[0],s.size());
+        pointer=d.pointer;
+        size=d.size;
+        type=d.type;
+      } else {
+        pointer=NULL;
+        size=0;
+      }
     }
   };
 public:
@@ -130,7 +164,9 @@ class Communicator {
   public:
     MPI_Status s;
     template <class T>
-    int Get_count()const {return Get_count(getMPIType<T>());}
+    int Get_count()const {
+      return Get_count(getMPIType<T>());
+    }
   };
 /// Special status used when status should be ignored.
 /// E.g. `Recv(a,0,1,Communicator::StatusIgnore);`
@@ -178,41 +214,65 @@ class Communicator {
 /// Wrapper for MPI_Allreduce with MPI_SUM (data struct)
   void Sum(Data);
 /// Wrapper for MPI_Allreduce with MPI_SUM (pointer)
-  template <class T> void Sum(T*buf,int count) {Sum(Data(buf,count));}
+  template <class T> void Sum(T*buf,int count) {
+    Sum(Data(buf,count));
+  }
 /// Wrapper for MPI_Allreduce with MPI_SUM (reference)
-  template <class T> void Sum(T&buf) {Sum(Data(buf));}
+  template <class T> void Sum(T&buf) {
+    Sum(Data(buf));
+  }
 /// Wrapper for MPI_Allreduce with MPI_PROD (data struct)
   void Prod(Data);
 /// Wrapper for MPI_Allreduce with MPI_PROD (pointer)
-  template <class T> void Prod(T*buf,int count) {Prod(Data(buf,count));}
+  template <class T> void Prod(T*buf,int count) {
+    Prod(Data(buf,count));
+  }
 /// Wrapper for MPI_Allreduce with MPI_PROD (reference)
-  template <class T> void Prod(T&buf) {Prod(Data(buf));}
+  template <class T> void Prod(T&buf) {
+    Prod(Data(buf));
+  }
 /// Wrapper for MPI_Allreduce with MPI_MAX (data struct)
   void Max(Data);
 /// Wrapper for MPI_Allreduce with MPI_MAX (pointer)
-  template <class T> void Max(T*buf,int count) {Max(Data(buf,count));}
+  template <class T> void Max(T*buf,int count) {
+    Max(Data(buf,count));
+  }
 /// Wrapper for MPI_Allreduce with MPI_MAX (reference)
-  template <class T> void Max(T&buf) {Max(Data(buf));}
+  template <class T> void Max(T&buf) {
+    Max(Data(buf));
+  }
 /// Wrapper for MPI_Allreduce with MPI_MIN (data struct)
   void Min(Data);
 /// Wrapper for MPI_Allreduce with MPI_MIN (pointer)
-  template <class T> void Min(T*buf,int count) {Min(Data(buf,count));}
+  template <class T> void Min(T*buf,int count) {
+    Min(Data(buf,count));
+  }
 /// Wrapper for MPI_Allreduce with MPI_MIN (reference)
-  template <class T> void Min(T&buf) {Min(Data(buf));}
+  template <class T> void Min(T&buf) {
+    Min(Data(buf));
+  }
 
 /// Wrapper for MPI_Bcast (data struct)
   void Bcast(Data,int);
 /// Wrapper for MPI_Bcast (pointer)
-  template <class T> void Bcast(T*buf,int count,int root) {Bcast(Data(buf,count),root);}
+  template <class T> void Bcast(T*buf,int count,int root) {
+    Bcast(Data(buf,count),root);
+  }
 /// Wrapper for MPI_Bcast (reference)
-  template <class T> void Bcast(T&buf,int root) {Bcast(Data(buf),root);}
+  template <class T> void Bcast(T&buf,int root) {
+    Bcast(Data(buf),root);
+  }
 
 /// Wrapper for MPI_Isend (data struct)
   Request Isend(ConstData,int,int);
 /// Wrapper for MPI_Isend (pointer)
-  template <class T> Request Isend(const T*buf,int count,int source,int tag) {return Isend(ConstData(buf,count),source,tag);}
+  template <class T> Request Isend(const T*buf,int count,int source,int tag) {
+    return Isend(ConstData(buf,count),source,tag);
+  }
 /// Wrapper for MPI_Isend (reference)
-  template <class T> Request Isend(const T&buf,int source,int tag) {return Isend(ConstData(buf),source,tag);}
+  template <class T> Request Isend(const T&buf,int source,int tag) {
+    return Isend(ConstData(buf),source,tag);
+  }
 
 /// Wrapper for MPI_Allgatherv (data struct)
   void Allgatherv(ConstData in,Data out,const int*,const int*);
@@ -239,9 +299,13 @@ class Communicator {
 /// Wrapper for MPI_Recv (data struct)
   void Recv(Data,int,int,Status&s=StatusIgnore);
 /// Wrapper for MPI_Recv (pointer)
-  template <class T> void Recv(T*buf,int count,int source,int tag,Status&s=StatusIgnore) {Recv(Data(buf,count),source,tag,s);}
+  template <class T> void Recv(T*buf,int count,int source,int tag,Status&s=StatusIgnore) {
+    Recv(Data(buf,count),source,tag,s);
+  }
 /// Wrapper for MPI_Recv (reference)
-  template <class T> void Recv(T&buf,int source,int tag,Status&s=StatusIgnore) {Recv(Data(buf),source,tag,s);}
+  template <class T> void Recv(T&buf,int source,int tag,Status&s=StatusIgnore) {
+    Recv(Data(buf),source,tag,s);
+  }
 
 /// Wrapper to MPI_Comm_split
   void Split(int,int,Communicator&)const;
diff --git a/src/tools/ConjugateGradient.h b/src/tools/ConjugateGradient.h
index 9b786a1783..1ecd38e70b 100644
--- a/src/tools/ConjugateGradient.h
+++ b/src/tools/ConjugateGradient.h
@@ -43,20 +43,34 @@ template <class FCLASS>
 void ConjugateGradient<FCLASS>::minimise( const double& ftol, std::vector<double>& p, engf_pointer myfunc ) const {
   std::vector<double> xi( p.size() ), g( p.size() ), h( p.size() );
   double fp = this->calcDerivatives( p, xi, myfunc );
-  for(unsigned j=0; j<p.size(); ++j) { g[j] = -xi[j]; xi[j]=h[j]=g[j]; }
+  for(unsigned j=0; j<p.size(); ++j) {
+    g[j] = -xi[j];
+    xi[j]=h[j]=g[j];
+  }
 
   for(unsigned its=0; its<ITMAX; ++its) {
     double fret=this->linemin( xi, p, myfunc );
     // The exit condition
-    if( 2.0*std::fabs(fret-fp) <= ftol*(std::fabs(fret)+std::fabs(fp)+EPS)) { return; }
-    fp = fret; this->calcDerivatives( p, xi, myfunc );
+    if( 2.0*std::fabs(fret-fp) <= ftol*(std::fabs(fret)+std::fabs(fp)+EPS)) {
+      return;
+    }
+    fp = fret;
+    this->calcDerivatives( p, xi, myfunc );
     double ddg=0., gg=0.;
-    for(unsigned j=0; j<p.size(); ++j) { gg += g[j]*g[j]; ddg += (xi[j]+g[j])*xi[j]; }
+    for(unsigned j=0; j<p.size(); ++j) {
+      gg += g[j]*g[j];
+      ddg += (xi[j]+g[j])*xi[j];
+    }
 
-    if( gg==0.0 ) return;
+    if( gg==0.0 ) {
+      return;
+    }
 
     double gam=ddg/gg;
-    for(unsigned j=0; j<p.size(); ++j) { g[j] = -xi[j]; xi[j]=h[j]=g[j]+gam*h[j]; }
+    for(unsigned j=0; j<p.size(); ++j) {
+      g[j] = -xi[j];
+      xi[j]=h[j]=g[j]+gam*h[j];
+    }
   }
   plumed_merror("Too many interactions in conjugate gradient");
 }
diff --git a/src/tools/DLLoader.cpp b/src/tools/DLLoader.cpp
index b8e1ab03e1..fbf5b5aee0 100644
--- a/src/tools/DLLoader.cpp
+++ b/src/tools/DLLoader.cpp
@@ -46,7 +46,9 @@ void* DLLoader::load(const std::string&s) {
 #ifdef __PLUMED_HAS_DLOPEN
   auto lockerAction=Register::registrationLock(s);
   void* p=dlopen(s.c_str(),RTLD_NOW|RTLD_LOCAL);
-  if(!p) plumed_error()<<"Could not load library "<<s<<"\n"<<dlerror();
+  if(!p) {
+    plumed_error()<<"Could not load library "<<s<<"\n"<<dlerror();
+  }
   handles.push_back(p);
   Register::completeAllRegistrations(p);
   return p;
@@ -58,7 +60,9 @@ void* DLLoader::load(const std::string&s) {
 DLLoader::~DLLoader() {
   auto debug=std::getenv("PLUMED_LOAD_DEBUG");
 #ifdef __PLUMED_HAS_DLOPEN
-  if(debug) std::fprintf(stderr,"delete dlloader\n");
+  if(debug) {
+    std::fprintf(stderr,"delete dlloader\n");
+  }
   while(!handles.empty()) {
     int ret=dlclose(handles.back());
     if(ret) {
@@ -66,7 +70,9 @@ DLLoader::~DLLoader() {
     }
     handles.pop_back();
   }
-  if(debug) std::fprintf(stderr,"end delete dlloader\n");
+  if(debug) {
+    std::fprintf(stderr,"end delete dlloader\n");
+  }
 #endif
 }
 
@@ -126,7 +132,9 @@ bool DLLoader::isPlumedGlobal() {
 #endif
   // we check for two variants, see wrapper/Plumed.h for an explanation:
   result=dlsym(handle,"plumed_plumedmain_create") || dlsym(handle,"plumedmain_create");
-  if(handle) dlclose(handle);
+  if(handle) {
+    dlclose(handle);
+  }
 #else
   // if a system cannot use dlopen, we assume plumed is globally available
   result=true;
diff --git a/src/tools/ERMSD.cpp b/src/tools/ERMSD.cpp
index f0fb2d125c..05aff35e26 100644
--- a/src/tools/ERMSD.cpp
+++ b/src/tools/ERMSD.cpp
@@ -67,10 +67,16 @@ void ERMSD::setReference(const std::vector<Vector> & reference, const std::vecto
 
 bool ERMSD::inPair(unsigned i, unsigned j) {
 
-  if(pairs.size()==0) return true;
+  if(pairs.size()==0) {
+    return true;
+  }
   for(unsigned idx=0; idx<pairs.size(); idx++) {
-    if(pairs[idx].first == i && pairs[idx].second == j) return true;
-    if(pairs[idx].second == i && pairs[idx].first == j) return true;
+    if(pairs[idx].first == i && pairs[idx].second == j) {
+      return true;
+    }
+    if(pairs[idx].second == i && pairs[idx].first == j) {
+      return true;
+    }
   }
   return false;
 }
@@ -294,7 +300,9 @@ double ERMSD::calculate(const std::vector<Vector> & positions,const Pbc& pbc,\
 
   ermsd = std::sqrt(ermsd/nresidues);
   double iermsd = 1.0/(ermsd*nresidues);
-  for(unsigned i=0; i<natoms; ++i) {derivatives[i] *= iermsd;}
+  for(unsigned i=0; i<natoms; ++i) {
+    derivatives[i] *= iermsd;
+  }
 
   return ermsd;
 }
diff --git a/src/tools/Exception.cpp b/src/tools/Exception.cpp
index bd29c16388..fb56a3efd0 100644
--- a/src/tools/Exception.cpp
+++ b/src/tools/Exception.cpp
@@ -37,8 +37,7 @@ namespace {
 
 // function to simplify a Unix - styled
 // absolute path
-std::string simplify(const std::string & path)
-{
+std::string simplify(const std::string & path) {
   // using vector in place of stack
   std::vector<std::string> v;
   int n = path.length();
@@ -53,13 +52,12 @@ std::string simplify(const std::string & path)
 
     // if ".." , we pop.
     if (dir == "..") {
-      if (!v.empty())
+      if (!v.empty()) {
         v.pop_back();
-    }
-    else if (dir == "." || dir == "") {
+      }
+    } else if (dir == "." || dir == "") {
       // do nothing (added for better understanding.)
-    }
-    else {
+    } else {
       // push the current directory into the vector.
       v.push_back(dir);
     }
@@ -68,22 +66,24 @@ std::string simplify(const std::string & path)
   // forming the ans
   bool first=true;
   for (const auto & i : v) {
-    if(!first) ans += "/";
+    if(!first) {
+      ans += "/";
+    }
     first=false;
     ans += i;
   }
 
   // vector is empty
-  if (ans == "")
+  if (ans == "") {
     return "/";
+  }
 
   return ans;
 }
 
 }
 
-Exception::Exception()
-{
+Exception::Exception() {
   callstack.fill(nullptr);
 #ifdef __PLUMED_HAS_EXECINFO
   callstack_n = backtrace(&callstack[0], callstack.size()-1);
@@ -96,18 +96,18 @@ Exception::Exception()
 #endif
 }
 
-Exception& Exception::operator<<(const std::string&msg)
-{
+Exception& Exception::operator<<(const std::string&msg) {
   if(msg.length()>0) {
-    if(note) this->msg +="\n";
+    if(note) {
+      this->msg +="\n";
+    }
     this->msg +=msg;
     note=false;
   }
   return *this;
 }
 
-Exception& Exception::operator<<(const Location&loc)
-{
+Exception& Exception::operator<<(const Location&loc) {
   if(loc.file) {
     const std::size_t clinelen=1000;
     char cline[clinelen];
@@ -130,8 +130,7 @@ Exception& Exception::operator<<(const Location&loc)
   return *this;
 }
 
-Exception& Exception::operator<<(const Assertion&as)
-{
+Exception& Exception::operator<<(const Assertion&as) {
   if(as.assertion) {
     this->msg += "\n+++ assertion failed: ";
     this->msg += as.assertion;
@@ -144,7 +143,10 @@ const char* Exception::stack() const {
 #ifdef __PLUMED_HAS_EXECINFO
   if(stackTrace.length()==0) {
     char** strs = backtrace_symbols(&callstack[0], callstack_n);
-    for (int i = 0; i < callstack_n; ++i) {stackTrace+=strs[i]; stackTrace+="\n";}
+    for (int i = 0; i < callstack_n; ++i) {
+      stackTrace+=strs[i];
+      stackTrace+="\n";
+    }
     free(strs);
   }
 #endif
diff --git a/src/tools/Exception.h b/src/tools/Exception.h
index 4b008fda12..8dafcb4137 100644
--- a/src/tools/Exception.h
+++ b/src/tools/Exception.h
@@ -152,8 +152,7 @@ this in all previous PLUMED versions. In case it is necessary, we can replace
 it later with a fixed size array placed on the stack.
 
 */
-class Exception : public std::exception
-{
+class Exception : public std::exception {
 /// Reported message. Can be updated.
   std::string msg;
 /// Flag to remember if we have to write the `+++ message follows +++` string.
@@ -220,8 +219,7 @@ class Exception : public std::exception
 
 /// Constructor compatible with PLUMED <=2.4.
   explicit Exception(const std::string & msg):
-    Exception()
-  {
+    Exception() {
     *this << msg;
   }
 
@@ -232,8 +230,7 @@ class Exception : public std::exception
     note(e.note),
     callstack(e.callstack),
     callstack_n(e.callstack_n),
-    stackTrace(e.stackTrace)
-  {
+    stackTrace(e.stackTrace) {
   }
 
 /// Assignment.
@@ -252,7 +249,9 @@ class Exception : public std::exception
 /// In case the environment variable PLUMED_STACK_TRACE was defined
 /// and equal to `yes` when the exception was raised,
 /// the error message will contain the stack trace as well.
-  const char* what() const noexcept override {return msg.c_str();}
+  const char* what() const noexcept override {
+    return msg.c_str();
+  }
 
 /// Returns the stack trace as a string.
 /// This function is slow as it requires building a parsed string.
@@ -260,10 +259,14 @@ class Exception : public std::exception
   const char* stack() const;
 
 /// Returns the callstack.
-  const std::array<void*,128> & trace() const noexcept {return callstack;}
+  const std::array<void*,128> & trace() const noexcept {
+    return callstack;
+  }
 
 /// Returns the number of elements in the trace array
-  int trace_n() const noexcept {return callstack_n;}
+  int trace_n() const noexcept {
+    return callstack_n;
+  }
 
 /// Destructor should be defined and should not throw other exceptions
   ~Exception() noexcept override {}
diff --git a/src/tools/FileBase.cpp b/src/tools/FileBase.cpp
index 3cc79af87e..3a5257e1cc 100644
--- a/src/tools/FileBase.cpp
+++ b/src/tools/FileBase.cpp
@@ -47,7 +47,9 @@ FileBase& FileBase::link(FILE*fp) {
 }
 
 FileBase& FileBase::flush() {
-  if(fp) fflush(fp);
+  if(fp) {
+    fflush(fp);
+  }
   return *this;
 }
 
@@ -78,7 +80,11 @@ bool FileBase::FileExist(const std::string& path) {
   // first try with suffix
   FILE *ff=std::fopen(const_cast<char*>(this->path.c_str()),"r");
 // call fclose when ff goes out of scope
-  auto deleter=[](auto f) { if(f) std::fclose(f); };
+  auto deleter=[](auto f) {
+    if(f) {
+      std::fclose(f);
+    }
+  };
   std::unique_ptr<FILE,decltype(deleter)> fp_deleter(ff,deleter);
 
   if(!ff) {
@@ -87,14 +93,20 @@ bool FileBase::FileExist(const std::string& path) {
     ff=std::fopen(const_cast<char*>(this->path.c_str()),"r");
     mode="r";
   }
-  if(ff) do_exist=true;
-  if(comm) comm->Barrier();
+  if(ff) {
+    do_exist=true;
+  }
+  if(comm) {
+    comm->Barrier();
+  }
   return do_exist;
 }
 
 bool FileBase::isOpen() {
   bool isopen=false;
-  if(fp) isopen=true;
+  if(fp) {
+    isopen=true;
+  }
   return isopen;
 }
 
@@ -102,9 +114,13 @@ void        FileBase::close() {
   plumed_assert(!cloned);
   eof=false;
   err=false;
-  if(fp)   std::fclose(fp);
+  if(fp) {
+    std::fclose(fp);
+  }
 #ifdef __PLUMED_HAS_ZLIB
-  if(gzfp) gzclose(gzFile(gzfp));
+  if(gzfp) {
+    gzclose(gzFile(gzfp));
+  }
 #endif
   fp=NULL;
   gzfp=NULL;
@@ -120,16 +136,20 @@ FileBase::FileBase():
   eof(false),
   err(false),
   heavyFlush(false),
-  enforcedSuffix_(false)
-{
+  enforcedSuffix_(false) {
 }
 
-FileBase::~FileBase()
-{
-  if(plumed) plumed->eraseFile(*this);
-  if(!cloned && fp)   std::fclose(fp);
+FileBase::~FileBase() {
+  if(plumed) {
+    plumed->eraseFile(*this);
+  }
+  if(!cloned && fp) {
+    std::fclose(fp);
+  }
 #ifdef __PLUMED_HAS_ZLIB
-  if(!cloned && gzfp) gzclose(gzFile(gzfp));
+  if(!cloned && gzfp) {
+    gzclose(gzFile(gzfp));
+  }
 #endif
 }
 
@@ -138,7 +158,9 @@ FileBase::operator bool()const {
 }
 
 std::string FileBase::appendSuffix(const std::string&path,const std::string&suffix) {
-  if(path=="/dev/null") return path; // do not append a suffix to /dev/null
+  if(path=="/dev/null") {
+    return path;  // do not append a suffix to /dev/null
+  }
   std::string ret=path;
   std::string ext=Tools::extension(path);
 
@@ -156,7 +178,9 @@ std::string FileBase::appendSuffix(const std::string&path,const std::string&suff
     ret.resize(l);
   }
   ret+=suffix;
-  if(ext.length()>0)ret+="."+ext;
+  if(ext.length()>0) {
+    ret+="."+ext;
+  }
   return ret;
 }
 
@@ -167,8 +191,12 @@ FileBase& FileBase::enforceSuffix(const std::string&suffix) {
 }
 
 std::string FileBase::getSuffix()const {
-  if(enforcedSuffix_) return enforcedSuffix;
-  if(plumed) return plumed->getSuffix();
+  if(enforcedSuffix_) {
+    return enforcedSuffix;
+  }
+  if(plumed) {
+    return plumed->getSuffix();
+  }
   return "";
 }
 
diff --git a/src/tools/FileBase.h b/src/tools/FileBase.h
index 5f148e4041..714182131c 100644
--- a/src/tools/FileBase.h
+++ b/src/tools/FileBase.h
@@ -113,7 +113,9 @@ class FileBase {
 /// Check for error/eof.
   operator bool () const;
 /// Set heavyFlush flag
-  void setHeavyFlush() { heavyFlush=true;}
+  void setHeavyFlush() {
+    heavyFlush=true;
+  }
 /// Opens the file
   virtual FileBase& open(const std::string&name)=0;
 /// Check if the file exists
diff --git a/src/tools/ForwardDecl.h b/src/tools/ForwardDecl.h
index ec1257850f..bb12014bb4 100644
--- a/src/tools/ForwardDecl.h
+++ b/src/tools/ForwardDecl.h
@@ -33,8 +33,7 @@ namespace PLMD {
 */
 template <class T>
 class ForwardDecl:
-  std::unique_ptr<T>
-{
+  std::unique_ptr<T> {
 public:
 // Construction with arbitrary argument.
   template<typename ...Args>
diff --git a/src/tools/Grid.cpp b/src/tools/Grid.cpp
index f539aeb3f7..82fe6a2118 100644
--- a/src/tools/Grid.cpp
+++ b/src/tools/Grid.cpp
@@ -44,8 +44,7 @@ constexpr std::size_t GridBase::maxdim;
 
 template<unsigned dimension_>
 class Accelerator final:
-  public Grid::AcceleratorBase
-{
+  public Grid::AcceleratorBase {
 
 public:
 
@@ -68,23 +67,36 @@ class Accelerator final:
     }
     neighbors.reserve(small_nbin);
 
-    for(unsigned j=0; j<dimension_; j++) small_indices[j]=0;
+    for(unsigned j=0; j<dimension_; j++) {
+      small_indices[j]=0;
+    }
 
     for(unsigned index=0; index<small_nbin; ++index) {
       unsigned ll=0;
       for(unsigned i=0; i<dimension_; ++i) {
         int i0=small_indices[i]-nneigh[i]+indices[i];
-        if(!pbc_[i] && i0<0)         continue;
-        if(!pbc_[i] && i0>=static_cast<int>(nbin_[i])) continue;
-        if( pbc_[i] && i0<0)         i0=nbin_[i]-(-i0)%nbin_[i];
-        if( pbc_[i] && i0>=static_cast<int>(nbin_[i])) i0%=nbin_[i];
+        if(!pbc_[i] && i0<0) {
+          continue;
+        }
+        if(!pbc_[i] && i0>=static_cast<int>(nbin_[i])) {
+          continue;
+        }
+        if( pbc_[i] && i0<0) {
+          i0=nbin_[i]-(-i0)%nbin_[i];
+        }
+        if( pbc_[i] && i0>=static_cast<int>(nbin_[i])) {
+          i0%=nbin_[i];
+        }
         tmp_indices[ll]=static_cast<unsigned>(i0);
         ll++;
       }
-      if(ll==dimension_) {neighbors.push_back(getIndex(grid,nbin_,&tmp_indices[0],dimension_));}
+      if(ll==dimension_) {
+        neighbors.push_back(getIndex(grid,nbin_,&tmp_indices[0],dimension_));
+      }
 
       small_indices[0]++;
-      for(unsigned j=0; j<dimension_-1; j++) if(small_indices[j]==small_bin[j]) {
+      for(unsigned j=0; j<dimension_-1; j++)
+        if(small_indices[j]==small_bin[j]) {
           small_indices[j]=0;
           small_indices[j+1]++;
         }
@@ -95,7 +107,9 @@ class Accelerator final:
   // we are flattening arrays using a column-major order
   GridBase::index_t getIndex(const GridBase& grid, const std::vector<unsigned> & nbin_,const unsigned* indices,std::size_t indices_size) const override {
     for(unsigned int i=0; i<dimension_; i++)
-      if(indices[i]>=nbin_[i]) plumed_error() << "Looking for a value outside the grid along the " << i << " dimension (arg name: "<<grid.getArgNames()[i]<<")";
+      if(indices[i]>=nbin_[i]) {
+        plumed_error() << "Looking for a value outside the grid along the " << i << " dimension (arg name: "<<grid.getArgNames()[i]<<")";
+      }
     auto index=indices[dimension_-1];
     for(unsigned int i=dimension_-1; i>0; --i) {
       index=index*nbin_[i-1]+indices[i-1];
@@ -133,22 +147,54 @@ class Accelerator final:
 std::unique_ptr<Grid::AcceleratorBase> Grid::AcceleratorBase::create(unsigned dim) {
 // I do this by enumeration.
 // Maybe can be simplified using the preprocessor, but I am not sure it's worth it
-  if(dim==1) return std::make_unique<Accelerator<1>>();
-  if(dim==2) return std::make_unique<Accelerator<2>>();
-  if(dim==3) return std::make_unique<Accelerator<3>>();
-  if(dim==4) return std::make_unique<Accelerator<4>>();
-  if(dim==5) return std::make_unique<Accelerator<5>>();
-  if(dim==6) return std::make_unique<Accelerator<6>>();
-  if(dim==7) return std::make_unique<Accelerator<7>>();
-  if(dim==8) return std::make_unique<Accelerator<8>>();
-  if(dim==9) return std::make_unique<Accelerator<9>>();
-  if(dim==10) return std::make_unique<Accelerator<10>>();
-  if(dim==11) return std::make_unique<Accelerator<11>>();
-  if(dim==12) return std::make_unique<Accelerator<12>>();
-  if(dim==13) return std::make_unique<Accelerator<13>>();
-  if(dim==14) return std::make_unique<Accelerator<14>>();
-  if(dim==15) return std::make_unique<Accelerator<15>>();
-  if(dim==16) return std::make_unique<Accelerator<16>>();
+  if(dim==1) {
+    return std::make_unique<Accelerator<1>>();
+  }
+  if(dim==2) {
+    return std::make_unique<Accelerator<2>>();
+  }
+  if(dim==3) {
+    return std::make_unique<Accelerator<3>>();
+  }
+  if(dim==4) {
+    return std::make_unique<Accelerator<4>>();
+  }
+  if(dim==5) {
+    return std::make_unique<Accelerator<5>>();
+  }
+  if(dim==6) {
+    return std::make_unique<Accelerator<6>>();
+  }
+  if(dim==7) {
+    return std::make_unique<Accelerator<7>>();
+  }
+  if(dim==8) {
+    return std::make_unique<Accelerator<8>>();
+  }
+  if(dim==9) {
+    return std::make_unique<Accelerator<9>>();
+  }
+  if(dim==10) {
+    return std::make_unique<Accelerator<10>>();
+  }
+  if(dim==11) {
+    return std::make_unique<Accelerator<11>>();
+  }
+  if(dim==12) {
+    return std::make_unique<Accelerator<12>>();
+  }
+  if(dim==13) {
+    return std::make_unique<Accelerator<13>>();
+  }
+  if(dim==14) {
+    return std::make_unique<Accelerator<14>>();
+  }
+  if(dim==15) {
+    return std::make_unique<Accelerator<15>>();
+  }
+  if(dim==16) {
+    return std::make_unique<Accelerator<16>>();
+  }
 // no need to go beyond this
   plumed_error();
 }
@@ -201,7 +247,8 @@ void GridBase::Init(const std::string& funcl, const std::vector<std::string> &na
   plumed_massert(names.size()==gmax.size(),"grid dimensions in input do not match number of arguments");
   dimension_=gmax.size();
   accelerator=AcceleratorHandler(dimension_);
-  str_min_=gmin; str_max_=gmax;
+  str_min_=gmin;
+  str_max_=gmax;
   argnames.resize( dimension_ );
   min_.resize( dimension_ );
   max_.resize( dimension_ );
@@ -224,11 +271,16 @@ void GridBase::Init(const std::string& funcl, const std::vector<std::string> &na
   nbin_=nbin;
   dospline_=dospline;
   usederiv_=usederiv;
-  if(dospline_) plumed_assert(dospline_==usederiv_);
+  if(dospline_) {
+    plumed_assert(dospline_==usederiv_);
+  }
   maxsize_=1;
   for(unsigned int i=0; i<dimension_; ++i) {
     dx_.push_back( (max_[i]-min_[i])/static_cast<double>( nbin_[i] ) );
-    if( !pbc_[i] ) { max_[i] += dx_[i]; nbin_[i] += 1; }
+    if( !pbc_[i] ) {
+      max_[i] += dx_[i];
+      nbin_[i] += 1;
+    }
     maxsize_*=nbin_[i];
   }
 }
@@ -251,7 +303,9 @@ double GridBase::getDx(index_t j) const {
 
 double GridBase::getBinVolume() const {
   double vol=1.;
-  for(unsigned i=0; i<dx_.size(); ++i) vol*=dx_[i];
+  for(unsigned i=0; i<dx_.size(); ++i) {
+    vol*=dx_[i];
+  }
   return vol;
 }
 
@@ -281,15 +335,22 @@ unsigned GridBase::getSplineNeighbors(const unsigned* indices, std::size_t indic
   std::array<unsigned,maxdim> nindices;
   unsigned inind;
   for(unsigned int i=0; i<nneigh; ++i) {
-    unsigned tmp=i; inind=0;
+    unsigned tmp=i;
+    inind=0;
     for(unsigned int j=0; j<dimension_; ++j) {
       unsigned i0=tmp%2+indices[j];
       tmp/=2;
-      if(!pbc_[j] && i0==nbin_[j]) continue;
-      if( pbc_[j] && i0==nbin_[j]) i0=0;
+      if(!pbc_[j] && i0==nbin_[j]) {
+        continue;
+      }
+      if( pbc_[j] && i0==nbin_[j]) {
+        i0=0;
+      }
       nindices[inind++]=i0;
     }
-    if(inind==dimension_) neighbors[nneighbors++]=getIndex(nindices.data(),dimension_);
+    if(inind==dimension_) {
+      neighbors[nneighbors++]=getIndex(nindices.data(),dimension_);
+    }
   }
   return nneighbors;
 }
@@ -343,10 +404,15 @@ void GridBase::addKernel( const KernelFunctions& kernel ) {
   for(unsigned i=0; i<neighbors.size(); ++i) {
     index_t ineigh=neighbors[i];
     getPoint( ineigh, xx );
-    for(unsigned j=0; j<dimension_; ++j) vv[j]->set(xx[j]);
+    for(unsigned j=0; j<dimension_; ++j) {
+      vv[j]->set(xx[j]);
+    }
     double newval = kernel.evaluate( vv_ptr, der, usederiv_ );
-    if( usederiv_ ) addValueAndDerivatives( ineigh, newval, der );
-    else addValue( ineigh, newval );
+    if( usederiv_ ) {
+      addValueAndDerivatives( ineigh, newval, der );
+    } else {
+      addValue( ineigh, newval );
+    }
   }
 }
 
@@ -382,7 +448,9 @@ double GridBase::getValueAndDerivatives(const std::vector<double> & x, std::vect
     std::array<double,maxdim> dder;
 // reset
     value=0.0;
-    for(unsigned int i=0; i<dimension_; ++i) der[i]=0.0;
+    for(unsigned int i=0; i<dimension_; ++i) {
+      der[i]=0.0;
+    }
 
     std::array<unsigned,maxdim> indices;
     getIndices(x, indices.data(),dimension_);
@@ -400,14 +468,19 @@ double GridBase::getValueAndDerivatives(const std::vector<double> & x, std::vect
 
       for(unsigned j=0; j<dimension_; ++j) {
         int x0=1;
-        if(nindices[j]==indices[j]) x0=0;
+        if(nindices[j]==indices[j]) {
+          x0=0;
+        }
         double dx=getDx(j);
         X=std::abs((x[j]-xfloor[j])/dx-(double)x0);
         X2=X*X;
         X3=X2*X;
         double yy;
-        if(std::abs(grid)<0.0000001) yy=0.0;
-        else yy=-dder[j]/grid;
+        if(std::abs(grid)<0.0000001) {
+          yy=0.0;
+        } else {
+          yy=-dder[j]/grid;
+        }
         C[j]=(1.0-3.0*X2+2.0*X3) - (x0?-1.0:1.0)*yy*(X-2.0*X2+X3)*dx;
         D[j]=( -6.0*X +6.0*X2) - (x0?-1.0:1.0)*yy*(1.0-4.0*X +3.0*X2)*dx;
         D[j]*=(x0?-1.0:1.0)/dx;
@@ -415,10 +488,15 @@ double GridBase::getValueAndDerivatives(const std::vector<double> & x, std::vect
       }
       for(unsigned j=0; j<dimension_; ++j) {
         fd[j]=D[j];
-        for(unsigned i=0; i<dimension_; ++i) if(i!=j) fd[j]*=C[i];
+        for(unsigned i=0; i<dimension_; ++i)
+          if(i!=j) {
+            fd[j]*=C[i];
+          }
       }
       value+=grid*ff;
-      for(unsigned j=0; j<dimension_; ++j) der[j]+=grid*fd[j];
+      for(unsigned j=0; j<dimension_; ++j) {
+        der[j]+=grid*fd[j];
+      }
     }
     return value;
   } else {
@@ -453,7 +531,9 @@ void GridBase::writeHeader(OFile& ofile) {
 
 void Grid::clear() {
   grid_.assign(maxsize_,0.0);
-  if(usederiv_) der_.assign(maxsize_*dimension_,0.0);
+  if(usederiv_) {
+    der_.assign(maxsize_*dimension_,0.0);
+  }
 }
 
 void Grid::writeToFile(OFile& ofile) {
@@ -463,19 +543,35 @@ void Grid::writeToFile(OFile& ofile) {
   writeHeader(ofile);
   for(index_t i=0; i<getSize(); ++i) {
     xx=getPoint(i);
-    if(usederiv_) {f=getValueAndDerivatives(i,der);}
-    else {f=getValue(i);}
-    if(i>0 && dimension_>1 && getIndices(i)[dimension_-2]==0) ofile.printf("\n");
+    if(usederiv_) {
+      f=getValueAndDerivatives(i,der);
+    } else {
+      f=getValue(i);
+    }
+    if(i>0 && dimension_>1 && getIndices(i)[dimension_-2]==0) {
+      ofile.printf("\n");
+    }
     for(unsigned j=0; j<dimension_; ++j) {
       ofile.printField("min_" + argnames[j], str_min_[j] );
       ofile.printField("max_" + argnames[j], str_max_[j] );
       ofile.printField("nbins_" + argnames[j], static_cast<int>(nbin_[j]) );
-      if( pbc_[j] ) ofile.printField("periodic_" + argnames[j], "true" );
-      else          ofile.printField("periodic_" + argnames[j], "false" );
+      if( pbc_[j] ) {
+        ofile.printField("periodic_" + argnames[j], "true" );
+      } else {
+        ofile.printField("periodic_" + argnames[j], "false" );
+      }
+    }
+    for(unsigned j=0; j<dimension_; ++j) {
+      ofile.fmtField(" "+fmt_);
+      ofile.printField(argnames[j],xx[j]);
     }
-    for(unsigned j=0; j<dimension_; ++j) { ofile.fmtField(" "+fmt_); ofile.printField(argnames[j],xx[j]); }
-    ofile.fmtField(" "+fmt_); ofile.printField(funcname,f);
-    if(usederiv_) for(unsigned j=0; j<dimension_; ++j) { ofile.fmtField(" "+fmt_); ofile.printField("der_" + argnames[j],der[j]); }
+    ofile.fmtField(" "+fmt_);
+    ofile.printField(funcname,f);
+    if(usederiv_)
+      for(unsigned j=0; j<dimension_; ++j) {
+        ofile.fmtField(" "+fmt_);
+        ofile.printField("der_" + argnames[j],der[j]);
+      }
     ofile.printField();
   }
 }
@@ -495,7 +591,9 @@ void GridBase::writeCubeFile(OFile& ofile, const double& lunit) {
     for(pp[1]=0; pp[1]<nbin_[1]; ++pp[1]) {
       for(pp[2]=0; pp[2]<nbin_[2]; ++pp[2]) {
         ofile.printf("%f ",getValue(pp) );
-        if(pp[2]%6==5) ofile.printf("\n");
+        if(pp[2]%6==5) {
+          ofile.printf("\n");
+        }
       }
       ofile.printf("\n");
     }
@@ -520,26 +618,36 @@ std::unique_ptr<GridBase> GridBase::create(const std::string& funcl, const std::
   return grid;
 }
 
-std::unique_ptr<GridBase> GridBase::create(const std::string& funcl, const std::vector<Value*> & args, IFile& ifile, bool dosparse, bool dospline, bool doder)
-{
+std::unique_ptr<GridBase> GridBase::create(const std::string& funcl, const std::vector<Value*> & args, IFile& ifile, bool dosparse, bool dospline, bool doder) {
   std::unique_ptr<GridBase> grid;
-  unsigned nvar=args.size(); bool hasder=false; std::string pstring;
-  std::vector<int> gbin1(nvar); std::vector<unsigned> gbin(nvar);
+  unsigned nvar=args.size();
+  bool hasder=false;
+  std::string pstring;
+  std::vector<int> gbin1(nvar);
+  std::vector<unsigned> gbin(nvar);
   std::vector<std::string> labels(nvar),gmin(nvar),gmax(nvar);
-  std::vector<std::string> fieldnames; ifile.scanFieldList( fieldnames );
+  std::vector<std::string> fieldnames;
+  ifile.scanFieldList( fieldnames );
 
 // Retrieve names for fields
   for(unsigned i=0; i<args.size(); ++i) {
-    labels[i]=args[i]->getName(); bool found=false;
+    labels[i]=args[i]->getName();
+    bool found=false;
     for(unsigned j=0; j<fieldnames.size(); ++j) {
-      if( labels[i]==fieldnames[j] ) { found=true; break; }
+      if( labels[i]==fieldnames[j] ) {
+        found=true;
+        break;
+      }
     }
     // This is a change to ensure that we can deal with old style names for multicolvars
     std::size_t und = labels[i].find_first_of("_");
     if( !found && und!=std::string::npos ) {
       labels[i] = labels[i].substr(0,und) + "." + labels[i].substr(und+1);
       for(unsigned j=0; j<fieldnames.size(); ++j) {
-        if( labels[i]==fieldnames[j] ) { found=true; break; }
+        if( labels[i]==fieldnames[j] ) {
+          found=true;
+          break;
+        }
       }
     }
   }
@@ -554,40 +662,60 @@ std::unique_ptr<GridBase> GridBase::create(const std::string& funcl, const std::
     if( args[i]->isPeriodic() ) {
       plumed_massert( pstring=="true", "input value is periodic but grid is not");
       std::string pmin, pmax;
-      args[i]->getDomain( pmin, pmax ); gbin[i]=gbin1[i];
-      if( pmin!=gmin[i] || pmax!=gmax[i] ) plumed_merror("mismatch between grid boundaries and periods of values");
+      args[i]->getDomain( pmin, pmax );
+      gbin[i]=gbin1[i];
+      if( pmin!=gmin[i] || pmax!=gmax[i] ) {
+        plumed_merror("mismatch between grid boundaries and periods of values");
+      }
     } else {
       gbin[i]=gbin1[i]-1;  // Note header in grid file indicates one more bin that there should be when data is not periodic
       plumed_massert( pstring=="false", "input value is not periodic but grid is");
     }
     hasder=ifile.FieldExist( "der_" + labels[i] );
-    if( doder && !hasder ) plumed_merror("missing derivatives from grid file");
+    if( doder && !hasder ) {
+      plumed_merror("missing derivatives from grid file");
+    }
     for(unsigned j=0; j<fieldnames.size(); ++j) {
       for(unsigned k=i+1; k<args.size(); ++k) {
-        if( fieldnames[j]==labels[k] ) plumed_merror("arguments in input are not in same order as in grid file");
+        if( fieldnames[j]==labels[k] ) {
+          plumed_merror("arguments in input are not in same order as in grid file");
+        }
+      }
+      if( fieldnames[j]==labels[i] ) {
+        break;
       }
-      if( fieldnames[j]==labels[i] ) break;
     }
   }
 
-  if(!dosparse) {grid=Tools::make_unique<Grid>(funcl,args,gmin,gmax,gbin,dospline,doder);}
-  else {grid=Tools::make_unique<SparseGrid>(funcl,args,gmin,gmax,gbin,dospline,doder);}
+  if(!dosparse) {
+    grid=Tools::make_unique<Grid>(funcl,args,gmin,gmax,gbin,dospline,doder);
+  } else {
+    grid=Tools::make_unique<SparseGrid>(funcl,args,gmin,gmax,gbin,dospline,doder);
+  }
 
   std::vector<double> xx(nvar),dder(nvar);
   std::vector<double> dx=grid->getDx();
   double f,x;
   while( ifile.scanField(funcl,f) ) {
     for(unsigned i=0; i<nvar; ++i) {
-      ifile.scanField(labels[i],x); xx[i]=x+dx[i]/2.0;
+      ifile.scanField(labels[i],x);
+      xx[i]=x+dx[i]/2.0;
       ifile.scanField( "min_" + labels[i], gmin[i]);
       ifile.scanField( "max_" + labels[i], gmax[i]);
       ifile.scanField( "nbins_" + labels[i], gbin1[i]);
       ifile.scanField( "periodic_" + labels[i], pstring );
     }
-    if(hasder) { for(unsigned i=0; i<nvar; ++i) { ifile.scanField( "der_" + labels[i], dder[i] ); } }
+    if(hasder) {
+      for(unsigned i=0; i<nvar; ++i) {
+        ifile.scanField( "der_" + labels[i], dder[i] );
+      }
+    }
     index_t index=grid->getIndex(xx);
-    if(doder) {grid->setValueAndDerivatives(index,f,dder);}
-    else {grid->setValue(index,f);}
+    if(doder) {
+      grid->setValueAndDerivatives(index,f,dder);
+    } else {
+      grid->setValue(index,f);
+    }
     ifile.scanField();
   }
   return grid;
@@ -597,7 +725,9 @@ double Grid::getMinValue() const {
   double minval;
   minval=DBL_MAX;
   for(index_t i=0; i<grid_.size(); ++i) {
-    if(grid_[i]<minval)minval=grid_[i];
+    if(grid_[i]<minval) {
+      minval=grid_[i];
+    }
   }
   return minval;
 }
@@ -606,7 +736,9 @@ double Grid::getMaxValue() const {
   double maxval;
   maxval=DBL_MIN;
   for(index_t i=0; i<grid_.size(); ++i) {
-    if(grid_[i]>maxval)maxval=grid_[i];
+    if(grid_[i]>maxval) {
+      maxval=grid_[i];
+    }
   }
   return maxval;
 }
@@ -615,10 +747,14 @@ void Grid::scaleAllValuesAndDerivatives( const double& scalef ) {
   if(usederiv_) {
     for(index_t i=0; i<grid_.size(); ++i) {
       grid_[i]*=scalef;
-      for(unsigned j=0; j<dimension_; ++j) der_[i*dimension_+j]*=scalef;
+      for(unsigned j=0; j<dimension_; ++j) {
+        der_[i*dimension_+j]*=scalef;
+      }
     }
   } else {
-    for(index_t i=0; i<grid_.size(); ++i) grid_[i]*=scalef;
+    for(index_t i=0; i<grid_.size(); ++i) {
+      grid_[i]*=scalef;
+    }
   }
 }
 
@@ -626,27 +762,40 @@ void Grid::logAllValuesAndDerivatives( const double& scalef ) {
   if(usederiv_) {
     for(index_t i=0; i<grid_.size(); ++i) {
       grid_[i] = scalef*std::log(grid_[i]);
-      for(unsigned j=0; j<dimension_; ++j) der_[i*dimension_+j] = scalef/der_[i*dimension_+j];
+      for(unsigned j=0; j<dimension_; ++j) {
+        der_[i*dimension_+j] = scalef/der_[i*dimension_+j];
+      }
     }
   } else {
-    for(index_t i=0; i<grid_.size(); ++i) grid_[i] = scalef*std::log(grid_[i]);
+    for(index_t i=0; i<grid_.size(); ++i) {
+      grid_[i] = scalef*std::log(grid_[i]);
+    }
   }
 }
 
 void Grid::setMinToZero() {
   double min=grid_[0];
-  for(index_t i=1; i<grid_.size(); ++i) if(grid_[i]<min) min=grid_[i];
-  for(index_t i=0; i<grid_.size(); ++i) grid_[i] -= min;
+  for(index_t i=1; i<grid_.size(); ++i)
+    if(grid_[i]<min) {
+      min=grid_[i];
+    }
+  for(index_t i=0; i<grid_.size(); ++i) {
+    grid_[i] -= min;
+  }
 }
 
 void Grid::applyFunctionAllValuesAndDerivatives( double (*func)(double val), double (*funcder)(double valder) ) {
   if(usederiv_) {
     for(index_t i=0; i<grid_.size(); ++i) {
       grid_[i]=func(grid_[i]);
-      for(unsigned j=0; j<dimension_; ++j) der_[i*dimension_+j]=funcder(der_[i*dimension_+j]);
+      for(unsigned j=0; j<dimension_; ++j) {
+        der_[i*dimension_+j]=funcder(der_[i*dimension_+j]);
+      }
     }
   } else {
-    for(index_t i=0; i<grid_.size(); ++i) grid_[i]=func(grid_[i]);
+    for(index_t i=0; i<grid_.size(); ++i) {
+      grid_[i]=func(grid_[i]);
+    }
   }
 }
 
@@ -666,9 +815,12 @@ void Grid::findSetOfPointsOnContour(const double& target, const std::vector<bool
   std::vector<double> direction( dimension_, 0 );
 
 // Run over whole grid
-  npoints=0; RootFindingBase<Grid> mymin( this );
+  npoints=0;
+  RootFindingBase<Grid> mymin( this );
   for(unsigned i=0; i<maxsize_; ++i) {
-    for(unsigned j=0; j<dimension_; ++j) ind[j]=getIndices(i)[j];
+    for(unsigned j=0; j<dimension_; ++j) {
+      ind[j]=getIndices(i)[j];
+    }
 
     // Get the value of a point on the grid
     double val1=getValue(i) - target;
@@ -676,23 +828,38 @@ void Grid::findSetOfPointsOnContour(const double& target, const std::vector<bool
     // Now search for contour in each direction
     bool edge=false;
     for(unsigned j=0; j<dimension_; ++j) {
-      if( nosearch[j] ) continue ;
+      if( nosearch[j] ) {
+        continue ;
+      }
       // Make sure we don't search at the edge of the grid
-      if( !pbc_[j] && (ind[j]+1)==nbin_[j] ) continue;
-      else if( (ind[j]+1)==nbin_[j] ) { edge=true; ind[j]=0; }
-      else ind[j]+=1;
+      if( !pbc_[j] && (ind[j]+1)==nbin_[j] ) {
+        continue;
+      } else if( (ind[j]+1)==nbin_[j] ) {
+        edge=true;
+        ind[j]=0;
+      } else {
+        ind[j]+=1;
+      }
       double val2=getValue(ind) - target;
       if( val1*val2<0 ) {
         // Use initial point location as first guess for search
-        points[npoints].resize(dimension_); for(unsigned k=0; k<dimension_; ++k) points[npoints][k]=getPoint(i)[k];
+        points[npoints].resize(dimension_);
+        for(unsigned k=0; k<dimension_; ++k) {
+          points[npoints][k]=getPoint(i)[k];
+        }
         // Setup direction vector
         direction[j]=0.999999999*dx_[j];
         // And do proper search for contour point
         mymin.linesearch( direction, points[npoints], &Grid::getDifferenceFromContour );
-        direction[j]=0.0; npoints++;
+        direction[j]=0.0;
+        npoints++;
+      }
+      if( pbc_[j] && edge ) {
+        edge=false;
+        ind[j]=nbin_[j]-1;
+      } else {
+        ind[j]-=1;
       }
-      if( pbc_[j] && edge ) { edge=false; ind[j]=nbin_[j]-1; }
-      else ind[j]-=1;
     }
   }
 }
@@ -710,7 +877,9 @@ double Grid::getValue(index_t index) const {
 
 double Grid::getValueAndDerivatives(index_t index, double* der,std::size_t der_size) const {
   plumed_dbg_assert(index<maxsize_ && usederiv_ && der_size==dimension_);
-  for(unsigned i=0; i<dimension_; i++) der[i]=der_[dimension_*index+i];
+  for(unsigned i=0; i<dimension_; i++) {
+    der[i]=der_[dimension_*index+i];
+  }
   return grid_[index];
 }
 
@@ -722,7 +891,9 @@ void Grid::setValue(index_t index, double value) {
 void Grid::setValueAndDerivatives(index_t index, double value, std::vector<double>& der) {
   plumed_dbg_assert(index<maxsize_ && usederiv_ && der.size()==dimension_);
   grid_[index]=value;
-  for(unsigned i=0; i<dimension_; i++) der_[dimension_*index+i]=der[i];
+  for(unsigned i=0; i<dimension_; i++) {
+    der_[dimension_*index+i]=der[i];
+  }
 }
 
 void Grid::addValue(index_t index, double value) {
@@ -733,7 +904,9 @@ void Grid::addValue(index_t index, double value) {
 void Grid::addValueAndDerivatives(index_t index, double value, std::vector<double>& der) {
   plumed_dbg_assert(index<maxsize_ && usederiv_ && der.size()==dimension_);
   grid_[index]+=value;
-  for(unsigned int i=0; i<dimension_; ++i) der_[index*dimension_+i]+=der[i];
+  for(unsigned int i=0; i<dimension_; ++i) {
+    der_[index*dimension_+i]+=der[i];
+  }
 }
 
 Grid::index_t SparseGrid::getSize() const {
@@ -748,20 +921,28 @@ double SparseGrid::getValue(index_t index)const {
   plumed_assert(index<maxsize_);
   double value=0.0;
   const auto it=map_.find(index);
-  if(it!=map_.end()) value=it->second;
+  if(it!=map_.end()) {
+    value=it->second;
+  }
   return value;
 }
 
 double SparseGrid::getValueAndDerivatives(index_t index, double* der, std::size_t der_size)const {
   plumed_assert(index<maxsize_ && usederiv_ && der_size==dimension_);
   double value=0.0;
-  for(unsigned int i=0; i<dimension_; ++i) der[i]=0.0;
+  for(unsigned int i=0; i<dimension_; ++i) {
+    der[i]=0.0;
+  }
   const auto it=map_.find(index);
-  if(it!=map_.end()) value=it->second;
+  if(it!=map_.end()) {
+    value=it->second;
+  }
   const auto itder=der_.find(index);
   if(itder!=der_.end()) {
     const auto & second(itder->second);
-    for(unsigned i=0; i<second.size(); i++) der[i]=itder->second[i];
+    for(unsigned i=0; i<second.size(); i++) {
+      der[i]=itder->second[i];
+    }
   }
   return value;
 }
@@ -786,7 +967,9 @@ void SparseGrid::addValueAndDerivatives(index_t index, double value, std::vector
   plumed_assert(index<maxsize_ && usederiv_ && der.size()==dimension_);
   map_[index]+=value;
   der_[index].resize(dimension_);
-  for(unsigned int i=0; i<dimension_; ++i) der_[index][i]+=der[i];
+  for(unsigned int i=0; i<dimension_; ++i) {
+    der_[index][i]+=der[i];
+  }
 }
 
 void SparseGrid::writeToFile(OFile& ofile) {
@@ -798,19 +981,33 @@ void SparseGrid::writeToFile(OFile& ofile) {
   for(const auto & it : map_) {
     index_t i=it.first;
     xx=getPoint(i);
-    if(usederiv_) {f=getValueAndDerivatives(i,der);}
-    else {f=getValue(i);}
-    if(i>0 && dimension_>1 && getIndices(i)[dimension_-2]==0) ofile.printf("\n");
+    if(usederiv_) {
+      f=getValueAndDerivatives(i,der);
+    } else {
+      f=getValue(i);
+    }
+    if(i>0 && dimension_>1 && getIndices(i)[dimension_-2]==0) {
+      ofile.printf("\n");
+    }
     for(unsigned j=0; j<dimension_; ++j) {
       ofile.printField("min_" + argnames[j], str_min_[j] );
       ofile.printField("max_" + argnames[j], str_max_[j] );
       ofile.printField("nbins_" + argnames[j], static_cast<int>(nbin_[j]) );
-      if( pbc_[j] ) ofile.printField("periodic_" + argnames[j], "true" );
-      else          ofile.printField("periodic_" + argnames[j], "false" );
+      if( pbc_[j] ) {
+        ofile.printField("periodic_" + argnames[j], "true" );
+      } else {
+        ofile.printField("periodic_" + argnames[j], "false" );
+      }
+    }
+    for(unsigned j=0; j<dimension_; ++j) {
+      ofile.printField(argnames[j],xx[j]);
     }
-    for(unsigned j=0; j<dimension_; ++j) ofile.printField(argnames[j],xx[j]);
     ofile.printField(funcname, f);
-    if(usederiv_) { for(unsigned j=0; j<dimension_; ++j) ofile.printField("der_" + argnames[j],der[j]); }
+    if(usederiv_) {
+      for(unsigned j=0; j<dimension_; ++j) {
+        ofile.printField("der_" + argnames[j],der[j]);
+      }
+    }
     ofile.printField();
   }
 }
@@ -819,7 +1016,9 @@ double SparseGrid::getMinValue() const {
   double minval;
   minval=0.0;
   for(auto const & i : map_) {
-    if(i.second<minval) minval=i.second;
+    if(i.second<minval) {
+      minval=i.second;
+    }
   }
   return minval;
 }
@@ -828,7 +1027,9 @@ double SparseGrid::getMaxValue() const {
   double maxval;
   maxval=0.0;
   for(auto const & i : map_) {
-    if(i.second>maxval) maxval=i.second;
+    if(i.second>maxval) {
+      maxval=i.second;
+    }
   }
   return maxval;
 }
@@ -853,7 +1054,9 @@ void Grid::projectOnLowDimension(double &val, std::vector<int> &vHigh, WeightBas
     //   std::cerr<<vHigh[j]<<" ";
     //}
     std::vector<unsigned> vv(vHigh.size());
-    for(unsigned j=0; j<vHigh.size(); j++)vv[j]=unsigned(vHigh[j]);
+    for(unsigned j=0; j<vHigh.size(); j++) {
+      vv[j]=unsigned(vHigh[j]);
+    }
     //
     // this is the real assignment !!!!! (hack this to have bias or other stuff)
     //
@@ -877,14 +1080,20 @@ Grid Grid::project(const std::vector<std::string> & proj, WeightBase *ptr2obj )
 
   // check if the two key methods are there
   WeightBase* pp = dynamic_cast<WeightBase*>(ptr2obj);
-  if (!pp)plumed_merror("This WeightBase is not complete: you need a projectInnerLoop and projectOuterLoop ");
+  if (!pp) {
+    plumed_merror("This WeightBase is not complete: you need a projectInnerLoop and projectOuterLoop ");
+  }
 
   for(unsigned j=0; j<proj.size(); j++) {
     for(unsigned i=0; i<getArgNames().size(); i++) {
       if(proj[j]==getArgNames()[i]) {
         unsigned offset;
         // note that at sizetime the non periodic dimension get a bin more
-        if(getIsPeriodic()[i]) {offset=0;} else {offset=1;}
+        if(getIsPeriodic()[i]) {
+          offset=0;
+        } else {
+          offset=1;
+        }
         smallMax.push_back(getMax()[i]);
         smallMin.push_back(getMin()[i]);
         smallBin.push_back(getNbin()[i]-offset);
@@ -906,9 +1115,14 @@ Grid Grid::project(const std::vector<std::string> & proj, WeightBase *ptr2obj )
   for(unsigned i=0; i<getArgNames().size(); i++) {
     bool doappend=true;
     for(unsigned j=0; j<dimMapping.size(); j++) {
-      if(dimMapping[j]==i) {doappend=false; break;}
+      if(dimMapping[j]==i) {
+        doappend=false;
+        break;
+      }
+    }
+    if(doappend) {
+      toBeIntegrated.push_back(i);
     }
-    if(doappend)toBeIntegrated.push_back(i);
   }
 
   // loop over all the points in the Grid, find the corresponding fixed index, rotate over all the other ones
@@ -916,7 +1130,9 @@ Grid Grid::project(const std::vector<std::string> & proj, WeightBase *ptr2obj )
     std::vector<unsigned> v;
     v=smallgrid.getIndices(i);
     std::vector<int> vHigh((getArgNames()).size(),-1);
-    for(unsigned j=0; j<dimMapping.size(); j++)vHigh[dimMapping[j]]=int(v[j]);
+    for(unsigned j=0; j<dimMapping.size(); j++) {
+      vHigh[dimMapping[j]]=int(v[j]);
+    }
     // the vector vhigh now contains at the beginning the index of the low dimension and -1 for the values that need to be integrated
     double initval=0.;
     projectOnLowDimension(initval,vHigh, ptr2obj);
@@ -927,9 +1143,11 @@ Grid Grid::project(const std::vector<std::string> & proj, WeightBase *ptr2obj )
 }
 
 double Grid::integrate( std::vector<unsigned>& npoints ) {
-  plumed_dbg_assert( npoints.size()==dimension_ ); plumed_assert( dospline_ );
+  plumed_dbg_assert( npoints.size()==dimension_ );
+  plumed_assert( dospline_ );
 
-  unsigned ntotgrid=1; double box_vol=1.0;
+  unsigned ntotgrid=1;
+  double box_vol=1.0;
   std::vector<double> ispacing( npoints.size() );
   for(unsigned j=0; j<dimension_; ++j) {
     if( !pbc_[j] ) {
@@ -938,18 +1156,27 @@ double Grid::integrate( std::vector<unsigned>& npoints ) {
     } else {
       ispacing[j] = ( max_[j] - min_[j] ) / static_cast<double>( npoints[j] );
     }
-    ntotgrid*=npoints[j]; box_vol*=ispacing[j];
+    ntotgrid*=npoints[j];
+    box_vol*=ispacing[j];
   }
 
   std::vector<double> vals( dimension_ );
-  std::vector<unsigned> t_index( dimension_ ); double integral=0.0;
+  std::vector<unsigned> t_index( dimension_ );
+  double integral=0.0;
   for(unsigned i=0; i<ntotgrid; ++i) {
     t_index[0]=(i%npoints[0]);
     unsigned kk=i;
-    for(unsigned j=1; j<dimension_-1; ++j) { kk=(kk-t_index[j-1])/npoints[j-1]; t_index[j]=(kk%npoints[j]); }
-    if( dimension_>=2 ) t_index[dimension_-1]=((kk-t_index[dimension_-2])/npoints[dimension_-2]);
+    for(unsigned j=1; j<dimension_-1; ++j) {
+      kk=(kk-t_index[j-1])/npoints[j-1];
+      t_index[j]=(kk%npoints[j]);
+    }
+    if( dimension_>=2 ) {
+      t_index[dimension_-1]=((kk-t_index[dimension_-2])/npoints[dimension_-2]);
+    }
 
-    for(unsigned j=0; j<dimension_; ++j) vals[j]=min_[j] + t_index[j]*ispacing[j];
+    for(unsigned j=0; j<dimension_; ++j) {
+      vals[j]=min_[j] + t_index[j]*ispacing[j];
+    }
 
     integral += getValue( vals );
   }
@@ -958,7 +1185,10 @@ double Grid::integrate( std::vector<unsigned>& npoints ) {
 }
 
 void Grid::mpiSumValuesAndDerivatives( Communicator& comm ) {
-  comm.Sum( grid_ ); for(unsigned i=0; i<der_.size(); ++i) comm.Sum( der_[i] );
+  comm.Sum( grid_ );
+  for(unsigned i=0; i<der_.size(); ++i) {
+    comm.Sum( der_[i] );
+  }
 }
 
 
diff --git a/src/tools/Grid.h b/src/tools/Grid.h
index f8ad142d3e..4badb857af 100644
--- a/src/tools/Grid.h
+++ b/src/tools/Grid.h
@@ -48,7 +48,10 @@ class BiasWeight:public WeightBase {
 public:
   double beta,invbeta;
   double shift=0.0;
-  explicit BiasWeight(double v) {beta=v; invbeta=1./beta;}
+  explicit BiasWeight(double v) {
+    beta=v;
+    invbeta=1./beta;
+  }
   //double projectInnerLoop(double &input, double &v) override {return  input+exp(beta*v);}
   //double projectOuterLoop(double &v) override {return -invbeta*std::log(v);}
   double projectInnerLoop(double &input, double &v) override {
@@ -71,9 +74,16 @@ class BiasWeight:public WeightBase {
 class ProbWeight:public WeightBase {
 public:
   double beta,invbeta;
-  explicit ProbWeight(double v) {beta=v; invbeta=1./beta;}
-  double projectInnerLoop(double &input, double &v) override {return  input+v;}
-  double projectOuterLoop(double &v) override {return -invbeta*std::log(v);}
+  explicit ProbWeight(double v) {
+    beta=v;
+    invbeta=1./beta;
+  }
+  double projectInnerLoop(double &input, double &v) override {
+    return  input+v;
+  }
+  double projectOuterLoop(double &v) override {
+    return -invbeta*std::log(v);
+  }
 };
 
 
@@ -88,8 +98,7 @@ class KernelFunctions;
 class Communicator;
 
 /// \ingroup TOOLBOX
-class GridBase
-{
+class GridBase {
 public:
 // we use a size_t here
 // should be 8 bytes on all 64-bit machines
@@ -190,7 +199,9 @@ class GridBase
     AcceleratorHandler & operator=(const AcceleratorHandler & other) {
       if(this!=&other) {
         ptr.reset();
-        if(other.ptr) ptr=AcceleratorBase::create(other->getDimension());
+        if(other.ptr) {
+          ptr=AcceleratorBase::create(other->getDimension());
+        }
       }
       return *this;
     }
@@ -251,7 +262,9 @@ class GridBase
 /// get argument names  of this grid
   std::vector<std::string> getArgNames() const;
 /// get if the grid has derivatives
-  bool hasDerivatives() const {return usederiv_;}
+  bool hasDerivatives() const {
+    return usederiv_;
+  }
 
 /// methods to handle grid indices
   void getIndices(index_t index, std::vector<unsigned>& rindex) const;
@@ -330,17 +343,20 @@ class GridBase
   virtual ~GridBase() = default;
 
 /// set output format
-  void setOutputFmt(const std::string & ss) {fmt_=ss;}
+  void setOutputFmt(const std::string & ss) {
+    fmt_=ss;
+  }
 /// reset output format to the default %14.9f format
-  void resetToDefaultOutputFmt() {fmt_="%14.9f";}
+  void resetToDefaultOutputFmt() {
+    fmt_="%14.9f";
+  }
 ///
 /// Find the maximum over paths of the minimum value of the gridded function along the paths
 /// for all paths of neighboring grid lattice points from a source point to a sink point.
   double findMaximalPathMinimum(const std::vector<double> &source, const std::vector<double> &sink);
 };
 
-class Grid : public GridBase
-{
+class Grid : public GridBase {
   std::vector<double> grid_;
   std::vector<double> der_;
   double contour_location=0.0;
@@ -348,20 +364,22 @@ class Grid : public GridBase
   Grid(const std::string& funcl, const std::vector<Value*> & args, const std::vector<std::string> & gmin,
        const std::vector<std::string> & gmax,
        const std::vector<unsigned> & nbin, bool dospline, bool usederiv):
-    GridBase(funcl,args,gmin,gmax,nbin,dospline,usederiv)
-  {
+    GridBase(funcl,args,gmin,gmax,nbin,dospline,usederiv) {
     grid_.assign(maxsize_,0.0);
-    if(usederiv_) der_.assign(maxsize_*dimension_,0.0);
+    if(usederiv_) {
+      der_.assign(maxsize_*dimension_,0.0);
+    }
   }
 /// this constructor here is not Value-aware
   Grid(const std::string& funcl, const std::vector<std::string> &names, const std::vector<std::string> & gmin,
        const std::vector<std::string> & gmax, const std::vector<unsigned> & nbin, bool dospline,
        bool usederiv, const std::vector<bool> &isperiodic, const std::vector<std::string> &pmin,
        const std::vector<std::string> &pmax ):
-    GridBase(funcl,names,gmin,gmax,nbin,dospline,usederiv,isperiodic,pmin,pmax)
-  {
+    GridBase(funcl,names,gmin,gmax,nbin,dospline,usederiv,isperiodic,pmin,pmax) {
     grid_.assign(maxsize_,0.0);
-    if(usederiv_) der_.assign(maxsize_*dimension_,0.0);
+    if(usederiv_) {
+      der_.assign(maxsize_*dimension_,0.0);
+    }
   }
   index_t getSize() const override;
 /// this is to access to Grid:: version of these methods (allowing overloading of virtual methods)
@@ -415,8 +433,7 @@ class Grid : public GridBase
 };
 
 
-class SparseGrid : public GridBase
-{
+class SparseGrid : public GridBase {
 
   std::map<index_t,double> map_;
   std::map< index_t,std::vector<double> > der_;
@@ -499,7 +516,9 @@ void GridBase::getIndices(index_t index, unsigned* indices, std::size_t indices_
 
 inline
 void GridBase::getIndices(index_t index, std::vector<unsigned>& indices) const {
-  if (indices.size()!=dimension_) indices.resize(dimension_);
+  if (indices.size()!=dimension_) {
+    indices.resize(dimension_);
+  }
   getIndices(index,indices.data(),indices.size());
 }
 
diff --git a/src/tools/HistogramBead.cpp b/src/tools/HistogramBead.cpp
index eec7d7a312..0fb95191e1 100644
--- a/src/tools/HistogramBead.cpp
+++ b/src/tools/HistogramBead.cpp
@@ -101,8 +101,7 @@ HistogramBead::HistogramBead():
   min(0.0),
   max(0.0),
   max_minus_min(0.0),
-  inv_max_minus_min(0.0)
-{
+  inv_max_minus_min(0.0) {
 }
 
 std::string HistogramBead::description() const {
@@ -117,7 +116,9 @@ void HistogramBead::generateBins( const std::string& params, std::vector<std::st
 
   std::string name=data[0];
 
-  unsigned nbins; std::vector<double> range(2); std::string smear;
+  unsigned nbins;
+  std::vector<double> range(2);
+  std::string smear;
   bool found_nb=Tools::parse(data,"NBINS",nbins);
   plumed_massert(found_nb,"Number of bins in histogram not found");
   bool found_r=Tools::parse(data,"LOWER",range[0]);
@@ -126,9 +127,12 @@ void HistogramBead::generateBins( const std::string& params, std::vector<std::st
   plumed_massert(found_r,"Upper bound for histogram not specified");
   plumed_massert(range[0]<range[1],"Range specification is dubious");
   bool found_b=Tools::parse(data,"SMEAR",smear);
-  if(!found_b) { Tools::convert(0.5,smear); }
+  if(!found_b) {
+    Tools::convert(0.5,smear);
+  }
 
-  std::string lb,ub; double delr = ( range[1]-range[0] ) / static_cast<double>( nbins );
+  std::string lb,ub;
+  double delr = ( range[1]-range[0] ) / static_cast<double>( nbins );
   for(unsigned i=0; i<nbins; ++i) {
     Tools::convert( range[0]+i*delr, lb );
     Tools::convert( range[0]+(i+1)*delr, ub );
@@ -144,34 +148,60 @@ void HistogramBead::set( const std::string& params, std::string& errormsg ) {
     return;
   }
 
-  std::string name=data[0]; const double DP2CUTOFF=6.25;
-  if(name=="GAUSSIAN") { type=gaussian; cutoff=std::sqrt(2.0*DP2CUTOFF); }
-  else if(name=="TRIANGULAR") { type=triangular; cutoff=1.; }
-  else plumed_merror("cannot understand kernel type " + name );
+  std::string name=data[0];
+  const double DP2CUTOFF=6.25;
+  if(name=="GAUSSIAN") {
+    type=gaussian;
+    cutoff=std::sqrt(2.0*DP2CUTOFF);
+  } else if(name=="TRIANGULAR") {
+    type=triangular;
+    cutoff=1.;
+  } else {
+    plumed_merror("cannot understand kernel type " + name );
+  }
 
   double smear;
   bool found_r=Tools::parse(data,"LOWER",lowb);
-  if( !found_r ) errormsg="Lower bound has not been specified use LOWER";
+  if( !found_r ) {
+    errormsg="Lower bound has not been specified use LOWER";
+  }
   found_r=Tools::parse(data,"UPPER",highb);
-  if( !found_r ) errormsg="Upper bound has not been specified use UPPER";
-  if( lowb>=highb ) errormsg="Lower bound is higher than upper bound";
+  if( !found_r ) {
+    errormsg="Upper bound has not been specified use UPPER";
+  }
+  if( lowb>=highb ) {
+    errormsg="Lower bound is higher than upper bound";
+  }
 
-  smear=0.5; Tools::parse(data,"SMEAR",smear);
-  width=smear*(highb-lowb); init=true;
+  smear=0.5;
+  Tools::parse(data,"SMEAR",smear);
+  width=smear*(highb-lowb);
+  init=true;
 }
 
 void HistogramBead::set( double l, double h, double w) {
-  init=true; lowb=l; highb=h; width=w;
+  init=true;
+  lowb=l;
+  highb=h;
+  width=w;
   const double DP2CUTOFF=6.25;
-  if( type==gaussian ) cutoff=std::sqrt(2.0*DP2CUTOFF);
-  else if( type==triangular ) cutoff=1.;
-  else plumed_error();
+  if( type==gaussian ) {
+    cutoff=std::sqrt(2.0*DP2CUTOFF);
+  } else if( type==triangular ) {
+    cutoff=1.;
+  } else {
+    plumed_error();
+  }
 }
 
 void HistogramBead::setKernelType( const std::string& ktype ) {
-  if(ktype=="gaussian") type=gaussian;
-  else if(ktype=="triangular") type=triangular;
-  else plumed_merror("cannot understand kernel type " + ktype );
+  if(ktype=="gaussian") {
+    type=gaussian;
+  } else if(ktype=="triangular") {
+    type=triangular;
+  } else {
+    plumed_merror("cannot understand kernel type " + ktype );
+  }
 }
 
 double HistogramBead::calculate( double x, double& df ) const {
@@ -186,14 +216,26 @@ double HistogramBead::calculate( double x, double& df ) const {
     lowB = ( difference( x, lowb ) / width );
     upperB = ( difference( x, highb ) / width );
     df=0;
-    if( std::fabs(lowB)<1. ) df = (1 - std::fabs(lowB)) / width;
-    if( std::fabs(upperB)<1. ) df -= (1 - std::fabs(upperB)) / width;
+    if( std::fabs(lowB)<1. ) {
+      df = (1 - std::fabs(lowB)) / width;
+    }
+    if( std::fabs(upperB)<1. ) {
+      df -= (1 - std::fabs(upperB)) / width;
+    }
     if (upperB<=-1. || lowB >=1.) {
       f=0.;
     } else {
       double ia, ib;
-      if( lowB>-1.0 ) { ia=lowB; } else { ia=-1.0; }
-      if( upperB<1.0 ) { ib=upperB; } else { ib=1.0; }
+      if( lowB>-1.0 ) {
+        ia=lowB;
+      } else {
+        ia=-1.0;
+      }
+      if( upperB<1.0 ) {
+        ib=upperB;
+      } else {
+        ib=1.0;
+      }
       f = (ib*(2.-std::fabs(ib))-ia*(2.-std::fabs(ia)))*0.5;
     }
   } else {
@@ -206,23 +248,40 @@ double HistogramBead::calculateWithCutoff( double x, double& df ) const {
   plumed_dbg_assert(init && periodicity!=unset );
 
   double lowB, upperB, f;
-  lowB = difference( x, lowb ) / width ; upperB = difference( x, highb ) / width;
-  if( upperB<=-cutoff || lowB>=cutoff ) { df=0; return 0; }
+  lowB = difference( x, lowb ) / width ;
+  upperB = difference( x, highb ) / width;
+  if( upperB<=-cutoff || lowB>=cutoff ) {
+    df=0;
+    return 0;
+  }
 
   if( type==gaussian ) {
-    lowB /= std::sqrt(2.0); upperB /= std::sqrt(2.0);
+    lowB /= std::sqrt(2.0);
+    upperB /= std::sqrt(2.0);
     df = ( exp( -lowB*lowB ) - exp( -upperB*upperB ) ) / ( std::sqrt(2*pi)*width );
     f = 0.5*( erf( upperB ) - erf( lowB ) );
   } else if( type==triangular ) {
     df=0;
-    if( std::fabs(lowB)<1. ) df = (1 - std::fabs(lowB)) / width;
-    if( std::fabs(upperB)<1. ) df -= (1 - std::fabs(upperB)) / width;
+    if( std::fabs(lowB)<1. ) {
+      df = (1 - std::fabs(lowB)) / width;
+    }
+    if( std::fabs(upperB)<1. ) {
+      df -= (1 - std::fabs(upperB)) / width;
+    }
     if (upperB<=-1. || lowB >=1.) {
       f=0.;
     } else {
       double ia, ib;
-      if( lowB>-1.0 ) { ia=lowB; } else { ia=-1.0; }
-      if( upperB<1.0 ) { ib=upperB; } else { ib=1.0; }
+      if( lowB>-1.0 ) {
+        ia=lowB;
+      } else {
+        ia=-1.0;
+      }
+      if( upperB<1.0 ) {
+        ib=upperB;
+      } else {
+        ib=1.0;
+      }
       f = (ib*(2.-std::fabs(ib))-ia*(2.-std::fabs(ia)))*0.5;
     }
   } else {
diff --git a/src/tools/HistogramBead.h b/src/tools/HistogramBead.h
index 247ec47c52..35d3bd0ca9 100644
--- a/src/tools/HistogramBead.h
+++ b/src/tools/HistogramBead.h
@@ -80,20 +80,28 @@ void HistogramBead::isNotPeriodic() {
 
 inline
 void HistogramBead::isPeriodic( const double& mlow, const double& mhigh ) {
-  periodicity=periodic; min=mlow; max=mhigh;
+  periodicity=periodic;
+  min=mlow;
+  max=mhigh;
   max_minus_min=max-min;
   plumed_massert(max_minus_min>0, "your function has a very strange domain?");
   inv_max_minus_min=1.0/max_minus_min;
 }
 
 inline
-double HistogramBead::getlowb() const { return lowb; }
+double HistogramBead::getlowb() const {
+  return lowb;
+}
 
 inline
-double HistogramBead::getbigb() const { return highb; }
+double HistogramBead::getbigb() const {
+  return highb;
+}
 
 inline
-double HistogramBead::getCutoff() const { return cutoff*width; }
+double HistogramBead::getCutoff() const {
+  return cutoff*width;
+}
 
 inline
 double HistogramBead::difference( const double& d1, const double& d2 ) const {
@@ -105,7 +113,9 @@ double HistogramBead::difference( const double& d1, const double& d2 ) const {
     newx=Tools::pbc(newx);
     newx*=max_minus_min;
     return d2-newx;
-  } else plumed_merror("periodicty was not set");
+  } else {
+    plumed_merror("periodicty was not set");
+  }
   return 0;
 }
 
diff --git a/src/tools/IFile.cpp b/src/tools/IFile.cpp
index 760400ede6..444bd69a1c 100644
--- a/src/tools/IFile.cpp
+++ b/src/tools/IFile.cpp
@@ -44,16 +44,24 @@ size_t IFile::llread(char*ptr,size_t s) {
   if(gzfp) {
 #ifdef __PLUMED_HAS_ZLIB
     int rr=gzread(gzFile(gzfp),ptr,s);
-    if(rr==0)   eof=true;
-    if(rr<0)    err=true;
+    if(rr==0) {
+      eof=true;
+    }
+    if(rr<0) {
+      err=true;
+    }
     r=rr;
 #else
     plumed_merror("file " + getPath() + ": trying to use a gz file without zlib being linked");
 #endif
   } else {
     r=std::fread(ptr,1,s,fp);
-    if(std::feof(fp))   eof=true;
-    if(std::ferror(fp)) err=true;
+    if(std::feof(fp)) {
+      eof=true;
+    }
+    if(std::ferror(fp)) {
+      err=true;
+    }
   }
   return r;
 }
@@ -65,7 +73,9 @@ IFile& IFile::advanceField() {
   while(!done) {
     getline(line);
 // using explicit conversion not to confuse cppcheck 1.86
-    if(!bool(*this)) {return *this;}
+    if(!bool(*this)) {
+      return *this;
+    }
     std::vector<std::string> words=Tools::getWords(line);
     if(words.size()>=2 && words[0]=="#!" && words[1]=="FIELDS") {
       fields.clear();
@@ -82,13 +92,18 @@ IFile& IFile::advanceField() {
       fields.push_back(field);
     } else {
       unsigned nf=0;
-      for(unsigned i=0; i<fields.size(); i++) if(!fields[i].constant) nf++;
+      for(unsigned i=0; i<fields.size(); i++)
+        if(!fields[i].constant) {
+          nf++;
+        }
       Tools::trimComments(line);
       words=Tools::getWords(line);
       if( words.size()==nf ) {
         unsigned j=0;
         for(unsigned i=0; i<fields.size(); i++) {
-          if(fields[i].constant) continue;
+          if(fields[i].constant) {
+            continue;
+          }
           fields[i].value=words[j];
           fields[i].read=false;
           j++;
@@ -119,17 +134,24 @@ IFile& IFile::open(const std::string&path) {
     plumed_merror("file " + getPath() + ": trying to use a gz file without zlib being linked");
 #endif
   }
-  if(plumed) plumed->insertFile(*this);
+  if(plumed) {
+    plumed->insertFile(*this);
+  }
   return *this;
 }
 
 IFile& IFile::scanFieldList(std::vector<std::string>&s) {
-  if(!inMiddleOfField) advanceField();
+  if(!inMiddleOfField) {
+    advanceField();
+  }
 // using explicit conversion not to confuse cppcheck 1.86
-  if(!bool(*this)) return *this;
+  if(!bool(*this)) {
+    return *this;
+  }
   s.clear();
-  for(unsigned i=0; i<fields.size(); i++)
+  for(unsigned i=0; i<fields.size(); i++) {
     s.push_back(fields[i].name);
+  }
   return *this;
 }
 
@@ -137,14 +159,21 @@ bool IFile::FieldExist(const std::string& s) {
   std::vector<std::string> slist;
   scanFieldList(slist);
   int mycount = (int) std::count(slist.begin(), slist.end(), s);
-  if(mycount>0) return true;
-  else return false;
+  if(mycount>0) {
+    return true;
+  } else {
+    return false;
+  }
 }
 
 IFile& IFile::scanField(const std::string&name,std::string&str) {
-  if(!inMiddleOfField) advanceField();
+  if(!inMiddleOfField) {
+    advanceField();
+  }
 // using explicit conversion not to confuse cppcheck 1.86
-  if(!bool(*this)) return *this;
+  if(!bool(*this)) {
+    return *this;
+  }
   unsigned i=findField(name);
   str=fields[i].value;
   fields[i].read=true;
@@ -154,49 +183,63 @@ IFile& IFile::scanField(const std::string&name,std::string&str) {
 IFile& IFile::scanField(const std::string&name,double &x) {
   std::string str;
   scanField(name,str);
-  if(*this) Tools::convert(str,x);
+  if(*this) {
+    Tools::convert(str,x);
+  }
   return *this;
 }
 
 IFile& IFile::scanField(const std::string&name,int &x) {
   std::string str;
   scanField(name,str);
-  if(*this) Tools::convert(str,x);
+  if(*this) {
+    Tools::convert(str,x);
+  }
   return *this;
 }
 
 IFile& IFile::scanField(const std::string&name,long int &x) {
   std::string str;
   scanField(name,str);
-  if(*this) Tools::convert(str,x);
+  if(*this) {
+    Tools::convert(str,x);
+  }
   return *this;
 }
 
 IFile& IFile::scanField(const std::string&name,long long int &x) {
   std::string str;
   scanField(name,str);
-  if(*this) Tools::convert(str,x);
+  if(*this) {
+    Tools::convert(str,x);
+  }
   return *this;
 }
 
 IFile& IFile::scanField(const std::string&name,unsigned &x) {
   std::string str;
   scanField(name,str);
-  if(*this) Tools::convert(str,x);
+  if(*this) {
+    Tools::convert(str,x);
+  }
   return *this;
 }
 
 IFile& IFile::scanField(const std::string&name,long unsigned &x) {
   std::string str;
   scanField(name,str);
-  if(*this) Tools::convert(str,x);
+  if(*this) {
+    Tools::convert(str,x);
+  }
   return *this;
 }
 
 IFile& IFile::scanField(const std::string&name,long long unsigned &x) {
   std::string str;
   scanField(name,str);
-  if(*this) Tools::convert(str,x);
+  if(*this) {
+    Tools::convert(str,x);
+  }
   return *this;
 }
 
@@ -228,12 +271,13 @@ IFile& IFile::scanField() {
 IFile::IFile():
   inMiddleOfField(false),
   ignoreFields(false),
-  noEOL(false)
-{
+  noEOL(false) {
 }
 
 IFile::~IFile() {
-  if(inMiddleOfField) std::cerr<<"WARNING: IFile closed in the middle of reading. seems strange!\n";
+  if(inMiddleOfField) {
+    std::cerr<<"WARNING: IFile closed in the middle of reading. seems strange!\n";
+  }
 }
 
 IFile& IFile::getline(std::string &str) {
@@ -249,11 +293,15 @@ IFile& IFile::getline(std::string &str) {
     plumed_massert(tmp=='\n',"plumed only accepts \\n (unix) or \\r\\n (dos) new lines");
   }
   if(eof && noEOL) {
-    if(str.length()>0) eof=false;
+    if(str.length()>0) {
+      eof=false;
+    }
   } else if(eof || err || tmp!='\n') {
     eof = true;
     str="";
-    if(!err) fsetpos(fp,&pos);
+    if(!err) {
+      fsetpos(fp,&pos);
+    }
 // there was a fsetpos here that apparently is not necessary
 //  fsetpos(fp,&pos);
 // I think it was necessary to have rewind working correctly
@@ -267,7 +315,10 @@ IFile& IFile::getline(std::string &str) {
 
 unsigned IFile::findField(const std::string&name)const {
   unsigned i;
-  for(i=0; i<fields.size(); i++) if(fields[i].name==name) break;
+  for(i=0; i<fields.size(); i++)
+    if(fields[i].name==name) {
+      break;
+    }
   if(i>=fields.size()) {
     plumed_merror("file " + getPath() + ": field " + name + " cannot be found");
   }
@@ -277,9 +328,13 @@ unsigned IFile::findField(const std::string&name)const {
 void IFile::reset(bool reset) {
   eof = reset;
   err = reset;
-  if(!reset && fp) clearerr(fp);
+  if(!reset && fp) {
+    clearerr(fp);
+  }
 #ifdef __PLUMED_HAS_ZLIB
-  if(!reset && gzfp) gzclearerr(gzFile(gzfp));
+  if(!reset && gzfp) {
+    gzclearerr(gzFile(gzfp));
+  }
 #endif
   return;
 }
diff --git a/src/tools/KernelFunctions.cpp b/src/tools/KernelFunctions.cpp
index b824d7048d..ad69465590 100644
--- a/src/tools/KernelFunctions.cpp
+++ b/src/tools/KernelFunctions.cpp
@@ -105,26 +105,48 @@ KernelFunctions::KernelFunctions( const std::string& input ) {
 
   std::vector<double> at;
   bool foundc = Tools::parseVector(data,"CENTER",at);
-  if(!foundc) plumed_merror("failed to find center keyword in definition of kernel");
+  if(!foundc) {
+    plumed_merror("failed to find center keyword in definition of kernel");
+  }
   std::vector<double> sig;
   bool founds = Tools::parseVector(data,"SIGMA",sig);
-  if(!founds) plumed_merror("failed to find sigma keyword in definition of kernel");
+  if(!founds) {
+    plumed_merror("failed to find sigma keyword in definition of kernel");
+  }
 
-  bool multi=false; Tools::parseFlag(data,"MULTIVARIATE",multi);
-  bool vonmises=false; Tools::parseFlag(data,"VON-MISSES",vonmises);
-  if( center.size()==1 && multi ) plumed_merror("one dimensional kernel cannot be multivariate");
-  if( center.size()==1 && vonmises ) plumed_merror("one dimensional kernal cannot be von-misses");
-  if( center.size()==1 && sig.size()!=1 ) plumed_merror("size mismatch between center size and sigma size");
-  if( multi && center.size()>1 && sig.size()!=0.5*center.size()*(center.size()-1) ) plumed_merror("size mismatch between center size and sigma size");
-  if( !multi && center.size()>1 && sig.size()!=center.size() ) plumed_merror("size mismatch between center size and sigma size");
+  bool multi=false;
+  Tools::parseFlag(data,"MULTIVARIATE",multi);
+  bool vonmises=false;
+  Tools::parseFlag(data,"VON-MISSES",vonmises);
+  if( center.size()==1 && multi ) {
+    plumed_merror("one dimensional kernel cannot be multivariate");
+  }
+  if( center.size()==1 && vonmises ) {
+    plumed_merror("one dimensional kernal cannot be von-misses");
+  }
+  if( center.size()==1 && sig.size()!=1 ) {
+    plumed_merror("size mismatch between center size and sigma size");
+  }
+  if( multi && center.size()>1 && sig.size()!=0.5*center.size()*(center.size()-1) ) {
+    plumed_merror("size mismatch between center size and sigma size");
+  }
+  if( !multi && center.size()>1 && sig.size()!=center.size() ) {
+    plumed_merror("size mismatch between center size and sigma size");
+  }
 
   double h;
   bool foundh = Tools::parse(data,"HEIGHT",h);
-  if( !foundh) h=1.0;
+  if( !foundh) {
+    h=1.0;
+  }
 
-  if( multi ) setData( at, sig, name, "MULTIVARIATE", h );
-  else if( vonmises ) setData( at, sig, name, "VON-MISSES", h );
-  else setData( at, sig, name, "DIAGONAL", h );
+  if( multi ) {
+    setData( at, sig, name, "MULTIVARIATE", h );
+  } else if( vonmises ) {
+    setData( at, sig, name, "VON-MISSES", h );
+  } else {
+    setData( at, sig, name, "DIAGONAL", h );
+  }
 }
 
 KernelFunctions::KernelFunctions( const std::vector<double>& at, const std::vector<double>& sig, const std::string& type, const std::string& mtype, const double& w ) {
@@ -142,8 +164,7 @@ KernelFunctions::KernelFunctions( const KernelFunctions* in ):
   ktype(in->ktype),
   center(in->center),
   width(in->width),
-  height(in->height)
-{
+  height(in->height) {
   if(!dp2cutoffNoStretch()) {
     stretchA=dp2cutoffA;
     stretchB=dp2cutoffB;
@@ -153,12 +174,23 @@ KernelFunctions::KernelFunctions( const KernelFunctions* in ):
 void KernelFunctions::setData( const std::vector<double>& at, const std::vector<double>& sig, const std::string& type, const std::string& mtype, const double& w ) {
 
   height=w;
-  center.resize( at.size() ); for(unsigned i=0; i<at.size(); ++i) center[i]=at[i];
-  width.resize( sig.size() ); for(unsigned i=0; i<sig.size(); ++i) width[i]=sig[i];
-  if( mtype=="MULTIVARIATE" ) dtype=multi;
-  else if( mtype=="VON-MISSES" ) dtype=vonmises;
-  else if( mtype=="DIAGONAL" ) dtype=diagonal;
-  else plumed_merror(mtype + " is not a valid metric type");
+  center.resize( at.size() );
+  for(unsigned i=0; i<at.size(); ++i) {
+    center[i]=at[i];
+  }
+  width.resize( sig.size() );
+  for(unsigned i=0; i<sig.size(); ++i) {
+    width[i]=sig[i];
+  }
+  if( mtype=="MULTIVARIATE" ) {
+    dtype=multi;
+  } else if( mtype=="VON-MISSES" ) {
+    dtype=vonmises;
+  } else if( mtype=="DIAGONAL" ) {
+    dtype=diagonal;
+  } else {
+    plumed_merror(mtype + " is not a valid metric type");
+  }
 
   // Setup the kernel type
   if(type=="GAUSSIAN" || type=="gaussian" ) {
@@ -181,10 +213,13 @@ void KernelFunctions::normalize( const std::vector<Value*>& myvals ) {
   double det=1.;
   unsigned ncv=ndim();
   if(dtype==diagonal) {
-    for(unsigned i=0; i<width.size(); ++i) det*=width[i]*width[i];
+    for(unsigned i=0; i<width.size(); ++i) {
+      det*=width[i]*width[i];
+    }
   } else if(dtype==multi) {
     Matrix<double> mymatrix( getMatrix() ), myinv( ncv, ncv );
-    Invert(mymatrix,myinv); double logd;
+    Invert(mymatrix,myinv);
+    double logd;
     logdet( myinv, logd );
     det=std::exp(logd);
   }
@@ -199,15 +234,22 @@ void KernelFunctions::normalize( const std::vector<Value*>& myvals ) {
     } else if( ktype==uniform || ktype==triangular ) {
       if( ncv%2==1 ) {
         double dfact=1;
-        for(unsigned i=1; i<ncv; i+=2) dfact*=static_cast<double>(i);
+        for(unsigned i=1; i<ncv; i+=2) {
+          dfact*=static_cast<double>(i);
+        }
         volume=( pow( pi, (ncv-1)/2 ) ) * ( pow( 2., (ncv+1)/2 ) ) / dfact;
       } else {
         double fact=1.;
-        for(unsigned i=1; i<ncv/2; ++i) fact*=static_cast<double>(i);
+        for(unsigned i=1; i<ncv/2; ++i) {
+          fact*=static_cast<double>(i);
+        }
         volume=pow( pi,ncv/2 ) / fact;
       }
-      if(ktype==uniform) volume*=det;
-      else if(ktype==triangular) volume*=det / 3.;
+      if(ktype==uniform) {
+        volume*=det;
+      } else if(ktype==triangular) {
+        volume*=det / 3.;
+      }
     } else {
       plumed_merror("not a valid kernel type");
     }
@@ -218,7 +260,9 @@ void KernelFunctions::normalize( const std::vector<Value*>& myvals ) {
   // Now calculate determinant for aperiodic variables
   unsigned naper=0;
   for(unsigned i=0; i<ncv; ++i) {
-    if( !myvals[i]->isPeriodic() ) naper++;
+    if( !myvals[i]->isPeriodic() ) {
+      naper++;
+    }
   }
   // Now construct sub matrix
   double volume=1;
@@ -226,16 +270,23 @@ void KernelFunctions::normalize( const std::vector<Value*>& myvals ) {
     unsigned isub=0;
     Matrix<double> mymatrix( getMatrix() ), mysub( naper, naper );
     for(unsigned i=0; i<ncv; ++i) {
-      if( myvals[i]->isPeriodic() ) continue;
+      if( myvals[i]->isPeriodic() ) {
+        continue;
+      }
       unsigned jsub=0;
       for(unsigned j=0; j<ncv; ++j) {
-        if( myvals[j]->isPeriodic() ) continue;
-        mysub( isub, jsub ) = mymatrix( i, j ); jsub++;
+        if( myvals[j]->isPeriodic() ) {
+          continue;
+        }
+        mysub( isub, jsub ) = mymatrix( i, j );
+        jsub++;
       }
       isub++;
     }
-    Matrix<double> myisub( naper, naper ); double logd;
-    Invert( mysub, myisub ); logdet( myisub, logd );
+    Matrix<double> myisub( naper, naper );
+    double logd;
+    Invert( mysub, myisub );
+    logdet( myisub, logd );
     det=std::exp(logd);
     volume=pow( 2*pi, 0.5*ncv ) * pow( det, 0.5 );
   }
@@ -243,7 +294,9 @@ void KernelFunctions::normalize( const std::vector<Value*>& myvals ) {
   // Calculate volume of periodic variables
   unsigned nper=0;
   for(unsigned i=0; i<ncv; ++i) {
-    if( myvals[i]->isPeriodic() ) nper++;
+    if( myvals[i]->isPeriodic() ) {
+      nper++;
+    }
   }
 
   // Now construct sub matrix
@@ -251,18 +304,24 @@ void KernelFunctions::normalize( const std::vector<Value*>& myvals ) {
     unsigned isub=0;
     Matrix<double> mymatrix( getMatrix() ),  mysub( nper, nper );
     for(unsigned i=0; i<ncv; ++i) {
-      if( !myvals[i]->isPeriodic() ) continue;
+      if( !myvals[i]->isPeriodic() ) {
+        continue;
+      }
       unsigned jsub=0;
       for(unsigned j=0; j<ncv; ++j) {
-        if( !myvals[j]->isPeriodic() ) continue;
-        mysub( isub, jsub ) = mymatrix( i, j ); jsub++;
+        if( !myvals[j]->isPeriodic() ) {
+          continue;
+        }
+        mysub( isub, jsub ) = mymatrix( i, j );
+        jsub++;
       }
       isub++;
     }
     Matrix<double>  eigvec( nper, nper );
     std::vector<double> eigval( nper );
     diagMat( mysub, eigval, eigvec );
-    unsigned iper=0; volume=1;
+    unsigned iper=0;
+    volume=1;
     for(unsigned i=0; i<ncv; ++i) {
       if( myvals[i]->isPeriodic() ) {
         volume *= myvals[i]->getMaxMinusMin()*Tools::bessel0(eigval[iper])*std::exp(-eigval[iper]);
@@ -275,10 +334,15 @@ void KernelFunctions::normalize( const std::vector<Value*>& myvals ) {
 
 double KernelFunctions::getCutoff( const double& width ) const {
   const double DP2CUTOFF=6.25;
-  if( ktype==gaussian || ktype==truncatedgaussian || ktype==stretchedgaussian ) return std::sqrt(2.0*DP2CUTOFF)*width;
-  else if(ktype==triangular ) return width;
-  else if(ktype==uniform) return width;
-  else plumed_merror("No valid kernel type");
+  if( ktype==gaussian || ktype==truncatedgaussian || ktype==stretchedgaussian ) {
+    return std::sqrt(2.0*DP2CUTOFF)*width;
+  } else if(ktype==triangular ) {
+    return width;
+  } else if(ktype==uniform) {
+    return width;
+  } else {
+    plumed_merror("No valid kernel type");
+  }
   return 0.0;
 }
 
@@ -286,16 +350,22 @@ std::vector<double> KernelFunctions::getContinuousSupport( ) const {
   unsigned ncv=ndim();
   std::vector<double> support( ncv );
   if(dtype==diagonal) {
-    for(unsigned i=0; i<ncv; ++i) support[i]=getCutoff(width[i]);
+    for(unsigned i=0; i<ncv; ++i) {
+      support[i]=getCutoff(width[i]);
+    }
   } else if(dtype==multi) {
     Matrix<double> mymatrix( getMatrix() ), myinv( ncv,ncv );
     Invert(mymatrix,myinv);
-    Matrix<double> myautovec(ncv,ncv); std::vector<double> myautoval(ncv);
+    Matrix<double> myautovec(ncv,ncv);
+    std::vector<double> myautoval(ncv);
     diagMat(myinv,myautoval,myautovec);
     double maxautoval=0.;
     unsigned ind_maxautoval=0;
     for (unsigned i=0; i<ncv; i++) {
-      if(myautoval[i]>maxautoval) {maxautoval=myautoval[i]; ind_maxautoval=i;}
+      if(myautoval[i]>maxautoval) {
+        maxautoval=myautoval[i];
+        ind_maxautoval=i;
+      }
     }
     for(unsigned i=0; i<ncv; ++i) {
       double extent=std::fabs(std::sqrt(maxautoval)*myautovec(i,ind_maxautoval));
@@ -311,19 +381,27 @@ std::vector<unsigned> KernelFunctions::getSupport( const std::vector<double>& dx
   plumed_assert( ndim()==dx.size() );
   std::vector<unsigned> support( dx.size() );
   std::vector<double> vv=getContinuousSupport( );
-  for(unsigned i=0; i<dx.size(); ++i) support[i]=static_cast<unsigned>(ceil( vv[i]/dx[i] ));
+  for(unsigned i=0; i<dx.size(); ++i) {
+    support[i]=static_cast<unsigned>(ceil( vv[i]/dx[i] ));
+  }
   return support;
 }
 
 double KernelFunctions::evaluate( const std::vector<Value*>& pos, std::vector<double>& derivatives, bool usederiv, bool doInt, double lowI_, double uppI_) const {
   plumed_dbg_assert( pos.size()==ndim() && derivatives.size()==ndim() );
 #ifndef NDEBUG
-  if( usederiv ) plumed_massert( ktype!=uniform, "step function can not be differentiated" );
+  if( usederiv ) {
+    plumed_massert( ktype!=uniform, "step function can not be differentiated" );
+  }
 #endif
   if(doInt) {
     plumed_dbg_assert(center.size()==1);
-    if(pos[0]->get()<lowI_) pos[0]->set(lowI_);
-    if(pos[0]->get()>uppI_) pos[0]->set(uppI_);
+    if(pos[0]->get()<lowI_) {
+      pos[0]->set(lowI_);
+    }
+    if(pos[0]->get()>uppI_) {
+      pos[0]->set(uppI_);
+    }
   }
   double r2=0;
   if(dtype==diagonal) {
@@ -335,11 +413,15 @@ double KernelFunctions::evaluate( const std::vector<Value*>& pos, std::vector<do
   } else if(dtype==multi) {
     Matrix<double> mymatrix( getMatrix() );
     for(unsigned i=0; i<mymatrix.nrows(); ++i) {
-      double dp_i, dp_j; derivatives[i]=0;
+      double dp_i, dp_j;
+      derivatives[i]=0;
       dp_i=-pos[i]->difference( center[i] );
       for(unsigned j=0; j<mymatrix.ncols(); ++j) {
-        if(i==j) dp_j=dp_i;
-        else dp_j=-pos[j]->difference( center[j] );
+        if(i==j) {
+          dp_j=dp_i;
+        } else {
+          dp_j=-pos[j]->difference( center[j] );
+        }
 
         derivatives[i]+=mymatrix(i,j)*dp_j;
         r2+=dp_i*dp_j*mymatrix(i,j);
@@ -366,16 +448,23 @@ double KernelFunctions::evaluate( const std::vector<Value*>& pos, std::vector<do
         r2+=sintmp[i]*sintmp[i]*mymatrix(i,i);
       }
       for(unsigned j=0; j<mymatrix.ncols(); ++j) {
-        if( i!=j ) sinout[i]+=mymatrix(i,j)*sintmp[j];
+        if( i!=j ) {
+          sinout[i]+=mymatrix(i,j)*sintmp[j];
+        }
       }
       derivatives[i] = mymatrix(i,i)*sintmp[i] + sinout[i]*costmp[i];
-      if( pos[i]->isPeriodic() ) derivatives[i] *= (2*pi/pos[i]->getMaxMinusMin());
+      if( pos[i]->isPeriodic() ) {
+        derivatives[i] *= (2*pi/pos[i]->getMaxMinusMin());
+      }
+    }
+    for(unsigned i=0; i<sinout.size(); ++i) {
+      r2+=sintmp[i]*sinout[i];
     }
-    for(unsigned i=0; i<sinout.size(); ++i) r2+=sintmp[i]*sinout[i];
   }
   double kderiv, kval;
   if(ktype==gaussian || ktype==truncatedgaussian) {
-    kval=height*std::exp(-0.5*r2); kderiv=-kval;
+    kval=height*std::exp(-0.5*r2);
+    kderiv=-kval;
   } else if(ktype==stretchedgaussian) {
     auto dp=0.5*r2;
     if(dp<dp2cutoff) {
@@ -390,45 +479,67 @@ double KernelFunctions::evaluate( const std::vector<Value*>& pos, std::vector<do
     double r=std::sqrt(r2);
     if(ktype==triangular) {
       if( r<1.0 ) {
-        if(r==0) kderiv=0;
-        kderiv=-1; kval=height*( 1. - std::fabs(r) );
+        if(r==0) {
+          kderiv=0;
+        }
+        kderiv=-1;
+        kval=height*( 1. - std::fabs(r) );
       } else {
-        kval=0.; kderiv=0.;
+        kval=0.;
+        kderiv=0.;
       }
     } else if(ktype==uniform) {
       kderiv=0.;
-      if(r<1.0) kval=height;
-      else kval=0;
+      if(r<1.0) {
+        kval=height;
+      } else {
+        kval=0;
+      }
     } else {
       plumed_merror("Not a valid kernel type");
     }
     kderiv*=height / r ;
   }
-  for(unsigned i=0; i<ndim(); ++i) derivatives[i]*=kderiv;
+  for(unsigned i=0; i<ndim(); ++i) {
+    derivatives[i]*=kderiv;
+  }
   if(doInt) {
-    if((pos[0]->get() <= lowI_ || pos[0]->get() >= uppI_) && usederiv ) for(unsigned i=0; i<ndim(); ++i)derivatives[i]=0;
+    if((pos[0]->get() <= lowI_ || pos[0]->get() >= uppI_) && usederiv )
+      for(unsigned i=0; i<ndim(); ++i) {
+        derivatives[i]=0;
+      }
   }
   return kval;
 }
 
 std::unique_ptr<KernelFunctions> KernelFunctions::read( IFile* ifile, const bool& cholesky, const std::vector<std::string>& valnames ) {
   double h;
-  if( !ifile->scanField("height",h) ) return NULL;;
-
-  std::string sss; ifile->scanField("multivariate",sss);
-  std::string ktype="stretched-gaussian"; if( ifile->FieldExist("kerneltype") ) ifile->scanField("kerneltype",ktype);
+  if( !ifile->scanField("height",h) ) {
+    return NULL;
+  };
+
+  std::string sss;
+  ifile->scanField("multivariate",sss);
+  std::string ktype="stretched-gaussian";
+  if( ifile->FieldExist("kerneltype") ) {
+    ifile->scanField("kerneltype",ktype);
+  }
   plumed_massert( sss=="false" || sss=="true" || sss=="von-misses", "multivariate flag must be either false, true or von-misses");
 
   // Read the position of the center
   std::vector<double> cc( valnames.size() );
-  for(unsigned i=0; i<valnames.size(); ++i) ifile->scanField(valnames[i],cc[i]);
+  for(unsigned i=0; i<valnames.size(); ++i) {
+    ifile->scanField(valnames[i],cc[i]);
+  }
 
   std::vector<double> sig;
   if( sss=="false" ) {
     sig.resize( valnames.size() );
     for(unsigned i=0; i<valnames.size(); ++i) {
       ifile->scanField("sigma_"+valnames[i],sig[i]);
-      if( !cholesky ) sig[i]=std::sqrt(sig[i]);
+      if( !cholesky ) {
+        sig[i]=std::sqrt(sig[i]);
+      }
     }
     return Tools::make_unique<KernelFunctions>(cc, sig, ktype, "DIAGONAL", h);
   }
@@ -439,16 +550,24 @@ std::unique_ptr<KernelFunctions> KernelFunctions::read( IFile* ifile, const bool
   for(unsigned i=0; i<ncv; ++i) {
     for(unsigned j=0; j<ncv-i; j++) {
       ifile->scanField("sigma_" +valnames[j+i] + "_" + valnames[j], lower(j+i,j) );
-      upper(j,j+i)=lower(j+i,j); mymult(j+i,j)=mymult(j,j+i)=lower(j+i,j);
+      upper(j,j+i)=lower(j+i,j);
+      mymult(j+i,j)=mymult(j,j+i)=lower(j+i,j);
     }
   }
-  if( cholesky ) mult(lower,upper,mymult);
+  if( cholesky ) {
+    mult(lower,upper,mymult);
+  }
   Invert( mymult, invmatrix );
   unsigned k=0;
   for(unsigned i=0; i<ncv; i++) {
-    for(unsigned j=i; j<ncv; j++) { sig[k]=invmatrix(i,j); k++; }
+    for(unsigned j=i; j<ncv; j++) {
+      sig[k]=invmatrix(i,j);
+      k++;
+    }
+  }
+  if( sss=="true" ) {
+    return Tools::make_unique<KernelFunctions>(cc, sig, ktype, "MULTIVARIATE", h);
   }
-  if( sss=="true" ) return Tools::make_unique<KernelFunctions>(cc, sig, ktype, "MULTIVARIATE", h);
   return Tools::make_unique<KernelFunctions>( cc, sig, ktype, "VON-MISSES", h );
 }
 
diff --git a/src/tools/KernelFunctions.h b/src/tools/KernelFunctions.h
index 7e9def564a..72b1ba9c42 100644
--- a/src/tools/KernelFunctions.h
+++ b/src/tools/KernelFunctions.h
@@ -73,7 +73,8 @@ class KernelFunctions {
 
 inline
 Matrix<double> KernelFunctions::getMatrix() const {
-  unsigned k=0, ncv=ndim(); Matrix<double> mymatrix(ncv,ncv);
+  unsigned k=0, ncv=ndim();
+  Matrix<double> mymatrix(ncv,ncv);
   for(unsigned i=0; i<ncv; i++) {
     for(unsigned j=i; j<ncv; j++) {
       mymatrix(i,j)=mymatrix(j,i)=width[k]; // recompose the full inverse matrix
diff --git a/src/tools/Keywords.cpp b/src/tools/Keywords.cpp
index 1b68bf4cb4..5b9d316ab8 100644
--- a/src/tools/Keywords.cpp
+++ b/src/tools/Keywords.cpp
@@ -78,37 +78,59 @@ void Keywords::copyData( std::vector<std::string>& kk, std::vector<std::string>&
                          std::map<std::string,std::string>& cd ) const {
   for(unsigned i=0; i<keys.size(); ++i) {
     std::string thiskey=keys[i];
-    for(unsigned j=0; j<kk.size(); ++j) plumed_massert( thiskey!=kk[j], "keyword " + thiskey + " is in twice" );
-    for(unsigned j=0; j<rk.size(); ++j) plumed_massert( thiskey!=rk[j], "keyword " + thiskey + " is in twice" );
+    for(unsigned j=0; j<kk.size(); ++j) {
+      plumed_massert( thiskey!=kk[j], "keyword " + thiskey + " is in twice" );
+    }
+    for(unsigned j=0; j<rk.size(); ++j) {
+      plumed_massert( thiskey!=rk[j], "keyword " + thiskey + " is in twice" );
+    }
     kk.push_back( thiskey );
     plumed_massert( types.count( thiskey ), "no type data on keyword " + thiskey + " to copy" );
     tt.insert( std::pair<std::string,KeyType>( thiskey,types.find(thiskey)->second) );
-    if( (types.find(thiskey)->second).isAtomList() ) atags.insert( std::pair<std::string,std::string>( thiskey,atomtags.find(thiskey)->second) );
+    if( (types.find(thiskey)->second).isAtomList() ) {
+      atags.insert( std::pair<std::string,std::string>( thiskey,atomtags.find(thiskey)->second) );
+    }
     plumed_massert( allowmultiple.count( thiskey ), "no numbered data on keyword " + thiskey + " to copy" );
     am.insert( std::pair<std::string,bool>(thiskey,allowmultiple.find(thiskey)->second) );
     plumed_massert( documentation.count( thiskey ), "no documentation for keyword " + thiskey + " to copy" );
     docs.insert( std::pair<std::string,std::string>(thiskey,documentation.find(thiskey)->second) );
-    if( booldefs.count( thiskey ) ) bools.insert( std::pair<std::string,bool>( thiskey,booldefs.find(thiskey)->second) );
-    if( numdefs.count( thiskey ) ) nums.insert( std::pair<std::string,std::string>( thiskey,numdefs.find(thiskey)->second) );
+    if( booldefs.count( thiskey ) ) {
+      bools.insert( std::pair<std::string,bool>( thiskey,booldefs.find(thiskey)->second) );
+    }
+    if( numdefs.count( thiskey ) ) {
+      nums.insert( std::pair<std::string,std::string>( thiskey,numdefs.find(thiskey)->second) );
+    }
   }
   for(unsigned i=0; i<reserved_keys.size(); ++i) {
     std::string thiskey=reserved_keys[i];
-    for(unsigned j=0; j<kk.size(); ++j) plumed_massert( thiskey!=kk[j], "keyword " + thiskey + " is in twice" );
-    for(unsigned j=0; j<rk.size(); ++j) plumed_massert( thiskey!=rk[j], "keyword " + thiskey + " is in twice" );
+    for(unsigned j=0; j<kk.size(); ++j) {
+      plumed_massert( thiskey!=kk[j], "keyword " + thiskey + " is in twice" );
+    }
+    for(unsigned j=0; j<rk.size(); ++j) {
+      plumed_massert( thiskey!=rk[j], "keyword " + thiskey + " is in twice" );
+    }
     rk.push_back( thiskey );
     plumed_massert( types.count( thiskey ), "no type data on keyword " + thiskey + " to copy" );
     tt.insert( std::pair<std::string,KeyType>( thiskey,types.find(thiskey)->second) );
-    if( (types.find(thiskey)->second).isAtomList() ) atags.insert( std::pair<std::string,std::string>( thiskey,atomtags.find(thiskey)->second) );
+    if( (types.find(thiskey)->second).isAtomList() ) {
+      atags.insert( std::pair<std::string,std::string>( thiskey,atomtags.find(thiskey)->second) );
+    }
     plumed_massert( allowmultiple.count( thiskey ), "no numbered data on keyword " + thiskey + " to copy" );
     am.insert( std::pair<std::string,bool>(thiskey,allowmultiple.find(thiskey)->second) );
     plumed_massert( documentation.count( thiskey ), "no documentation for keyword " + thiskey + " to copy" );
     docs.insert( std::pair<std::string,std::string>(thiskey,documentation.find(thiskey)->second) );
-    if( booldefs.count( thiskey ) ) bools.insert( std::pair<std::string,bool>( thiskey,booldefs.find(thiskey)->second) );
-    if( numdefs.count( thiskey ) ) nums.insert( std::pair<std::string,std::string>( thiskey,numdefs.find(thiskey)->second) );
+    if( booldefs.count( thiskey ) ) {
+      bools.insert( std::pair<std::string,bool>( thiskey,booldefs.find(thiskey)->second) );
+    }
+    if( numdefs.count( thiskey ) ) {
+      nums.insert( std::pair<std::string,std::string>( thiskey,numdefs.find(thiskey)->second) );
+    }
   }
   for(unsigned i=0; i<cnames.size(); ++i) {
     std::string thisnam=cnames[i];
-    for(unsigned j=0; j<cnam.size(); ++j) plumed_massert( thisnam!=cnam[j], "component " + thisnam + " is in twice" );
+    for(unsigned j=0; j<cnam.size(); ++j) {
+      plumed_massert( thisnam!=cnam[j], "component " + thisnam + " is in twice" );
+    }
     cnam.push_back( thisnam );
     plumed_massert( ckey.count( thisnam ), "no keyword data on component " + thisnam + " to copy" );
     ck.insert( std::pair<std::string,std::string>( thisnam, ckey.find(thisnam)->second) );
@@ -121,19 +143,24 @@ void Keywords::reserve( const std::string & t, const std::string & k, const std:
   plumed_assert( !exists(k) && !reserved(k) );
   std::string fd, lowkey=k;
   // Convert to lower case
-  std::transform(lowkey.begin(),lowkey.end(),lowkey.begin(),[](unsigned char c) { return std::tolower(c); });
+  std::transform(lowkey.begin(),lowkey.end(),lowkey.begin(),[](unsigned char c) {
+    return std::tolower(c);
+  });
 // Remove any underscore characters
   for(unsigned i=0;; ++i) {
     std::size_t num=lowkey.find_first_of("_");
-    if( num==std::string::npos ) break;
+    if( num==std::string::npos ) {
+      break;
+    }
     lowkey.erase( lowkey.begin() + num, lowkey.begin() + num + 1 );
   }
   if( t=="vessel" ) {
     fd = d + " The final value can be referenced using <em>label</em>." + lowkey;
-    if(d.find("flag")==std::string::npos) fd += ".  You can use multiple instances of this keyword i.e. " +
-          k +"1, " + k + "2, " + k + "3...  The corresponding values are then "
-          "referenced using <em>label</em>."+ lowkey +"-1,  <em>label</em>." + lowkey +
-          "-2,  <em>label</em>." + lowkey + "-3...";
+    if(d.find("flag")==std::string::npos)
+      fd += ".  You can use multiple instances of this keyword i.e. " +
+            k +"1, " + k + "2, " + k + "3...  The corresponding values are then "
+            "referenced using <em>label</em>."+ lowkey +"-1,  <em>label</em>." + lowkey +
+            "-2,  <em>label</em>." + lowkey + "-3...";
     allowmultiple.insert( std::pair<std::string,bool>(k,true) );
     types.insert( std::pair<std::string,KeyType>(k,KeyType("vessel")) );
   } else if( t=="numbered" ) {
@@ -142,10 +169,14 @@ void Keywords::reserve( const std::string & t, const std::string & k, const std:
     types.insert( std::pair<std::string,KeyType>(k,KeyType("optional")) );
   } else {
     fd = d;
-    if( t=="atoms" && isaction ) fd = d + ".  For more information on how to specify lists of atoms see \\ref Group";
+    if( t=="atoms" && isaction ) {
+      fd = d + ".  For more information on how to specify lists of atoms see \\ref Group";
+    }
     allowmultiple.insert( std::pair<std::string,bool>(k,false) );
     types.insert( std::pair<std::string,KeyType>(k,KeyType(t)) );
-    if( (types.find(k)->second).isAtomList() ) atomtags.insert( std::pair<std::string,std::string>(k,t) );
+    if( (types.find(k)->second).isAtomList() ) {
+      atomtags.insert( std::pair<std::string,std::string>(k,t) );
+    }
   }
   documentation.insert( std::pair<std::string,std::string>(k,fd) );
   reserved_keys.push_back(k);
@@ -154,9 +185,16 @@ void Keywords::reserve( const std::string & t, const std::string & k, const std:
 void Keywords::reserveFlag( const std::string & k, const bool def, const std::string & d ) {
   plumed_assert( !exists(k) && !reserved(k) );
   std::string defstr;
-  if( def ) { defstr="( default=on ) "; } else { defstr="( default=off ) "; }
+  if( def ) {
+    defstr="( default=on ) ";
+  } else {
+    defstr="( default=off ) ";
+  }
   types.insert( std::pair<std::string,KeyType>(k,KeyType("flag")) );
-  std::string fd,lowkey=k; std::transform(lowkey.begin(),lowkey.end(),lowkey.begin(),[](unsigned char c) { return std::tolower(c); });
+  std::string fd,lowkey=k;
+  std::transform(lowkey.begin(),lowkey.end(),lowkey.begin(),[](unsigned char c) {
+    return std::tolower(c);
+  });
   fd=defstr + d;
   documentation.insert( std::pair<std::string,std::string>(k,fd) );
   allowmultiple.insert( std::pair<std::string,bool>(k,false) );
@@ -167,16 +205,25 @@ void Keywords::reserveFlag( const std::string & k, const bool def, const std::st
 void Keywords::use( const std::string & k ) {
   plumed_massert( reserved(k), "the " + k + " keyword is not reserved");
   for(unsigned i=0; i<reserved_keys.size(); ++i) {
-    if(reserved_keys[i]==k) keys.push_back( reserved_keys[i] );
+    if(reserved_keys[i]==k) {
+      keys.push_back( reserved_keys[i] );
+    }
   }
 }
 
 void Keywords::reset_style( const std::string & k, const std::string & style ) {
   plumed_massert( exists(k) || reserved(k), "no " + k + " keyword" );
-  if( style=="numbered" ) { allowmultiple[k]=true; return; }
+  if( style=="numbered" ) {
+    allowmultiple[k]=true;
+    return;
+  }
   (types.find(k)->second).setStyle(style);
-  if( (types.find(k)->second).isVessel() ) allowmultiple[k]=true;
-  if( (types.find(k)->second).isAtomList() ) atomtags.insert( std::pair<std::string,std::string>(k,style) );
+  if( (types.find(k)->second).isVessel() ) {
+    allowmultiple[k]=true;
+  }
+  if( (types.find(k)->second).isAtomList() ) {
+    atomtags.insert( std::pair<std::string,std::string>(k,style) );
+  }
 }
 
 void Keywords::add( const std::string & t, const std::string & k, const std::string & d ) {
@@ -190,9 +237,13 @@ void Keywords::add( const std::string & t, const std::string & k, const std::str
     fd=d;
     allowmultiple.insert( std::pair<std::string,bool>(k,false) );
     types.insert( std::pair<std::string,KeyType>(k,KeyType(t)) );
-    if( (types.find(k)->second).isAtomList() ) atomtags.insert( std::pair<std::string,std::string>(k,t) );
+    if( (types.find(k)->second).isAtomList() ) {
+      atomtags.insert( std::pair<std::string,std::string>(k,t) );
+    }
+  }
+  if( t=="atoms" && isaction ) {
+    fd = d + ".  For more information on how to specify lists of atoms see \\ref Group";
   }
-  if( t=="atoms" && isaction ) fd = d + ".  For more information on how to specify lists of atoms see \\ref Group";
   documentation.insert( std::pair<std::string,std::string>(k,fd) );
   keys.push_back(k);
 }
@@ -208,7 +259,8 @@ void Keywords::add( const std::string & t, const std::string & k, const std::str
 
 void Keywords::addFlag( const std::string & k, const bool def, const std::string & d ) {
   plumed_massert( !exists(k) && !reserved(k), "keyword " + k + " has already been registered");
-  std::string defstr; plumed_massert( !def, "the second argument to addFlag must be false " + k );
+  std::string defstr;
+  plumed_massert( !def, "the second argument to addFlag must be false " + k );
   defstr="( default=off ) ";
   types.insert( std::pair<std::string,KeyType>(k,KeyType("flag")) );
   documentation.insert( std::pair<std::string,std::string>(k,defstr + d) );
@@ -218,36 +270,55 @@ void Keywords::addFlag( const std::string & k, const bool def, const std::string
 }
 
 void Keywords::remove( const std::string & k ) {
-  bool found=false; unsigned j=0, n=0;
+  bool found=false;
+  unsigned j=0, n=0;
 
   while(true) {
-    for(j=0; j<keys.size(); j++) if(keys[j]==k)break;
-    for(n=0; n<reserved_keys.size(); n++) if(reserved_keys[n]==k)break;
+    for(j=0; j<keys.size(); j++)
+      if(keys[j]==k) {
+        break;
+      }
+    for(n=0; n<reserved_keys.size(); n++)
+      if(reserved_keys[n]==k) {
+        break;
+      }
     if(j<keys.size()) {
       keys.erase(keys.begin()+j);
       found=true;
     } else if(n<reserved_keys.size()) {
       reserved_keys.erase(reserved_keys.begin()+n);
       found=true;
-    } else break;
+    } else {
+      break;
+    }
   }
   // Delete documentation, type and so on from the description
-  types.erase(k); documentation.erase(k); allowmultiple.erase(k); booldefs.erase(k); numdefs.erase(k);
+  types.erase(k);
+  documentation.erase(k);
+  allowmultiple.erase(k);
+  booldefs.erase(k);
+  numdefs.erase(k);
   // Remove any output comonents that this keyword creates
   for(const auto& dkey : ckey ) {
-    if( dkey.second==k ) removeOutputComponent( dkey.first );
+    if( dkey.second==k ) {
+      removeOutputComponent( dkey.first );
+    }
   }
   plumed_massert(found,"You are trying to forbid " + k + " a keyword that isn't there"); // You have tried to forbid a keyword that isn't there
 }
 
 bool Keywords::numbered( const std::string & k ) const {
-  if( style( k,"atoms") ) return true;
+  if( style( k,"atoms") ) {
+    return true;
+  }
   plumed_massert( allowmultiple.count(k), "Did not find keyword " + k );
   return allowmultiple.find(k)->second;
 }
 
 bool Keywords::style( const std::string & k, const std::string & t ) const {
-  if( getStyle(k)==t ) return true;
+  if( getStyle(k)==t ) {
+    return true;
+  }
   return false;
 }
 
@@ -262,14 +333,18 @@ std::string Keywords::getKeyword( const unsigned i ) const {
 
 bool Keywords::exists( const std::string & k ) const {
   for(unsigned i=0; i<keys.size(); ++i) {
-    if( keys[i]==k ) return true;
+    if( keys[i]==k ) {
+      return true;
+    }
   }
   return false;
 }
 
 bool Keywords::reserved( const std::string & k ) const {
   for(unsigned i=0; i<reserved_keys.size(); ++i) {
-    if( reserved_keys[i]==k ) return true;
+    if( reserved_keys[i]==k ) {
+      return true;
+    }
   }
   return false;
 }
@@ -278,16 +353,23 @@ void Keywords::print_template(const std::string& actionname, bool include_option
   unsigned nkeys=0;
   std::printf("%s",actionname.c_str());
   for(unsigned i=0; i<keys.size(); ++i) {
-    if ( (types.find(keys[i])->second).isAtomList() ) nkeys++;
+    if ( (types.find(keys[i])->second).isAtomList() ) {
+      nkeys++;
+    }
   }
   if( nkeys>0 ) {
     std::string prevtag="start";
     for(unsigned i=0; i<keys.size(); ++i) {
       if( (types.find(keys[i])->second).isAtomList() ) {
         plumed_massert( atomtags.count(keys[i]), "keyword " + keys[i] + " allegedly specifies atoms but no tag has been specified. Please email Gareth Tribello");
-        if( prevtag!="start" && prevtag!=atomtags.find(keys[i])->second ) break;
-        if( (atomtags.find(keys[i])->second).find("residues")!=std::string::npos) std::printf(" %s=<residue selection>", keys[i].c_str() );
-        else std::printf(" %s=<atom selection>", keys[i].c_str() );
+        if( prevtag!="start" && prevtag!=atomtags.find(keys[i])->second ) {
+          break;
+        }
+        if( (atomtags.find(keys[i])->second).find("residues")!=std::string::npos) {
+          std::printf(" %s=<residue selection>", keys[i].c_str() );
+        } else {
+          std::printf(" %s=<atom selection>", keys[i].c_str() );
+        }
         prevtag=atomtags.find(keys[i])->second;
       }
     }
@@ -295,7 +377,9 @@ void Keywords::print_template(const std::string& actionname, bool include_option
   nkeys=0;
   for(unsigned i=0; i<keys.size(); ++i) {
     if ( include_optional || \
-         (types.find(keys[i])->second).isCompulsory() ) nkeys++;
+         (types.find(keys[i])->second).isCompulsory() ) {
+      nkeys++;
+    }
   }
   if( nkeys>0 ) {
     for(unsigned i=0; i<keys.size(); ++i) {
@@ -321,8 +405,11 @@ void Keywords::print_vim() const {
     if( (types.find(keys[i])->second).isFlag() ) {
       std::printf( ",flag:%s", keys[i].c_str() );
     } else {
-      if( allowmultiple.find(keys[i])->second ) std::printf(",numbered:%s",keys[i].c_str() );
-      else std::printf(",option:%s",keys[i].c_str() );
+      if( allowmultiple.find(keys[i])->second ) {
+        std::printf(",numbered:%s",keys[i].c_str() );
+      } else {
+        std::printf(",option:%s",keys[i].c_str() );
+      }
     }
   }
   std::fprintf(stdout, "\n%s", getHelpString().c_str() );
@@ -334,7 +421,9 @@ void Keywords::print_html() const {
   if( cnames.size()>0 ) {
     unsigned ndef=0;
     for(unsigned i=0; i<cnames.size(); ++i) {
-      if(ckey.find(cnames[i])->second=="default") ndef++;
+      if(ckey.find(cnames[i])->second=="default") {
+        ndef++;
+      }
     }
 
     if( ndef>0 ) {
@@ -345,7 +434,10 @@ void Keywords::print_html() const {
       unsigned nndef=0;
       for(unsigned i=0; i<cnames.size(); ++i) {
         //plumed_assert( ckey.find(cnames[i])->second=="default" );
-        if( ckey.find(cnames[i])->second!="default" ) { nndef++; continue; }
+        if( ckey.find(cnames[i])->second!="default" ) {
+          nndef++;
+          continue;
+        }
         std::printf("<tr>\n");
         std::printf("<td width=15%%> <b> %s </b></td>\n",cnames[i].c_str() );
         std::printf("<td> %s </td>\n",(cdocs.find(cnames[i])->second).c_str() );
@@ -371,7 +463,9 @@ void Keywords::print_html() const {
     } else {
       unsigned nregs=0;
       for(unsigned i=0; i<cnames.size(); ++i) {
-        if( exists(ckey.find(cnames[i])->second) ) nregs++;
+        if( exists(ckey.find(cnames[i])->second) ) {
+          nregs++;
+        }
       }
       if( nregs>0 ) {
         std::cout<<"\\par Description of components\n\n";
@@ -394,22 +488,34 @@ void Keywords::print_html() const {
 
   unsigned nkeys=0;
   for(unsigned i=0; i<keys.size(); ++i) {
-    if ( (types.find(keys[i])->second).isAtomList() ) nkeys++;
+    if ( (types.find(keys[i])->second).isAtomList() ) {
+      nkeys++;
+    }
   }
   if( nkeys>0 ) {
-    if(isaction && isatoms) std::cout<<"\\par The atoms involved can be specified using\n\n";
-    else if(isaction) std::cout<<"\\par The data to analyze can be the output from another analysis algorithm\n\n";
-    else std::cout<<"\\par The input trajectory is specified using one of the following\n\n";
+    if(isaction && isatoms) {
+      std::cout<<"\\par The atoms involved can be specified using\n\n";
+    } else if(isaction) {
+      std::cout<<"\\par The data to analyze can be the output from another analysis algorithm\n\n";
+    } else {
+      std::cout<<"\\par The input trajectory is specified using one of the following\n\n";
+    }
     std::cout<<" <table align=center frame=void width=95%% cellpadding=5%%> \n";
-    std::string prevtag="start"; unsigned counter=0;
+    std::string prevtag="start";
+    unsigned counter=0;
     for(unsigned i=0; i<keys.size(); ++i) {
       if ( (types.find(keys[i])->second).isAtomList() ) {
         plumed_massert( atomtags.count(keys[i]), "keyword " + keys[i] + " allegedly specifies atoms but no tag has been specified. Please email Gareth Tribello");
         if( prevtag!="start" && prevtag!=atomtags.find(keys[i])->second && isaction ) {
           std::cout<<"</table>\n\n";
-          if( isatoms ) std::cout<<"\\par Or alternatively by using\n\n";
-          else if( counter==0 ) { std::cout<<"\\par Alternatively data can be collected from the trajectory using \n\n"; counter++; }
-          else std::cout<<"\\par Lastly data collected in a previous analysis action can be reanalyzed by using the keyword \n\n";
+          if( isatoms ) {
+            std::cout<<"\\par Or alternatively by using\n\n";
+          } else if( counter==0 ) {
+            std::cout<<"\\par Alternatively data can be collected from the trajectory using \n\n";
+            counter++;
+          } else {
+            std::cout<<"\\par Lastly data collected in a previous analysis action can be reanalyzed by using the keyword \n\n";
+          }
           std::cout<<" <table align=center frame=void width=95%% cellpadding=5%%> \n";
         }
         print_html_item( keys[i] );
@@ -420,102 +526,152 @@ void Keywords::print_html() const {
   }
   nkeys=0;
   for(unsigned i=0; i<keys.size(); ++i) {
-    if ( (types.find(keys[i])->second).isCompulsory() ) nkeys++;
+    if ( (types.find(keys[i])->second).isCompulsory() ) {
+      nkeys++;
+    }
   }
   if( nkeys>0 ) {
-    if(isaction) std::cout<< "\\par Compulsory keywords\n\n";
-    else std::cout<<"\\par The following must be present\n\n";
+    if(isaction) {
+      std::cout<< "\\par Compulsory keywords\n\n";
+    } else {
+      std::cout<<"\\par The following must be present\n\n";
+    }
     std::cout<<" <table align=center frame=void width=95%% cellpadding=5%%> \n";
     for(unsigned i=0; i<keys.size(); ++i) {
-      if ( (types.find(keys[i])->second).isCompulsory() ) print_html_item( keys[i] );
+      if ( (types.find(keys[i])->second).isCompulsory() ) {
+        print_html_item( keys[i] );
+      }
     }
     std::cout<<"</table>\n\n";
   }
   nkeys=0;
   for(unsigned i=0; i<keys.size(); ++i) {
-    if ( (types.find(keys[i])->second).isFlag() || (types.find(keys[i])->second).isOptional() || (types.find(keys[i])->second).isVessel() ) nkeys++;
+    if ( (types.find(keys[i])->second).isFlag() || (types.find(keys[i])->second).isOptional() || (types.find(keys[i])->second).isVessel() ) {
+      nkeys++;
+    }
   }
   if( nkeys>0 ) {
-    if(isaction) std::cout<<"\\par Options\n\n";
-    else std::cout<<"\\par The following options are available\n\n";
+    if(isaction) {
+      std::cout<<"\\par Options\n\n";
+    } else {
+      std::cout<<"\\par The following options are available\n\n";
+    }
     std::cout<<" <table align=center frame=void width=95%% cellpadding=5%%> \n";
     for(unsigned i=0; i<keys.size(); ++i) {
-      if ( (types.find(keys[i])->second).isFlag() ) print_html_item( keys[i] );
+      if ( (types.find(keys[i])->second).isFlag() ) {
+        print_html_item( keys[i] );
+      }
     }
     std::cout<<"\n";
   }
   nkeys=0;
   for(unsigned i=0; i<keys.size(); ++i) {
-    if ( (types.find(keys[i])->second).isOptional() || (types.find(keys[i])->second).isVessel() ) nkeys++;
+    if ( (types.find(keys[i])->second).isOptional() || (types.find(keys[i])->second).isVessel() ) {
+      nkeys++;
+    }
   }
   if( nkeys>0 ) {
     for(unsigned i=0; i<keys.size(); ++i) {
-      if ( (types.find(keys[i])->second).isOptional() || (types.find(keys[i])->second).isVessel() ) print_html_item( keys[i] );
+      if ( (types.find(keys[i])->second).isOptional() || (types.find(keys[i])->second).isVessel() ) {
+        print_html_item( keys[i] );
+      }
     }
   }
   std::cout<<"</table>\n\n";
 }
 
 void Keywords::print_spelling() const {
-  for(unsigned i=0; i<keys.size(); ++i) std::printf("%s\n", keys[i].c_str() );
-  for(unsigned i=0; i<cnames.size(); ++i) std::printf("%s\n",cnames[i].c_str() );
+  for(unsigned i=0; i<keys.size(); ++i) {
+    std::printf("%s\n", keys[i].c_str() );
+  }
+  for(unsigned i=0; i<cnames.size(); ++i) {
+    std::printf("%s\n",cnames[i].c_str() );
+  }
 }
 
 std::string Keywords::getKeywordDocs( const std::string& key ) const {
   bool killdot=( (documentation.find(key)->second).find("\\f$")!=std::string::npos ); // Check for latex
   std::vector<std::string> w=Tools::getWords( documentation.find(key)->second );
-  std::stringstream sstr; sstr<<std::setw(23)<<key<<" - ";
-  unsigned nl=0; std::string blank=" ";
+  std::stringstream sstr;
+  sstr<<std::setw(23)<<key<<" - ";
+  unsigned nl=0;
+  std::string blank=" ";
   for(unsigned i=0; i<w.size(); ++i) {
     nl+=w[i].length() + 1;
     if( nl>60 ) {
-      sstr<<"\n"<<std::setw(23)<<blank<<"   "<<w[i]<<" "; nl=0;
-    } else sstr<<w[i]<<" ";
-    if( killdot && w[i].find(".")!=std::string::npos ) break; // If there is latex only write up to first dot
+      sstr<<"\n"<<std::setw(23)<<blank<<"   "<<w[i]<<" ";
+      nl=0;
+    } else {
+      sstr<<w[i]<<" ";
+    }
+    if( killdot && w[i].find(".")!=std::string::npos ) {
+      break;  // If there is latex only write up to first dot
+    }
   }
-  sstr<<"\n"; return sstr.str();
+  sstr<<"\n";
+  return sstr.str();
 }
 
 std::string Keywords::getHelpString() const {
-  std::string helpstr; unsigned nkeys=0;
+  std::string helpstr;
+  unsigned nkeys=0;
   for(unsigned i=0; i<keys.size(); ++i) {
-    if ( (types.find(keys[i])->second).isAtomList() ) nkeys++;
+    if ( (types.find(keys[i])->second).isAtomList() ) {
+      nkeys++;
+    }
   }
   if( nkeys>0 ) {
     helpstr += "The input trajectory can be in any of the following formats: \n\n";
     for(unsigned i=0; i<keys.size(); ++i) {
-      if ( (types.find(keys[i])->second).isAtomList() ) helpstr += getKeywordDocs( keys[i] );
+      if ( (types.find(keys[i])->second).isAtomList() ) {
+        helpstr += getKeywordDocs( keys[i] );
+      }
     }
   }
   nkeys=0;
   for(unsigned i=0; i<keys.size(); ++i) {
-    if ( (types.find(keys[i])->second).isCompulsory() ) nkeys++;
+    if ( (types.find(keys[i])->second).isCompulsory() ) {
+      nkeys++;
+    }
   }
   unsigned ncompulsory=nkeys;
   if( nkeys>0 ) {
     helpstr += "\nThe following arguments are compulsory: \n\n";
     for(unsigned i=0; i<keys.size(); ++i) {
-      if ( (types.find(keys[i])->second).isCompulsory() ) helpstr += getKeywordDocs( keys[i] );
+      if ( (types.find(keys[i])->second).isCompulsory() ) {
+        helpstr += getKeywordDocs( keys[i] );
+      }
     }
   }
   nkeys=0;
   for(unsigned i=0; i<keys.size(); ++i) {
-    if ( (types.find(keys[i])->second).isFlag() ) nkeys++;
+    if ( (types.find(keys[i])->second).isFlag() ) {
+      nkeys++;
+    }
   }
   if( nkeys>0 ) {
-    if(ncompulsory>0) helpstr += "\nIn addition you may use the following options: \n\n";
-    else helpstr += "\nThe following options are available\n\n";
+    if(ncompulsory>0) {
+      helpstr += "\nIn addition you may use the following options: \n\n";
+    } else {
+      helpstr += "\nThe following options are available\n\n";
+    }
     for(unsigned i=0; i<keys.size(); ++i) {
-      if ( (types.find(keys[i])->second).isFlag() ) helpstr += getKeywordDocs( keys[i] ).c_str();
+      if ( (types.find(keys[i])->second).isFlag() ) {
+        helpstr += getKeywordDocs( keys[i] ).c_str();
+      }
     }
   }
   nkeys=0;
   for(unsigned i=0; i<keys.size(); ++i) {
-    if ( (types.find(keys[i])->second).isOptional() || (types.find(keys[i])->second).isVessel() ) nkeys++;
+    if ( (types.find(keys[i])->second).isOptional() || (types.find(keys[i])->second).isVessel() ) {
+      nkeys++;
+    }
   }
   if( nkeys>0 ) {
     for(unsigned i=0; i<keys.size(); ++i) {
-      if ( (types.find(keys[i])->second).isOptional() || (types.find(keys[i])->second).isVessel() ) helpstr += getKeywordDocs( keys[i] );
+      if ( (types.find(keys[i])->second).isOptional() || (types.find(keys[i])->second).isVessel() ) {
+        helpstr += getKeywordDocs( keys[i] );
+      }
     }
     helpstr += "\n";
   }
@@ -531,22 +687,34 @@ void Keywords::print( FILE* out ) const {
 }
 
 std::string Keywords::getTooltip( const std::string& name ) const {
-  std::size_t dd=name.find_first_of("0123456789"); std::string kname=name.substr(0,dd);
-  if( !exists(kname) ) return "<b> could not find this keyword </b>";
+  std::size_t dd=name.find_first_of("0123456789");
+  std::string kname=name.substr(0,dd);
+  if( !exists(kname) ) {
+    return "<b> could not find this keyword </b>";
+  }
   std::string mystring, docstr = documentation.find(kname)->second;
   if( types.find(kname)->second.isCompulsory() ) {
     mystring += "<b>compulsory keyword ";
     if( docstr.find("default")!=std::string::npos ) {
-      std::size_t bra = docstr.find_first_of(")"); mystring += docstr.substr(0,bra+1); docstr = docstr.substr(bra+1);
+      std::size_t bra = docstr.find_first_of(")");
+      mystring += docstr.substr(0,bra+1);
+      docstr = docstr.substr(bra+1);
     }
     mystring += "</b>\n";
   }
-  std::vector<std::string> w=Tools::getWords( docstr ); unsigned nl=0;
+  std::vector<std::string> w=Tools::getWords( docstr );
+  unsigned nl=0;
   for(unsigned i=0; i<w.size(); ++i) {
     nl+=w[i].length() + 1;
-    if( nl>80 ) { mystring += w[i] + "\n"; nl=0; }
-    else { mystring += w[i] + " "; }
-    if( w[i].find(".")!=std::string::npos ) break; // Only write up the the first dot
+    if( nl>80 ) {
+      mystring += w[i] + "\n";
+      nl=0;
+    } else {
+      mystring += w[i] + " ";
+    }
+    if( w[i].find(".")!=std::string::npos ) {
+      break;  // Only write up the the first dot
+    }
   }
   return mystring;
 }
@@ -584,10 +752,17 @@ bool Keywords::getDefaultValue(const std::string & key, std::string& def ) const
 }
 
 void Keywords::destroyData() {
-  keys.clear(); reserved_keys.clear(); types.clear();
-  allowmultiple.clear(); documentation.clear();
-  booldefs.clear(); numdefs.clear(); atomtags.clear();
-  ckey.clear(); cdocs.clear(); ckey.clear();
+  keys.clear();
+  reserved_keys.clear();
+  types.clear();
+  allowmultiple.clear();
+  documentation.clear();
+  booldefs.clear();
+  numdefs.clear();
+  atomtags.clear();
+  ckey.clear();
+  cdocs.clear();
+  ckey.clear();
 }
 
 void Keywords::setComponentsIntroduction( const std::string& instr ) {
@@ -601,7 +776,8 @@ void Keywords::addOutputComponent( const std::string& name, const std::string& k
 
   std::size_t num2=name.find_first_of("_");
   if( num2!=std::string::npos ) {
-    char uu = '_'; plumed_massert( std::count(name.begin(),name.end(), uu)==1, "underscore is reserved character in component names and there should only be one");
+    char uu = '_';
+    plumed_massert( std::count(name.begin(),name.end(), uu)==1, "underscore is reserved character in component names and there should only be one");
     plumed_massert( num2==0, "underscore is reserved character in component names that has special meaning");
   }
   if( key=="default" ) {
@@ -618,9 +794,15 @@ void Keywords::addOutputComponent( const std::string& name, const std::string& k
 void Keywords::removeOutputComponent( const std::string& name ) {
   unsigned j=0;
   while(true) {
-    for(j=0; j<cnames.size(); j++) if(cnames[j]==name)break;
-    if(j<cnames.size()) cnames.erase(cnames.begin()+j);
-    else break;
+    for(j=0; j<cnames.size(); j++)
+      if(cnames[j]==name) {
+        break;
+      }
+    if(j<cnames.size()) {
+      cnames.erase(cnames.begin()+j);
+    } else {
+      break;
+    }
   }
   cdocs.erase(name);
 }
@@ -630,22 +812,32 @@ void Keywords::setValueDescription( const std::string& descr ) {
     ckey.insert( std::pair<std::string,std::string>(".#!value","default") );
     cdocs.insert( std::pair<std::string,std::string>(".#!value",descr) );
     cnames.push_back(".#!value");
-  } else cdocs[".#!value"] = descr;
+  } else {
+    cdocs[".#!value"] = descr;
+  }
 }
 
 bool Keywords::outputComponentExists( const std::string& name ) const {
-  if( cstring.find("customize")!=std::string::npos ) return true;
+  if( cstring.find("customize")!=std::string::npos ) {
+    return true;
+  }
 
   std::string sname;
   std::size_t num=name.find_first_of("-");
   std::size_t num2=name.find_last_of("_");
 
-  if( num2!=std::string::npos ) sname=name.substr(num2);
-  else if( num!=std::string::npos ) sname=name.substr(0,num);
-  else sname=name;
+  if( num2!=std::string::npos ) {
+    sname=name.substr(num2);
+  } else if( num!=std::string::npos ) {
+    sname=name.substr(0,num);
+  } else {
+    sname=name;
+  }
 
   for(unsigned i=0; i<cnames.size(); ++i) {
-    if( sname==cnames[i] ) return true;
+    if( sname==cnames[i] ) {
+      return true;
+    }
   }
   return false;
 }
@@ -655,16 +847,25 @@ std::string Keywords::getOutputComponentFlag( const std::string& name ) const {
 }
 
 std::string Keywords::getOutputComponentDescription( const std::string& name ) const {
-  std::string checkname = name; std::size_t hyp=name.find_first_of("-");
-  if( hyp!=std::string::npos ) checkname = name.substr(0,hyp);
+  std::string checkname = name;
+  std::size_t hyp=name.find_first_of("-");
+  if( hyp!=std::string::npos ) {
+    checkname = name.substr(0,hyp);
+  }
 
   bool found=false;
   for(unsigned i=0; i<cnames.size(); ++i) {
-    if( checkname==cnames[i] ) found=true;
+    if( checkname==cnames[i] ) {
+      found=true;
+    }
   }
   if( !found ) {
-    if( name==".#!value" ) return "the value calculated by this action";
-    if( outputComponentExists( name ) ) plumed_merror("cannot find description for component " + name + " that allegedly exists. Gareth Tribello might know what the fuck that is about.");
+    if( name==".#!value" ) {
+      return "the value calculated by this action";
+    }
+    if( outputComponentExists( name ) ) {
+      plumed_merror("cannot find description for component " + name + " that allegedly exists. Gareth Tribello might know what the fuck that is about.");
+    }
     plumed_merror("could not find output component named " + name );
   }
   return cdocs.find(checkname)->second;
@@ -675,14 +876,20 @@ void Keywords::removeComponent( const std::string& name ) {
 
   while(true) {
     unsigned j;
-    for(j=0; j<cnames.size(); j++) if(cnames[j]==name)break;
+    for(j=0; j<cnames.size(); j++)
+      if(cnames[j]==name) {
+        break;
+      }
     if(j<cnames.size()) {
       cnames.erase(cnames.begin()+j);
       found=true;
-    } else break;
+    } else {
+      break;
+    }
   }
   // Delete documentation, type and so on from the description
-  cdocs.erase(name); ckey.erase(name);
+  cdocs.erase(name);
+  ckey.erase(name);
   plumed_massert(found,"You are trying to remove " + name + " a component that isn't there");
 }
 
@@ -691,11 +898,14 @@ std::vector<std::string> Keywords::getOutputComponents() const {
 }
 
 std::string Keywords::getKeywordDescription( const std::string& key ) const {
-  plumed_assert( exists( key ) ); return documentation.find(key)->second;
+  plumed_assert( exists( key ) );
+  return documentation.find(key)->second;
 }
 
 void Keywords::needsAction( const std::string& name ) {
-  if( std::find(neededActions.begin(), neededActions.end(), name )!=neededActions.end() ) return;
+  if( std::find(neededActions.begin(), neededActions.end(), name )!=neededActions.end() ) {
+    return;
+  }
   neededActions.push_back( name );
 }
 
@@ -704,7 +914,9 @@ const std::vector<std::string>& Keywords::getNeededKeywords() const {
 }
 
 void Keywords::addActionNameSuffix( const std::string& suffix ) {
-  if( std::find(actionNameSuffixes.begin(), actionNameSuffixes.end(), suffix )!=actionNameSuffixes.end() ) return;
+  if( std::find(actionNameSuffixes.begin(), actionNameSuffixes.end(), suffix )!=actionNameSuffixes.end() ) {
+    return;
+  }
   actionNameSuffixes.push_back( suffix );
 }
 
diff --git a/src/tools/Keywords.h b/src/tools/Keywords.h
index 16c0cc60fd..85873a11e6 100644
--- a/src/tools/Keywords.h
+++ b/src/tools/Keywords.h
@@ -40,19 +40,37 @@ class Keywords {
     enum {hidden,compulsory,flag,optional,atoms,vessel} style;
     explicit KeyType( const std::string& type );
     void setStyle( const std::string& type );
-    bool isCompulsory() const { return (style==compulsory); }
-    bool isFlag() const { return (style==flag); }
-    bool isOptional() const { return (style==optional); }
-    bool isAtomList() const { return (style==atoms); }
-    bool isVessel() const { return (style==vessel); }
+    bool isCompulsory() const {
+      return (style==compulsory);
+    }
+    bool isFlag() const {
+      return (style==flag);
+    }
+    bool isOptional() const {
+      return (style==optional);
+    }
+    bool isAtomList() const {
+      return (style==atoms);
+    }
+    bool isVessel() const {
+      return (style==vessel);
+    }
     std::string toString() const {
-      if(style==compulsory) return "compulsory";
-      else if(style==optional) return "optional";
-      else if(style==atoms) return "atoms";
-      else if(style==flag) return "flag";
-      else if(style==hidden) return "hidden";
-      else if(style==vessel) return "vessel";
-      else plumed_assert(0);
+      if(style==compulsory) {
+        return "compulsory";
+      } else if(style==optional) {
+        return "optional";
+      } else if(style==atoms) {
+        return "atoms";
+      } else if(style==flag) {
+        return "flag";
+      } else if(style==hidden) {
+        return "hidden";
+      } else if(style==vessel) {
+        return "vessel";
+      } else {
+        plumed_assert(0);
+      }
       return "";
     }
   };
@@ -100,9 +118,13 @@ class Keywords {
 /// Constructor
   Keywords() : isaction(true), isatoms(true) {}
 ///
-  void isDriver() { isaction=false; }
+  void isDriver() {
+    isaction=false;
+  }
 ///
-  void isAnalysis() { isatoms=false; }
+  void isAnalysis() {
+    isatoms=false;
+  }
 /// find out whether flag key is on or off by default.
   bool getLogicalDefault(const std::string & key, bool& def ) const ;
 /// Get the value of the default for the keyword named key
@@ -186,7 +208,9 @@ class Keywords {
 /// Remove a component with a particular name from the keywords
   void removeComponent( const std::string& name );
 /// Reference to keys
-  std::vector<std::string> getKeys() const { return keys; }
+  std::vector<std::string> getKeys() const {
+    return keys;
+  }
 /// Get the description of a particular keyword
   std::string getTooltip( const std::string& name ) const ;
 /// Note that another actions is required to create this shortcut
diff --git a/src/tools/LatticeReduction.cpp b/src/tools/LatticeReduction.cpp
index c7d388161c..2893c1bcf2 100644
--- a/src/tools/LatticeReduction.cpp
+++ b/src/tools/LatticeReduction.cpp
@@ -34,7 +34,9 @@ void LatticeReduction::sort(Vector v[3]) {
   m[0]=modulo2(v[0]);
   m[1]=modulo2(v[1]);
   m[2]=modulo2(v[2]);
-  for(int i=0; i<3; i++) for(int j=i+1; j<3; j++) if(m[i]>m[j]) {
+  for(int i=0; i<3; i++)
+    for(int j=i+1; j<3; j++)
+      if(m[i]>m[j]) {
         std::swap(v[i],v[j]);
         std::swap(m[i],m[j]);
       }
@@ -54,13 +56,17 @@ void LatticeReduction::reduce(Vector&a,Vector&b) {
     }
     a-=b*floor(dotProduct(a,b)/mb+0.5);
     ma=modulo2(a);
-    if(mb<=ma*onePlusEpsilon) break;
+    if(mb<=ma*onePlusEpsilon) {
+      break;
+    }
     counter++;
     if(counter%100==0) { // only test rarely since this might be expensive
       plumed_assert(!std::isnan(ma));
       plumed_assert(!std::isnan(mb));
     }
-    if(counter%10000==0) std::fprintf(stderr,"WARNING: LatticeReduction::reduce stuck after %u iterations\n",counter);
+    if(counter%10000==0) {
+      std::fprintf(stderr,"WARNING: LatticeReduction::reduce stuck after %u iterations\n",counter);
+    }
   }
 
   std::swap(a,b);
@@ -68,32 +74,42 @@ void LatticeReduction::reduce(Vector&a,Vector&b) {
 
 void LatticeReduction::reduce2(Vector&a,Vector&b,Vector&c) {
   Vector v[3];
-  v[0]=a; v[1]=b; v[2]=c;
+  v[0]=a;
+  v[1]=b;
+  v[2]=c;
   int iter=0;
   int ok=0;
   while(ok<3) {
     int i,j;
     if(iter%3==0) {
-      i=0; j=1;
+      i=0;
+      j=1;
     } else if(iter%3==1) {
-      i=0; j=2;
+      i=0;
+      j=2;
     } else {
-      i=1; j=2;
+      i=1;
+      j=2;
     }
-    if(isReduced(v[i],v[j])) ok++;
-    else {
+    if(isReduced(v[i],v[j])) {
+      ok++;
+    } else {
       reduce(v[i],v[j]);
       ok=1;
     }
     iter++;
   }
-  a=v[0]; b=v[1]; c=v[2];
+  a=v[0];
+  b=v[1];
+  c=v[2];
 }
 
 bool LatticeReduction::isReduced(const Vector&a,const Vector&b) {
   const int cut=5;
   for(int i=-cut; i<=cut; i++) {
-    if(modulo2(b+i*a)<modulo2(b)) return false;
+    if(modulo2(b+i*a)<modulo2(b)) {
+      return false;
+    }
   }
   return modulo2(a)<=modulo2(b) && 2.0*dotProduct(a,b)<=modulo2(a);
 }
@@ -147,9 +163,13 @@ void LatticeReduction::reduceFast(Tensor&t) {
           first=false;
         }
       }
-    if(modulo2(best)*onePlusEpsilon>=modulo2(v[2])) break;
+    if(modulo2(best)*onePlusEpsilon>=modulo2(v[2])) {
+      break;
+    }
     counter++;
-    if(counter%10000==0) std::fprintf(stderr,"WARNING: LatticeReduction::reduceFast stuck after %u iterations\n",counter);
+    if(counter%10000==0) {
+      std::fprintf(stderr,"WARNING: LatticeReduction::reduceFast stuck after %u iterations\n",counter);
+    }
     v[2]=best;
   }
   sort(v);
@@ -169,10 +189,21 @@ void LatticeReduction::reduceSlow(Tensor&t) {
   double e02=dotProduct(v[0],v[2]);
   double e12=dotProduct(v[1],v[2]);
   if(e01*e02*e12<0) {
-    int eps01=0; if(e01>0.0) eps01=1; else if(e01<0.0) eps01=-1;
-    int eps02=0; if(e02>0.0) eps02=1; else if(e02<0.0) eps02=-1;
+    int eps01=0;
+    if(e01>0.0) {
+      eps01=1;
+    } else if(e01<0.0) {
+      eps01=-1;
+    }
+    int eps02=0;
+    if(e02>0.0) {
+      eps02=1;
+    } else if(e02<0.0) {
+      eps02=-1;
+    }
     Vector n=v[0]-eps01*v[1]-eps02*v[2];
-    int i=0; double mx=modulo2(v[i]);
+    int i=0;
+    double mx=modulo2(v[i]);
     for(int j=1; j<3; j++) {
       double f=modulo2(v[j]);
       if(f>mx) {
@@ -180,7 +211,9 @@ void LatticeReduction::reduceSlow(Tensor&t) {
         mx=f;
       }
     }
-    if(modulo2(n)<mx) v[i]=n;
+    if(modulo2(n)<mx) {
+      v[i]=n;
+    }
   }
   sort(v);
   t.setRow(0,v[0]);
@@ -198,15 +231,23 @@ bool LatticeReduction::isReduced(const Tensor&t) {
   v[0]=t.getRow(0);
   v[1]=t.getRow(1);
   v[2]=t.getRow(2);
-  for(int i=0; i<3; i++) m[i]=modulo2(v[i]);
-  if(!((m[0]<=m[1]) && m[1]<=m[2])) return false;
+  for(int i=0; i<3; i++) {
+    m[i]=modulo2(v[i]);
+  }
+  if(!((m[0]<=m[1]) && m[1]<=m[2])) {
+    return false;
+  }
   const int cut=5;
   for(int i=-cut; i<=cut; i++) {
     double mm=modulo2(v[1]+i*v[0]);
-    if(mm<m[1]) return false;
+    if(mm<m[1]) {
+      return false;
+    }
     for(int j=-cut; j<=cut; j++) {
       double mx=modulo2(v[2]+i*v[1]+j*v[0]);
-      if(mx<m[2])return false;
+      if(mx<m[2]) {
+        return false;
+      }
     }
   }
   return true;
diff --git a/src/tools/LeptonCall.cpp b/src/tools/LeptonCall.cpp
index 80b0b3ca45..f16277634d 100644
--- a/src/tools/LeptonCall.cpp
+++ b/src/tools/LeptonCall.cpp
@@ -25,14 +25,22 @@
 namespace PLMD {
 
 void LeptonCall::set(const std::string & func, const std::vector<std::string>& var, Action* action, const bool& a ) {
-  unsigned nth=OpenMP::getNumThreads(); expression.resize(nth); expression_deriv.resize(var.size());
+  unsigned nth=OpenMP::getNumThreads();
+  expression.resize(nth);
+  expression_deriv.resize(var.size());
   // Resize the expression for the derivatives
-  for(unsigned i=0; i<expression_deriv.size(); ++i) expression_deriv[i].resize(OpenMP::getNumThreads());
-  allow_extra_args=a; nargs=var.size();
+  for(unsigned i=0; i<expression_deriv.size(); ++i) {
+    expression_deriv[i].resize(OpenMP::getNumThreads());
+  }
+  allow_extra_args=a;
+  nargs=var.size();
 
   lepton_ref.resize(nth*nargs,nullptr);
-  lepton::ParsedExpression pe=lepton::Parser::parse(func).optimize(lepton::Constants()); unsigned nt=0;
-  if( action ) action->log<<"  function as parsed by lepton: "<<pe<<"\n";
+  lepton::ParsedExpression pe=lepton::Parser::parse(func).optimize(lepton::Constants());
+  unsigned nt=0;
+  if( action ) {
+    action->log<<"  function as parsed by lepton: "<<pe<<"\n";
+  }
   for(auto & e : expression) {
     e=pe.createCompiledExpression();
     for(unsigned j=0; j<var.size(); ++j) {
@@ -47,14 +55,23 @@ void LeptonCall::set(const std::string & func, const std::vector<std::string>& v
   }
   for(auto & p : expression[0].getVariables()) {
     if(std::find(var.begin(),var.end(),p)==var.end()) {
-      if( action ) action->error("variable " + p + " is not defined");
-      else plumed_merror("variable " + p + " is not defined in lepton function");
+      if( action ) {
+        action->error("variable " + p + " is not defined");
+      } else {
+        plumed_merror("variable " + p + " is not defined in lepton function");
+      }
     }
   }
-  if( action ) action->log<<"  derivatives as computed by lepton:\n";
+  if( action ) {
+    action->log<<"  derivatives as computed by lepton:\n";
+  }
   lepton_ref_deriv.resize(nth*nargs*nargs,nullptr);
   for(unsigned i=0; i<var.size(); i++) {
-    lepton::ParsedExpression pe=lepton::Parser::parse(func).differentiate(var[i]).optimize(lepton::Constants()); nt=0; if( action ) action->log<<"    "<<pe<<"\n";
+    lepton::ParsedExpression pe=lepton::Parser::parse(func).differentiate(var[i]).optimize(lepton::Constants());
+    nt=0;
+    if( action ) {
+      action->log<<"    "<<pe<<"\n";
+    }
     for(auto & e : expression_deriv[i]) {
       e=pe.createCompiledExpression();
       for(unsigned j=0; j<var.size(); ++j) {
@@ -74,16 +91,21 @@ double LeptonCall::evaluate( const std::vector<double>& args ) const {
   plumed_dbg_assert( allow_extra_args || args.size()==nargs );
   const unsigned t=OpenMP::getThreadNum(), tbas=t*nargs;
   for(unsigned i=0; i<nargs; ++i) {
-    if( lepton_ref[tbas+i] ) *lepton_ref[tbas+i] = args[i];
+    if( lepton_ref[tbas+i] ) {
+      *lepton_ref[tbas+i] = args[i];
+    }
   }
   return expression[t].evaluate();
 }
 
 double LeptonCall::evaluateDeriv( const unsigned& ider, const std::vector<double>& args ) const {
-  plumed_dbg_assert( allow_extra_args || args.size()==nargs ); plumed_dbg_assert( ider<nargs );
+  plumed_dbg_assert( allow_extra_args || args.size()==nargs );
+  plumed_dbg_assert( ider<nargs );
   const unsigned t=OpenMP::getThreadNum(), dbas = ider*OpenMP::getNumThreads()*nargs + t*nargs;
   for(unsigned j=0; j<nargs; j++) {
-    if(lepton_ref_deriv[dbas+j] ) *lepton_ref_deriv[dbas+j] = args[j];
+    if(lepton_ref_deriv[dbas+j] ) {
+      *lepton_ref_deriv[dbas+j] = args[j];
+    }
   }
   return expression_deriv[ider][t].evaluate();
 }
diff --git a/src/tools/LinkCells.cpp b/src/tools/LinkCells.cpp
index ef323ed89a..0211e4d8df 100644
--- a/src/tools/LinkCells.cpp
+++ b/src/tools/LinkCells.cpp
@@ -30,16 +30,17 @@ LinkCells::LinkCells( Communicator& cc ) :
   cutoffwasset(false),
   link_cutoff(0.0),
   ncells(3),
-  nstride(3)
-{
+  nstride(3) {
 }
 
 void LinkCells::setCutoff( const double& lcut ) {
-  cutoffwasset=true; link_cutoff=lcut;
+  cutoffwasset=true;
+  link_cutoff=lcut;
 }
 
 double LinkCells::getCutoff() const {
-  plumed_assert( cutoffwasset ); return link_cutoff;
+  plumed_assert( cutoffwasset );
+  return link_cutoff;
 }
 
 void LinkCells::buildCellLists( const std::vector<Vector>& pos, const std::vector<unsigned>& indices, const Pbc& pbc ) {
@@ -52,7 +53,8 @@ void LinkCells::buildCellLists( const std::vector<Vector>& pos, const std::vecto
 
   // Setup the lists
   if( pos.size()!=allcells.size() ) {
-    allcells.resize( pos.size() ); lcell_lists.resize( pos.size() );
+    allcells.resize( pos.size() );
+    lcell_lists.resize( pos.size() );
   }
 
   {
@@ -61,22 +63,33 @@ void LinkCells::buildCellLists( const std::vector<Vector>& pos, const std::vecto
 // This allows to use linked cells in non orthorhomic boxes
     Tensor reciprocal(transpose(mypbc.getInvBox()));
     ncells[0] = std::floor( 1.0/ reciprocal.getRow(0).modulo() / link_cutoff );
-    if( ncells[0]==0 ) ncells[0]=1;
+    if( ncells[0]==0 ) {
+      ncells[0]=1;
+    }
     ncells[1] = std::floor( 1.0/ reciprocal.getRow(1).modulo() / link_cutoff );
-    if( ncells[1]==0 ) ncells[1]=1;
+    if( ncells[1]==0 ) {
+      ncells[1]=1;
+    }
     ncells[2] = std::floor( 1.0/ reciprocal.getRow(2).modulo() / link_cutoff );
-    if( ncells[2]==0 ) ncells[2]=1;
+    if( ncells[2]==0 ) {
+      ncells[2]=1;
+    }
   }
   // Setup the strides
-  nstride[0]=1; nstride[1]=ncells[0]; nstride[2]=ncells[0]*ncells[1];
+  nstride[0]=1;
+  nstride[1]=ncells[0];
+  nstride[2]=ncells[0]*ncells[1];
 
   // Setup the storage for link cells
   unsigned ncellstot=ncells[0]*ncells[1]*ncells[2];
   if( lcell_tots.size()!=ncellstot ) {
-    lcell_tots.resize( ncellstot ); lcell_starts.resize( ncellstot );
+    lcell_tots.resize( ncellstot );
+    lcell_starts.resize( ncellstot );
   }
   // Clear nlcells
-  for(unsigned i=0; i<ncellstot; ++i) lcell_tots[i]=0;
+  for(unsigned i=0; i<ncellstot; ++i) {
+    lcell_tots[i]=0;
+  }
   // Clear allcells
   allcells.assign( allcells.size(), 0 );
 
@@ -87,11 +100,16 @@ void LinkCells::buildCellLists( const std::vector<Vector>& pos, const std::vecto
     lcell_tots[allcells[i]]++;
   }
   // And gather all this information on every node
-  comm.Sum( allcells ); comm.Sum( lcell_tots );
+  comm.Sum( allcells );
+  comm.Sum( lcell_tots );
 
   // Now prepare the link cell lists
   unsigned tot=0;
-  for(unsigned i=0; i<lcell_tots.size(); ++i) { lcell_starts[i]=tot; tot+=lcell_tots[i]; lcell_tots[i]=0; }
+  for(unsigned i=0; i<lcell_tots.size(); ++i) {
+    lcell_starts[i]=tot;
+    tot+=lcell_tots[i];
+    lcell_tots[i]=0;
+  }
   plumed_assert( tot==pos.size() );
 
   // And setup the link cells properly
@@ -119,11 +137,18 @@ void LinkCells::addRequiredCells( const std::array<unsigned,3>& celn, unsigned&
         int zval = celn[2] + nz;
         zval=LINKC_PBC(zval,ncells[2])*nstride[2];
 
-        unsigned mybox=xval+yval+zval; bool added=false;
+        unsigned mybox=xval+yval+zval;
+        bool added=false;
         for(unsigned k=0; k<ncells_required; ++k) {
-          if( mybox==cells_required[k] ) { added=true; break; }
+          if( mybox==cells_required[k] ) {
+            added=true;
+            break;
+          }
+        }
+        if( !added ) {
+          cells_required[ncells_required+nnew_cells]=mybox;
+          nnew_cells++;
         }
-        if( !added ) { cells_required[ncells_required+nnew_cells]=mybox; nnew_cells++; }
       }
     }
   }
@@ -132,8 +157,11 @@ void LinkCells::addRequiredCells( const std::array<unsigned,3>& celn, unsigned&
 
 void LinkCells::retrieveNeighboringAtoms( const Vector& pos, std::vector<unsigned>& cell_list,
     unsigned& natomsper, std::vector<unsigned>& atoms ) const {
-  if( cell_list.size()!=getNumberOfCells() ) cell_list.resize( getNumberOfCells() );
-  unsigned ncellt=0; addRequiredCells( findMyCell( pos ), ncellt, cell_list );
+  if( cell_list.size()!=getNumberOfCells() ) {
+    cell_list.resize( getNumberOfCells() );
+  }
+  unsigned ncellt=0;
+  addRequiredCells( findMyCell( pos ), ncellt, cell_list );
   retrieveAtomsInCells( ncellt, cell_list, natomsper, atoms );
 }
 
@@ -174,7 +202,9 @@ unsigned LinkCells::findCell( const Vector& pos ) const {
 unsigned LinkCells::getMaxInCell() const {
   unsigned maxn = lcell_tots[0];
   for(unsigned i=1; i<lcell_tots.size(); ++i) {
-    if( lcell_tots[i]>maxn ) { maxn=lcell_tots[i]; }
+    if( lcell_tots[i]>maxn ) {
+      maxn=lcell_tots[i];
+    }
   }
   return maxn;
 }
diff --git a/src/tools/Log.h b/src/tools/Log.h
index 8475822fb6..fb8ce4a1a1 100644
--- a/src/tools/Log.h
+++ b/src/tools/Log.h
@@ -33,8 +33,7 @@ namespace PLMD {
 /// lines with the "PLUMED:" prefix, useful to grep out plumed
 /// log from output
 class Log :
-  public OFile
-{
+  public OFile {
 };
 
 }
diff --git a/src/tools/Matrix.h b/src/tools/Matrix.h
index aa55c43909..064ec604d9 100644
--- a/src/tools/Matrix.h
+++ b/src/tools/Matrix.h
@@ -36,21 +36,26 @@ namespace PLMD {
 /// Calculate the dot product between two vectors
 template <typename T> T dotProduct( const std::vector<T>& A, const std::vector<T>& B ) {
   plumed_assert( A.size()==B.size() );
-  T val; for(unsigned i=0; i<A.size(); ++i) { val+=A[i]*B[i]; }
+  T val;
+  for(unsigned i=0; i<A.size(); ++i) {
+    val+=A[i]*B[i];
+  }
   return val;
 }
 
 /// Calculate the dot product between a vector and itself
 template <typename T> T norm( const std::vector<T>& A ) {
-  T val; for(unsigned i=0; i<A.size(); ++i) { val+=A[i]*A[i]; }
+  T val;
+  for(unsigned i=0; i<A.size(); ++i) {
+    val+=A[i]*A[i];
+  }
   return val;
 }
 
 /// This class stores a full matrix and allows one to do some simple matrix operations
 template <typename T>
 class Matrix:
-  public MatrixSquareBracketsAccess<Matrix<T>,T>
-{
+  public MatrixSquareBracketsAccess<Matrix<T>,T> {
   /// Multiply matrix by scalar
   template <typename U> friend Matrix<U> operator*(U&, const Matrix<U>& );
   /// Matrix matrix multiply
@@ -90,22 +95,44 @@ class Matrix:
   explicit Matrix(const unsigned nr=0, const unsigned nc=0 )  : sz(nr*nc), rw(nr), cl(nc), data(nr*nc) {}
   Matrix(const Matrix<T>& t) : sz(t.sz), rw(t.rw), cl(t.cl), data(t.data) {}
   /// Resize the matrix
-  void resize( const unsigned nr, const unsigned nc ) { rw=nr; cl=nc; sz=nr*nc; data.resize(sz); }
+  void resize( const unsigned nr, const unsigned nc ) {
+    rw=nr;
+    cl=nc;
+    sz=nr*nc;
+    data.resize(sz);
+  }
   /// Return the number of rows
-  inline unsigned nrows() const { return rw; }
+  inline unsigned nrows() const {
+    return rw;
+  }
   /// Return the number of columns
-  inline unsigned ncols() const { return cl; }
+  inline unsigned ncols() const {
+    return cl;
+  }
   /// Return the contents of the matrix as a vector of length rw*cl
-  inline std::vector<T>& getVector() { return data; }
+  inline std::vector<T>& getVector() {
+    return data;
+  }
   /// Set the matrix from a vector input
-  inline void setFromVector( const std::vector<T>& vecin ) { plumed_assert( vecin.size()==sz ); for(unsigned i=0; i<sz; ++i) data[i]=vecin[i]; }
+  inline void setFromVector( const std::vector<T>& vecin ) {
+    plumed_assert( vecin.size()==sz );
+    for(unsigned i=0; i<sz; ++i) {
+      data[i]=vecin[i];
+    }
+  }
   /// Return element i,j of the matrix
-  inline const T& operator () (const unsigned& i, const unsigned& j) const { return data[j+i*cl]; }
+  inline const T& operator () (const unsigned& i, const unsigned& j) const {
+    return data[j+i*cl];
+  }
   /// Return a referenre to element i,j of the matrix
-  inline T& operator () (const unsigned& i, const unsigned& j)      { return data[j+i*cl]; }
+  inline T& operator () (const unsigned& i, const unsigned& j)      {
+    return data[j+i*cl];
+  }
   /// Set all elements of the matrix equal to the value of v
   Matrix<T>& operator=(const T& v) {
-    for(unsigned i=0; i<sz; ++i) { data[i]=v; }
+    for(unsigned i=0; i<sz; ++i) {
+      data[i]=v;
+    }
     return *this;
   }
   /// Set the Matrix equal to another Matrix
@@ -119,17 +146,23 @@ class Matrix:
   /// Set the Matrix equal to the value of a standard vector - used for readin
   Matrix<T>& operator=(const std::vector<T>& v) {
     plumed_dbg_assert( v.size()==sz );
-    for(unsigned i=0; i<sz; ++i) { data[i]=v[i]; }
+    for(unsigned i=0; i<sz; ++i) {
+      data[i]=v[i];
+    }
     return *this;
   }
   /// Add v to all elements of the Matrix
   Matrix<T> operator+=(const T& v) {
-    for(unsigned i=0; i<sz; ++i) { data[i]+=v; }
+    for(unsigned i=0; i<sz; ++i) {
+      data[i]+=v;
+    }
     return *this;
   }
   /// Multiply all elements by v
   Matrix<T> operator*=(const T& v) {
-    for(unsigned i=0; i<sz; ++i) { data[i]*=v; }
+    for(unsigned i=0; i<sz; ++i) {
+      data[i]*=v;
+    }
     return *this;
   }
   /// Matrix addition
@@ -140,7 +173,9 @@ class Matrix:
   }
   /// Subtract v from all elements of the Matrix
   Matrix<T> operator-=(const T& v) {
-    for(unsigned i=0; i<sz; ++i) { data-=v; }
+    for(unsigned i=0; i<sz; ++i) {
+      data-=v;
+    }
     return *this;
   }
   /// Matrix subtraction
@@ -151,9 +186,16 @@ class Matrix:
   }
   /// Test if the matrix is symmetric or not
   unsigned isSymmetric() const {
-    if (rw!=cl) { return 0; }
+    if (rw!=cl) {
+      return 0;
+    }
     unsigned sym=1;
-    for(unsigned i=1; i<rw; ++i) for(unsigned j=0; j<i; ++j) if( std::fabs(data[i+j*cl]-data[j+i*cl])>1.e-10 ) { sym=0; break; }
+    for(unsigned i=1; i<rw; ++i)
+      for(unsigned j=0; j<i; ++j)
+        if( std::fabs(data[i+j*cl]-data[j+i*cl])>1.e-10 ) {
+          sym=0;
+          break;
+        }
     return sym;
   }
 };
@@ -167,37 +209,67 @@ template <typename T> Matrix<T> operator*(T& v, const Matrix<T>& m ) {
 
 template <typename T> void mult( const Matrix<T>& A, const Matrix<T>& B, Matrix<T>& C ) {
   plumed_assert(A.cl==B.rw);
-  if( A.rw !=C.rw  || B.cl !=C.cl ) { C.resize( A.rw, B.cl ); } C=static_cast<T>( 0 );
-  for(unsigned i=0; i<A.rw; ++i) for(unsigned j=0; j<B.cl; ++j) for (unsigned k=0; k<A.cl; ++k) C(i,j)+=A(i,k)*B(k,j);
+  if( A.rw !=C.rw  || B.cl !=C.cl ) {
+    C.resize( A.rw, B.cl );
+  }
+  C=static_cast<T>( 0 );
+  for(unsigned i=0; i<A.rw; ++i)
+    for(unsigned j=0; j<B.cl; ++j)
+      for (unsigned k=0; k<A.cl; ++k) {
+        C(i,j)+=A(i,k)*B(k,j);
+      }
 }
 
 template <typename T> void mult( const Matrix<T>& A, const std::vector<T>& B, std::vector<T>& C) {
   plumed_assert( A.cl==B.size() );
-  if( C.size()!=A.rw  ) { C.resize(A.rw); }
-  for(unsigned i=0; i<A.rw; ++i) { C[i]= static_cast<T>( 0 ); }
-  for(unsigned i=0; i<A.rw; ++i) for(unsigned k=0; k<A.cl; ++k) C[i]+=A(i,k)*B[k] ;
+  if( C.size()!=A.rw  ) {
+    C.resize(A.rw);
+  }
+  for(unsigned i=0; i<A.rw; ++i) {
+    C[i]= static_cast<T>( 0 );
+  }
+  for(unsigned i=0; i<A.rw; ++i)
+    for(unsigned k=0; k<A.cl; ++k) {
+      C[i]+=A(i,k)*B[k] ;
+    }
 }
 
 template <typename T> void mult( const std::vector<T>& A, const Matrix<T>& B, std::vector<T>& C) {
   plumed_assert( B.rw==A.size() );
-  if( C.size()!=B.cl ) {C.resize( B.cl );}
-  for(unsigned i=0; i<B.cl; ++i) { C[i]=static_cast<T>( 0 ); }
-  for(unsigned i=0; i<B.cl; ++i) for(unsigned k=0; k<B.rw; ++k) C[i]+=A[k]*B(k,i);
+  if( C.size()!=B.cl ) {
+    C.resize( B.cl );
+  }
+  for(unsigned i=0; i<B.cl; ++i) {
+    C[i]=static_cast<T>( 0 );
+  }
+  for(unsigned i=0; i<B.cl; ++i)
+    for(unsigned k=0; k<B.rw; ++k) {
+      C[i]+=A[k]*B(k,i);
+    }
 }
 
 template <typename T> void transpose( const Matrix<T>& A, Matrix<T>& AT ) {
-  if( A.rw!=AT.cl || A.cl!=AT.rw ) AT.resize( A.cl, A.rw );
-  for(unsigned i=0; i<A.cl; ++i) for(unsigned j=0; j<A.rw; ++j) AT(i,j)=A(j,i);
+  if( A.rw!=AT.cl || A.cl!=AT.rw ) {
+    AT.resize( A.cl, A.rw );
+  }
+  for(unsigned i=0; i<A.cl; ++i)
+    for(unsigned j=0; j<A.rw; ++j) {
+      AT(i,j)=A(j,i);
+    }
 }
 
 template <typename T> Log& operator<<(Log& ostr, const Matrix<T>& mat) {
-  for(unsigned i=0; i<mat.sz; ++i) ostr<<mat.data[i]<<" ";
+  for(unsigned i=0; i<mat.sz; ++i) {
+    ostr<<mat.data[i]<<" ";
+  }
   return ostr;
 }
 
 template <typename T> void matrixOut( Log& ostr, const Matrix<T>& mat) {
   for(unsigned i=0; i<mat.rw; ++i) {
-    for(unsigned j=0; j<mat.cl; ++j) { ostr<<mat(i,j)<<" "; }
+    for(unsigned j=0; j<mat.cl; ++j) {
+      ostr<<mat(i,j)<<" ";
+    }
     ostr<<"\n";
   }
   return;
@@ -206,14 +278,19 @@ template <typename T> void matrixOut( Log& ostr, const Matrix<T>& mat) {
 template <typename T> int diagMat( const Matrix<T>& A, std::vector<double>& eigenvals, Matrix<double>& eigenvecs ) {
 
   // Check matrix is square and symmetric
-  plumed_assert( A.rw==A.cl ); plumed_assert( A.isSymmetric()==1 );
+  plumed_assert( A.rw==A.cl );
+  plumed_assert( A.isSymmetric()==1 );
   std::vector<double> da(A.sz);
   unsigned k=0;
   std::vector<double> evals(A.cl);
   // Transfer the matrix to the local array
-  for (unsigned i=0; i<A.cl; ++i) for (unsigned j=0; j<A.rw; ++j) da[k++]=static_cast<double>( A(j,i) );
+  for (unsigned i=0; i<A.cl; ++i)
+    for (unsigned j=0; j<A.rw; ++j) {
+      da[k++]=static_cast<double>( A(j,i) );
+    }
 
-  int n=A.cl; int lwork=-1, liwork=-1, m, info, one=1;
+  int n=A.cl;
+  int lwork=-1, liwork=-1, m, info, one=1;
   std::vector<double> work(A.cl);
   std::vector<int> iwork(A.cl);
   double vl, vu, abstol=0.0;
@@ -223,26 +300,38 @@ template <typename T> int diagMat( const Matrix<T>& A, std::vector<double>& eige
   plumed_lapack_dsyevr("V", "I", "U", &n, da.data(), &n, &vl, &vu, &one, &n,
                        &abstol, &m, evals.data(), evecs.data(), &n,
                        isup.data(), work.data(), &lwork, iwork.data(), &liwork, &info);
-  if (info!=0) return info;
+  if (info!=0) {
+    return info;
+  }
 
   // Retrieve correct sizes for work and iwork then reallocate
-  liwork=iwork[0]; iwork.resize(liwork);
-  lwork=static_cast<int>( work[0] ); work.resize(lwork);
+  liwork=iwork[0];
+  iwork.resize(liwork);
+  lwork=static_cast<int>( work[0] );
+  work.resize(lwork);
 
   plumed_lapack_dsyevr("V", "I", "U", &n, da.data(), &n, &vl, &vu, &one, &n,
                        &abstol, &m, evals.data(), evecs.data(), &n,
                        isup.data(), work.data(), &lwork, iwork.data(), &liwork, &info);
-  if (info!=0) return info;
+  if (info!=0) {
+    return info;
+  }
 
-  if( eigenvals.size()!=A.cl ) { eigenvals.resize( A.cl ); }
-  if( eigenvecs.rw!=A.rw || eigenvecs.cl!=A.cl ) { eigenvecs.resize( A.rw, A.cl ); }
+  if( eigenvals.size()!=A.cl ) {
+    eigenvals.resize( A.cl );
+  }
+  if( eigenvecs.rw!=A.rw || eigenvecs.cl!=A.cl ) {
+    eigenvecs.resize( A.rw, A.cl );
+  }
   k=0;
   for(unsigned i=0; i<A.cl; ++i) {
     eigenvals[i]=evals[i];
     // N.B. For ease of producing projectors we store the eigenvectors
     // ROW-WISE in the eigenvectors matrix.  The first index is the
     // eigenvector number and the second the component
-    for(unsigned j=0; j<A.rw; ++j) { eigenvecs(i,j)=evecs[k++]; }
+    for(unsigned j=0; j<A.rw; ++j) {
+      eigenvecs(i,j)=evecs[k++];
+    }
   }
 
   // This changes eigenvectors so that the first non-null element
@@ -251,8 +340,15 @@ template <typename T> int diagMat( const Matrix<T>& A, std::vector<double>& eige
   // the result reproducible
   for(int i=0; i<n; ++i) {
     int j;
-    for(j=0; j<n; j++) if(eigenvecs(i,j)*eigenvecs(i,j)>1e-14) break;
-    if(j<n) if(eigenvecs(i,j)<0.0) for(j=0; j<n; j++) eigenvecs(i,j)*=-1;
+    for(j=0; j<n; j++)
+      if(eigenvecs(i,j)*eigenvecs(i,j)>1e-14) {
+        break;
+      }
+    if(j<n)
+      if(eigenvecs(i,j)<0.0)
+        for(j=0; j<n; j++) {
+          eigenvecs(i,j)*=-1;
+        }
   }
   return 0;
 }
@@ -261,10 +357,17 @@ template <typename T> int pseudoInvert( const Matrix<T>& A, Matrix<double>& pseu
   std::vector<double> da(A.sz);
   unsigned k=0;
   // Transfer the matrix to the local array
-  for (unsigned i=0; i<A.cl; ++i) for (unsigned j=0; j<A.rw; ++j) da[k++]=static_cast<double>( A(j,i) );
+  for (unsigned i=0; i<A.cl; ++i)
+    for (unsigned j=0; j<A.rw; ++j) {
+      da[k++]=static_cast<double>( A(j,i) );
+    }
 
   int nsv, info, nrows=A.rw, ncols=A.cl;
-  if(A.rw>A.cl) {nsv=A.cl;} else {nsv=A.rw;}
+  if(A.rw>A.cl) {
+    nsv=A.cl;
+  } else {
+    nsv=A.rw;
+  }
 
   // Create some containers for stuff from single value decomposition
   std::vector<double> S(nsv);
@@ -276,30 +379,62 @@ template <typename T> int pseudoInvert( const Matrix<T>& A, Matrix<double>& pseu
   int lwork=-1;
   std::vector<double> work(1);
   plumed_lapack_dgesdd( "A", &nrows, &ncols, da.data(), &nrows, S.data(), U.data(), &nrows, VT.data(), &ncols, work.data(), &lwork, iwork.data(), &info );
-  if(info!=0) return info;
+  if(info!=0) {
+    return info;
+  }
 
   // Retrieve correct sizes for work and rellocate
-  lwork=(int) work[0]; work.resize(lwork);
+  lwork=(int) work[0];
+  work.resize(lwork);
 
   // This does the singular value decomposition
   plumed_lapack_dgesdd( "A", &nrows, &ncols, da.data(), &nrows, S.data(), U.data(), &nrows, VT.data(), &ncols, work.data(), &lwork, iwork.data(), &info );
-  if(info!=0) return info;
+  if(info!=0) {
+    return info;
+  }
 
   // Compute the tolerance on the singular values ( machine epsilon * number of singular values * maximum singular value )
-  double tol; tol=S[0]; for(int i=1; i<nsv; ++i) { if( S[i]>tol ) { tol=S[i]; } } tol*=nsv*epsilon;
+  double tol;
+  tol=S[0];
+  for(int i=1; i<nsv; ++i) {
+    if( S[i]>tol ) {
+      tol=S[i];
+    }
+  }
+  tol*=nsv*epsilon;
 
   // Get the inverses of the singlular values
-  Matrix<double> Si( ncols, nrows ); Si=0.0;
-  for(int i=0; i<nsv; ++i) { if( S[i]>tol ) { Si(i,i)=1./S[i]; } else { Si(i,i)=0.0; } }
+  Matrix<double> Si( ncols, nrows );
+  Si=0.0;
+  for(int i=0; i<nsv; ++i) {
+    if( S[i]>tol ) {
+      Si(i,i)=1./S[i];
+    } else {
+      Si(i,i)=0.0;
+    }
+  }
 
   // Now extract matrices for pseudoinverse
   Matrix<double> V( ncols, ncols ), UT( nrows, nrows ), tmp( ncols, nrows );
-  k=0; for(int i=0; i<nrows; ++i) { for(int j=0; j<nrows; ++j) { UT(i,j)=U[k++]; } }
-  k=0; for(int i=0; i<ncols; ++i) { for(int j=0; j<ncols; ++j) { V(i,j)=VT[k++]; } }
+  k=0;
+  for(int i=0; i<nrows; ++i) {
+    for(int j=0; j<nrows; ++j) {
+      UT(i,j)=U[k++];
+    }
+  }
+  k=0;
+  for(int i=0; i<ncols; ++i) {
+    for(int j=0; j<ncols; ++j) {
+      V(i,j)=VT[k++];
+    }
+  }
 
   // And do matrix algebra to construct the pseudoinverse
-  if( pseudoinverse.rw!=ncols || pseudoinverse.cl!=nrows ) pseudoinverse.resize( ncols, nrows );
-  mult( V, Si, tmp ); mult( tmp, UT, pseudoinverse );
+  if( pseudoinverse.rw!=ncols || pseudoinverse.cl!=nrows ) {
+    pseudoinverse.resize( ncols, nrows );
+  }
+  mult( V, Si, tmp );
+  mult( tmp, UT, pseudoinverse );
 
   return 0;
 }
@@ -310,31 +445,55 @@ template <typename T> int Invert( const Matrix<T>& A, Matrix<double>& inverse )
     // GAT -- I only ever use symmetric matrices so I can invert them like this.
     // I choose to do this as I have had problems with the more general way of doing this that
     // is implemented below.
-    std::vector<double> eval(A.rw); Matrix<double> evec(A.rw,A.cl), tevec(A.rw,A.cl);
-    int err; err=diagMat( A, eval, evec );
-    if(err!=0) return err;
-    for (unsigned i=0; i<A.rw; ++i) for (unsigned j=0; j<A.cl; ++j) tevec(i,j)=evec(j,i)/eval[j];
+    std::vector<double> eval(A.rw);
+    Matrix<double> evec(A.rw,A.cl), tevec(A.rw,A.cl);
+    int err;
+    err=diagMat( A, eval, evec );
+    if(err!=0) {
+      return err;
+    }
+    for (unsigned i=0; i<A.rw; ++i)
+      for (unsigned j=0; j<A.cl; ++j) {
+        tevec(i,j)=evec(j,i)/eval[j];
+      }
     mult(tevec,evec,inverse);
   } else {
     std::vector<double> da(A.sz);
     std::vector<int> ipiv(A.cl);
-    unsigned k=0; int n=A.rw, info;
-    for(unsigned i=0; i<A.cl; ++i) for(unsigned j=0; j<A.rw; ++j) da[k++]=static_cast<double>( A(j,i) );
+    unsigned k=0;
+    int n=A.rw, info;
+    for(unsigned i=0; i<A.cl; ++i)
+      for(unsigned j=0; j<A.rw; ++j) {
+        da[k++]=static_cast<double>( A(j,i) );
+      }
 
     plumed_lapack_dgetrf(&n,&n,da.data(),&n,ipiv.data(),&info);
-    if(info!=0) return info;
+    if(info!=0) {
+      return info;
+    }
 
     int lwork=-1;
     std::vector<double> work(A.cl);
     plumed_lapack_dgetri(&n,da.data(),&n,ipiv.data(),work.data(),&lwork,&info);
-    if(info!=0) return info;
+    if(info!=0) {
+      return info;
+    }
 
-    lwork=static_cast<int>( work[0] ); work.resize(lwork);
+    lwork=static_cast<int>( work[0] );
+    work.resize(lwork);
     plumed_lapack_dgetri(&n,da.data(),&n,ipiv.data(),work.data(),&lwork,&info);
-    if(info!=0) return info;
+    if(info!=0) {
+      return info;
+    }
 
-    if( inverse.cl!=A.cl || inverse.rw!=A.rw ) { inverse.resize(A.rw,A.cl); }
-    k=0; for(unsigned i=0; i<A.rw; ++i) for(unsigned j=0; j<A.cl; ++j) inverse(j,i)=da[k++];
+    if( inverse.cl!=A.cl || inverse.rw!=A.rw ) {
+      inverse.resize(A.rw,A.cl);
+    }
+    k=0;
+    for(unsigned i=0; i<A.rw; ++i)
+      for(unsigned j=0; j<A.cl; ++j) {
+        inverse(j,i)=da[k++];
+      }
   }
 
   return 0;
@@ -343,31 +502,52 @@ template <typename T> int Invert( const Matrix<T>& A, Matrix<double>& inverse )
 template <typename T> void cholesky( const Matrix<T>& A, Matrix<T>& B ) {
 
   plumed_assert( A.rw==A.cl && A.isSymmetric() );
-  Matrix<T> L(A.rw,A.cl); L=0.;
+  Matrix<T> L(A.rw,A.cl);
+  L=0.;
   std::vector<T> D(A.rw,0.);
   for(unsigned i=0; i<A.rw; ++i) {
     L(i,i)=static_cast<T>( 1 );
     for (unsigned j=0; j<i; ++j) {
       L(i,j)=A(i,j);
-      for (unsigned k=0; k<j; ++k) L(i,j)-=L(i,k)*L(j,k)*D[k];
-      if (D[j]!=0.) L(i,j)/=D[j]; else L(i,j)=static_cast<T>( 0 );
+      for (unsigned k=0; k<j; ++k) {
+        L(i,j)-=L(i,k)*L(j,k)*D[k];
+      }
+      if (D[j]!=0.) {
+        L(i,j)/=D[j];
+      } else {
+        L(i,j)=static_cast<T>( 0 );
+      }
     }
     D[i]=A(i,i);
-    for (unsigned k=0; k<i; ++k) D[i]-=L(i,k)*L(i,k)*D[k];
+    for (unsigned k=0; k<i; ++k) {
+      D[i]-=L(i,k)*L(i,k)*D[k];
+    }
   }
 
-  for(unsigned i=0; i<A.rw; ++i) D[i]=(D[i]>0.?std::sqrt(D[i]):0.);
-  if( B.rw!=A.rw || B.cl!=A.cl ) { B.resize( A.rw, A.cl); }
-  B=0.; for(unsigned i=0; i<A.rw; ++i) for(unsigned j=0; j<=i; ++j) B(i,j)+=L(i,j)*D[j];
+  for(unsigned i=0; i<A.rw; ++i) {
+    D[i]=(D[i]>0.?std::sqrt(D[i]):0.);
+  }
+  if( B.rw!=A.rw || B.cl!=A.cl ) {
+    B.resize( A.rw, A.cl);
+  }
+  B=0.;
+  for(unsigned i=0; i<A.rw; ++i)
+    for(unsigned j=0; j<=i; ++j) {
+      B(i,j)+=L(i,j)*D[j];
+    }
 }
 
 template <typename T> void chol_elsolve( const Matrix<T>& M, const std::vector<T>& b, std::vector<T>& y ) {
 
   plumed_assert( M.rw==M.cl && M(0,1)==0.0 && b.size()==M.rw );
-  if( y.size()!=M.rw ) { y.resize( M.rw ); }
+  if( y.size()!=M.rw ) {
+    y.resize( M.rw );
+  }
   for(unsigned i=0; i<M.rw; ++i) {
     y[i]=b[i];
-    for(unsigned j=0; j<i; ++j) y[i]-=M(i,j)*y[j];
+    for(unsigned j=0; j<i; ++j) {
+      y[i]-=M(i,j)*y[j];
+    }
     y[i]*=1.0/M(i,i);
   }
 }
@@ -380,9 +560,13 @@ template <typename T> int logdet( const Matrix<T>& M, double& ldet ) {
   unsigned k=0;
   std::vector<double> evals(M.cl);
   // Transfer the matrix to the local array
-  for (unsigned i=0; i<M.rw; ++i) for (unsigned j=0; j<M.cl; ++j) da[k++]=static_cast<double>( M(j,i) );
+  for (unsigned i=0; i<M.rw; ++i)
+    for (unsigned j=0; j<M.cl; ++j) {
+      da[k++]=static_cast<double>( M(j,i) );
+    }
 
-  int n=M.cl; int lwork=-1, liwork=-1, info, m, one=1;
+  int n=M.cl;
+  int lwork=-1, liwork=-1, info, m, one=1;
   std::vector<double> work(M.rw);
   std::vector<int> iwork(M.rw);
   double vl, vu, abstol=0.0;
@@ -391,19 +575,28 @@ template <typename T> int logdet( const Matrix<T>& M, double& ldet ) {
   plumed_lapack_dsyevr("N", "I", "U", &n, da.data(), &n, &vl, &vu, &one, &n,
                        &abstol, &m, evals.data(), evecs.data(), &n,
                        isup.data(), work.data(), &lwork, iwork.data(), &liwork, &info);
-  if (info!=0) return info;
+  if (info!=0) {
+    return info;
+  }
 
   // Retrieve correct sizes for work and iwork then reallocate
-  lwork=static_cast<int>( work[0] ); work.resize(lwork);
-  liwork=iwork[0]; iwork.resize(liwork);
+  lwork=static_cast<int>( work[0] );
+  work.resize(lwork);
+  liwork=iwork[0];
+  iwork.resize(liwork);
 
   plumed_lapack_dsyevr("N", "I", "U", &n, da.data(), &n, &vl, &vu, &one, &n,
                        &abstol, &m, evals.data(), evecs.data(), &n,
                        isup.data(), work.data(), &lwork, iwork.data(), &liwork, &info);
-  if (info!=0) return info;
+  if (info!=0) {
+    return info;
+  }
 
   // Transfer the eigenvalues and eigenvectors to the output
-  ldet=0; for(unsigned i=0; i<M.cl; i++) { ldet+=log(evals[i]); }
+  ldet=0;
+  for(unsigned i=0; i<M.cl; i++) {
+    ldet+=log(evals[i]);
+  }
 
   return 0;
 }
diff --git a/src/tools/MergeVectorTools.h b/src/tools/MergeVectorTools.h
index 34400b8d66..e3560c4f01 100644
--- a/src/tools/MergeVectorTools.h
+++ b/src/tools/MergeVectorTools.h
@@ -40,19 +40,26 @@ template<class C>
 static void mergeSortedVectors(const C* const* vecs, std::size_t size, std::vector<typename C::value_type> & result) {
 
   /// local class storing the range of remaining objects to be pushed
-  class Entry
-  {
+  class Entry {
     typename C::const_iterator fwdIt,endIt;
 
   public:
     explicit Entry(C const& v) : fwdIt(v.begin()), endIt(v.end()) {}
     /// check if this vector still contains something to be pushed
-    bool empty() const { return fwdIt == endIt; }
+    bool empty() const {
+      return fwdIt == endIt;
+    }
     /// to allow using a priority_queu, which selects the highest element.
     /// we here (counterintuitively) define < as >
-    bool operator< (Entry const& rhs) const { return top() > rhs.top(); }
-    const auto & top() const { return *fwdIt; }
-    void next() { ++fwdIt;};
+    bool operator< (Entry const& rhs) const {
+      return top() > rhs.top();
+    }
+    const auto & top() const {
+      return *fwdIt;
+    }
+    void next() {
+      ++fwdIt;
+    };
   };
 
   // preprocessing
@@ -65,7 +72,9 @@ static void mergeSortedVectors(const C* const* vecs, std::size_t size, std::vect
     // this is just to decrease the number of reallocations on push_back
     result.reserve(maxsize);
     // if vectors are empty we are done
-    if(maxsize==0) return;
+    if(maxsize==0) {
+      return;
+    }
   }
 
   // start
@@ -93,8 +102,11 @@ static void mergeSortedVectors(const C* const* vecs, std::size_t size, std::vect
     // here, we append inconditionally
     result.push_back(val);
     tmp.next();
-    if(tmp.empty()) heap.pop_back();
-    else std::push_heap(std::begin(heap), std::end(heap));
+    if(tmp.empty()) {
+      heap.pop_back();
+    } else {
+      std::push_heap(std::begin(heap), std::end(heap));
+    }
   }
 
   while(!heap.empty()) {
@@ -106,13 +118,19 @@ static void mergeSortedVectors(const C* const* vecs, std::size_t size, std::vect
     const auto val=tmp.top();
     // if the element is larger than the current largest element,
     // push it to result
-    if(val > result.back()) result.push_back(val);
+    if(val > result.back()) {
+      result.push_back(val);
+    }
     // move forward the used entry
     tmp.next();
     // if this entry is exhausted, remove it from the array
-    if(tmp.empty()) heap.pop_back();
+    if(tmp.empty()) {
+      heap.pop_back();
+    }
     // otherwise, sort again the array
-    else std::push_heap(std::begin(heap), std::end(heap));
+    else {
+      std::push_heap(std::begin(heap), std::end(heap));
+    }
   }
 }
 
diff --git a/src/tools/Minimise1DBrent.h b/src/tools/Minimise1DBrent.h
index d338c407db..dfaa38f742 100644
--- a/src/tools/Minimise1DBrent.h
+++ b/src/tools/Minimise1DBrent.h
@@ -83,18 +83,24 @@ Minimise1DBrent<FCLASS>::Minimise1DBrent( const FCLASS& pf, const double& t ):
   ax(0),bx(0),cx(0),
   fa(0),fb(0),fc(0),
   fmin(0),
-  myclass_func(pf)
-{
+  myclass_func(pf) {
 }
 
 template <class FCLASS>
 void Minimise1DBrent<FCLASS>::bracket( const double& a, const double& b, eng_pointer eng ) {
-  ax=a; bx=b; double fu;
-  fa=(myclass_func.*eng)(ax); fb=(myclass_func.*eng)(bx);
+  ax=a;
+  bx=b;
+  double fu;
+  fa=(myclass_func.*eng)(ax);
+  fb=(myclass_func.*eng)(bx);
   if( fb>fa ) {
     double tmp;
-    tmp=ax; ax=bx; bx=tmp;
-    tmp=fa; fa=fb; fb=tmp;
+    tmp=ax;
+    ax=bx;
+    bx=tmp;
+    tmp=fa;
+    fa=fb;
+    fb=tmp;
   }
   cx=bx+GOLD*(bx-ax);
   fc=(myclass_func.*eng)(cx);
@@ -106,16 +112,29 @@ void Minimise1DBrent<FCLASS>::bracket( const double& a, const double& b, eng_poi
     if((bx-u)*(u-cx) > 0.0 ) {
       fu=(myclass_func.*eng)(u);
       if( fu < fc ) {
-        ax=bx; bx=u; fa=fb; fb=fu; bracketed=true; return;
+        ax=bx;
+        bx=u;
+        fa=fb;
+        fb=fu;
+        bracketed=true;
+        return;
       } else if( fu > fb ) {
-        cx=u; fc=fu; bracketed=true; return;
+        cx=u;
+        fc=fu;
+        bracketed=true;
+        return;
       }
-      u=cx+GOLD*(cx-bx); fu=(myclass_func.*eng)(u);
+      u=cx+GOLD*(cx-bx);
+      fu=(myclass_func.*eng)(u);
     } else if((cx-u)*(u-ulim) > 0.0 ) {
       fu=(myclass_func.*eng)(u);
       if( fu<fc ) {
-        bx=cx; cx=u; u+=GOLD*(u-bx);
-        fb=fc; fc=fu; fu=(myclass_func.*eng)(u);
+        bx=cx;
+        cx=u;
+        u+=GOLD*(u-bx);
+        fb=fc;
+        fc=fu;
+        fu=(myclass_func.*eng)(u);
       }
     } else if( (u-ulim)*(ulim-cx) >= 0.0 ) {
       u=ulim;
@@ -124,8 +143,12 @@ void Minimise1DBrent<FCLASS>::bracket( const double& a, const double& b, eng_poi
       u=cx+GOLD*(cx-bx);
       fu=(myclass_func.*eng)(u);
     }
-    ax=bx; bx=cx; cx=u;
-    fa=fb; fb=fc; fc=fu;
+    ax=bx;
+    bx=cx;
+    cx=u;
+    fa=fb;
+    fb=fc;
+    fc=fu;
   }
   bracketed=true;
 }
@@ -146,39 +169,65 @@ double Minimise1DBrent<FCLASS>::minimise( eng_pointer eng ) {
     xm=0.5*(a+b);
     tol2=2.0*(tol1=tol*std::fabs(x)+ZEPS);
     if( std::fabs(x-xm) <= (tol2-0.5*(b-a))) {
-      fmin=fx; minimised=true; return x;
+      fmin=fx;
+      minimised=true;
+      return x;
     }
     if( std::fabs(e) > tol1 ) {
       r=(x-w)*(fx-fv);
       q=(x-v)*(fx-fw);
       p=(x-v)*q-(x-w)*r;
       q=2.0*(q-r);
-      if( q > 0.0 ) p = -p;
+      if( q > 0.0 ) {
+        p = -p;
+      }
       q=std::fabs(q);
       etemp=e;
       e=d;
       if( std::fabs(p) >= std::fabs(0.5*q*etemp) || p <= q*(a-x) || p >= q*(b-x) ) {
         d = CGOLD*(e=(x >= xm ? a-x : b-x ));
       } else {
-        d=p/q; u=x+d;
-        if(u-a < tol2 || b-u < tol2 ) d=(xm-x>=0?std::fabs(tol1):-std::fabs(tol1));
+        d=p/q;
+        u=x+d;
+        if(u-a < tol2 || b-u < tol2 ) {
+          d=(xm-x>=0?std::fabs(tol1):-std::fabs(tol1));
+        }
       }
     } else {
       d=CGOLD*(e=( x >= xm ? a-x : b-x ));
     }
-    if( std::fabs(d)>=tol1) u=x+d; else u=x+(d>=0?std::fabs(tol1):-std::fabs(tol1));
+    if( std::fabs(d)>=tol1) {
+      u=x+d;
+    } else {
+      u=x+(d>=0?std::fabs(tol1):-std::fabs(tol1));
+    }
     fu=(myclass_func.*eng)(u);
     if( fu <= fx ) {
-      if( u >= x ) a=x; else b=x;
-      v=w; fv=fw;
-      w=x; fw=fx;
-      x=u; fx=fu;
+      if( u >= x ) {
+        a=x;
+      } else {
+        b=x;
+      }
+      v=w;
+      fv=fw;
+      w=x;
+      fw=fx;
+      x=u;
+      fx=fu;
     } else {
-      if( u < x ) a=u; else b=u;
+      if( u < x ) {
+        a=u;
+      } else {
+        b=u;
+      }
       if( fu <=fw || w==x ) {
-        v=w; w=u; fv=fw; fw=fu;
+        v=w;
+        w=u;
+        fv=fw;
+        fw=fu;
       } else if( fu <= fv || v==x || v==w ) {
-        v=u; fv=fu;
+        v=u;
+        fv=fu;
       }
     }
   }
diff --git a/src/tools/MinimiseBase.h b/src/tools/MinimiseBase.h
index f8a67250cd..28cc7246a5 100644
--- a/src/tools/MinimiseBase.h
+++ b/src/tools/MinimiseBase.h
@@ -61,15 +61,18 @@ F1dim<FCLASS>::F1dim( const std::vector<double>& pp, const std::vector<double>&
   fake_der(pp.size()),
   func(ff),
   calc(cc),
-  calc2(cc2)
-{
+  calc2(cc2) {
   plumed_assert( calc || calc2 );
 }
 
 template <class FCLASS>
 double F1dim<FCLASS>::getEng( const double& xt ) {
-  for(unsigned j=0; j<pt.size(); ++j) pt[j] = p[j] + xt*dir[j];
-  if( calc ) return (func->*calc)(pt,fake_der);
+  for(unsigned j=0; j<pt.size(); ++j) {
+    pt[j] = p[j] + xt*dir[j];
+  }
+  if( calc ) {
+    return (func->*calc)(pt,fake_der);
+  }
   return (func->*calc2)(pt,fake_der);
 }
 
@@ -102,7 +105,9 @@ double MinimiseBase<FCLASS>::linemin( const std::vector<double>& dir, std::vecto
   double ax=0.0, xx=1.0;
   bb.bracket( ax, xx, &F1dim<FCLASS>::getEng );
   double xmin=bb.minimise( &F1dim<FCLASS>::getEng );
-  for(unsigned i=0; i<p.size(); ++i) p[i] += xmin*dir[i];
+  for(unsigned i=0; i<p.size(); ++i) {
+    p[i] += xmin*dir[i];
+  }
   return bb.getMinimumValue();
 }
 
diff --git a/src/tools/MolDataClass.cpp b/src/tools/MolDataClass.cpp
index baecf5dc83..bd89233303 100644
--- a/src/tools/MolDataClass.cpp
+++ b/src/tools/MolDataClass.cpp
@@ -27,134 +27,269 @@
 namespace PLMD {
 
 unsigned MolDataClass::numberOfAtomsPerResidueInBackbone( const std::string& type ) {
-  if( type=="protein" ) return 5;
-  else if( type=="dna" ) return 6;
-  else if( type=="rna" ) return 6;
-  else return 0;
+  if( type=="protein" ) {
+    return 5;
+  } else if( type=="dna" ) {
+    return 6;
+  } else if( type=="rna" ) {
+    return 6;
+  } else {
+    return 0;
+  }
 }
 
 bool MolDataClass::allowedResidue( const std::string& type, const std::string& residuename ) {
   if( type=="protein" ) {
-    if(residuename=="ALA") return true;
-    else if(residuename=="ARG") return true;
-    else if(residuename=="ASN") return true;
-    else if(residuename=="ASP") return true;
-    else if(residuename=="CYS") return true;
-    else if(residuename=="GLN") return true;
-    else if(residuename=="GLU") return true;
-    else if(residuename=="GLY") return true;
-    else if(residuename=="HIS") return true;
-    else if(residuename=="ILE") return true;
-    else if(residuename=="LEU") return true;
-    else if(residuename=="LYS") return true;
-    else if(residuename=="MET") return true;
-    else if(residuename=="PHE") return true;
-    else if(residuename=="PRO") return true;
-    else if(residuename=="SER") return true;
-    else if(residuename=="THR") return true;
-    else if(residuename=="TRP") return true;
-    else if(residuename=="TYR") return true;
-    else if(residuename=="VAL") return true;
+    if(residuename=="ALA") {
+      return true;
+    } else if(residuename=="ARG") {
+      return true;
+    } else if(residuename=="ASN") {
+      return true;
+    } else if(residuename=="ASP") {
+      return true;
+    } else if(residuename=="CYS") {
+      return true;
+    } else if(residuename=="GLN") {
+      return true;
+    } else if(residuename=="GLU") {
+      return true;
+    } else if(residuename=="GLY") {
+      return true;
+    } else if(residuename=="HIS") {
+      return true;
+    } else if(residuename=="ILE") {
+      return true;
+    } else if(residuename=="LEU") {
+      return true;
+    } else if(residuename=="LYS") {
+      return true;
+    } else if(residuename=="MET") {
+      return true;
+    } else if(residuename=="PHE") {
+      return true;
+    } else if(residuename=="PRO") {
+      return true;
+    } else if(residuename=="SER") {
+      return true;
+    } else if(residuename=="THR") {
+      return true;
+    } else if(residuename=="TRP") {
+      return true;
+    } else if(residuename=="TYR") {
+      return true;
+    } else if(residuename=="VAL") {
+      return true;
+    }
 // Terminal groups
-    else if(residuename=="ACE") return true;
-    else if(residuename=="NME") return true;
-    else if(residuename=="NH2") return true;
+    else if(residuename=="ACE") {
+      return true;
+    } else if(residuename=="NME") {
+      return true;
+    } else if(residuename=="NH2") {
+      return true;
+    }
 // Alternative residue names in common force fields
-    else if(residuename=="GLH") return true; // neutral GLU
-    else if(residuename=="ASH") return true; // neutral ASP
-    else if(residuename=="HID") return true; // HIS-D amber
-    else if(residuename=="HSD") return true; // HIS-D charmm
-    else if(residuename=="HIE") return true; // HIS-E amber
-    else if(residuename=="HSE") return true; // HIS-E charmm
-    else if(residuename=="HIP") return true; // HIS-P amber
-    else if(residuename=="HSP") return true; // HIS-P charmm
+    else if(residuename=="GLH") {
+      return true;  // neutral GLU
+    } else if(residuename=="ASH") {
+      return true;  // neutral ASP
+    } else if(residuename=="HID") {
+      return true;  // HIS-D amber
+    } else if(residuename=="HSD") {
+      return true;  // HIS-D charmm
+    } else if(residuename=="HIE") {
+      return true;  // HIS-E amber
+    } else if(residuename=="HSE") {
+      return true;  // HIS-E charmm
+    } else if(residuename=="HIP") {
+      return true;  // HIS-P amber
+    } else if(residuename=="HSP") {
+      return true;  // HIS-P charmm
+    }
 // Weird amino acids
-    else if(residuename=="NLE") return true;
-    else if(residuename=="SFO") return true;
-    else return false;
+    else if(residuename=="NLE") {
+      return true;
+    } else if(residuename=="SFO") {
+      return true;
+    } else {
+      return false;
+    }
   } else if( type=="dna" ) {
-    if(residuename=="A") return true;
-    else if(residuename=="A5") return true;
-    else if(residuename=="A3") return true;
-    else if(residuename=="AN") return true;
-    else if(residuename=="G") return true;
-    else if(residuename=="G5") return true;
-    else if(residuename=="G3") return true;
-    else if(residuename=="GN") return true;
-    else if(residuename=="T") return true;
-    else if(residuename=="T5") return true;
-    else if(residuename=="T3") return true;
-    else if(residuename=="TN") return true;
-    else if(residuename=="C") return true;
-    else if(residuename=="C5") return true;
-    else if(residuename=="C3") return true;
-    else if(residuename=="CN") return true;
-    else if(residuename=="DA") return true;
-    else if(residuename=="DA5") return true;
-    else if(residuename=="DA3") return true;
-    else if(residuename=="DAN") return true;
-    else if(residuename=="DG") return true;
-    else if(residuename=="DG5") return true;
-    else if(residuename=="DG3") return true;
-    else if(residuename=="DGN") return true;
-    else if(residuename=="DT") return true;
-    else if(residuename=="DT5") return true;
-    else if(residuename=="DT3") return true;
-    else if(residuename=="DTN") return true;
-    else if(residuename=="DC") return true;
-    else if(residuename=="DC5") return true;
-    else if(residuename=="DC3") return true;
-    else if(residuename=="DCN") return true;
-    else return false;
+    if(residuename=="A") {
+      return true;
+    } else if(residuename=="A5") {
+      return true;
+    } else if(residuename=="A3") {
+      return true;
+    } else if(residuename=="AN") {
+      return true;
+    } else if(residuename=="G") {
+      return true;
+    } else if(residuename=="G5") {
+      return true;
+    } else if(residuename=="G3") {
+      return true;
+    } else if(residuename=="GN") {
+      return true;
+    } else if(residuename=="T") {
+      return true;
+    } else if(residuename=="T5") {
+      return true;
+    } else if(residuename=="T3") {
+      return true;
+    } else if(residuename=="TN") {
+      return true;
+    } else if(residuename=="C") {
+      return true;
+    } else if(residuename=="C5") {
+      return true;
+    } else if(residuename=="C3") {
+      return true;
+    } else if(residuename=="CN") {
+      return true;
+    } else if(residuename=="DA") {
+      return true;
+    } else if(residuename=="DA5") {
+      return true;
+    } else if(residuename=="DA3") {
+      return true;
+    } else if(residuename=="DAN") {
+      return true;
+    } else if(residuename=="DG") {
+      return true;
+    } else if(residuename=="DG5") {
+      return true;
+    } else if(residuename=="DG3") {
+      return true;
+    } else if(residuename=="DGN") {
+      return true;
+    } else if(residuename=="DT") {
+      return true;
+    } else if(residuename=="DT5") {
+      return true;
+    } else if(residuename=="DT3") {
+      return true;
+    } else if(residuename=="DTN") {
+      return true;
+    } else if(residuename=="DC") {
+      return true;
+    } else if(residuename=="DC5") {
+      return true;
+    } else if(residuename=="DC3") {
+      return true;
+    } else if(residuename=="DCN") {
+      return true;
+    } else {
+      return false;
+    }
   } else if( type=="rna" ) {
-    if(residuename=="A") return true;
-    else if(residuename=="A5") return true;
-    else if(residuename=="A3") return true;
-    else if(residuename=="AN") return true;
-    else if(residuename=="G") return true;
-    else if(residuename=="G5") return true;
-    else if(residuename=="G3") return true;
-    else if(residuename=="GN") return true;
-    else if(residuename=="U") return true;
-    else if(residuename=="U5") return true;
-    else if(residuename=="U3") return true;
-    else if(residuename=="UN") return true;
-    else if(residuename=="C") return true;
-    else if(residuename=="C5") return true;
-    else if(residuename=="C3") return true;
-    else if(residuename=="CN") return true;
-    else if(residuename=="RA") return true;
-    else if(residuename=="RA5") return true;
-    else if(residuename=="RA3") return true;
-    else if(residuename=="RAN") return true;
-    else if(residuename=="RG") return true;
-    else if(residuename=="RG5") return true;
-    else if(residuename=="RG3") return true;
-    else if(residuename=="RGN") return true;
-    else if(residuename=="RU") return true;
-    else if(residuename=="RU5") return true;
-    else if(residuename=="RU3") return true;
-    else if(residuename=="RUN") return true;
-    else if(residuename=="RC") return true;
-    else if(residuename=="RC5") return true;
-    else if(residuename=="RC3") return true;
-    else if(residuename=="RCN") return true;
-    else return false;
+    if(residuename=="A") {
+      return true;
+    } else if(residuename=="A5") {
+      return true;
+    } else if(residuename=="A3") {
+      return true;
+    } else if(residuename=="AN") {
+      return true;
+    } else if(residuename=="G") {
+      return true;
+    } else if(residuename=="G5") {
+      return true;
+    } else if(residuename=="G3") {
+      return true;
+    } else if(residuename=="GN") {
+      return true;
+    } else if(residuename=="U") {
+      return true;
+    } else if(residuename=="U5") {
+      return true;
+    } else if(residuename=="U3") {
+      return true;
+    } else if(residuename=="UN") {
+      return true;
+    } else if(residuename=="C") {
+      return true;
+    } else if(residuename=="C5") {
+      return true;
+    } else if(residuename=="C3") {
+      return true;
+    } else if(residuename=="CN") {
+      return true;
+    } else if(residuename=="RA") {
+      return true;
+    } else if(residuename=="RA5") {
+      return true;
+    } else if(residuename=="RA3") {
+      return true;
+    } else if(residuename=="RAN") {
+      return true;
+    } else if(residuename=="RG") {
+      return true;
+    } else if(residuename=="RG5") {
+      return true;
+    } else if(residuename=="RG3") {
+      return true;
+    } else if(residuename=="RGN") {
+      return true;
+    } else if(residuename=="RU") {
+      return true;
+    } else if(residuename=="RU5") {
+      return true;
+    } else if(residuename=="RU3") {
+      return true;
+    } else if(residuename=="RUN") {
+      return true;
+    } else if(residuename=="RC") {
+      return true;
+    } else if(residuename=="RC5") {
+      return true;
+    } else if(residuename=="RC3") {
+      return true;
+    } else if(residuename=="RCN") {
+      return true;
+    } else {
+      return false;
+    }
   } else if( type=="water" ) {
-    if(residuename=="SOL") return true;
-    if(residuename=="WAT") return true;
+    if(residuename=="SOL") {
+      return true;
+    }
+    if(residuename=="WAT") {
+      return true;
+    }
     return false;
   } else if( type=="ion" ) {
-    if(residuename=="IB+") return true;
-    if(residuename=="CA") return true;
-    if(residuename=="CL") return true;
-    if(residuename=="NA") return true;
-    if(residuename=="MG") return true;
-    if(residuename=="K") return true;
-    if(residuename=="RB") return true;
-    if(residuename=="CS") return true;
-    if(residuename=="LI") return true;
-    if(residuename=="ZN") return true;
+    if(residuename=="IB+") {
+      return true;
+    }
+    if(residuename=="CA") {
+      return true;
+    }
+    if(residuename=="CL") {
+      return true;
+    }
+    if(residuename=="NA") {
+      return true;
+    }
+    if(residuename=="MG") {
+      return true;
+    }
+    if(residuename=="K") {
+      return true;
+    }
+    if(residuename=="RB") {
+      return true;
+    }
+    if(residuename=="CS") {
+      return true;
+    }
+    if(residuename=="LI") {
+      return true;
+    }
+    if(residuename=="ZN") {
+      return true;
+    }
     return false;
   }
   return false;
@@ -193,18 +328,22 @@ void MolDataClass::getBackboneForResidue( const std::string& type, const unsigne
     atoms[3]=mypdb.getNamedAtomFromResidue("C4\'",residuenum);
     atoms[4]=mypdb.getNamedAtomFromResidue("C3\'",residuenum);
     atoms[5]=mypdb.getNamedAtomFromResidue("O3\'",residuenum);
-  }
-  else {
+  } else {
     plumed_merror(type + " is not a valid molecule type");
   }
 }
 
 bool MolDataClass::isTerminalGroup( const std::string& type, const std::string& residuename ) {
   if( type=="protein" ) {
-    if( residuename=="ACE" ) return true;
-    else if( residuename=="NME" ) return true;
-    else if( residuename=="NH2" ) return true;
-    else return false;
+    if( residuename=="ACE" ) {
+      return true;
+    } else if( residuename=="NME" ) {
+      return true;
+    } else if( residuename=="NH2" ) {
+      return true;
+    } else {
+      return false;
+    }
   } else {
     plumed_merror(type + " is not a valid molecule type");
   }
@@ -226,7 +365,9 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
       for(auto a : all) {
         auto resname=mypdb.getResidueName(a);
         Tools::stripLeadingAndTrailingBlanks(resname);
-        if(allowedResidue("protein",resname)) numbers.push_back(a);
+        if(allowedResidue("protein",resname)) {
+          numbers.push_back(a);
+        }
       }
       return;
     }
@@ -236,7 +377,9 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
       for(auto a : all) {
         auto resname=mypdb.getResidueName(a);
         Tools::stripLeadingAndTrailingBlanks(resname);
-        if(allowedResidue("dna",resname) || allowedResidue("rna",resname)) numbers.push_back(a);
+        if(allowedResidue("dna",resname) || allowedResidue("rna",resname)) {
+          numbers.push_back(a);
+        }
       }
       return;
     }
@@ -246,7 +389,9 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
       for(auto a : all) {
         auto resname=mypdb.getResidueName(a);
         Tools::stripLeadingAndTrailingBlanks(resname);
-        if(allowedResidue("ion",resname)) numbers.push_back(a);
+        if(allowedResidue("ion",resname)) {
+          numbers.push_back(a);
+        }
       }
       return;
     }
@@ -256,7 +401,9 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
       for(auto a : all) {
         auto resname=mypdb.getResidueName(a);
         Tools::stripLeadingAndTrailingBlanks(resname);
-        if(allowedResidue("water",resname)) numbers.push_back(a);
+        if(allowedResidue("water",resname)) {
+          numbers.push_back(a);
+        }
       }
       return;
     }
@@ -267,7 +414,9 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
         auto atomname=mypdb.getAtomName(a);
         Tools::stripLeadingAndTrailingBlanks(atomname);
         auto notnumber=atomname.find_first_not_of("0123456789");
-        if(notnumber!=std::string::npos && atomname[notnumber]=='H') numbers.push_back(a);
+        if(notnumber!=std::string::npos && atomname[notnumber]=='H') {
+          numbers.push_back(a);
+        }
       }
       return;
     }
@@ -278,14 +427,18 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
         auto atomname=mypdb.getAtomName(a);
         Tools::stripLeadingAndTrailingBlanks(atomname);
         auto notnumber=atomname.find_first_not_of("0123456789");
-        if(!(notnumber!=std::string::npos && atomname[notnumber]=='H')) numbers.push_back(a);
+        if(!(notnumber!=std::string::npos && atomname[notnumber]=='H')) {
+          numbers.push_back(a);
+        }
       }
       return;
     }
 
 
     std::size_t dash=symbol.find_first_of('-');
-    if(dash==std::string::npos) plumed_error() << "Unrecognized symbol "<<symbol;
+    if(dash==std::string::npos) {
+      plumed_error() << "Unrecognized symbol "<<symbol;
+    }
 
     std::size_t firstunderscore=symbol.find_first_of('_',dash+1);
     std::size_t firstnum=symbol.find_first_of("0123456789",dash+1);
@@ -323,7 +476,9 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("N",resnum,chainid));
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("CA",resnum,chainid));
       } else if( name=="chi1" && !isTerminalGroup("protein",resname) ) {
-        if ( resname=="GLY" || resname=="ALA" || resname=="SFO" ) plumed_merror("chi-1 is not defined for ALA, GLY and SFO");
+        if ( resname=="GLY" || resname=="ALA" || resname=="SFO" ) {
+          plumed_merror("chi-1 is not defined for ALA, GLY and SFO");
+        }
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("N",resnum,chainid));
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("CA",resnum,chainid));
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("CB",resnum,chainid));
@@ -340,7 +495,9 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
         }
       } else if( name=="chi2" && !isTerminalGroup("protein",resname) ) {
         if ( resname=="GLY" || resname=="ALA" || resname=="SFO" || resname=="CYS" || resname=="SER" ||
-             resname=="THR" || resname=="VAL" ) plumed_merror("chi-2 is not defined for ALA, GLY, CYS, SER, THR, VAL and SFO");
+             resname=="THR" || resname=="VAL" ) {
+          plumed_merror("chi-2 is not defined for ALA, GLY, CYS, SER, THR, VAL and SFO");
+        }
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("CA",resnum,chainid));
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("CB",resnum,chainid));
 
@@ -362,7 +519,9 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
         }
       } else if( name=="chi3" && !isTerminalGroup("protein",resname) ) {
         if (!( resname=="ARG" || resname=="GLN" || resname=="GLU" || resname=="LYS" ||
-               resname=="MET" )) plumed_merror("chi-3 is defined only for ARG, GLN, GLU, LYS and MET");
+               resname=="MET" )) {
+          plumed_merror("chi-3 is defined only for ARG, GLN, GLU, LYS and MET");
+        }
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("CB",resnum,chainid));
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("CG",resnum,chainid));
 
@@ -379,7 +538,9 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
           numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("NE",resnum,chainid));
         }
       } else if( name=="chi4" && !isTerminalGroup("protein",resname) ) {
-        if (!( resname=="ARG" || resname=="LYS" )) plumed_merror("chi-4 is defined only for ARG and LYS");
+        if (!( resname=="ARG" || resname=="LYS" )) {
+          plumed_merror("chi-4 is defined only for ARG and LYS");
+        }
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("CG",resnum,chainid));
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("CD",resnum,chainid));
 
@@ -391,13 +552,17 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
           numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("NZ",resnum,chainid));
         }
       } else if( name=="chi5" && !isTerminalGroup("protein",resname) ) {
-        if (!( resname=="ARG" )) plumed_merror("chi-5 is defined only for ARG");
+        if (!( resname=="ARG" )) {
+          plumed_merror("chi-5 is defined only for ARG");
+        }
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("CD",resnum,chainid));
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("NE",resnum,chainid));
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("CZ",resnum,chainid));
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("NH1",resnum,chainid));
       } else if( name=="sidechain" && !isTerminalGroup("protein",resname) ) {
-        if(resname=="GLY") plumed_merror("sidechain is not defined for GLY");
+        if(resname=="GLY") {
+          plumed_merror("sidechain is not defined for GLY");
+        }
         std::vector<AtomNumber> tmpnum1(mypdb.getAtomsInResidue(resnum,chainid));
         for(unsigned i=0; i<tmpnum1.size(); i++) {
           if(mypdb.getAtomName(tmpnum1[i])!="N"&&mypdb.getAtomName(tmpnum1[i])!="CA"&&
@@ -426,15 +591,27 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
             numbers.push_back( tmpnum1[i] );
           }
         }
-      } else numbers.push_back(mypdb.getNamedAtomFromResidueAndChain(name,resnum,chainid));
+      } else {
+        numbers.push_back(mypdb.getNamedAtomFromResidueAndChain(name,resnum,chainid));
+      }
 
     } else if( allowedResidue("rna",resname) || allowedResidue("dna",resname)) {
       std::string basetype;
-      if(resname.find_first_of("A")!=std::string::npos) basetype+="A";
-      if(resname.find_first_of("U")!=std::string::npos) basetype+="U";
-      if(resname.find_first_of("T")!=std::string::npos) basetype+="T";
-      if(resname.find_first_of("C")!=std::string::npos) basetype+="C";
-      if(resname.find_first_of("G")!=std::string::npos) basetype+="G";
+      if(resname.find_first_of("A")!=std::string::npos) {
+        basetype+="A";
+      }
+      if(resname.find_first_of("U")!=std::string::npos) {
+        basetype+="U";
+      }
+      if(resname.find_first_of("T")!=std::string::npos) {
+        basetype+="T";
+      }
+      if(resname.find_first_of("C")!=std::string::npos) {
+        basetype+="C";
+      }
+      if(resname.find_first_of("G")!=std::string::npos) {
+        basetype+="G";
+      }
       plumed_massert(basetype.length()==1,"cannot find type of rna/dna residue "+resname+" "+basetype);
       if( name=="chi" ) {
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("O4\'",resnum,chainid));
@@ -445,7 +622,9 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
         } else if(basetype=="G" || basetype=="A") {
           numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("N9",resnum,chainid));
           numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("C4",resnum,chainid));
-        } else plumed_error();
+        } else {
+          plumed_error();
+        }
       } else if( name=="alpha" ) {
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("O3\'",resnum-1,chainid));
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("P",resnum,chainid));
@@ -566,7 +745,9 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
           numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("C5",resnum,chainid));
           numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("N7",resnum,chainid));
           numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("C8",resnum,chainid));
-        } else plumed_error();
+        } else {
+          plumed_error();
+        }
       } else if( name=="lcs" ) {
         numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("C2",resnum,chainid));
         if(basetype=="T" || basetype=="U" || basetype=="C") {
@@ -575,11 +756,16 @@ void MolDataClass::specialSymbol( const std::string& type, const std::string& sy
         } else if(basetype=="G" || basetype=="A") {
           numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("C6",resnum,chainid));
           numbers.push_back(mypdb.getNamedAtomFromResidueAndChain("C4",resnum,chainid));
-        } else plumed_error();
-      } else numbers.push_back(mypdb.getNamedAtomFromResidueAndChain(name,resnum,chainid));
-    } else numbers.push_back(mypdb.getNamedAtomFromResidueAndChain(name,resnum,chainid));
-  }
-  else {
+        } else {
+          plumed_error();
+        }
+      } else {
+        numbers.push_back(mypdb.getNamedAtomFromResidueAndChain(name,resnum,chainid));
+      }
+    } else {
+      numbers.push_back(mypdb.getNamedAtomFromResidueAndChain(name,resnum,chainid));
+    }
+  } else {
     plumed_merror(type + " is not a valid molecule type");
   }
 }
diff --git a/src/tools/MultiValue.cpp b/src/tools/MultiValue.cpp
index c374a5d286..2355122044 100644
--- a/src/tools/MultiValue.cpp
+++ b/src/tools/MultiValue.cpp
@@ -44,55 +44,85 @@ MultiValue::MultiValue( const size_t& nvals, const size_t& nder, const size_t& n
   matrix_force_stash(nder*nmat),
   matrix_bookeeping(nbook,0),
   matrix_row_nderivatives(nmat,0),
-  matrix_row_derivative_indices(nmat)
-{
-  for(unsigned i=0; i<nmat; ++i) matrix_row_derivative_indices[i].resize( nder );
+  matrix_row_derivative_indices(nmat) {
+  for(unsigned i=0; i<nmat; ++i) {
+    matrix_row_derivative_indices[i].resize( nder );
+  }
   // This is crap that will be deleted in future
   std::vector<unsigned> myind( nder );
-  for(unsigned i=0; i<nder; ++i) myind[i]=i;
+  for(unsigned i=0; i<nder; ++i) {
+    myind[i]=i;
+  }
 }
 
 void MultiValue::resize( const size_t& nvals, const size_t& nder, const size_t& nmat, const size_t& maxcol, const size_t& nbook ) {
-  values.resize(nvals); nderivatives=nder; derivatives.resize( nvals*nder );
-  hasderiv.resize(nvals*nder,false); nactive.resize(nvals); active_list.resize(nvals*nder);
-  nmatrix_cols=maxcol; matrix_row_stash.resize(nmat*maxcol,0); matrix_force_stash.resize(nmat*nder,0); matrix_bookeeping.resize(nbook, 0);
-  matrix_row_nderivatives.resize(nmat,0); matrix_row_derivative_indices.resize(nmat); atLeastOneSet=false;
-  for(unsigned i=0; i<nmat; ++i) matrix_row_derivative_indices[i].resize( nder );
+  values.resize(nvals);
+  nderivatives=nder;
+  derivatives.resize( nvals*nder );
+  hasderiv.resize(nvals*nder,false);
+  nactive.resize(nvals);
+  active_list.resize(nvals*nder);
+  nmatrix_cols=maxcol;
+  matrix_row_stash.resize(nmat*maxcol,0);
+  matrix_force_stash.resize(nmat*nder,0);
+  matrix_bookeeping.resize(nbook, 0);
+  matrix_row_nderivatives.resize(nmat,0);
+  matrix_row_derivative_indices.resize(nmat);
+  atLeastOneSet=false;
+  for(unsigned i=0; i<nmat; ++i) {
+    matrix_row_derivative_indices[i].resize( nder );
+  }
   // All crap from here onwards
-  tmpder.resize( nder ); std::vector<unsigned> myind( nder );
-  for(unsigned i=0; i<nder; ++i) myind[i]=i;
+  tmpder.resize( nder );
+  std::vector<unsigned> myind( nder );
+  for(unsigned i=0; i<nder; ++i) {
+    myind[i]=i;
+  }
 }
 
 void MultiValue::clearAll() {
-  for(unsigned i=0; i<values.size(); ++i) values[i]=0;
+  for(unsigned i=0; i<values.size(); ++i) {
+    values[i]=0;
+  }
   // Clear matrix row
   std::fill( matrix_row_stash.begin(), matrix_row_stash.end(), 0 );
   // Clear matrix derivative indices
   std::fill( matrix_row_nderivatives.begin(), matrix_row_nderivatives.end(), 0 );
   // Clear matrix forces
   std::fill(matrix_force_stash.begin(),matrix_force_stash.end(),0);
-  if( !atLeastOneSet ) return;
-  for(unsigned i=0; i<values.size(); ++i) clearDerivatives(i);
+  if( !atLeastOneSet ) {
+    return;
+  }
+  for(unsigned i=0; i<values.size(); ++i) {
+    clearDerivatives(i);
+  }
   atLeastOneSet=false;
 }
 
 void MultiValue::clearDerivatives( const unsigned& ival ) {
   values[ival]=0;
-  if( !atLeastOneSet ) return;
+  if( !atLeastOneSet ) {
+    return;
+  }
   unsigned base=ival*nderivatives;
   for(unsigned i=0; i<nactive[ival]; ++i) {
-    unsigned k = base+active_list[base+i]; derivatives[k]=0.; hasderiv[k]=false;
+    unsigned k = base+active_list[base+i];
+    derivatives[k]=0.;
+    hasderiv[k]=false;
   }
   nactive[ival]=0;
 #ifndef NDEBUG
   for(unsigned i=0; i<nderivatives; ++i) {
     if( hasderiv[base+i] ) {
       std::string num1, num2;
-      Tools::convert(ival,num1); Tools::convert(i,num2);
+      Tools::convert(ival,num1);
+      Tools::convert(i,num2);
       plumed_merror("FAILING TO CLEAR VALUE " + num1 + " DERIVATIVE " + num2 + " IS PROBLEMATIC");
     }
     // As this is debugging code we hard code an escape here otherwise this check is really expensive
-    if( i>1000 ) return;
+    if( i>1000 ) {
+      return;
+    }
   }
 #endif
 }
diff --git a/src/tools/MultiValue.h b/src/tools/MultiValue.h
index 87acba096b..1e26015747 100644
--- a/src/tools/MultiValue.h
+++ b/src/tools/MultiValue.h
@@ -179,14 +179,18 @@ void MultiValue::addValue( const std::size_t& ival,  const double& val) {
 
 inline
 void MultiValue::addDerivative( const std::size_t& ival, const std::size_t& jder, const double& der) {
-  plumed_dbg_assert( ival<=values.size() && jder<nderivatives ); atLeastOneSet=true;
-  hasderiv[nderivatives*ival+jder]=true; derivatives[nderivatives*ival+jder] += der;
+  plumed_dbg_assert( ival<=values.size() && jder<nderivatives );
+  atLeastOneSet=true;
+  hasderiv[nderivatives*ival+jder]=true;
+  derivatives[nderivatives*ival+jder] += der;
 }
 
 inline
 void MultiValue::setDerivative( const std::size_t& ival, const std::size_t& jder, const double& der) {
-  plumed_dbg_assert( ival<=values.size() && jder<nderivatives ); atLeastOneSet=true;
-  hasderiv[nderivatives*ival+jder]=true; derivatives[nderivatives*ival+jder]=der;
+  plumed_dbg_assert( ival<=values.size() && jder<nderivatives );
+  atLeastOneSet=true;
+  hasderiv[nderivatives*ival+jder]=true;
+  derivatives[nderivatives*ival+jder]=der;
 }
 
 
@@ -200,7 +204,9 @@ inline
 void MultiValue::updateIndex( const std::size_t& ival, const std::size_t& jder ) {
   plumed_dbg_assert( ival<values.size() && jder<nderivatives );
 #ifdef DNDEBUG
-  for(unsigned i=0; i<nactive[ival]; ++i) plumed_dbg_assert( active_list[nderivatives*ival+nactive[ival]]!=jder );
+  for(unsigned i=0; i<nactive[ival]; ++i) {
+    plumed_dbg_assert( active_list[nderivatives*ival+nactive[ival]]!=jder );
+  }
 #endif
   if( hasderiv[nderivatives*ival+jder] ) {
     plumed_dbg_assert( nactive[ival]<nderivatives);
@@ -305,7 +311,9 @@ std::vector<Tensor>& MultiValue::getFirstAtomVirialVector() {
 inline
 void MultiValue::stashMatrixElement( const unsigned& nmat, const unsigned& rowstart, const unsigned& jcol, const double& val ) {
   plumed_dbg_assert( jcol<nmatrix_cols && rowstart + matrix_bookeeping[rowstart]<matrix_bookeeping.size() && nmatrix_cols*nmat + matrix_bookeeping[rowstart]<matrix_row_stash.size() );
-  matrix_bookeeping[rowstart]++; matrix_bookeeping[rowstart + matrix_bookeeping[rowstart]]=jcol; matrix_row_stash[ nmatrix_cols*nmat + jcol] = val;
+  matrix_bookeeping[rowstart]++;
+  matrix_bookeeping[rowstart + matrix_bookeeping[rowstart]]=jcol;
+  matrix_row_stash[ nmatrix_cols*nmat + jcol] = val;
 }
 
 inline
@@ -327,12 +335,14 @@ void MultiValue::setNumberOfMatrixRowDerivatives( const unsigned& nmat, const un
 
 inline
 unsigned MultiValue::getNumberOfMatrixRowDerivatives( const unsigned& nmat ) const {
-  plumed_dbg_assert( nmat<matrix_row_nderivatives.size() ); return matrix_row_nderivatives[nmat];
+  plumed_dbg_assert( nmat<matrix_row_nderivatives.size() );
+  return matrix_row_nderivatives[nmat];
 }
 
 inline
 std::vector<unsigned>& MultiValue::getMatrixRowDerivativeIndices( const unsigned& nmat ) {
-  plumed_dbg_assert( nmat<matrix_row_nderivatives.size() ); return matrix_row_derivative_indices[nmat];
+  plumed_dbg_assert( nmat<matrix_row_nderivatives.size() );
+  return matrix_row_derivative_indices[nmat];
 }
 
 inline
@@ -347,7 +357,9 @@ double MultiValue::getStashedMatrixForce( const unsigned& imat, const unsigned&
 
 inline
 void MultiValue::resizeTemporyVector(const unsigned& n ) {
-  if( n>tmp_vectors.size() ) tmp_vectors.resize(n);
+  if( n>tmp_vectors.size() ) {
+    tmp_vectors.resize(n);
+  }
 }
 
 inline
diff --git a/src/tools/NeighborList.cpp b/src/tools/NeighborList.cpp
index 58fba82a6c..0c09be76f9 100644
--- a/src/tools/NeighborList.cpp
+++ b/src/tools/NeighborList.cpp
@@ -119,8 +119,9 @@ void NeighborList::initialize() {
   }
   //TODO: test if this is feasible for accelerating the loop
   //#pragma omp parallel for default(shared)
-  for(unsigned int i=0; i<nallpairs_; ++i)
+  for(unsigned int i=0; i<nallpairs_; ++i) {
     neighbors_[i]=getIndexPair(i);
+  }
 }
 
 std::vector<AtomNumber>& NeighborList::getFullAtomList() {
@@ -129,11 +130,11 @@ std::vector<AtomNumber>& NeighborList::getFullAtomList() {
 
 NeighborList::pairIDs NeighborList::getIndexPair(const unsigned ipair) {
   pairIDs index;
-  if(twolists_ && do_pair_)
+  if(twolists_ && do_pair_) {
     index=pairIDs(ipair,ipair+nlist0_);
-  else if (twolists_ && !do_pair_)
+  } else if (twolists_ && !do_pair_) {
     index=pairIDs(ipair/nlist1_,ipair%nlist1_+nlist0_);
-  else if (!twolists_) {
+  } else if (!twolists_) {
     unsigned ii = nallpairs_-1-ipair;
     unsigned  K = unsigned(std::floor((std::sqrt(double(8*ii+1))+1)/2));
     unsigned jj = ii-K*(K-1)/2;
@@ -187,8 +188,9 @@ void NeighborList::update(const std::vector<Vector>& positions) {
   // find total dimension of neighborlist
   std::vector <int> local_nl_size(stride, 0);
   local_nl_size[rank] = local_flat_nl.size();
-  if(!serial_)
+  if(!serial_) {
     comm.Sum(&local_nl_size[0], stride);
+  }
   int tot_size = std::accumulate(local_nl_size.begin(), local_nl_size.end(), 0);
   if(tot_size==0) {
     setRequestList();
@@ -211,8 +213,9 @@ void NeighborList::update(const std::vector<Vector>& positions) {
                     &merge_nl[0],
                     &local_nl_size[0],
                     &disp[0]);
-  } else
+  } else {
     merge_nl = local_flat_nl;
+  }
   // resize neighbor stuff
   neighbors_.resize(tot_size/2);
   for(unsigned i=0; i<tot_size/2; i++) {
@@ -283,10 +286,12 @@ NeighborList::getClosePairAtomNumber(const unsigned i) const {
 std::vector<unsigned> NeighborList::getNeighbors(const unsigned index) {
   std::vector<unsigned> neighbors;
   for(unsigned int i=0; i<size(); ++i) {
-    if(neighbors_[i].first==index)
+    if(neighbors_[i].first==index) {
       neighbors.push_back(neighbors_[i].second);
-    if(neighbors_[i].second==index)
+    }
+    if(neighbors_[i].second==index) {
       neighbors.push_back(neighbors_[i].first);
+    }
   }
   return neighbors;
 }
diff --git a/src/tools/OFile.cpp b/src/tools/OFile.cpp
index f4fe6673aa..2f1103aa75 100644
--- a/src/tools/OFile.cpp
+++ b/src/tools/OFile.cpp
@@ -45,9 +45,13 @@ namespace PLMD {
 
 size_t OFile::llwrite(const char*ptr,size_t s) {
   size_t r;
-  if(linked) return linked->llwrite(ptr,s);
+  if(linked) {
+    return linked->llwrite(ptr,s);
+  }
   if(! (comm && comm->Get_rank()>0)) {
-    if(!fp) plumed_merror("writing on uninitialized File");
+    if(!fp) {
+      plumed_merror("writing on uninitialized File");
+    }
     if(gzfp) {
 #ifdef __PLUMED_HAS_ZLIB
       r=gzwrite(gzFile(gzfp),ptr,s);
@@ -77,14 +81,15 @@ OFile::OFile():
   fieldChanged(false),
   backstring("bck"),
   enforceRestart_(false),
-  enforceBackup_(false)
-{
+  enforceBackup_(false) {
   fmtField();
   buflen=1;
   actual_buffer_length=0;
   buffer.resize(buflen);
 // these are set to zero to avoid valgrind errors
-  for(int i=0; i<buflen; ++i) buffer[i]=0;
+  for(int i=0; i<buflen; ++i) {
+    buffer[i]=0;
+  }
 // these are set to zero to avoid valgrind errors
   buffer_string.resize(1000,0);
 }
@@ -108,10 +113,14 @@ int OFile::printf(const char*fmt,...) {
   va_end(arg);
   if(r>=buflen-actual_buffer_length) {
     int newlen=buflen;
-    while(newlen<=r+actual_buffer_length) newlen*=2;
+    while(newlen<=r+actual_buffer_length) {
+      newlen*=2;
+    }
     std::vector<char> newbuf(newlen);
     std::memmove(newbuf.data(),buffer.data(),buflen);
-    for(int k=buflen; k<newlen; k++) newbuf[k]=0;
+    for(int k=buflen; k<newlen; k++) {
+      newbuf[k]=0;
+    }
     std::swap(buffer,newbuf);
     buflen=newlen;
     va_list arg;
@@ -128,13 +137,17 @@ int OFile::printf(const char*fmt,...) {
   char*psearch=p1+actual_buffer_length;
   actual_buffer_length+=r;
   while((p2=std::strchr(psearch,'\n'))) {
-    if(linePrefix.length()>0) llwrite(linePrefix.c_str(),linePrefix.length());
+    if(linePrefix.length()>0) {
+      llwrite(linePrefix.c_str(),linePrefix.length());
+    }
     llwrite(p1,p2-p1+1);
     actual_buffer_length-=(p2-p1)+1;
     p1=p2+1;
     psearch=p1;
   };
-  if(buffer.data()!=p1) std::memmove(buffer.data(),p1,actual_buffer_length);
+  if(buffer.data()!=p1) {
+    std::memmove(buffer.data(),p1,actual_buffer_length);
+  }
   return r;
 }
 
@@ -167,7 +180,9 @@ OFile& OFile::printField(const std::string&name,double v) {
 // When one tries to print -nan we print nan instead.
 // The distinction between +nan and -nan is not well defined
 // Always printing nan simplifies some regtest (special functions computed our of range).
-  if(std::isnan(v)) v=std::numeric_limits<double>::quiet_NaN();
+  if(std::isnan(v)) {
+    v=std::numeric_limits<double>::quiet_NaN();
+  }
   std::snprintf(buffer_string.data(),buffer_string.size(),fieldFmt.c_str(),v);
   printField(name,buffer_string.data());
   return *this;
@@ -211,14 +226,19 @@ OFile& OFile::printField(const std::string&name,long long unsigned v) {
 
 OFile& OFile::printField(const std::string&name,const std::string & v) {
   unsigned i;
-  for(i=0; i<const_fields.size(); i++) if(const_fields[i].name==name) break;
+  for(i=0; i<const_fields.size(); i++)
+    if(const_fields[i].name==name) {
+      break;
+    }
   if(i>=const_fields.size()) {
     Field field;
     field.name=name;
     field.value=v;
     fields.push_back(field);
   } else {
-    if(const_fields[i].value!=v) fieldChanged=true;
+    if(const_fields[i].value!=v) {
+      fieldChanged=true;
+    }
     const_fields[i].value=v;
   }
   return *this;
@@ -235,7 +255,8 @@ OFile& OFile::setupPrintValue( Value *val ) {
 OFile& OFile::printField( Value* val, const double& v ) {
   printField( val->getName(), v );
   if( val->isPeriodic() ) {
-    std::string min, max; val->getDomain( min, max );
+    std::string min, max;
+    val->getDomain( min, max );
     printField( "min_" + val->getName(), min );
     printField("max_" + val->getName(), max );
   }
@@ -246,7 +267,8 @@ OFile& OFile::printField() {
   bool reprint=false;
   if(fieldChanged || fields.size()!=previous_fields.size()) {
     reprint=true;
-  } else for(unsigned i=0; i<fields.size(); i++) {
+  } else
+    for(unsigned i=0; i<fields.size(); i++) {
       if( previous_fields[i].name!=fields[i].name ||
           (fields[i].constant && fields[i].value!=previous_fields[i].value) ) {
         reprint=true;
@@ -255,14 +277,18 @@ OFile& OFile::printField() {
     }
   if(reprint) {
     printf("#! FIELDS");
-    for(unsigned i=0; i<fields.size(); i++) printf(" %s",fields[i].name.c_str());
+    for(unsigned i=0; i<fields.size(); i++) {
+      printf(" %s",fields[i].name.c_str());
+    }
     printf("\n");
     for(unsigned i=0; i<const_fields.size(); i++) {
       printf("#! SET %s %s",const_fields[i].name.c_str(),const_fields[i].value.c_str());
       printf("\n");
     }
   }
-  for(unsigned i=0; i<fields.size(); i++) printf("%s",fields[i].value.c_str());
+  for(unsigned i=0; i<fields.size(); i++) {
+    printf("%s",fields[i].value.c_str());
+  }
   printf("\n");
   previous_fields=fields;
   fields.clear();
@@ -275,25 +301,36 @@ void OFile::setBackupString( const std::string& str ) {
 }
 
 void OFile::backupAllFiles( const std::string& str ) {
-  if(str=="/dev/null") return;
+  if(str=="/dev/null") {
+    return;
+  }
   plumed_assert( backstring!="bck" && !checkRestart());
   size_t found=str.find_last_of("/\\");
   std::string filename = appendSuffix(str,getSuffix());
   std::string directory=filename.substr(0,found+1);
   std::string file=filename.substr(found+1);
-  if( FileExist(filename) ) backupFile("bck", filename);
+  if( FileExist(filename) ) {
+    backupFile("bck", filename);
+  }
   for(int i=0;; i++) {
-    std::string num; Tools::convert(i,num);
+    std::string num;
+    Tools::convert(i,num);
     std::string filestr = directory + backstring + "." + num + "." + file;
-    if( !FileExist(filestr) ) break;
+    if( !FileExist(filestr) ) {
+      break;
+    }
     backupFile( "bck", filestr);
   }
 }
 
 void OFile::backupFile( const std::string& bstring, const std::string& fname ) {
-  if(fname=="/dev/null") return;
+  if(fname=="/dev/null") {
+    return;
+  }
   int maxbackup=100;
-  if(std::getenv("PLUMED_MAXBACKUP")) Tools::convert(std::getenv("PLUMED_MAXBACKUP"),maxbackup);
+  if(std::getenv("PLUMED_MAXBACKUP")) {
+    Tools::convert(std::getenv("PLUMED_MAXBACKUP"),maxbackup);
+  }
   if(maxbackup>0 && (!comm || comm->Get_rank()==0)) {
     FILE* ff=std::fopen(const_cast<char*>(fname.c_str()),"r");
     if(ff) {
@@ -306,12 +343,17 @@ void OFile::backupFile( const std::string& bstring, const std::string& fname ) {
       for(int i=0;; i++) {
         std::string num;
         Tools::convert(i,num);
-        if(i>maxbackup) plumed_merror("cannot backup file "+file+" maximum number of backup is "+num+"\n");
+        if(i>maxbackup) {
+          plumed_merror("cannot backup file "+file+" maximum number of backup is "+num+"\n");
+        }
         backup=directory+bstring +"."+num+"."+file;
         FILE* fff=std::fopen(backup.c_str(),"r");
         // no exception here
-        if(!fff) break;
-        else std::fclose(fff);
+        if(!fff) {
+          break;
+        } else {
+          std::fclose(fff);
+        }
       }
       int check=rename(fname.c_str(),backup.c_str());
       plumed_massert(check==0,"renaming "+fname+" into "+backup+" failed for reason: "+std::strerror(errno));
@@ -339,7 +381,9 @@ OFile& OFile::open(const std::string&path) {
     }
   } else {
     backupFile( backstring, this->path );
-    if(comm)comm->Barrier();
+    if(comm) {
+      comm->Barrier();
+    }
     fp=std::fopen(const_cast<char*>(this->path.c_str()),"w");
     mode="w";
     if(Tools::extension(this->path)=="gz") {
@@ -350,7 +394,9 @@ OFile& OFile::open(const std::string&path) {
 #endif
     }
   }
-  if(plumed) plumed->insertFile(*this);
+  if(plumed) {
+    plumed->insertFile(*this);
+  }
   return *this;
 }
 
@@ -371,7 +417,9 @@ OFile& OFile::rewind() {
     plumed_massert(check==0,"renaming "+fname+" into "+backup+" failed for reason: "+std::strerror(errno));
   }
 
-  if(comm) comm->Barrier();
+  if(comm) {
+    comm->Barrier();
+  }
 
   if(gzfp) {
 #ifdef __PLUMED_HAS_ZLIB
@@ -406,18 +454,26 @@ FileBase& OFile::flush() {
     // for some reason flushing with Z_FINISH has problems on linux
     // I thus use this (incomplete) flush
 #ifdef __PLUMED_HAS_ZLIB
-    if(gzfp) gzflush(gzFile(gzfp),Z_FULL_FLUSH);
+    if(gzfp) {
+      gzflush(gzFile(gzfp),Z_FULL_FLUSH);
+    }
 #endif
   }
   return *this;
 }
 
 bool OFile::checkRestart()const {
-  if(enforceRestart_) return true;
-  else if(enforceBackup_) return false;
-  else if(action) return action->getRestart();
-  else if(plumed) return plumed->getRestart();
-  else return false;
+  if(enforceRestart_) {
+    return true;
+  } else if(enforceBackup_) {
+    return false;
+  } else if(action) {
+    return action->getRestart();
+  } else if(plumed) {
+    return plumed->getRestart();
+  } else {
+    return false;
+  }
 }
 
 OFile& OFile::enforceRestart() {
diff --git a/src/tools/OpenMP.h b/src/tools/OpenMP.h
index 64a5df21ae..c3fe24b8b8 100644
--- a/src/tools/OpenMP.h
+++ b/src/tools/OpenMP.h
@@ -62,8 +62,11 @@ unsigned getGoodNumThreads(const T* /*getTheType*/,unsigned n) {
 /// Get a reasonable number of threads so as to access to vector v
 template<typename T>
 unsigned getGoodNumThreads(const std::vector<T> & v) {
-  if(v.size()==0) return 1;
-  else return getGoodNumThreads(&v[0],v.size());
+  if(v.size()==0) {
+    return 1;
+  } else {
+    return getGoodNumThreads(&v[0],v.size());
+  }
 }
 
 }//namespace OpenMP
diff --git a/src/tools/PDB.cpp b/src/tools/PDB.cpp
index 92101810fb..e04129ec04 100644
--- a/src/tools/PDB.cpp
+++ b/src/tools/PDB.cpp
@@ -131,13 +131,20 @@ In addition, as of PLUMED 2.5, we provide a \ref pdbrenumber "command line tool"
 namespace PLMD {
 
 void PDB::setAtomNumbers( const std::vector<AtomNumber>& atoms ) {
-  positions.resize( atoms.size() ); occupancy.resize( atoms.size() );
-  beta.resize( atoms.size() ); numbers.resize( atoms.size() );
-  for(unsigned i=0; i<atoms.size(); ++i) { numbers[i]=atoms[i]; beta[i]=1.0; occupancy[i]=1.0; }
+  positions.resize( atoms.size() );
+  occupancy.resize( atoms.size() );
+  beta.resize( atoms.size() );
+  numbers.resize( atoms.size() );
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    numbers[i]=atoms[i];
+    beta[i]=1.0;
+    occupancy[i]=1.0;
+  }
 }
 
 void PDB::setArgumentNames( const std::vector<std::string>& argument_names ) {
-  argnames.resize( argument_names.size() ); std::vector<double> tmp(1,0);
+  argnames.resize( argument_names.size() );
+  std::vector<double> tmp(1,0);
   for(unsigned i=0; i<argument_names.size(); ++i) {
     argnames[i]=argument_names[i];
     arg_data.insert( std::pair<std::string,std::vector<double> >( argnames[i], tmp ) );
@@ -147,8 +154,12 @@ void PDB::setArgumentNames( const std::vector<std::string>& argument_names ) {
 bool PDB::getArgumentValue( const std::string& name, std::vector<double>& value ) const {
   std::map<std::string,std::vector<double> >::const_iterator it = arg_data.find(name);
   if( it!=arg_data.end() ) {
-    if( value.size()!=it->second.size() ) return false;
-    for(unsigned i=0; i<value.size(); ++i) value[i] = it->second[i];
+    if( value.size()!=it->second.size() ) {
+      return false;
+    }
+    for(unsigned i=0; i<value.size(); ++i) {
+      value[i] = it->second[i];
+    }
     return true;
   }
   return false;
@@ -156,7 +167,9 @@ bool PDB::getArgumentValue( const std::string& name, std::vector<double>& value
 
 void PDB::setAtomPositions( const std::vector<Vector>& pos ) {
   plumed_assert( pos.size()==positions.size() );
-  for(unsigned i=0; i<positions.size(); ++i) positions[i]=pos[i];
+  for(unsigned i=0; i<positions.size(); ++i) {
+    positions[i]=pos[i];
+  }
 }
 
 void PDB::setArgumentValue( const std::string& argname, const double& val ) {
@@ -226,7 +239,9 @@ void PDB::addRemark( std::vector<std::string>& v1 ) {
       // double val; Tools::convert( sval, val );
       std::vector<std::string> words=Tools::getWords(sval,"\t\n ,");
       std::vector<double> val( words.size() );
-      for(unsigned i=0; i<val.size(); ++i) Tools::convert( words[i], val[i] );
+      for(unsigned i=0; i<val.size(); ++i) {
+        Tools::convert( words[i], val[i] );
+      }
       arg_data.insert( std::pair<std::string,std::vector<double> >( name, val ) );
     } else {
       flags.push_back(v1[i]);
@@ -236,7 +251,9 @@ void PDB::addRemark( std::vector<std::string>& v1 ) {
 
 bool PDB::hasFlag( const std::string& fname ) const {
   for(unsigned i=0; i<flags.size(); ++i) {
-    if( flags[i]==fname ) return true;
+    if( flags[i]==fname ) {
+      return true;
+    }
   }
   return false;
 }
@@ -261,25 +278,34 @@ const Tensor & PDB::getBoxVec()const {
 std::string PDB::getAtomName(AtomNumber a)const {
   const auto p=number2index.find(a);
   if(p==number2index.end()) {
-    std::string num; Tools::convert( a.serial(), num );
+    std::string num;
+    Tools::convert( a.serial(), num );
     plumed_merror("Name of atom " + num + " not found" );
-  } else return atomsymb[p->second];
+  } else {
+    return atomsymb[p->second];
+  }
 }
 
 unsigned PDB::getResidueNumber(AtomNumber a)const {
   const auto p=number2index.find(a);
   if(p==number2index.end()) {
-    std::string num; Tools::convert( a.serial(), num );
+    std::string num;
+    Tools::convert( a.serial(), num );
     plumed_merror("Residue for atom " + num + " not found" );
-  } else return residue[p->second];
+  } else {
+    return residue[p->second];
+  }
 }
 
 std::string PDB::getResidueName(AtomNumber a) const {
   const auto p=number2index.find(a);
   if(p==number2index.end()) {
-    std::string num; Tools::convert( a.serial(), num );
+    std::string num;
+    Tools::convert( a.serial(), num );
     plumed_merror("Residue for atom " + num + " not found" );
-  } else return residuenames[p->second];
+  } else {
+    return residuenames[p->second];
+  }
 }
 
 unsigned PDB::size()const {
@@ -289,13 +315,18 @@ unsigned PDB::size()const {
 bool PDB::readFromFilepointer(FILE *fp,bool naturalUnits,double scale) {
   //cerr<<file<<endl;
   bool file_is_alive=false;
-  if(naturalUnits) scale=1.0;
+  if(naturalUnits) {
+    scale=1.0;
+  }
   std::string line;
-  fpos_t pos; bool between_ters=true;
+  fpos_t pos;
+  bool between_ters=true;
   while(Tools::getline(fp,line)) {
     //cerr<<line<<"\n";
     fgetpos (fp,&pos);
-    while(line.length()<80) line.push_back(' ');
+    while(line.length()<80) {
+      line.push_back(' ');
+    }
     std::string record=line.substr(0,6);
     std::string serial=line.substr(6,5);
     std::string atomname=line.substr(12,4);
@@ -314,11 +345,21 @@ bool PDB::readFromFilepointer(FILE *fp,bool naturalUnits,double scale) {
     std::string BoxB=line.substr(40,7);
     std::string BoxG=line.substr(47,7);
     Tools::trim(record);
-    if(record=="TER") { between_ters=false; block_ends.push_back( positions.size() ); }
-    if(record=="END") { file_is_alive=true;  break;}
-    if(record=="ENDMDL") { file_is_alive=true;  break;}
+    if(record=="TER") {
+      between_ters=false;
+      block_ends.push_back( positions.size() );
+    }
+    if(record=="END") {
+      file_is_alive=true;
+      break;
+    }
+    if(record=="ENDMDL") {
+      file_is_alive=true;
+      break;
+    }
     if(record=="REMARK") {
-      std::vector<std::string> v1;  v1=Tools::getWords(line.substr(6));
+      std::vector<std::string> v1;
+      v1=Tools::getWords(line.substr(6));
       addRemark( v1 );
     }
     if(record=="CRYST1") {
@@ -333,7 +374,11 @@ bool PDB::readFromFilepointer(FILE *fp,bool naturalUnits,double scale) {
       double cosB=std::cos(BoxABG[1]*pi/180.);
       double cosG=std::cos(BoxABG[2]*pi/180.);
       double sinG=std::sin(BoxABG[2]*pi/180.);
-      for (unsigned i=0; i<3; i++) {Box[i][0]=0.; Box[i][1]=0.; Box[i][2]=0.;}
+      for (unsigned i=0; i<3; i++) {
+        Box[i][0]=0.;
+        Box[i][1]=0.;
+        Box[i][2]=0.;
+      }
       Box[0][0]=BoxXYZ[0];
       Box[1][0]=BoxXYZ[1]*cosG;
       Box[1][1]=BoxXYZ[1]*sinG;
@@ -351,7 +396,9 @@ bool PDB::readFromFilepointer(FILE *fp,bool naturalUnits,double scale) {
         int result;
         auto trimmed=serial;
         Tools::trim(trimmed);
-        while(trimmed.length()<5) trimmed = std::string(" ") + trimmed;
+        while(trimmed.length()<5) {
+          trimmed = std::string(" ") + trimmed;
+        }
         const char* errmsg = h36::hy36decode(5, trimmed.c_str(),trimmed.length(), &result);
         if(errmsg) {
           std::string msg(errmsg);
@@ -366,7 +413,9 @@ bool PDB::readFromFilepointer(FILE *fp,bool naturalUnits,double scale) {
         Tools::trim(trimmed);
         if(trimmed.length()>0) {
           int result;
-          while(trimmed.length()<4) trimmed = std::string(" ") + trimmed;
+          while(trimmed.length()<4) {
+            trimmed = std::string(" ") + trimmed;
+          }
           const char* errmsg = h36::hy36decode(4, trimmed.c_str(),trimmed.length(), &result);
           if(errmsg) {
             std::string msg(errmsg);
@@ -396,15 +445,21 @@ bool PDB::readFromFilepointer(FILE *fp,bool naturalUnits,double scale) {
       residuenames.push_back(residuename);
     }
   }
-  if( between_ters ) block_ends.push_back( positions.size() );
+  if( between_ters ) {
+    block_ends.push_back( positions.size() );
+  }
   return file_is_alive;
 }
 
 bool PDB::read(const std::string&file,bool naturalUnits,double scale) {
   FILE* fp=std::fopen(file.c_str(),"r");
-  if(!fp) return false;
+  if(!fp) {
+    return false;
+  }
 // call fclose when exiting this function
-  auto deleter=[](auto f) { std::fclose(f); };
+  auto deleter=[](auto f) {
+    std::fclose(f);
+  };
   std::unique_ptr<FILE,decltype(deleter)> fp_deleter(fp,deleter);
   readFromFilepointer(fp,naturalUnits,scale);
   return true;
@@ -414,7 +469,9 @@ void PDB::getChainNames( std::vector<std::string>& chains ) const {
   chains.resize(0);
   chains.push_back( chain[0] );
   for(unsigned i=1; i<size(); ++i) {
-    if( chains[chains.size()-1]!=chain[i] ) chains.push_back( chain[i] );
+    if( chains[chains.size()-1]!=chain[i] ) {
+      chains.push_back( chain[i] );
+    }
   }
 }
 
@@ -423,16 +480,21 @@ void PDB::getResidueRange( const std::string& chainname, unsigned& res_start, un
   for(unsigned i=0; i<size(); ++i) {
     if( chain[i]==chainname ) {
       if(!inres) {
-        if(foundchain) errmsg="found second start of chain named " + chainname;
+        if(foundchain) {
+          errmsg="found second start of chain named " + chainname;
+        }
         res_start=residue[i];
       }
-      inres=true; foundchain=true;
+      inres=true;
+      foundchain=true;
     } else if( inres && chain[i]!=chainname ) {
       inres=false;
       res_end=residue[i-1];
     }
   }
-  if(inres) res_end=residue[size()-1];
+  if(inres) {
+    res_end=residue[size()-1];
+  }
 }
 
 void PDB::getAtomRange( const std::string& chainname, AtomNumber& a_start, AtomNumber& a_end, std::string& errmsg ) const {
@@ -440,58 +502,78 @@ void PDB::getAtomRange( const std::string& chainname, AtomNumber& a_start, AtomN
   for(unsigned i=0; i<size(); ++i) {
     if( chain[i]==chainname ) {
       if(!inres) {
-        if(foundchain) errmsg="found second start of chain named " + chainname;
+        if(foundchain) {
+          errmsg="found second start of chain named " + chainname;
+        }
         a_start=numbers[i];
       }
-      inres=true; foundchain=true;
+      inres=true;
+      foundchain=true;
     } else if( inres && chain[i]!=chainname ) {
       inres=false;
       a_end=numbers[i-1];
     }
   }
-  if(inres) a_end=numbers[size()-1];
+  if(inres) {
+    a_end=numbers[size()-1];
+  }
 }
 
 std::string PDB::getResidueName( const unsigned& resnum ) const {
   for(unsigned i=0; i<size(); ++i) {
-    if( residue[i]==resnum ) return residuenames[i];
+    if( residue[i]==resnum ) {
+      return residuenames[i];
+    }
   }
-  std::string num; Tools::convert( resnum, num );
+  std::string num;
+  Tools::convert( resnum, num );
   plumed_merror("residue " + num + " not found" );
 }
 
 std::string PDB::getResidueName(const unsigned& resnum,const std::string& chainid ) const {
   for(unsigned i=0; i<size(); ++i) {
-    if( residue[i]==resnum && ( chainid=="*" || chain[i]==chainid) ) return residuenames[i];
+    if( residue[i]==resnum && ( chainid=="*" || chain[i]==chainid) ) {
+      return residuenames[i];
+    }
   }
-  std::string num; Tools::convert( resnum, num );
+  std::string num;
+  Tools::convert( resnum, num );
   plumed_merror("residue " + num + " not found in chain " + chainid );
 }
 
 
 AtomNumber PDB::getNamedAtomFromResidue( const std::string& aname, const unsigned& resnum ) const {
   for(unsigned i=0; i<size(); ++i) {
-    if( residue[i]==resnum && atomsymb[i]==aname ) return numbers[i];
+    if( residue[i]==resnum && atomsymb[i]==aname ) {
+      return numbers[i];
+    }
   }
-  std::string num; Tools::convert( resnum, num );
+  std::string num;
+  Tools::convert( resnum, num );
   plumed_merror("residue " + num + " does not contain an atom named " + aname );
 }
 
 AtomNumber PDB::getNamedAtomFromResidueAndChain( const std::string& aname, const unsigned& resnum, const std::string& chainid ) const {
   for(unsigned i=0; i<size(); ++i) {
-    if( residue[i]==resnum && atomsymb[i]==aname && ( chainid=="*" || chain[i]==chainid) ) return numbers[i];
+    if( residue[i]==resnum && atomsymb[i]==aname && ( chainid=="*" || chain[i]==chainid) ) {
+      return numbers[i];
+    }
   }
-  std::string num; Tools::convert( resnum, num );
+  std::string num;
+  Tools::convert( resnum, num );
   plumed_merror("residue " + num + " from chain " + chainid + " does not contain an atom named " + aname );
 }
 
 std::vector<AtomNumber> PDB::getAtomsInResidue(const unsigned& resnum,const std::string& chainid)const {
   std::vector<AtomNumber> tmp;
   for(unsigned i=0; i<size(); ++i) {
-    if( residue[i]==resnum && ( chainid=="*" || chain[i]==chainid) ) tmp.push_back(numbers[i]);
+    if( residue[i]==resnum && ( chainid=="*" || chain[i]==chainid) ) {
+      tmp.push_back(numbers[i]);
+    }
   }
   if(tmp.size()==0) {
-    std::string num; Tools::convert( resnum, num );
+    std::string num;
+    Tools::convert( resnum, num );
     plumed_merror("Cannot find residue " + num + " from chain " + chainid  );
   }
   return tmp;
@@ -500,7 +582,9 @@ std::vector<AtomNumber> PDB::getAtomsInResidue(const unsigned& resnum,const std:
 std::vector<AtomNumber> PDB::getAtomsInChain(const std::string& chainid)const {
   std::vector<AtomNumber> tmp;
   for(unsigned i=0; i<size(); ++i) {
-    if( chainid=="*" || chain[i]==chainid ) tmp.push_back(numbers[i]);
+    if( chainid=="*" || chain[i]==chainid ) {
+      tmp.push_back(numbers[i]);
+    }
   }
   if(tmp.size()==0) {
     plumed_merror("Cannot find atoms from chain " + chainid  );
@@ -510,7 +594,9 @@ std::vector<AtomNumber> PDB::getAtomsInChain(const std::string& chainid)const {
 
 std::string PDB::getChainID(const unsigned& resnumber) const {
   for(unsigned i=0; i<size(); ++i) {
-    if(resnumber==residue[i]) return chain[i];
+    if(resnumber==residue[i]) {
+      return chain[i];
+    }
   }
   plumed_merror("Not enough residues in pdb input file");
 }
@@ -518,7 +604,8 @@ std::string PDB::getChainID(const unsigned& resnumber) const {
 std::string PDB::getChainID(AtomNumber a) const {
   const auto p=number2index.find(a);
   if(p==number2index.end()) {
-    std::string num; Tools::convert( a.serial(), num );
+    std::string num;
+    Tools::convert( a.serial(), num );
     plumed_merror("Chain for atom " + num + " not found" );
   }
   return chain[p->second];
@@ -526,14 +613,18 @@ std::string PDB::getChainID(AtomNumber a) const {
 
 bool PDB::checkForResidue( const std::string& name ) const {
   for(unsigned i=0; i<size(); ++i) {
-    if( residuenames[i]==name ) return true;
+    if( residuenames[i]==name ) {
+      return true;
+    }
   }
   return false;
 }
 
 bool PDB::checkForAtom( const std::string& name ) const {
   for(unsigned i=0; i<size(); ++i) {
-    if( atomsymb[i]==name ) return true;
+    if( atomsymb[i]==name ) {
+      return true;
+    }
   }
   return false;
 }
@@ -555,8 +646,11 @@ Log& operator<<(Log& ostr, const PDB&  pdb) {
 
 Vector PDB::getPosition(AtomNumber a)const {
   const auto p=number2index.find(a);
-  if(p==number2index.end()) plumed_merror("atom not available");
-  else return positions[p->second];
+  if(p==number2index.end()) {
+    plumed_merror("atom not available");
+  } else {
+    return positions[p->second];
+  }
 }
 
 std::vector<std::string> PDB::getArgumentNames()const {
@@ -570,8 +664,11 @@ std::string PDB::getMtype() const {
 void PDB::print( const double& lunits, GenericMolInfo* mymoldat, OFile& ofile, const std::string& fmt ) {
   if( argnames.size()>0 ) {
     ofile.printf("REMARK ARG=%s", argnames[0].c_str() );
-    for(unsigned i=1; i<argnames.size(); ++i) ofile.printf(",%s",argnames[i].c_str() );
-    ofile.printf("\n"); ofile.printf("REMARK ");
+    for(unsigned i=1; i<argnames.size(); ++i) {
+      ofile.printf(",%s",argnames[i].c_str() );
+    }
+    ofile.printf("\n");
+    ofile.printf("REMARK ");
   }
   std::string descr2;
   if(fmt.find("-")!=std::string::npos) {
@@ -582,8 +679,12 @@ void PDB::print( const double& lunits, GenericMolInfo* mymoldat, OFile& ofile, c
     plumed_assert( psign!=std::string::npos );
     descr2="%s=%-" + fmt.substr(psign+1) + " ";
   }
-  for(std::map<std::string,std::vector<double> >::iterator it=arg_data.begin(); it!=arg_data.end(); ++it) ofile.printf( descr2.c_str(),it->first.c_str(), it->second[0] );
-  if( argnames.size()>0 ) ofile.printf("\n");
+  for(std::map<std::string,std::vector<double> >::iterator it=arg_data.begin(); it!=arg_data.end(); ++it) {
+    ofile.printf( descr2.c_str(),it->first.c_str(), it->second[0] );
+  }
+  if( argnames.size()>0 ) {
+    ofile.printf("\n");
+  }
   if( !mymoldat ) {
     for(unsigned i=0; i<positions.size(); ++i) {
       std::array<char,6> at;
@@ -629,127 +730,258 @@ void PDB::print( const double& lunits, GenericMolInfo* mymoldat, OFile& ofile, c
 
 bool PDB::allowedResidue( const std::string& type, const std::string& residuename ) const {
   if( type=="protein" ) {
-    if(residuename=="ALA") return true;
-    else if(residuename=="ARG") return true;
-    else if(residuename=="ASN") return true;
-    else if(residuename=="ASP") return true;
-    else if(residuename=="CYS") return true;
-    else if(residuename=="GLN") return true;
-    else if(residuename=="GLU") return true;
-    else if(residuename=="GLY") return true;
-    else if(residuename=="HIS") return true;
-    else if(residuename=="ILE") return true;
-    else if(residuename=="LEU") return true;
-    else if(residuename=="LYS") return true;
-    else if(residuename=="MET") return true;
-    else if(residuename=="PHE") return true;
-    else if(residuename=="PRO") return true;
-    else if(residuename=="SER") return true;
-    else if(residuename=="THR") return true;
-    else if(residuename=="TRP") return true;
-    else if(residuename=="TYR") return true;
-    else if(residuename=="VAL") return true;
+    if(residuename=="ALA") {
+      return true;
+    } else if(residuename=="ARG") {
+      return true;
+    } else if(residuename=="ASN") {
+      return true;
+    } else if(residuename=="ASP") {
+      return true;
+    } else if(residuename=="CYS") {
+      return true;
+    } else if(residuename=="GLN") {
+      return true;
+    } else if(residuename=="GLU") {
+      return true;
+    } else if(residuename=="GLY") {
+      return true;
+    } else if(residuename=="HIS") {
+      return true;
+    } else if(residuename=="ILE") {
+      return true;
+    } else if(residuename=="LEU") {
+      return true;
+    } else if(residuename=="LYS") {
+      return true;
+    } else if(residuename=="MET") {
+      return true;
+    } else if(residuename=="PHE") {
+      return true;
+    } else if(residuename=="PRO") {
+      return true;
+    } else if(residuename=="SER") {
+      return true;
+    } else if(residuename=="THR") {
+      return true;
+    } else if(residuename=="TRP") {
+      return true;
+    } else if(residuename=="TYR") {
+      return true;
+    } else if(residuename=="VAL") {
+      return true;
+    }
 // Terminal groups
-    else if(residuename=="ACE") return true;
-    else if(residuename=="NME") return true;
-    else if(residuename=="NH2") return true;
+    else if(residuename=="ACE") {
+      return true;
+    } else if(residuename=="NME") {
+      return true;
+    } else if(residuename=="NH2") {
+      return true;
+    }
 // Alternative residue names in common force fields
-    else if(residuename=="GLH") return true; // neutral GLU
-    else if(residuename=="ASH") return true; // neutral ASP
-    else if(residuename=="HID") return true; // HIS-D amber
-    else if(residuename=="HSD") return true; // HIS-D charmm
-    else if(residuename=="HIE") return true; // HIS-E amber
-    else if(residuename=="HSE") return true; // HIS-E charmm
-    else if(residuename=="HIP") return true; // HIS-P amber
-    else if(residuename=="HSP") return true; // HIS-P charmm
-    else if(residuename=="CYX") return true; // disulfide bridge CYS
+    else if(residuename=="GLH") {
+      return true;  // neutral GLU
+    } else if(residuename=="ASH") {
+      return true;  // neutral ASP
+    } else if(residuename=="HID") {
+      return true;  // HIS-D amber
+    } else if(residuename=="HSD") {
+      return true;  // HIS-D charmm
+    } else if(residuename=="HIE") {
+      return true;  // HIS-E amber
+    } else if(residuename=="HSE") {
+      return true;  // HIS-E charmm
+    } else if(residuename=="HIP") {
+      return true;  // HIS-P amber
+    } else if(residuename=="HSP") {
+      return true;  // HIS-P charmm
+    } else if(residuename=="CYX") {
+      return true;  // disulfide bridge CYS
+    }
 // Weird amino acids
-    else if(residuename=="NLE") return true;
-    else if(residuename=="SFO") return true;
-    else return false;
+    else if(residuename=="NLE") {
+      return true;
+    } else if(residuename=="SFO") {
+      return true;
+    } else {
+      return false;
+    }
   } else if( type=="dna" ) {
-    if(residuename=="A") return true;
-    else if(residuename=="A5") return true;
-    else if(residuename=="A3") return true;
-    else if(residuename=="AN") return true;
-    else if(residuename=="G") return true;
-    else if(residuename=="G5") return true;
-    else if(residuename=="G3") return true;
-    else if(residuename=="GN") return true;
-    else if(residuename=="T") return true;
-    else if(residuename=="T5") return true;
-    else if(residuename=="T3") return true;
-    else if(residuename=="TN") return true;
-    else if(residuename=="C") return true;
-    else if(residuename=="C5") return true;
-    else if(residuename=="C3") return true;
-    else if(residuename=="CN") return true;
-    else if(residuename=="DA") return true;
-    else if(residuename=="DA5") return true;
-    else if(residuename=="DA3") return true;
-    else if(residuename=="DAN") return true;
-    else if(residuename=="DG") return true;
-    else if(residuename=="DG5") return true;
-    else if(residuename=="DG3") return true;
-    else if(residuename=="DGN") return true;
-    else if(residuename=="DT") return true;
-    else if(residuename=="DT5") return true;
-    else if(residuename=="DT3") return true;
-    else if(residuename=="DTN") return true;
-    else if(residuename=="DC") return true;
-    else if(residuename=="DC5") return true;
-    else if(residuename=="DC3") return true;
-    else if(residuename=="DCN") return true;
-    else return false;
+    if(residuename=="A") {
+      return true;
+    } else if(residuename=="A5") {
+      return true;
+    } else if(residuename=="A3") {
+      return true;
+    } else if(residuename=="AN") {
+      return true;
+    } else if(residuename=="G") {
+      return true;
+    } else if(residuename=="G5") {
+      return true;
+    } else if(residuename=="G3") {
+      return true;
+    } else if(residuename=="GN") {
+      return true;
+    } else if(residuename=="T") {
+      return true;
+    } else if(residuename=="T5") {
+      return true;
+    } else if(residuename=="T3") {
+      return true;
+    } else if(residuename=="TN") {
+      return true;
+    } else if(residuename=="C") {
+      return true;
+    } else if(residuename=="C5") {
+      return true;
+    } else if(residuename=="C3") {
+      return true;
+    } else if(residuename=="CN") {
+      return true;
+    } else if(residuename=="DA") {
+      return true;
+    } else if(residuename=="DA5") {
+      return true;
+    } else if(residuename=="DA3") {
+      return true;
+    } else if(residuename=="DAN") {
+      return true;
+    } else if(residuename=="DG") {
+      return true;
+    } else if(residuename=="DG5") {
+      return true;
+    } else if(residuename=="DG3") {
+      return true;
+    } else if(residuename=="DGN") {
+      return true;
+    } else if(residuename=="DT") {
+      return true;
+    } else if(residuename=="DT5") {
+      return true;
+    } else if(residuename=="DT3") {
+      return true;
+    } else if(residuename=="DTN") {
+      return true;
+    } else if(residuename=="DC") {
+      return true;
+    } else if(residuename=="DC5") {
+      return true;
+    } else if(residuename=="DC3") {
+      return true;
+    } else if(residuename=="DCN") {
+      return true;
+    } else {
+      return false;
+    }
   } else if( type=="rna" ) {
-    if(residuename=="A") return true;
-    else if(residuename=="A5") return true;
-    else if(residuename=="A3") return true;
-    else if(residuename=="AN") return true;
-    else if(residuename=="G") return true;
-    else if(residuename=="G5") return true;
-    else if(residuename=="G3") return true;
-    else if(residuename=="GN") return true;
-    else if(residuename=="U") return true;
-    else if(residuename=="U5") return true;
-    else if(residuename=="U3") return true;
-    else if(residuename=="UN") return true;
-    else if(residuename=="C") return true;
-    else if(residuename=="C5") return true;
-    else if(residuename=="C3") return true;
-    else if(residuename=="CN") return true;
-    else if(residuename=="RA") return true;
-    else if(residuename=="RA5") return true;
-    else if(residuename=="RA3") return true;
-    else if(residuename=="RAN") return true;
-    else if(residuename=="RG") return true;
-    else if(residuename=="RG5") return true;
-    else if(residuename=="RG3") return true;
-    else if(residuename=="RGN") return true;
-    else if(residuename=="RU") return true;
-    else if(residuename=="RU5") return true;
-    else if(residuename=="RU3") return true;
-    else if(residuename=="RUN") return true;
-    else if(residuename=="RC") return true;
-    else if(residuename=="RC5") return true;
-    else if(residuename=="RC3") return true;
-    else if(residuename=="RCN") return true;
-    else return false;
+    if(residuename=="A") {
+      return true;
+    } else if(residuename=="A5") {
+      return true;
+    } else if(residuename=="A3") {
+      return true;
+    } else if(residuename=="AN") {
+      return true;
+    } else if(residuename=="G") {
+      return true;
+    } else if(residuename=="G5") {
+      return true;
+    } else if(residuename=="G3") {
+      return true;
+    } else if(residuename=="GN") {
+      return true;
+    } else if(residuename=="U") {
+      return true;
+    } else if(residuename=="U5") {
+      return true;
+    } else if(residuename=="U3") {
+      return true;
+    } else if(residuename=="UN") {
+      return true;
+    } else if(residuename=="C") {
+      return true;
+    } else if(residuename=="C5") {
+      return true;
+    } else if(residuename=="C3") {
+      return true;
+    } else if(residuename=="CN") {
+      return true;
+    } else if(residuename=="RA") {
+      return true;
+    } else if(residuename=="RA5") {
+      return true;
+    } else if(residuename=="RA3") {
+      return true;
+    } else if(residuename=="RAN") {
+      return true;
+    } else if(residuename=="RG") {
+      return true;
+    } else if(residuename=="RG5") {
+      return true;
+    } else if(residuename=="RG3") {
+      return true;
+    } else if(residuename=="RGN") {
+      return true;
+    } else if(residuename=="RU") {
+      return true;
+    } else if(residuename=="RU5") {
+      return true;
+    } else if(residuename=="RU3") {
+      return true;
+    } else if(residuename=="RUN") {
+      return true;
+    } else if(residuename=="RC") {
+      return true;
+    } else if(residuename=="RC5") {
+      return true;
+    } else if(residuename=="RC3") {
+      return true;
+    } else if(residuename=="RCN") {
+      return true;
+    } else {
+      return false;
+    }
   } else if( type=="water" ) {
-    if(residuename=="SOL") return true;
-    if(residuename=="WAT") return true;
+    if(residuename=="SOL") {
+      return true;
+    }
+    if(residuename=="WAT") {
+      return true;
+    }
     return false;
   } else if( type=="ion" ) {
-    if(residuename=="IB+") return true;
-    if(residuename=="CA") return true;
-    if(residuename=="CL") return true;
-    if(residuename=="NA") return true;
-    if(residuename=="MG") return true;
-    if(residuename=="K") return true;
-    if(residuename=="RB") return true;
-    if(residuename=="CS") return true;
-    if(residuename=="LI") return true;
-    if(residuename=="ZN") return true;
+    if(residuename=="IB+") {
+      return true;
+    }
+    if(residuename=="CA") {
+      return true;
+    }
+    if(residuename=="CL") {
+      return true;
+    }
+    if(residuename=="NA") {
+      return true;
+    }
+    if(residuename=="MG") {
+      return true;
+    }
+    if(residuename=="K") {
+      return true;
+    }
+    if(residuename=="RB") {
+      return true;
+    }
+    if(residuename=="CS") {
+      return true;
+    }
+    if(residuename=="LI") {
+      return true;
+    }
+    if(residuename=="ZN") {
+      return true;
+    }
     return false;
   }
   return false;
diff --git a/src/tools/Pbc.cpp b/src/tools/Pbc.cpp
index 2423987a3d..f55ac8cdc3 100644
--- a/src/tools/Pbc.cpp
+++ b/src/tools/Pbc.cpp
@@ -30,8 +30,7 @@
 namespace PLMD {
 
 Pbc::Pbc():
-  type(unset)
-{
+  type(unset) {
   box.zero();
   invBox.zero();
 }
@@ -40,11 +39,17 @@ void Pbc::buildShifts(gch::small_vector<Vector,maxshiftsize> shifts[2][2][2])con
   const double small=1e-28;
 
 // clear all shifts
-  for(int i=0; i<2; i++) for(int j=0; j<2; j++) for(int k=0; k<2; k++) shifts[i][j][k].clear();
+  for(int i=0; i<2; i++)
+    for(int j=0; j<2; j++)
+      for(int k=0; k<2; k++) {
+        shifts[i][j][k].clear();
+      }
 
 // enumerate all possible shifts
 // since box is reduced, only 27 shifts have to be attempted
-  for(int l=-1; l<=1; l++) for(int m=-1; m<=1; m++) for(int n=-1; n<=1; n++) {
+  for(int l=-1; l<=1; l++)
+    for(int m=-1; m<=1; m++)
+      for(int n=-1; n<=1; n++) {
 
 // int/double shift vectors
         const int ishift[3]= {l,m,n};
@@ -52,11 +57,16 @@ void Pbc::buildShifts(gch::small_vector<Vector,maxshiftsize> shifts[2][2][2])con
 
 // count how many components are != 0
         unsigned count=0;
-        for(int s=0; s<3; s++) if(ishift[s]!=0) count++;
+        for(int s=0; s<3; s++)
+          if(ishift[s]!=0) {
+            count++;
+          }
 
 // skips trivial (0,0,0) and cases with three shifts
 // only 18 shifts survive past this point
-        if(count==0 || count==3) continue;
+        if(count==0 || count==3) {
+          continue;
+        }
 
 // check if that Wigner-Seitz face is perpendicular to the axis.
 // this allows to eliminate shifts in symmetric cells.
@@ -65,24 +75,37 @@ void Pbc::buildShifts(gch::small_vector<Vector,maxshiftsize> shifts[2][2][2])con
         Vector cosdir=matmul(reduced,transpose(reduced),dshift);
         double dp=dotProduct(dshift,cosdir);
         double ref=modulo2(dshift)*modulo2(cosdir);
-        if(std::fabs(ref-dp*dp)<small) continue;
+        if(std::fabs(ref-dp*dp)<small) {
+          continue;
+        }
 
 // here we start pruning depending on the sign of the scaled coordinate
-        for(int i=0; i<2; i++) for(int j=0; j<2; j++) for(int k=0; k<2; k++) {
+        for(int i=0; i<2; i++)
+          for(int j=0; j<2; j++)
+            for(int k=0; k<2; k++) {
 
               const int block[3]= {2*i-1,2*j-1,2*k-1};
 
 // skip cases where shift would bring too far from origin
               bool skip=false;
-              for(int s=0; s<3; s++) if(ishift[s]*block[s]>0) skip=true;
-              if(skip) continue;
+              for(int s=0; s<3; s++)
+                if(ishift[s]*block[s]>0) {
+                  skip=true;
+                }
+              if(skip) {
+                continue;
+              }
               skip=true;
               for(int s=0; s<3; s++) {
 // check that the components of cosdir along the non-shifted directions
 // have the proper sign
-                if(((1-ishift[s]*ishift[s])*block[s])*cosdir[s]<-small) skip=false;
+                if(((1-ishift[s]*ishift[s])*block[s])*cosdir[s]<-small) {
+                  skip=false;
+                }
+              }
+              if(skip) {
+                continue;
               }
-              if(skip)continue;
 
 // if we arrive to this point, shift is eligible and is added to the list
               shifts[i][j][k].push_back(matmul(transpose(reduced),dshift));
@@ -91,9 +114,13 @@ void Pbc::buildShifts(gch::small_vector<Vector,maxshiftsize> shifts[2][2][2])con
 }
 
 void Pbc::fullSearch(Vector&d)const {
-  if(type==unset) return;
+  if(type==unset) {
+    return;
+  }
   Vector s=matmul(invReduced.transpose(),d);
-  for(int i=0; i<3; i++) s[i]=Tools::pbc(s[i]);
+  for(int i=0; i<3; i++) {
+    s[i]=Tools::pbc(s[i]);
+  }
   d=matmul(reduced.transpose(),s);
   const int smax=4;
   Vector a0(reduced.getRow(0));
@@ -101,7 +128,9 @@ void Pbc::fullSearch(Vector&d)const {
   Vector a2(reduced.getRow(2));
   Vector best(d);
   double lbest=d.modulo2();
-  for(int i=-smax; i<=smax; i++) for(int j=-smax; j<=smax; j++) for(int k=-smax; k<=smax; k++) {
+  for(int i=-smax; i<=smax; i++)
+    for(int j=-smax; j<=smax; j++)
+      for(int k=-smax; k<=smax; k++) {
         Vector trial=d+i*a0+j*a1+k*a2;
         double ltrial=trial.modulo2();
         if(ltrial<lbest) {
@@ -119,19 +148,30 @@ void Pbc::setBox(const Tensor&b) {
 
   type=unset;
   double det=box.determinant();
-  if(det*det<epsilon) return;
+  if(det*det<epsilon) {
+    return;
+  }
 
   bool cxy=false;
   bool cxz=false;
   bool cyz=false;
-  if(box(0,1)*box(0,1)<epsilon && box(1,0)*box(1,0)<epsilon) cxy=true;
-  if(box(0,2)*box(0,2)<epsilon && box(2,0)*box(2,0)<epsilon) cxz=true;
-  if(box(1,2)*box(1,2)<epsilon && box(2,1)*box(2,1)<epsilon) cyz=true;
+  if(box(0,1)*box(0,1)<epsilon && box(1,0)*box(1,0)<epsilon) {
+    cxy=true;
+  }
+  if(box(0,2)*box(0,2)<epsilon && box(2,0)*box(2,0)<epsilon) {
+    cxz=true;
+  }
+  if(box(1,2)*box(1,2)<epsilon && box(2,1)*box(2,1)<epsilon) {
+    cyz=true;
+  }
 
   invBox=box.inverse();
 
-  if(cxy && cxz && cyz) type=orthorombic;
-  else type=generic;
+  if(cxy && cxz && cyz) {
+    type=orthorombic;
+  } else {
+    type=generic;
+  }
 
   if(type==orthorombic) {
     reduced=box;
@@ -151,8 +191,11 @@ void Pbc::setBox(const Tensor&b) {
 }
 
 double Pbc::distance( const bool pbc, const Vector& v1, const Vector& v2 ) const {
-  if(pbc) { return ( distance(v1,v2) ).modulo(); }
-  else { return ( delta(v1,v2) ).modulo(); }
+  if(pbc) {
+    return ( distance(v1,v2) ).modulo();
+  } else {
+    return ( delta(v1,v2) ).modulo();
+  }
 }
 
 void Pbc::apply(std::vector<Vector>& dlist, unsigned max_index) const {
@@ -160,18 +203,32 @@ void Pbc::apply(std::vector<Vector>& dlist, unsigned max_index) const {
 }
 
 void Pbc::apply(VectorView dlist, unsigned max_index) const {
-  if (max_index==0) max_index=dlist.size();
+  if (max_index==0) {
+    max_index=dlist.size();
+  }
   if(type==unset) {
     // do nothing
   } else if(type==orthorombic) {
 #ifdef __PLUMED_PBC_WHILE
     for(unsigned k=0; k<max_index; ++k) {
-      while(dlist[k][0]>hdiag[0])   dlist[k][0]-=diag[0];
-      while(dlist[k][0]<=mdiag[0])  dlist[k][0]+=diag[0];
-      while(dlist[k][1]>hdiag[1])   dlist[k][1]-=diag[1];
-      while(dlist[k][1]<=mdiag[1])  dlist[k][1]+=diag[1];
-      while(dlist[k][2]>hdiag[2])   dlist[k][2]-=diag[2];
-      while(dlist[k][2]<=mdiag[2])  dlist[k][2]+=diag[2];
+      while(dlist[k][0]>hdiag[0]) {
+        dlist[k][0]-=diag[0];
+      }
+      while(dlist[k][0]<=mdiag[0]) {
+        dlist[k][0]+=diag[0];
+      }
+      while(dlist[k][1]>hdiag[1]) {
+        dlist[k][1]-=diag[1];
+      }
+      while(dlist[k][1]<=mdiag[1]) {
+        dlist[k][1]+=diag[1];
+      }
+      while(dlist[k][2]>hdiag[2]) {
+        dlist[k][2]-=diag[2];
+      }
+      while(dlist[k][2]<=mdiag[2]) {
+        dlist[k][2]+=diag[2];
+      }
     }
 #else
     for(unsigned k=0; k<max_index; ++k) {
@@ -216,7 +273,9 @@ void Pbc::apply(VectorView dlist, unsigned max_index) const {
       dlist[k][1]  = best[1];
       dlist[k][2]  = best[2];
     }
-  } else plumed_merror("unknown pbc type");
+  } else {
+    plumed_merror("unknown pbc type");
+  }
 }
 
 Vector Pbc::distance(const Vector&v1,const Vector&v2,int*nshifts)const {
@@ -226,11 +285,17 @@ Vector Pbc::distance(const Vector&v1,const Vector&v2,int*nshifts)const {
   } else if(type==orthorombic) {
 #ifdef __PLUMED_PBC_WHILE
     for(unsigned i=0; i<3; i++) {
-      while(d[i]>hdiag[i]) d[i]-=diag[i];
-      while(d[i]<=mdiag[i]) d[i]+=diag[i];
+      while(d[i]>hdiag[i]) {
+        d[i]-=diag[i];
+      }
+      while(d[i]<=mdiag[i]) {
+        d[i]+=diag[i];
+      }
     }
 #else
-    for(int i=0; i<3; i++) d[i]=Tools::pbc(d[i]*invBox(i,i))*box(i,i);
+    for(int i=0; i<3; i++) {
+      d[i]=Tools::pbc(d[i]*invBox(i,i))*box(i,i);
+    }
 #endif
   } else if(type==generic) {
     Vector s=matmul(d,invReduced);
@@ -252,7 +317,9 @@ Vector Pbc::distance(const Vector&v1,const Vector&v2,int*nshifts)const {
         Vector best(d);
         double lbest(modulo2(best));
 // loop over possible shifts:
-        if(nshifts) *nshifts+=myshifts.size();
+        if(nshifts) {
+          *nshifts+=myshifts.size();
+        }
         for(unsigned i=0; i<myshifts.size(); i++) {
           Vector trial=d+myshifts[i];
           double ltrial=modulo2(trial);
@@ -264,7 +331,9 @@ Vector Pbc::distance(const Vector&v1,const Vector&v2,int*nshifts)const {
         d=best;
       }
     }
-  } else plumed_merror("unknown pbc type");
+  } else {
+    plumed_merror("unknown pbc type");
+  }
   return d;
 }
 
diff --git a/src/tools/Pbc.h b/src/tools/Pbc.h
index 29e3b3a86a..717cccdca1 100644
--- a/src/tools/Pbc.h
+++ b/src/tools/Pbc.h
@@ -36,10 +36,16 @@ class MemoryView {
   double *ptr_;
 public:
   MemoryView(double* p) :ptr_(p) {}
-  constexpr size_t size()const {return N;}
+  constexpr size_t size()const {
+    return N;
+  }
   static constexpr size_t extent = N;
-  double & operator[](size_t i) { return ptr_[i];}
-  const double & operator[](size_t i) const { return ptr_[i];}
+  double & operator[](size_t i) {
+    return ptr_[i];
+  }
+  const double & operator[](size_t i) const {
+    return ptr_[i];
+  }
 };
 
 namespace helpers {
@@ -57,10 +63,14 @@ class mdMemoryView {
   size_t size_;
 public:
   mdMemoryView(double* p, size_t s) :ptr_(p), size_(s) {}
-  size_t size()const {return size_;}
+  size_t size()const {
+    return size_;
+  }
   static constexpr size_t extent = N;
   static constexpr size_t stride = STRIDE;
-  MemoryView<STRIDE> operator[](size_t i) { return MemoryView<STRIDE>(ptr_ + i * STRIDE);}
+  MemoryView<STRIDE> operator[](size_t i) {
+    return MemoryView<STRIDE>(ptr_ + i * STRIDE);
+  }
 };
 
 using VectorView = mdMemoryView<helpers::dynamic_extent, 3>;
diff --git a/src/tools/PlumedHandle.cpp b/src/tools/PlumedHandle.cpp
index d58d13a208..5b72d617a4 100644
--- a/src/tools/PlumedHandle.cpp
+++ b/src/tools/PlumedHandle.cpp
@@ -38,20 +38,17 @@
 #define __PLUMED_WRAPPER_CXX_ANONYMOUS_NAMESPACE_PLMD_EXCEPTIONS 1
 #include "../wrapper/Plumed.h"
 
-namespace PLMD
-{
+namespace PLMD {
 
 
 PlumedHandle::PlumedHandle():
-  local(Tools::make_unique<PlumedMain>())
-{
+  local(Tools::make_unique<PlumedMain>()) {
 }
 
 PlumedHandle::PlumedHandle(const char* kernel)
 #ifdef __PLUMED_HAS_DLOPEN
   :
-  loaded(plumed_c2v(plumed_create_dlopen(kernel)))
-{
+  loaded(plumed_c2v(plumed_create_dlopen(kernel))) {
   if(!plumed_valid(plumed_v2c(loaded))) {
     // this is necessary to make sure loaded is properly destroyed
     plumed_finalize(plumed_v2c(loaded));
@@ -65,7 +62,9 @@ PlumedHandle::PlumedHandle(const char* kernel)
 #endif
 
 PlumedHandle::~PlumedHandle() {
-  if(loaded) plumed_finalize(plumed_v2c(loaded));
+  if(loaded) {
+    plumed_finalize(plumed_v2c(loaded));
+  }
 }
 
 PlumedHandle PlumedHandle::dlopen(const char* path) {
@@ -109,19 +108,22 @@ void PlumedHandle::cmd(std::string_view key,const TypesafePtr & ptr) {
 
     plumed_cmd(plumed_v2c(loaded),key_buffer,safe);
 
-  } else plumed_error() << "should never arrive here (either one or the other should work)";
+  } else {
+    plumed_error() << "should never arrive here (either one or the other should work)";
+  }
 }
 
 PlumedHandle::PlumedHandle(PlumedHandle && other) noexcept:
   local(std::move(other.local)),
-  loaded(other.loaded)
-{
+  loaded(other.loaded) {
   other.loaded=nullptr;
 }
 
 PlumedHandle & PlumedHandle::operator=(PlumedHandle && other) noexcept {
   if(this!=&other) {
-    if(loaded) plumed_finalize(plumed_v2c(loaded));
+    if(loaded) {
+      plumed_finalize(plumed_v2c(loaded));
+    }
     local=std::move(other.local);
     loaded=other.loaded;
     other.loaded=nullptr;
diff --git a/src/tools/PlumedHandle.h b/src/tools/PlumedHandle.h
index be22d5a661..cbf5ec6bd0 100644
--- a/src/tools/PlumedHandle.h
+++ b/src/tools/PlumedHandle.h
@@ -26,8 +26,7 @@
 #include "TypesafePtr.h"
 #include <memory>
 
-namespace PLMD
-{
+namespace PLMD {
 
 class PlumedMain;
 
@@ -71,8 +70,7 @@ Thus, once constructed the object is guaranteed to be functional.
 
 */
 class PlumedHandle :
-  public WithCmd
-{
+  public WithCmd {
 /// Pointer to PlumedMain.
 /// Used when using the current kernel in order to avoid unneeded indirections.
   std::unique_ptr<PlumedMain> local;
diff --git a/src/tools/RMSD.cpp b/src/tools/RMSD.cpp
index 05e787122a..bc7d5fbea7 100644
--- a/src/tools/RMSD.cpp
+++ b/src/tools/RMSD.cpp
@@ -54,14 +54,13 @@ void RMSD::setType(const std::string & mytype) {
   alignmentMethod=SIMPLE; // initialize with the simplest case: no rotation
   if (mytype=="SIMPLE") {
     alignmentMethod=SIMPLE;
-  }
-  else if (mytype=="OPTIMAL") {
+  } else if (mytype=="OPTIMAL") {
     alignmentMethod=OPTIMAL;
-  }
-  else if (mytype=="OPTIMAL-FAST") {
+  } else if (mytype=="OPTIMAL-FAST") {
     alignmentMethod=OPTIMAL_FAST;
+  } else {
+    plumed_merror("unknown RMSD type" + mytype);
   }
-  else plumed_merror("unknown RMSD type" + mytype);
 
 }
 
@@ -80,9 +79,15 @@ void RMSD::clear() {
 std::string RMSD::getMethod() {
   std::string mystring;
   switch(alignmentMethod) {
-  case SIMPLE: mystring.assign("SIMPLE"); break;
-  case OPTIMAL: mystring.assign("OPTIMAL"); break;
-  case OPTIMAL_FAST: mystring.assign("OPTIMAL-FAST"); break;
+  case SIMPLE:
+    mystring.assign("SIMPLE");
+    break;
+  case OPTIMAL:
+    mystring.assign("OPTIMAL");
+    break;
+  case OPTIMAL_FAST:
+    mystring.assign("OPTIMAL-FAST");
+    break;
   }
   return mystring;
 }
@@ -97,9 +102,13 @@ void RMSD::setReference(const std::vector<Vector> & reference) {
   plumed_massert(displace.empty(),"you should first clear() an RMSD object, then set a new reference");
   align.resize(n,1.0/n);
   displace.resize(n,1.0/n);
-  for(unsigned i=0; i<n; i++) reference_center+=this->reference[i]*align[i];
+  for(unsigned i=0; i<n; i++) {
+    reference_center+=this->reference[i]*align[i];
+  }
   #pragma omp simd
-  for(unsigned i=0; i<n; i++) this->reference[i]-=reference_center;
+  for(unsigned i=0; i<n; i++) {
+    this->reference[i]-=reference_center;
+  }
   reference_center_is_calculated=true;
   reference_center_is_removed=true;
 }
@@ -116,15 +125,21 @@ void RMSD::setAlign(const std::vector<double> & align, bool normalize_weights, b
   if(normalize_weights) {
     double w=0.0;
     #pragma omp simd reduction(+:w)
-    for(unsigned i=0; i<n; i++) w+=this->align[i];
+    for(unsigned i=0; i<n; i++) {
+      w+=this->align[i];
+    }
     if(w>epsilon) {
       double inv=1.0/w;
       #pragma omp simd
-      for(unsigned i=0; i<n; i++) this->align[i]*=inv;
+      for(unsigned i=0; i<n; i++) {
+        this->align[i]*=inv;
+      }
     } else {
       double inv=1.0/n;
       #pragma omp simd
-      for(unsigned i=0; i<n; i++) this->align[i]=inv;
+      for(unsigned i=0; i<n; i++) {
+        this->align[i]=inv;
+      }
     }
   }
   // recalculate the center anyway
@@ -156,15 +171,21 @@ void RMSD::setDisplace(const std::vector<double> & displace, bool normalize_weig
   if(normalize_weights) {
     double w=0.0;
     #pragma omp simd reduction(+:w)
-    for(unsigned i=0; i<n; i++) w+=this->displace[i];
+    for(unsigned i=0; i<n; i++) {
+      w+=this->displace[i];
+    }
     if(w>epsilon) {
       double inv=1.0/w;
       #pragma omp simd
-      for(unsigned i=0; i<n; i++) this->displace[i]*=inv;
+      for(unsigned i=0; i<n; i++) {
+        this->displace[i]*=inv;
+      }
     } else {
       double inv=1.0/n;
       #pragma omp simd
-      for(unsigned i=0; i<n; i++) this->displace[i]=inv;
+      for(unsigned i=0; i<n; i++) {
+        this->displace[i]=inv;
+      }
     }
   }
 }
@@ -184,16 +205,24 @@ double RMSD::calculate(const std::vector<Vector> & positions,std::vector<Vector>
     std::vector<Vector> displacement( derivatives.size() );
     ret=simpleAlignment(align,displace,positions,reference,derivatives,displacement,squared);
     break;
-  } case OPTIMAL_FAST : {
+  }
+  case OPTIMAL_FAST : {
     // this is calling the fastest option:
-    if(align==displace) ret=optimalAlignment<false,true>(align,displace,positions,reference,derivatives,squared);
-    else                ret=optimalAlignment<false,false>(align,displace,positions,reference,derivatives,squared);
+    if(align==displace) {
+      ret=optimalAlignment<false,true>(align,displace,positions,reference,derivatives,squared);
+    } else {
+      ret=optimalAlignment<false,false>(align,displace,positions,reference,derivatives,squared);
+    }
     break;
 
-  } case OPTIMAL : {
+  }
+  case OPTIMAL : {
     // this is the fast routine but in the "safe" mode, which gives less numerical error:
-    if(align==displace) ret=optimalAlignment<true,true>(align,displace,positions,reference,derivatives,squared);
-    else ret=optimalAlignment<true,false>(align,displace,positions,reference,derivatives,squared);
+    if(align==displace) {
+      ret=optimalAlignment<true,true>(align,displace,positions,reference,derivatives,squared);
+    } else {
+      ret=optimalAlignment<true,false>(align,displace,positions,reference,derivatives,squared);
+    }
     break;
   }
   }
@@ -211,12 +240,18 @@ double RMSD::calc_DDistDRef( const std::vector<Vector>& positions, std::vector<V
     plumed_merror("derivative of the refreence frame not implemented for SIMPLE alignmentMethod \n");
     break;
   case OPTIMAL_FAST:
-    if(align==displace) ret=optimalAlignment_DDistDRef<false,true>(align,displace,positions,reference,derivatives,DDistDRef, squared);
-    else                ret=optimalAlignment_DDistDRef<false,false>(align,displace,positions,reference,derivatives,DDistDRef,squared);
+    if(align==displace) {
+      ret=optimalAlignment_DDistDRef<false,true>(align,displace,positions,reference,derivatives,DDistDRef, squared);
+    } else {
+      ret=optimalAlignment_DDistDRef<false,false>(align,displace,positions,reference,derivatives,DDistDRef,squared);
+    }
     break;
   case OPTIMAL:
-    if(align==displace) ret=optimalAlignment_DDistDRef<true,true>(align,displace,positions,reference,derivatives,DDistDRef,squared);
-    else                ret=optimalAlignment_DDistDRef<true,false>(align,displace,positions,reference,derivatives,DDistDRef,squared);
+    if(align==displace) {
+      ret=optimalAlignment_DDistDRef<true,true>(align,displace,positions,reference,derivatives,DDistDRef,squared);
+    } else {
+      ret=optimalAlignment_DDistDRef<true,false>(align,displace,positions,reference,derivatives,DDistDRef,squared);
+    }
     break;
   }
   return ret;
@@ -232,12 +267,18 @@ double RMSD::calc_SOMA( const std::vector<Vector>& positions, std::vector<Vector
     plumed_merror("derivative of the refreence frame not implemented for SIMPLE alignmentMethod \n");
     break;
   case OPTIMAL_FAST:
-    if(align==displace) ret=optimalAlignment_SOMA<false,true>(align,displace,positions,reference,derivatives,DDistDRef, squared);
-    else                ret=optimalAlignment_SOMA<false,false>(align,displace,positions,reference,derivatives,DDistDRef,squared);
+    if(align==displace) {
+      ret=optimalAlignment_SOMA<false,true>(align,displace,positions,reference,derivatives,DDistDRef, squared);
+    } else {
+      ret=optimalAlignment_SOMA<false,false>(align,displace,positions,reference,derivatives,DDistDRef,squared);
+    }
     break;
   case OPTIMAL:
-    if(align==displace) ret=optimalAlignment_SOMA<true,true>(align,displace,positions,reference,derivatives,DDistDRef,squared);
-    else                ret=optimalAlignment_SOMA<true,false>(align,displace,positions,reference,derivatives,DDistDRef,squared);
+    if(align==displace) {
+      ret=optimalAlignment_SOMA<true,true>(align,displace,positions,reference,derivatives,DDistDRef,squared);
+    } else {
+      ret=optimalAlignment_SOMA<true,false>(align,displace,positions,reference,derivatives,DDistDRef,squared);
+    }
     break;
   }
   return ret;
@@ -251,12 +292,18 @@ double RMSD::calc_DDistDRef_Rot_DRotDPos( const std::vector<Vector>& positions,
     plumed_merror("derivative of the refreence frame not implemented for SIMPLE alignmentMethod \n");
     break;
   case OPTIMAL_FAST:
-    if(align==displace) ret=optimalAlignment_DDistDRef_Rot_DRotDPos<false,true>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos,  squared);
-    else                ret=optimalAlignment_DDistDRef_Rot_DRotDPos<false,false>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, squared);
+    if(align==displace) {
+      ret=optimalAlignment_DDistDRef_Rot_DRotDPos<false,true>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos,  squared);
+    } else {
+      ret=optimalAlignment_DDistDRef_Rot_DRotDPos<false,false>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, squared);
+    }
     break;
   case OPTIMAL:
-    if(align==displace) ret=optimalAlignment_DDistDRef_Rot_DRotDPos<true,true>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, squared);
-    else                ret=optimalAlignment_DDistDRef_Rot_DRotDPos<true,false>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, squared);
+    if(align==displace) {
+      ret=optimalAlignment_DDistDRef_Rot_DRotDPos<true,true>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, squared);
+    } else {
+      ret=optimalAlignment_DDistDRef_Rot_DRotDPos<true,false>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, squared);
+    }
     break;
   }
   return ret;
@@ -269,12 +316,18 @@ double RMSD::calc_DDistDRef_Rot_DRotDPos_DRotDRef( const std::vector<Vector>& po
     plumed_merror("derivative of the refreence frame not implemented for SIMPLE alignmentMethod \n");
     break;
   case OPTIMAL_FAST:
-    if(align==displace) ret=optimalAlignment_DDistDRef_Rot_DRotDPos_DRotDRef<false,true>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, DRotDRef,   squared);
-    else                ret=optimalAlignment_DDistDRef_Rot_DRotDPos_DRotDRef<false,false>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, DRotDRef,  squared);
+    if(align==displace) {
+      ret=optimalAlignment_DDistDRef_Rot_DRotDPos_DRotDRef<false,true>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, DRotDRef,   squared);
+    } else {
+      ret=optimalAlignment_DDistDRef_Rot_DRotDPos_DRotDRef<false,false>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, DRotDRef,  squared);
+    }
     break;
   case OPTIMAL:
-    if(align==displace) ret=optimalAlignment_DDistDRef_Rot_DRotDPos_DRotDRef<true,true>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, DRotDRef, squared);
-    else                ret=optimalAlignment_DDistDRef_Rot_DRotDPos_DRotDRef<true,false>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, DRotDRef, squared);
+    if(align==displace) {
+      ret=optimalAlignment_DDistDRef_Rot_DRotDPos_DRotDRef<true,true>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, DRotDRef, squared);
+    } else {
+      ret=optimalAlignment_DDistDRef_Rot_DRotDPos_DRotDRef<true,false>(align,displace,positions,reference,derivatives,DDistDRef, Rot, DRotDPos, DRotDRef, squared);
+    }
     break;
   }
   return ret;
@@ -287,12 +340,18 @@ double RMSD::calc_Rot_DRotDRr01( const std::vector<Vector>& positions, Tensor &
     plumed_merror("derivative of the refreence frame not implemented for SIMPLE alignmentMethod \n");
     break;
   case OPTIMAL_FAST:
-    if(align==displace) ret=optimalAlignment_Rot_DRotDRr01<false,true>(align,displace,positions,reference, Rotation, DRotDRr01,   squared);
-    else                ret=optimalAlignment_Rot_DRotDRr01<false,false>(align,displace,positions,reference, Rotation, DRotDRr01,  squared);
+    if(align==displace) {
+      ret=optimalAlignment_Rot_DRotDRr01<false,true>(align,displace,positions,reference, Rotation, DRotDRr01,   squared);
+    } else {
+      ret=optimalAlignment_Rot_DRotDRr01<false,false>(align,displace,positions,reference, Rotation, DRotDRr01,  squared);
+    }
     break;
   case OPTIMAL:
-    if(align==displace) ret=optimalAlignment_Rot_DRotDRr01<true,true>(align,displace,positions,reference, Rotation, DRotDRr01, squared);
-    else                ret=optimalAlignment_Rot_DRotDRr01<true,false>(align,displace,positions,reference, Rotation, DRotDRr01, squared);
+    if(align==displace) {
+      ret=optimalAlignment_Rot_DRotDRr01<true,true>(align,displace,positions,reference, Rotation, DRotDRr01, squared);
+    } else {
+      ret=optimalAlignment_Rot_DRotDRr01<true,false>(align,displace,positions,reference, Rotation, DRotDRr01, squared);
+    }
     break;
   }
   return ret;
@@ -305,12 +364,18 @@ double RMSD::calc_Rot( const std::vector<Vector>& positions, std::vector<Vector>
     plumed_merror("derivative of the refreence frame not implemented for SIMPLE alignmentMethod \n");
     break;
   case OPTIMAL_FAST:
-    if(align==displace) ret=optimalAlignment_Rot<false,true>(align,displace,positions,reference,derivatives, Rotation, squared);
-    else                ret=optimalAlignment_Rot<false,false>(align,displace,positions,reference,derivatives, Rotation, squared);
+    if(align==displace) {
+      ret=optimalAlignment_Rot<false,true>(align,displace,positions,reference,derivatives, Rotation, squared);
+    } else {
+      ret=optimalAlignment_Rot<false,false>(align,displace,positions,reference,derivatives, Rotation, squared);
+    }
     break;
   case OPTIMAL:
-    if(align==displace) ret=optimalAlignment_Rot<true,true>(align,displace,positions,reference,derivatives, Rotation, squared);
-    else                ret=optimalAlignment_Rot<true,false>(align,displace,positions,reference,derivatives, Rotation, squared);
+    if(align==displace) {
+      ret=optimalAlignment_Rot<true,true>(align,displace,positions,reference,derivatives, Rotation, squared);
+    } else {
+      ret=optimalAlignment_Rot<true,false>(align,displace,positions,reference,derivatives, Rotation, squared);
+    }
     break;
   }
   return ret;
@@ -323,12 +388,18 @@ double RMSD::calculateWithCloseStructure( const std::vector<Vector>& positions,
     plumed_merror("derivative of the refreence frame not implemented for SIMPLE alignmentMethod \n");
     break;
   case OPTIMAL_FAST:
-    if(align==displace) ret=optimalAlignmentWithCloseStructure<false,true>(align,displace,positions,reference,derivatives, rotationPosClose, rotationRefClose, drotationPosCloseDrr01, squared);
-    else                ret=optimalAlignmentWithCloseStructure<false,false>(align,displace,positions,reference,derivatives, rotationPosClose, rotationRefClose, drotationPosCloseDrr01, squared);
+    if(align==displace) {
+      ret=optimalAlignmentWithCloseStructure<false,true>(align,displace,positions,reference,derivatives, rotationPosClose, rotationRefClose, drotationPosCloseDrr01, squared);
+    } else {
+      ret=optimalAlignmentWithCloseStructure<false,false>(align,displace,positions,reference,derivatives, rotationPosClose, rotationRefClose, drotationPosCloseDrr01, squared);
+    }
     break;
   case OPTIMAL:
-    if(align==displace) ret=optimalAlignmentWithCloseStructure<true,true>(align,displace,positions,reference,derivatives, rotationPosClose, rotationRefClose, drotationPosCloseDrr01, squared);
-    else                ret=optimalAlignmentWithCloseStructure<true,false>(align,displace,positions,reference,derivatives, rotationPosClose, rotationRefClose, drotationPosCloseDrr01, squared);
+    if(align==displace) {
+      ret=optimalAlignmentWithCloseStructure<true,true>(align,displace,positions,reference,derivatives, rotationPosClose, rotationRefClose, drotationPosCloseDrr01, squared);
+    } else {
+      ret=optimalAlignmentWithCloseStructure<true,false>(align,displace,positions,reference,derivatives, rotationPosClose, rotationRefClose, drotationPosCloseDrr01, squared);
+    }
     break;
   }
   return ret;
@@ -341,12 +412,18 @@ double RMSD::calc_PCAelements( const std::vector<Vector>& positions, std::vector
     plumed_merror("derivative of the refreence frame not implemented for SIMPLE alignmentMethod \n");
     break;
   case OPTIMAL_FAST:
-    if(align==displace) ret=optimalAlignment_PCA<false,true>(align,displace,positions,reference, alignedpositions, centeredpositions,centeredreference,Rotation,DDistDPos,DRotDPos,squared);
-    else                ret=optimalAlignment_PCA<false,false>(align,displace,positions,reference, alignedpositions, centeredpositions,centeredreference,Rotation,DDistDPos,DRotDPos,squared);
+    if(align==displace) {
+      ret=optimalAlignment_PCA<false,true>(align,displace,positions,reference, alignedpositions, centeredpositions,centeredreference,Rotation,DDistDPos,DRotDPos,squared);
+    } else {
+      ret=optimalAlignment_PCA<false,false>(align,displace,positions,reference, alignedpositions, centeredpositions,centeredreference,Rotation,DDistDPos,DRotDPos,squared);
+    }
     break;
   case OPTIMAL:
-    if(align==displace) ret=optimalAlignment_PCA<true,true>(align,displace,positions,reference, alignedpositions, centeredpositions,centeredreference,Rotation,DDistDPos,DRotDPos,squared);
-    else                ret=optimalAlignment_PCA<true,false>(align,displace,positions,reference, alignedpositions, centeredpositions,centeredreference,Rotation,DDistDPos,DRotDPos,squared);
+    if(align==displace) {
+      ret=optimalAlignment_PCA<true,true>(align,displace,positions,reference, alignedpositions, centeredpositions,centeredreference,Rotation,DDistDPos,DRotDPos,squared);
+    } else {
+      ret=optimalAlignment_PCA<true,false>(align,displace,positions,reference, alignedpositions, centeredpositions,centeredreference,Rotation,DDistDPos,DRotDPos,squared);
+    }
     break;
   }
   return ret;
@@ -360,12 +437,18 @@ double RMSD::calc_FitElements( const std::vector<Vector>& positions, Tensor & Ro
     plumed_merror("derivative of the refreence frame not implemented for SIMPLE alignmentMethod \n");
     break;
   case OPTIMAL_FAST:
-    if(align==displace)ret=optimalAlignment_Fit<false,true>(align,displace,positions,reference, Rotation,DRotDPos,centeredpositions,center_positions,squared);
-    else               ret=optimalAlignment_Fit<false,false>(align,displace,positions,reference, Rotation,DRotDPos,centeredpositions,center_positions,squared);
+    if(align==displace) {
+      ret=optimalAlignment_Fit<false,true>(align,displace,positions,reference, Rotation,DRotDPos,centeredpositions,center_positions,squared);
+    } else {
+      ret=optimalAlignment_Fit<false,false>(align,displace,positions,reference, Rotation,DRotDPos,centeredpositions,center_positions,squared);
+    }
     break;
   case OPTIMAL:
-    if(align==displace)ret=optimalAlignment_Fit<true,true>(align,displace,positions,reference,Rotation,DRotDPos,centeredpositions,center_positions,squared);
-    else               ret=optimalAlignment_Fit<true,false>(align,displace,positions,reference,Rotation,DRotDPos,centeredpositions,center_positions,squared);
+    if(align==displace) {
+      ret=optimalAlignment_Fit<true,true>(align,displace,positions,reference,Rotation,DRotDPos,centeredpositions,center_positions,squared);
+    } else {
+      ret=optimalAlignment_Fit<true,false>(align,displace,positions,reference,Rotation,DRotDPos,centeredpositions,center_positions,squared);
+    }
     break;
   }
   return ret;
@@ -412,7 +495,9 @@ double RMSD::simpleAlignment(const  std::vector<double>  & align,
     // sqrt
     dist=std::sqrt(dist);
     ///// sqrt on derivatives
-    for(unsigned i=0; i<n; i++) {derivatives[i]*=(0.5/dist);}
+    for(unsigned i=0; i<n; i++) {
+      derivatives[i]*=(0.5/dist);
+    }
   }
   return dist;
 }
@@ -504,16 +589,21 @@ double RMSD::optimalAlignment(const  std::vector<double>  & align,
     dist=eigenvals[0]+rr00+rr11;
     q=Vector4d(eigenvecs[0][0],eigenvecs[0][1],eigenvecs[0][2],eigenvecs[0][3]);
     double dq_dm[4][4][4];
-    for(unsigned i=0; i<4; i++) for(unsigned j=0; j<4; j++) for(unsigned k=0; k<4; k++) {
+    for(unsigned i=0; i<4; i++)
+      for(unsigned j=0; j<4; j++)
+        for(unsigned k=0; k<4; k++) {
           double tmp=0.0;
 // perturbation theory for matrix m
-          for(unsigned l=1; l<4; l++) tmp+=eigenvecs[l][j]*eigenvecs[l][i]/(eigenvals[0]-eigenvals[l])*eigenvecs[0][k];
+          for(unsigned l=1; l<4; l++) {
+            tmp+=eigenvecs[l][j]*eigenvecs[l][i]/(eigenvals[0]-eigenvals[l])*eigenvecs[0][k];
+          }
           dq_dm[i][j][k]=tmp;
         }
 // propagation to _drr01
     for(unsigned i=0; i<4; i++) {
       Tensor tmp;
-      for(unsigned j=0; j<4; j++) for(unsigned k=0; k<4; k++) {
+      for(unsigned j=0; j<4; j++)
+        for(unsigned k=0; k<4; k++) {
           tmp+=dq_dm[i][j][k]*dm_drr01[j][k];
         }
       dq_drr01[i]=tmp;
@@ -557,10 +647,14 @@ double RMSD::optimalAlignment(const  std::vector<double>  & align,
 
   double prefactor=2.0;
 
-  if(!squared && alEqDis) prefactor*=0.5/std::sqrt(dist);
+  if(!squared && alEqDis) {
+    prefactor*=0.5/std::sqrt(dist);
+  }
 
 // if "safe", recompute dist here to a better accuracy
-  if(safe || !alEqDis) dist=0.0;
+  if(safe || !alEqDis) {
+    dist=0.0;
+  }
 
 // If safe is set to "false", MSD is taken from the eigenvalue of the M matrix
 // If safe is set to "true", MSD is recomputed from the rotational matrix
@@ -576,7 +670,9 @@ double RMSD::optimalAlignment(const  std::vector<double>  & align,
 // there is no need for derivatives of rotation and shift here as it is by construction zero
 // (similar to Hellman-Feynman forces)
       derivatives[iat]= prefactor*align[iat]*d;
-      if(safe) dist+=align[iat]*modulo2(d);
+      if(safe) {
+        dist+=align[iat]*modulo2(d);
+      }
     } else {
 // the case for align != displace is different, sob:
       dist+=displace[iat]*modulo2(d);
@@ -591,7 +687,10 @@ double RMSD::optimalAlignment(const  std::vector<double>  & align,
 
   if(!alEqDis) {
     Tensor ddist_drr01;
-    for(unsigned i=0; i<3; i++) for(unsigned j=0; j<3; j++) ddist_drr01+=ddist_drotation[i][j]*drotation_drr01[i][j];
+    for(unsigned i=0; i<3; i++)
+      for(unsigned j=0; j<3; j++) {
+        ddist_drr01+=ddist_drotation[i][j]*drotation_drr01[i][j];
+      }
     for(unsigned iat=0; iat<n; iat++) {
 // this is propagating to positions.
 // I am implicitly using the derivative of rr01 wrt positions here
@@ -603,7 +702,9 @@ double RMSD::optimalAlignment(const  std::vector<double>  & align,
     dist=std::sqrt(dist);
     if(!alEqDis) {
       double xx=0.5/dist;
-      for(unsigned iat=0; iat<n; iat++) derivatives[iat]*=xx;
+      for(unsigned iat=0; iat<n; iat++) {
+        derivatives[iat]*=xx;
+      }
     }
   }
 
@@ -625,12 +726,18 @@ double RMSD::optimalAlignment(const  std::vector<double>  & align,
 
   // transfer the settings for the center to let the CoreCalc deal with it
   cd.setPositionsCenterIsRemoved(positions_center_is_removed);
-  if(positions_center_is_calculated) {cd.setPositionsCenter(positions_center);}
-  else {cd.calcPositionsCenter();};
+  if(positions_center_is_calculated) {
+    cd.setPositionsCenter(positions_center);
+  } else {
+    cd.calcPositionsCenter();
+  };
 
   cd.setReferenceCenterIsRemoved(reference_center_is_removed);
-  if(!reference_center_is_calculated) {cd.calcReferenceCenter();}
-  else {cd.setReferenceCenter(reference_center);}
+  if(!reference_center_is_calculated) {
+    cd.calcReferenceCenter();
+  } else {
+    cd.setReferenceCenter(reference_center);
+  }
 
   // Perform the diagonalization and all the needed stuff
   cd.doCoreCalc(safe,alEqDis);
@@ -655,12 +762,18 @@ double RMSD::optimalAlignment_DDistDRef(const  std::vector<double>  & align,
   // transfer the settings for the center to let the CoreCalc deal with it
   // transfer the settings for the center to let the CoreCalc deal with it
   cd.setPositionsCenterIsRemoved(positions_center_is_removed);
-  if(positions_center_is_calculated) {cd.setPositionsCenter(positions_center);}
-  else {cd.calcPositionsCenter();};
+  if(positions_center_is_calculated) {
+    cd.setPositionsCenter(positions_center);
+  } else {
+    cd.calcPositionsCenter();
+  };
 
   cd.setReferenceCenterIsRemoved(reference_center_is_removed);
-  if(!reference_center_is_calculated) {cd.calcReferenceCenter();}
-  else {cd.setReferenceCenter(reference_center);}
+  if(!reference_center_is_calculated) {
+    cd.calcReferenceCenter();
+  } else {
+    cd.setReferenceCenter(reference_center);
+  }
 
   // Perform the diagonalization and all the needed stuff
   cd.doCoreCalc(safe,alEqDis);
@@ -686,12 +799,18 @@ double RMSD::optimalAlignment_SOMA(const  std::vector<double>  & align,
   // transfer the settings for the center to let the CoreCalc deal with it
   // transfer the settings for the center to let the CoreCalc deal with it
   cd.setPositionsCenterIsRemoved(positions_center_is_removed);
-  if(positions_center_is_calculated) {cd.setPositionsCenter(positions_center);}
-  else {cd.calcPositionsCenter();};
+  if(positions_center_is_calculated) {
+    cd.setPositionsCenter(positions_center);
+  } else {
+    cd.calcPositionsCenter();
+  };
 
   cd.setReferenceCenterIsRemoved(reference_center_is_removed);
-  if(!reference_center_is_calculated) {cd.calcReferenceCenter();}
-  else {cd.setReferenceCenter(reference_center);}
+  if(!reference_center_is_calculated) {
+    cd.calcReferenceCenter();
+  } else {
+    cd.setReferenceCenter(reference_center);
+  }
 
   // Perform the diagonalization and all the needed stuff
   cd.doCoreCalc(safe,alEqDis);
@@ -720,12 +839,18 @@ double RMSD::optimalAlignment_DDistDRef_Rot_DRotDPos(const  std::vector<double>
   // transfer the settings for the center to let the CoreCalc deal with it
   // transfer the settings for the center to let the CoreCalc deal with it
   cd.setPositionsCenterIsRemoved(positions_center_is_removed);
-  if(positions_center_is_calculated) {cd.setPositionsCenter(positions_center);}
-  else {cd.calcPositionsCenter();};
+  if(positions_center_is_calculated) {
+    cd.setPositionsCenter(positions_center);
+  } else {
+    cd.calcPositionsCenter();
+  };
 
   cd.setReferenceCenterIsRemoved(reference_center_is_removed);
-  if(!reference_center_is_calculated) {cd.calcReferenceCenter();}
-  else {cd.setReferenceCenter(reference_center);}
+  if(!reference_center_is_calculated) {
+    cd.calcReferenceCenter();
+  } else {
+    cd.setReferenceCenter(reference_center);
+  }
 
   // Perform the diagonalization and all the needed stuff
   cd.doCoreCalc(safe,alEqDis);
@@ -758,12 +883,18 @@ double RMSD::optimalAlignment_DDistDRef_Rot_DRotDPos_DRotDRef(const  std::vector
   // transfer the settings for the center to let the CoreCalc deal with it
   // transfer the settings for the center to let the CoreCalc deal with it
   cd.setPositionsCenterIsRemoved(positions_center_is_removed);
-  if(positions_center_is_calculated) {cd.setPositionsCenter(positions_center);}
-  else {cd.calcPositionsCenter();};
+  if(positions_center_is_calculated) {
+    cd.setPositionsCenter(positions_center);
+  } else {
+    cd.calcPositionsCenter();
+  };
 
   cd.setReferenceCenterIsRemoved(reference_center_is_removed);
-  if(!reference_center_is_calculated) {cd.calcReferenceCenter();}
-  else {cd.setReferenceCenter(reference_center);}
+  if(!reference_center_is_calculated) {
+    cd.calcReferenceCenter();
+  } else {
+    cd.setReferenceCenter(reference_center);
+  }
 
   // Perform the diagonalization and all the needed stuff
   cd.doCoreCalc(safe,alEqDis);
@@ -793,12 +924,18 @@ double RMSD::optimalAlignment_Rot_DRotDRr01(const  std::vector<double>  & align,
   RMSDCoreData cd(align,displace,positions,reference);
   // transfer the settings for the center to let the CoreCalc deal with it
   cd.setPositionsCenterIsRemoved(positions_center_is_removed);
-  if(positions_center_is_calculated) {cd.setPositionsCenter(positions_center);}
-  else {cd.calcPositionsCenter();};
+  if(positions_center_is_calculated) {
+    cd.setPositionsCenter(positions_center);
+  } else {
+    cd.calcPositionsCenter();
+  };
 
   cd.setReferenceCenterIsRemoved(reference_center_is_removed);
-  if(!reference_center_is_calculated) {cd.calcReferenceCenter();}
-  else {cd.setReferenceCenter(reference_center);}
+  if(!reference_center_is_calculated) {
+    cd.calcReferenceCenter();
+  } else {
+    cd.setReferenceCenter(reference_center);
+  }
 
   // Perform the diagonalization and all the needed stuff
   cd.doCoreCalc(safe,alEqDis);
@@ -824,12 +961,18 @@ double RMSD::optimalAlignment_Rot(const  std::vector<double>  & align,
   RMSDCoreData cd(align,displace,positions,reference);
   // transfer the settings for the center to let the CoreCalc deal with it
   cd.setPositionsCenterIsRemoved(positions_center_is_removed);
-  if(positions_center_is_calculated) {cd.setPositionsCenter(positions_center);}
-  else {cd.calcPositionsCenter();};
+  if(positions_center_is_calculated) {
+    cd.setPositionsCenter(positions_center);
+  } else {
+    cd.calcPositionsCenter();
+  };
 
   cd.setReferenceCenterIsRemoved(reference_center_is_removed);
-  if(!reference_center_is_calculated) {cd.calcReferenceCenter();}
-  else {cd.setReferenceCenter(reference_center);}
+  if(!reference_center_is_calculated) {
+    cd.calcReferenceCenter();
+  } else {
+    cd.setReferenceCenter(reference_center);
+  }
 
   // Perform the diagonalization and all the needed stuff
   cd.doCoreCalc(safe,alEqDis);
@@ -857,12 +1000,18 @@ double RMSD::optimalAlignmentWithCloseStructure(const  std::vector<double>  & al
   RMSDCoreData cd(align,displace,positions,reference);
   // transfer the settings for the center to let the CoreCalc deal with it
   cd.setPositionsCenterIsRemoved(positions_center_is_removed);
-  if(positions_center_is_calculated) {cd.setPositionsCenter(positions_center);}
-  else {cd.calcPositionsCenter();};
+  if(positions_center_is_calculated) {
+    cd.setPositionsCenter(positions_center);
+  } else {
+    cd.calcPositionsCenter();
+  };
 
   cd.setReferenceCenterIsRemoved(reference_center_is_removed);
-  if(!reference_center_is_calculated) {cd.calcReferenceCenter();}
-  else {cd.setReferenceCenter(reference_center);}
+  if(!reference_center_is_calculated) {
+    cd.calcReferenceCenter();
+  } else {
+    cd.setReferenceCenter(reference_center);
+  }
 
   // instead of diagonalization, approximate with saved rotation matrix
   cd.doCoreCalcWithCloseStructure(safe,alEqDis, rotationPosClose, rotationRefClose, drotationPosCloseDrr01);
@@ -891,12 +1040,18 @@ double RMSD::optimalAlignment_PCA(const  std::vector<double>  & align,
   RMSDCoreData cd(align,displace,positions,reference);
   // transfer the settings for the center to let the CoreCalc deal with it
   cd.setPositionsCenterIsRemoved(positions_center_is_removed);
-  if(positions_center_is_calculated) {cd.setPositionsCenter(positions_center);}
-  else {cd.calcPositionsCenter();};
+  if(positions_center_is_calculated) {
+    cd.setPositionsCenter(positions_center);
+  } else {
+    cd.calcPositionsCenter();
+  };
 
   cd.setReferenceCenterIsRemoved(reference_center_is_removed);
-  if(!reference_center_is_calculated) {cd.calcReferenceCenter();}
-  else {cd.setReferenceCenter(reference_center);}
+  if(!reference_center_is_calculated) {
+    cd.calcReferenceCenter();
+  } else {
+    cd.setReferenceCenter(reference_center);
+  }
 
   // Perform the diagonalization and all the needed stuff
   cd.doCoreCalc(safe,alEqDis);
@@ -933,12 +1088,18 @@ double RMSD::optimalAlignment_Fit(const  std::vector<double>  & align,
   RMSDCoreData cd(align,displace,positions,reference);
   // transfer the settings for the center to let the CoreCalc deal with it
   cd.setPositionsCenterIsRemoved(positions_center_is_removed);
-  if(positions_center_is_calculated) {cd.setPositionsCenter(positions_center);}
-  else {cd.calcPositionsCenter();};
+  if(positions_center_is_calculated) {
+    cd.setPositionsCenter(positions_center);
+  } else {
+    cd.calcPositionsCenter();
+  };
 
   cd.setReferenceCenterIsRemoved(reference_center_is_removed);
-  if(!reference_center_is_calculated) {cd.calcReferenceCenter();}
-  else {cd.setReferenceCenter(reference_center);}
+  if(!reference_center_is_calculated) {
+    cd.calcReferenceCenter();
+  } else {
+    cd.setReferenceCenter(reference_center);
+  }
 
   // Perform the diagonalization and all the needed stuff
   cd.doCoreCalc(safe,alEqDis);
@@ -979,8 +1140,16 @@ void RMSDCoreData::doCoreCalc(bool safe,bool alEqDis, bool only_rotation) {
 // This is positions*reference
   Tensor rr01;
 // center of mass managing: must subtract the center from the position or not?
-  Vector cp; cp.zero(); if(!cpositions_is_removed)cp=cpositions;
-  Vector cr; cr.zero(); if(!creference_is_removed)cr=creference;
+  Vector cp;
+  cp.zero();
+  if(!cpositions_is_removed) {
+    cp=cpositions;
+  }
+  Vector cr;
+  cr.zero();
+  if(!creference_is_removed) {
+    cr=creference;
+  }
 // second expensive loop: compute second moments wrt centers
   for(unsigned iat=0; iat<n; iat++) {
     double w=align[iat];
@@ -1038,16 +1207,21 @@ void RMSDCoreData::doCoreCalc(bool safe,bool alEqDis, bool only_rotation) {
     diagMatSym(m, eigenvals, eigenvecs );
     q=Vector4d(eigenvecs[0][0],eigenvecs[0][1],eigenvecs[0][2],eigenvecs[0][3]);
     double dq_dm[4][4][4];
-    for(unsigned i=0; i<4; i++) for(unsigned j=0; j<4; j++) for(unsigned k=0; k<4; k++) {
+    for(unsigned i=0; i<4; i++)
+      for(unsigned j=0; j<4; j++)
+        for(unsigned k=0; k<4; k++) {
           double tmp=0.0;
 // perturbation theory for matrix m
-          for(unsigned l=1; l<4; l++) tmp+=eigenvecs[l][j]*eigenvecs[l][i]/(eigenvals[0]-eigenvals[l])*eigenvecs[0][k];
+          for(unsigned l=1; l<4; l++) {
+            tmp+=eigenvecs[l][j]*eigenvecs[l][i]/(eigenvals[0]-eigenvals[l])*eigenvecs[0][k];
+          }
           dq_dm[i][j][k]=tmp;
         }
 // propagation to _drr01
     for(unsigned i=0; i<4; i++) {
       Tensor tmp;
-      for(unsigned j=0; j<4; j++) for(unsigned k=0; k<4; k++) {
+      for(unsigned j=0; j<4; j++)
+        for(unsigned k=0; k<4; k++) {
           tmp+=dq_dm[i][j][k]*dm_drr01[j][k];
         }
       dq_drr01[i]=tmp;
@@ -1056,7 +1230,9 @@ void RMSDCoreData::doCoreCalc(bool safe,bool alEqDis, bool only_rotation) {
     TensorGeneric<1,4> here_eigenvecs;
     VectorGeneric<1> here_eigenvals;
     diagMatSym(m, here_eigenvals, here_eigenvecs );
-    for(unsigned i=0; i<4; i++) eigenvecs[0][i]=here_eigenvecs[0][i];
+    for(unsigned i=0; i<4; i++) {
+      eigenvecs[0][i]=here_eigenvecs[0][i];
+    }
     eigenvals[0]=here_eigenvals[0];
     q=Vector4d(eigenvecs[0][0],eigenvecs[0][1],eigenvecs[0][2],eigenvecs[0][3]);
   }
@@ -1090,7 +1266,9 @@ void RMSDCoreData::doCoreCalc(bool safe,bool alEqDis, bool only_rotation) {
   d.resize(n);
 
   // calculate rotation matrix derivatives and components distances needed for components only when align!=displacement
-  if(!alEqDis)ddist_drotation.zero();
+  if(!alEqDis) {
+    ddist_drotation.zero();
+  }
   // This pragma leads to incorrect results with INTEL compiler.
   // Failures are seen in rt65-rmsd2, rt-close-structure, rt64-pca, and others.
   // Not really clear why. GB
@@ -1102,11 +1280,15 @@ void RMSDCoreData::doCoreCalc(bool safe,bool alEqDis, bool only_rotation) {
   }
   // ddist_drotation if needed
   if(!alEqDis or !only_rotation) {
-    for (unsigned iat=0; iat<n; iat++)
+    for (unsigned iat=0; iat<n; iat++) {
       ddist_drotation+=-2*displace[iat]*extProduct(d[iat],reference[iat]-cr);
+    }
 
     ddist_drr01.zero();
-    for(unsigned i=0; i<3; i++) for(unsigned j=0; j<3; j++) ddist_drr01+=ddist_drotation[i][j]*drotation_drr01[i][j];
+    for(unsigned i=0; i<3; i++)
+      for(unsigned j=0; j<3; j++) {
+        ddist_drr01+=ddist_drotation[i][j]*drotation_drr01[i][j];
+      }
   }
   // transfer this bools to the cd so that this settings will be reflected in the other calls
   this->alEqDis=alEqDis;
@@ -1117,17 +1299,23 @@ void RMSDCoreData::doCoreCalc(bool safe,bool alEqDis, bool only_rotation) {
 /// just retrieve the distance already calculated
 double RMSDCoreData::getDistance( bool squared) {
 
-  if(!isInitialized)plumed_merror("getDistance cannot calculate the distance without being initialized first by doCoreCalc ");
+  if(!isInitialized) {
+    plumed_merror("getDistance cannot calculate the distance without being initialized first by doCoreCalc ");
+  }
 
   double localDist=0.0;
   const unsigned n=static_cast<unsigned int>(reference.size());
-  if(safe || !alEqDis) localDist=0.0;
-  else
+  if(safe || !alEqDis) {
+    localDist=0.0;
+  } else {
     localDist=eigenvals[0]+rr00+rr11;
+  }
   #pragma omp simd reduction(+:localDist)
   for(unsigned iat=0; iat<n; iat++) {
     if(alEqDis) {
-      if(safe) localDist+=align[iat]*modulo2(d[iat]);
+      if(safe) {
+        localDist+=align[iat]*modulo2(d[iat]);
+      }
     } else {
       localDist+=displace[iat]*modulo2(d[iat]);
     }
@@ -1151,8 +1339,16 @@ void RMSDCoreData::doCoreCalcWithCloseStructure(bool safe,bool alEqDis, const Te
   d.resize(natoms);
 
   // center of mass managing: must subtract the center from the position or not?
-  Vector cp; cp.zero(); if(!cpositions_is_removed)cp=cpositions;
-  Vector cr; cr.zero(); if(!creference_is_removed)cr=creference;
+  Vector cp;
+  cp.zero();
+  if(!cpositions_is_removed) {
+    cp=cpositions;
+  }
+  Vector cr;
+  cr.zero();
+  if(!creference_is_removed) {
+    cr=creference;
+  }
   //distance = \sum_{n=0}^{N} w_n(x_n-cpos-R_{XY} R_{AY} a_n)^2
 
   Tensor rotation = matmul(rotationPosClose, rotationRefClose);
@@ -1170,8 +1366,9 @@ void RMSDCoreData::doCoreCalcWithCloseStructure(bool safe,bool alEqDis, const Te
       ddist_drxy += -2*displace[iat]*extProduct(matmul(d[iat], rotationRefClose), reference[iat]-cr);
     }
     for(unsigned i=0; i<3; i++)
-      for(unsigned j=0; j<3; j++)
+      for(unsigned j=0; j<3; j++) {
         ddist_drr01+=ddist_drxy[i][j]*drotationPosCloseDrr01[i][j];
+      }
   }
   this->alEqDis=alEqDis;
   this->safe=safe;
@@ -1184,10 +1381,16 @@ std::vector<Vector> RMSDCoreData::getDDistanceDPositions() {
   Vector ddist_dcpositions;
   derivatives.resize(n);
   double prefactor=1.0;
-  if(!distanceIsMSD) prefactor*=0.5/dist;
+  if(!distanceIsMSD) {
+    prefactor*=0.5/dist;
+  }
   plumed_massert(!retrieve_only_rotation,"You used  only_rotation=true in doCoreCalc therefore you cannot retrieve this information now");
-  if(!hasDistance)plumed_merror("getDPositionsDerivatives needs to calculate the distance via getDistance first !");
-  if(!isInitialized)plumed_merror("getDPositionsDerivatives needs to initialize the coreData first!");
+  if(!hasDistance) {
+    plumed_merror("getDPositionsDerivatives needs to calculate the distance via getDistance first !");
+  }
+  if(!isInitialized) {
+    plumed_merror("getDPositionsDerivatives needs to initialize the coreData first!");
+  }
   Vector csum;
   for(unsigned iat=0; iat<n; iat++) {
     if(alEqDis) {
@@ -1209,7 +1412,9 @@ std::vector<Vector> RMSDCoreData::getDDistanceDPositions() {
 
   if(!alEqDis)
     #pragma omp simd
-    for(unsigned iat=0; iat<n; iat++) {derivatives[iat]= prefactor*(derivatives[iat]+(ddist_dcpositions-csum)*align[iat]); }
+    for(unsigned iat=0; iat<n; iat++) {
+      derivatives[iat]= prefactor*(derivatives[iat]+(ddist_dcpositions-csum)*align[iat]);
+    }
 
   return derivatives;
 }
@@ -1220,12 +1425,18 @@ std::vector<Vector>  RMSDCoreData::getDDistanceDReference() {
   Vector ddist_dcreference;
   derivatives.resize(n);
   double prefactor=1.0;
-  if(!distanceIsMSD) prefactor*=0.5/dist;
+  if(!distanceIsMSD) {
+    prefactor*=0.5/dist;
+  }
   Vector csum;
 
   plumed_massert(!retrieve_only_rotation,"You used  only_rotation=true in doCoreCalc therefore you cannot retrieve this information now");
-  if(!hasDistance)plumed_merror("getDDistanceDReference needs to calculate the distance via getDistance first !");
-  if(!isInitialized)plumed_merror("getDDistanceDReference to initialize the coreData first!");
+  if(!hasDistance) {
+    plumed_merror("getDDistanceDReference needs to calculate the distance via getDistance first !");
+  }
+  if(!isInitialized) {
+    plumed_merror("getDDistanceDReference to initialize the coreData first!");
+  }
   // get the transpose rotation
   Tensor t_rotation=rotation.transpose();
   Tensor t_ddist_drr01=ddist_drr01.transpose();
@@ -1252,7 +1463,9 @@ std::vector<Vector>  RMSDCoreData::getDDistanceDReference() {
 
   if(!alEqDis)
     #pragma omp simd
-    for(unsigned iat=0; iat<n; iat++) {derivatives[iat]= prefactor*(derivatives[iat]+(ddist_dcreference-csum)*align[iat]);}
+    for(unsigned iat=0; iat<n; iat++) {
+      derivatives[iat]= prefactor*(derivatives[iat]+(ddist_dcreference-csum)*align[iat]);
+    }
 
   return derivatives;
 }
@@ -1264,12 +1477,18 @@ std::vector<Vector>  RMSDCoreData::getDDistanceDReferenceSOMA() {
   Vector ddist_dcreference;
   derivatives.resize(n);
   double prefactor=1.0;
-  if(!distanceIsMSD) prefactor*=0.5/dist;
+  if(!distanceIsMSD) {
+    prefactor*=0.5/dist;
+  }
   Vector csum,tmp1,tmp2;
 
   plumed_massert(!retrieve_only_rotation,"You used  only_rotation=true in doCoreCalc therefore you cannot retrieve this information now");
-  if(!hasDistance)plumed_merror("getDDistanceDReference needs to calculate the distance via getDistance first !");
-  if(!isInitialized)plumed_merror("getDDistanceDReference to initialize the coreData first!");
+  if(!hasDistance) {
+    plumed_merror("getDDistanceDReference needs to calculate the distance via getDistance first !");
+  }
+  if(!isInitialized) {
+    plumed_merror("getDDistanceDReference to initialize the coreData first!");
+  }
   // get the transpose rotation
   Tensor t_rotation=rotation.transpose();
 
@@ -1289,7 +1508,10 @@ std::vector<Vector>  RMSDCoreData::getDDistanceDReferenceSOMA() {
     }
   }
 
-  if(!alEqDis) for(unsigned iat=0; iat<n; iat++)derivatives[iat]=prefactor*(derivatives[iat]+ddist_dcreference*align[iat]);
+  if(!alEqDis)
+    for(unsigned iat=0; iat<n; iat++) {
+      derivatives[iat]=prefactor*(derivatives[iat]+ddist_dcreference*align[iat]);
+    }
 
   return derivatives;
 }
@@ -1305,17 +1527,31 @@ if inverseTransform=true then aligns the positions onto reference
 Matrix<std::vector<Vector> >  RMSDCoreData::getDRotationDPositions( bool inverseTransform ) {
   const unsigned n=static_cast<unsigned int>(reference.size());
   plumed_massert(!retrieve_only_rotation,"You used  only_rotation=true in doCoreCalc therefore you cannot retrieve this information now");
-  if(!isInitialized)plumed_merror("getDRotationDPosition to initialize the coreData first!");
+  if(!isInitialized) {
+    plumed_merror("getDRotationDPosition to initialize the coreData first!");
+  }
   Matrix<std::vector<Vector> > DRotDPos=Matrix<std::vector<Vector> >(3,3);
   // remember drotation_drr01 is Tensor drotation_drr01[3][3]
   //           (3x3 rot) (3x3 components of rr01)
   std::vector<Vector> v(n);
   Vector csum;
   // these below could probably be calculated in the main routine
-  Vector cp; cp.zero(); if(!cpositions_is_removed)cp=cpositions;
-  Vector cr; cr.zero(); if(!creference_is_removed)cr=creference;
-  for(unsigned iat=0; iat<n; iat++) csum+=(reference[iat]-cr)*align[iat];
-  for(unsigned iat=0; iat<n; iat++) v[iat]=(reference[iat]-cr-csum)*align[iat];
+  Vector cp;
+  cp.zero();
+  if(!cpositions_is_removed) {
+    cp=cpositions;
+  }
+  Vector cr;
+  cr.zero();
+  if(!creference_is_removed) {
+    cr=creference;
+  }
+  for(unsigned iat=0; iat<n; iat++) {
+    csum+=(reference[iat]-cr)*align[iat];
+  }
+  for(unsigned iat=0; iat<n; iat++) {
+    v[iat]=(reference[iat]-cr-csum)*align[iat];
+  }
   for(unsigned a=0; a<3; a++) {
     for(unsigned b=0; b<3; b++) {
       if(inverseTransform) {
@@ -1343,17 +1579,31 @@ if inverseTransform=true then aligns the positions onto reference
 Matrix<std::vector<Vector> >  RMSDCoreData::getDRotationDReference( bool inverseTransform ) {
   const unsigned n=static_cast<unsigned int>(reference.size());
   plumed_massert(!retrieve_only_rotation,"You used  only_rotation=true in doCoreCalc therefore you cannot retrieve this information now");
-  if(!isInitialized)plumed_merror("getDRotationDPositions to initialize the coreData first!");
+  if(!isInitialized) {
+    plumed_merror("getDRotationDPositions to initialize the coreData first!");
+  }
   Matrix<std::vector<Vector> > DRotDRef=Matrix<std::vector<Vector> >(3,3);
   // remember drotation_drr01 is Tensor drotation_drr01[3][3]
   //           (3x3 rot) (3x3 components of rr01)
   std::vector<Vector> v(n);
   Vector csum;
   // these below could probably be calculated in the main routine
-  Vector cp; cp.zero(); if(!cpositions_is_removed)cp=cpositions;
-  Vector cr; cr.zero(); if(!creference_is_removed)cr=creference;
-  for(unsigned iat=0; iat<n; iat++) csum+=(positions[iat]-cp)*align[iat];
-  for(unsigned iat=0; iat<n; iat++) v[iat]=(positions[iat]-cp-csum)*align[iat];
+  Vector cp;
+  cp.zero();
+  if(!cpositions_is_removed) {
+    cp=cpositions;
+  }
+  Vector cr;
+  cr.zero();
+  if(!creference_is_removed) {
+    cr=creference;
+  }
+  for(unsigned iat=0; iat<n; iat++) {
+    csum+=(positions[iat]-cp)*align[iat];
+  }
+  for(unsigned iat=0; iat<n; iat++) {
+    v[iat]=(positions[iat]-cp-csum)*align[iat];
+  }
 
   for(unsigned a=0; a<3; a++) {
     for(unsigned b=0; b<3; b++) {
@@ -1379,20 +1629,36 @@ std::vector<Vector> RMSDCoreData::getAlignedReferenceToPositions() {
   std::vector<Vector> alignedref;
   const unsigned n=static_cast<unsigned int>(reference.size());
   alignedref.resize(n);
-  if(!isInitialized)plumed_merror("getAlignedReferenceToPostions needs to initialize the coreData first!");
+  if(!isInitialized) {
+    plumed_merror("getAlignedReferenceToPostions needs to initialize the coreData first!");
+  }
   // avoid to calculate matrix element but use the sum of what you have
-  Vector cp; cp.zero(); if(!cpositions_is_removed)cp=cpositions;
-  for(unsigned iat=0; iat<n; iat++)alignedref[iat]=-d[iat]+positions[iat]-cp;
+  Vector cp;
+  cp.zero();
+  if(!cpositions_is_removed) {
+    cp=cpositions;
+  }
+  for(unsigned iat=0; iat<n; iat++) {
+    alignedref[iat]=-d[iat]+positions[iat]-cp;
+  }
   return alignedref;
 }
 std::vector<Vector> RMSDCoreData::getAlignedPositionsToReference() {
   std::vector<Vector> alignedpos;
-  if(!isInitialized)plumed_merror("getAlignedPostionsToReference needs to initialize the coreData first!");
+  if(!isInitialized) {
+    plumed_merror("getAlignedPostionsToReference needs to initialize the coreData first!");
+  }
   const unsigned n=static_cast<unsigned int>(positions.size());
   alignedpos.resize(n);
-  Vector cp; cp.zero(); if(!cpositions_is_removed)cp=cpositions;
+  Vector cp;
+  cp.zero();
+  if(!cpositions_is_removed) {
+    cp=cpositions;
+  }
   // avoid to calculate matrix element but use the sum of what you have
-  for(unsigned iat=0; iat<n; iat++)alignedpos[iat]=matmul(rotation.transpose(),positions[iat]-cp);
+  for(unsigned iat=0; iat<n; iat++) {
+    alignedpos[iat]=matmul(rotation.transpose(),positions[iat]-cp);
+  }
   return alignedpos;
 }
 
@@ -1401,9 +1667,13 @@ std::vector<Vector> RMSDCoreData::getCenteredPositions() {
   std::vector<Vector> centeredpos;
   const unsigned n=static_cast<unsigned int>(reference.size());
   centeredpos.resize(n);
-  if(!isInitialized)plumed_merror("getCenteredPositions needs to initialize the coreData first!");
+  if(!isInitialized) {
+    plumed_merror("getCenteredPositions needs to initialize the coreData first!");
+  }
   // avoid to calculate matrix element but use the sum of what you have
-  for(unsigned iat=0; iat<n; iat++)centeredpos[iat]=positions[iat]-cpositions;
+  for(unsigned iat=0; iat<n; iat++) {
+    centeredpos[iat]=positions[iat]-cpositions;
+  }
   return centeredpos;
 }
 
@@ -1411,36 +1681,54 @@ std::vector<Vector> RMSDCoreData::getCenteredReference() {
   std::vector<Vector> centeredref;
   const unsigned n=static_cast<unsigned int>(reference.size());
   centeredref.resize(n);
-  if(!isInitialized)plumed_merror("getCenteredReference needs to initialize the coreData first!");
+  if(!isInitialized) {
+    plumed_merror("getCenteredReference needs to initialize the coreData first!");
+  }
   // avoid to calculate matrix element but use the sum of what you have
-  Vector cr; cr.zero(); if(!creference_is_removed)cr=creference;
-  for(unsigned iat=0; iat<n; iat++)centeredref[iat]=reference[iat]-cr;
+  Vector cr;
+  cr.zero();
+  if(!creference_is_removed) {
+    cr=creference;
+  }
+  for(unsigned iat=0; iat<n; iat++) {
+    centeredref[iat]=reference[iat]-cr;
+  }
   return centeredref;
 }
 
 
 Vector RMSDCoreData::getPositionsCenter() {
-  if(!isInitialized)plumed_merror("getCenteredPositions needs to initialize the coreData first!");
+  if(!isInitialized) {
+    plumed_merror("getCenteredPositions needs to initialize the coreData first!");
+  }
   return cpositions;
 }
 
 Vector RMSDCoreData::getReferenceCenter() {
-  if(!isInitialized)plumed_merror("getCenteredPositions needs to initialize the coreData first!");
+  if(!isInitialized) {
+    plumed_merror("getCenteredPositions needs to initialize the coreData first!");
+  }
   return creference;
 }
 
 Tensor RMSDCoreData::getRotationMatrixReferenceToPositions() {
-  if(!isInitialized)plumed_merror("getRotationMatrixReferenceToPositions needs to initialize the coreData first!");
+  if(!isInitialized) {
+    plumed_merror("getRotationMatrixReferenceToPositions needs to initialize the coreData first!");
+  }
   return rotation;
 }
 
 Tensor RMSDCoreData::getRotationMatrixPositionsToReference() {
-  if(!isInitialized)plumed_merror("getRotationMatrixReferenceToPositions needs to initialize the coreData first!");
+  if(!isInitialized) {
+    plumed_merror("getRotationMatrixReferenceToPositions needs to initialize the coreData first!");
+  }
   return rotation.transpose();
 }
 
 const std::array<std::array<Tensor,3>,3> &  RMSDCoreData::getDRotationDRr01() const {
-  if(!isInitialized)plumed_merror("getDRotationDRr01 needs to initialize the coreData first!");
+  if(!isInitialized) {
+    plumed_merror("getDRotationDRr01 needs to initialize the coreData first!");
+  }
   return drotation_drr01;
 }
 
diff --git a/src/tools/RMSD.h b/src/tools/RMSD.h
index b83524fc7b..17ad516955 100644
--- a/src/tools/RMSD.h
+++ b/src/tools/RMSD.h
@@ -61,8 +61,7 @@ val=rmsd.calculate(getPositions(),derivs,true);
 
 **/
 
-class RMSD
-{
+class RMSD {
   enum AlignmentMethod {SIMPLE, OPTIMAL, OPTIMAL_FAST};
   AlignmentMethod alignmentMethod;
 // Reference coordinates
@@ -82,18 +81,28 @@ class RMSD
 // calculates the center from the position provided
   Vector calculateCenter(const std::vector<Vector> &p,const std::vector<double> &w) {
     plumed_massert(p.size()==w.size(),"mismatch in dimension of position/align arrays while calculating the center");
-    unsigned n; n=p.size();
-    Vector c; c.zero();
-    for(unsigned i=0; i<n; i++)c+=p[i]*w[i];
+    unsigned n;
+    n=p.size();
+    Vector c;
+    c.zero();
+    for(unsigned i=0; i<n; i++) {
+      c+=p[i]*w[i];
+    }
     return c;
   };
 // removes the center for the position provided
   void removeCenter(std::vector<Vector> &p, const Vector &c) {
-    unsigned n; n=p.size();
-    for(unsigned i=0; i<n; i++)p[i]-=c;
+    unsigned n;
+    n=p.size();
+    for(unsigned i=0; i<n; i++) {
+      p[i]-=c;
+    }
   };
 // add center
-  void addCenter(std::vector<Vector> &p, const Vector &c) {Vector cc=c*-1.; removeCenter(p,cc);};
+  void addCenter(std::vector<Vector> &p, const Vector &c) {
+    Vector cc=c*-1.;
+    removeCenter(p,cc);
+  };
 
 public:
 /// Constructor
@@ -250,17 +259,22 @@ class RMSD
 /// static convenience method to get the matrix i,a from drotdpos (which is a bit tricky)
   static  Tensor getMatrixFromDRot(const Matrix< std::vector<Vector> > &drotdpos, const unsigned &i, const unsigned &a) {
     Tensor t;
-    t[0][0]=drotdpos(0,0)[i][a]; t[0][1]=drotdpos(0,1)[i][a]; t[0][2]=drotdpos(0,2)[i][a];
-    t[1][0]=drotdpos(1,0)[i][a]; t[1][1]=drotdpos(1,1)[i][a]; t[1][2]=drotdpos(1,2)[i][a];
-    t[2][0]=drotdpos(2,0)[i][a]; t[2][1]=drotdpos(2,1)[i][a]; t[2][2]=drotdpos(2,2)[i][a];
+    t[0][0]=drotdpos(0,0)[i][a];
+    t[0][1]=drotdpos(0,1)[i][a];
+    t[0][2]=drotdpos(0,2)[i][a];
+    t[1][0]=drotdpos(1,0)[i][a];
+    t[1][1]=drotdpos(1,1)[i][a];
+    t[1][2]=drotdpos(1,2)[i][a];
+    t[2][0]=drotdpos(2,0)[i][a];
+    t[2][1]=drotdpos(2,1)[i][a];
+    t[2][2]=drotdpos(2,2)[i][a];
     return t;
   };
 };
 
 /// this is a class which is needed to share information across the various non-threadsafe routines
 /// so that the public function of rmsd are threadsafe while the inner core can safely share information
-class RMSDCoreData
-{
+class RMSDCoreData {
 private:
   bool alEqDis;
   bool distanceIsMSD; // default is RMSD but can deliver the MSD
@@ -308,28 +322,54 @@ class RMSDCoreData
   RMSDCoreData(const std::vector<double> &a,const std::vector<double> &d,const std::vector<Vector> &p, const std::vector<Vector> &r):
     alEqDis(false),distanceIsMSD(false),hasDistance(false),isInitialized(false),safe(false),
     creference_is_calculated(false),creference_is_removed(false),
-    cpositions_is_calculated(false),cpositions_is_removed(false),retrieve_only_rotation(false),positions(p),reference(r),align(a),displace(d),dist(0.0),rr00(0.0),rr11(0.0)
-  {cpositions.zero(); creference.zero();};
+    cpositions_is_calculated(false),cpositions_is_removed(false),retrieve_only_rotation(false),positions(p),reference(r),align(a),displace(d),dist(0.0),rr00(0.0),rr11(0.0) {
+    cpositions.zero();
+    creference.zero();
+  };
 
   // set the center on the fly without subtracting
   void calcPositionsCenter() {
     plumed_massert(!cpositions_is_calculated,"the center was already calculated");
-    cpositions.zero(); for(unsigned i=0; i<positions.size(); i++) {cpositions+=positions[i]*align[i];} cpositions_is_calculated=true;
+    cpositions.zero();
+    for(unsigned i=0; i<positions.size(); i++) {
+      cpositions+=positions[i]*align[i];
+    }
+    cpositions_is_calculated=true;
   }
   void calcReferenceCenter() {
     plumed_massert(!creference_is_calculated,"the center was already calculated");
-    creference.zero(); for(unsigned i=0; i<reference.size(); i++) {creference+=reference[i]*align[i];} creference_is_calculated=true;
+    creference.zero();
+    for(unsigned i=0; i<reference.size(); i++) {
+      creference+=reference[i]*align[i];
+    }
+    creference_is_calculated=true;
   };
   // assume the center is given externally
   // cppcheck-suppress passedByValue
-  void setPositionsCenter(Vector v) {plumed_massert(!cpositions_is_calculated,"You are setting the center two times!"); cpositions=v; cpositions_is_calculated=true;};
+  void setPositionsCenter(Vector v) {
+    plumed_massert(!cpositions_is_calculated,"You are setting the center two times!");
+    cpositions=v;
+    cpositions_is_calculated=true;
+  };
   // cppcheck-suppress passedByValue
-  void setReferenceCenter(Vector v) {plumed_massert(!creference_is_calculated,"You are setting the center two times!"); creference=v; creference_is_calculated=true;};
+  void setReferenceCenter(Vector v) {
+    plumed_massert(!creference_is_calculated,"You are setting the center two times!");
+    creference=v;
+    creference_is_calculated=true;
+  };
   // the center is already removed
-  void setPositionsCenterIsRemoved(bool t) {cpositions_is_removed=t;};
-  void setReferenceCenterIsRemoved(bool t) {creference_is_removed=t;};
-  bool getPositionsCenterIsRemoved() {return cpositions_is_removed;};
-  bool getReferenceCenterIsRemoved() {return creference_is_removed;};
+  void setPositionsCenterIsRemoved(bool t) {
+    cpositions_is_removed=t;
+  };
+  void setReferenceCenterIsRemoved(bool t) {
+    creference_is_removed=t;
+  };
+  bool getPositionsCenterIsRemoved() {
+    return cpositions_is_removed;
+  };
+  bool getReferenceCenterIsRemoved() {
+    return creference_is_removed;
+  };
   //  does the core calc : first thing to call after the constructor:
   // only_rotation=true does not retrieve the derivatives, just retrieve the optimal rotation (the same calc cannot be exploit further)
   void doCoreCalc(bool safe,bool alEqDis, bool only_rotation=false);
diff --git a/src/tools/Random.cpp b/src/tools/Random.cpp
index a9717ed6d8..952115effd 100644
--- a/src/tools/Random.cpp
+++ b/src/tools/Random.cpp
@@ -43,30 +43,32 @@ Random::Random(const std::string & name):
 // In practice: without this it is not possible to declare
 // a static Random object without enforcing the order of the
 // static constructors.
-  name(&name!=&noname?name:"noname")
-{
+  name(&name!=&noname?name:"noname") {
   iy=0;
-  for(unsigned i=0; i<NTAB; i++) iv[i]=0;
+  for(unsigned i=0; i<NTAB; i++) {
+    iv[i]=0;
+  }
   setSeed(0);
 }
 
 void Random::setSeed(int idum_) {
-  if(idum_>0) idum_=-idum_;
+  if(idum_>0) {
+    idum_=-idum_;
+  }
   idum=idum_;
   incPrec=false;
 }
 
-double Random::RandU01 ()
-{
-  if (incPrec)
+double Random::RandU01 () {
+  if (incPrec) {
     return U01d();
-  else
+  } else {
     return U01();
+  }
 }
 
 
-double Random::U01d ()
-{
+double Random::U01d () {
   double u;
   u = U01();
   u += U01() * fact;
@@ -77,24 +79,36 @@ double Random::U01() {
   int j,k;
   double temp;
   if (idum <= 0 || !iy) {
-    if (-idum < 1) idum=1;
-    else idum = -idum;
+    if (-idum < 1) {
+      idum=1;
+    } else {
+      idum = -idum;
+    }
     for (j=NTAB+7; j>=0; j--) {
       k=idum/IQ;
       idum=IA*(idum-k*IQ)-IR*k;
-      if (idum < 0) idum += IM;
-      if (j < NTAB) iv[j] = idum;
+      if (idum < 0) {
+        idum += IM;
+      }
+      if (j < NTAB) {
+        iv[j] = idum;
+      }
     }
     iy=iv[0];
   }
   k=idum/IQ;
   idum=IA*(idum-k*IQ)-IR*k;
-  if (idum < 0) idum += IM;
+  if (idum < 0) {
+    idum += IM;
+  }
   j=iy/NDIV;
   iy=iv[j];
   iv[j] = idum;
-  if ((temp=AM*iy) > RNMX) return RNMX;
-  else return temp;
+  if ((temp=AM*iy) > RNMX) {
+    return RNMX;
+  } else {
+    return temp;
+  }
 }
 
 void Random::WriteStateFull(std::ostream & out)const {
@@ -111,7 +125,9 @@ void Random::WriteStateFull(std::ostream & out)const {
 void Random::ReadStateFull (std::istream & in) {
   getline(in,name);
   in>>idum>>iy;
-  for (int i = 0; i < NTAB; i++) in>>iv[i];
+  for (int i = 0; i < NTAB; i++) {
+    in>>iv[i];
+  }
   in>>switchGaussian;
   in>>saveGaussian;
 }
@@ -127,10 +143,15 @@ void Random::toString(std::string & str)const {
 
 void Random::fromString(const std::string & str) {
   std::string s=str;
-  for(unsigned i=0; i<s.length(); i++) if(s[i]=='|') s[i]=' ';
+  for(unsigned i=0; i<s.length(); i++)
+    if(s[i]=='|') {
+      s[i]=' ';
+    }
   std::istringstream istr(s.c_str());
   istr>>idum>>iy;
-  for (int i = 0; i < NTAB; i++) istr>>iv[i];
+  for (int i = 0; i < NTAB; i++) {
+    istr>>iv[i];
+  }
 }
 
 // This allows to have the same stream of random numbers
@@ -149,7 +170,9 @@ double Random::Gaussian() {
     v1=2.0*RandU01()-1.0;
     v2=2.0*RandU01()-1.0;
     rsq=v1*v1+v2*v2;
-    if(rsq<1.0 && rsq>0.0) break;
+    if(rsq<1.0 && rsq>0.0) {
+      break;
+    }
   }
   double fac=std::sqrt(-2.*std::log(rsq)/rsq);
   saveGaussian=v1*fac;
diff --git a/src/tools/Random.h b/src/tools/Random.h
index 279a8a7c3d..573e575539 100644
--- a/src/tools/Random.h
+++ b/src/tools/Random.h
@@ -57,13 +57,17 @@ class Random {
   void fromString(const std::string & str);
   void toString(std::string & str)const;
   friend std::ostream & operator<<(std::ostream & out,const Random & rng) {
-    rng.WriteStateFull(out); return out;
+    rng.WriteStateFull(out);
+    return out;
   }
   friend std::istream & operator>>(std::istream & in,Random & rng) {
-    rng.ReadStateFull(in); return in;
+    rng.ReadStateFull(in);
+    return in;
   }
   double Gaussian();
-  void IncreasedPrecis(bool i) {incPrec=i;}
+  void IncreasedPrecis(bool i) {
+    incPrec=i;
+  }
 };
 
 }
diff --git a/src/tools/RootFindingBase.h b/src/tools/RootFindingBase.h
index 7a097f9bfb..750b05210e 100644
--- a/src/tools/RootFindingBase.h
+++ b/src/tools/RootFindingBase.h
@@ -54,7 +54,9 @@ void RootFindingBase<FCLASS>::doSearch( const std::vector<double>& dir, std::vec
   double ax=0.0, xx=1.0;
   bb.bracket( ax, xx, &F1dim<FCLASS>::getEng );
   double xmin=bb.search( &F1dim<FCLASS>::getEng );
-  for(unsigned i=0; i<p.size(); ++i) p[i] += xmin*dir[i];
+  for(unsigned i=0; i<p.size(); ++i) {
+    p[i] += xmin*dir[i];
+  }
 }
 
 template <class FCLASS>
diff --git a/src/tools/Stopwatch.cpp b/src/tools/Stopwatch.cpp
index 84d6fa25bc..22f791ae71 100644
--- a/src/tools/Stopwatch.cpp
+++ b/src/tools/Stopwatch.cpp
@@ -42,7 +42,9 @@ Stopwatch::~Stopwatch() {
 // this is necessary e.g. to make sure the main watch present in PlumedMain
 // is stopped correctly.
     for(auto & w : watches) {
-      if(w.second.state==Watch::State::paused) w.second.start().stop();
+      if(w.second.state==Watch::State::paused) {
+        w.second.start().stop();
+      }
     }
     *mylog << *this;
   }
@@ -52,11 +54,15 @@ std::ostream& Stopwatch::log(std::ostream&os)const {
   const std::size_t bufferlen=1000;
   char buffer[bufferlen];
   buffer[0]=0;
-  for(unsigned i=0; i<40; i++) os<<" ";
+  for(unsigned i=0; i<40; i++) {
+    os<<" ";
+  }
   os<<"      Cycles        Total      Average      Minimum      Maximum\n";
 
   std::vector<std::string> names;
-  for(const auto & it : watches) names.emplace_back(it.first);
+  for(const auto & it : watches) {
+    names.emplace_back(it.first);
+  }
   std::sort(names.begin(),names.end());
 
   const double frac=1.0/1000000000.0;
@@ -64,7 +70,9 @@ std::ostream& Stopwatch::log(std::ostream&os)const {
   for(const auto & name : names) {
     const Watch&t(watches.find(name)->second);
     os<<name;
-    for(unsigned i=name.length(); i<40; i++) os<<" ";
+    for(unsigned i=name.length(); i<40; i++) {
+      os<<" ";
+    }
     std::snprintf(buffer,bufferlen,"%12u %12.6f %12.6f %12.6f %12.6f\n", t.cycles, frac*t.total, frac*t.total/t.cycles, frac*t.min,frac*t.max);
     os<<buffer;
   }
diff --git a/src/tools/Stopwatch.h b/src/tools/Stopwatch.h
index 2e22827fe8..43eea8a744 100644
--- a/src/tools/Stopwatch.h
+++ b/src/tools/Stopwatch.h
@@ -305,16 +305,18 @@ class Stopwatch {
 inline
 Stopwatch::Handler::Handler(Watch* watch,bool stop) :
   watch(watch),
-  stop(stop)
-{
+  stop(stop) {
   watch->start();
 }
 
 inline
 Stopwatch::Handler::~Handler() {
   if(watch) {
-    if(stop) watch->stop();
-    else watch->pause();
+    if(stop) {
+      watch->stop();
+    } else {
+      watch->pause();
+    }
   }
 }
 
@@ -359,8 +361,7 @@ long long int Stopwatch::getTotal(const std::string_view&name) {
 inline
 Stopwatch::Handler::Handler(Handler && handler) noexcept :
   watch(handler.watch),
-  stop(handler.stop)
-{
+  stop(handler.stop) {
   handler.watch=nullptr;
 }
 
@@ -369,8 +370,11 @@ Stopwatch::Handler & Stopwatch::Handler::operator=(Handler && handler) noexcept
   if(this!=&handler) {
     if(watch) {
       try {
-        if(stop) watch->stop();
-        else watch->pause();
+        if(stop) {
+          watch->stop();
+        } else {
+          watch->pause();
+        }
       } catch(...) {
 // this is to avoid problems with cppcheck, given than this method is declared as
 // noexcept and stop and pause might throw in case of an internal bug
@@ -398,8 +402,12 @@ Stopwatch::Watch & Stopwatch::Watch::stop() {
   state=State::stopped;
   cycles++;
   total+=lap;
-  if(lap>max)max=lap;
-  if(min>lap || cycles==1)min=lap;
+  if(lap>max) {
+    max=lap;
+  }
+  if(min>lap || cycles==1) {
+    min=lap;
+  }
   lastLap=lap;
   lap=0;
   return *this;
@@ -415,7 +423,9 @@ Stopwatch::Watch & Stopwatch::Watch::pause() {
   running--;
 // notice: with exception safety the following might be converted to a plain error.
 // I leave it like this for now:
-  if(running!=0) return *this;
+  if(running!=0) {
+    return *this;
+  }
   auto t=std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now()-lastStart);
   lap+=t.count();
   return *this;
@@ -444,8 +454,7 @@ long long int Stopwatch::Watch::getTotal() noexcept {
 inline
 Stopwatch::Stopwatch(Stopwatch&& other) noexcept:
   mylog(other.mylog),
-  watches(std::move(other.watches))
-{
+  watches(std::move(other.watches)) {
   other.mylog=nullptr;
 }
 
diff --git a/src/tools/Subprocess.cpp b/src/tools/Subprocess.cpp
index f156b830af..280c32e1d9 100644
--- a/src/tools/Subprocess.cpp
+++ b/src/tools/Subprocess.cpp
@@ -44,19 +44,22 @@ class SubprocessPid {
 public:
   const pid_t pid;
   explicit SubprocessPid(pid_t pid):
-    pid(pid)
-  {
+    pid(pid) {
     plumed_assert(pid!=0 && pid!=-1);
   }
   void stop() noexcept {
     // Signals give problems with MPI on Travis.
     // I disable them for now.
-    if(SubprocessPidGetenvSignals()) kill(pid,SIGSTOP);
+    if(SubprocessPidGetenvSignals()) {
+      kill(pid,SIGSTOP);
+    }
   }
   void cont() noexcept {
     // Signals give problems with MPI on Travis.
     // I disable them for now.
-    if(SubprocessPidGetenvSignals()) kill(pid,SIGCONT);
+    if(SubprocessPidGetenvSignals()) {
+      kill(pid,SIGCONT);
+    }
   }
   ~SubprocessPid() {
     // the destructor implies we do not need the subprocess anymore, so SIGKILL
@@ -83,30 +86,49 @@ Subprocess::Subprocess(const std::string & cmd) {
   };
   int cp[2];
   int pc[2];
-  if(pipe(pc)<0) plumed_error()<<"error creating parent to child pipe";
-  if(pipe(cp)<0) plumed_error()<<"error creating child to parent pipe";
+  if(pipe(pc)<0) {
+    plumed_error()<<"error creating parent to child pipe";
+  }
+  if(pipe(cp)<0) {
+    plumed_error()<<"error creating child to parent pipe";
+  }
   pid_t pid=fork();
   switch(pid) {
   case -1:
     plumed_error()<<"error forking";
     break;
 // CHILD:
-  case 0:
-  {
-    if(close(1)<0) plumed_error()<<"error closing file";
-    if(dup(cp[1])<0) plumed_error()<<"error duplicating file";
-    if(close(0)<0) plumed_error()<<"error closing file";
-    if(dup(pc[0])<0) plumed_error()<<"error duplicating file";
-    if(close(pc[1])<0) plumed_error()<<"error closing file";
-    if(close(cp[0])<0) plumed_error()<<"error closing file";
+  case 0: {
+    if(close(1)<0) {
+      plumed_error()<<"error closing file";
+    }
+    if(dup(cp[1])<0) {
+      plumed_error()<<"error duplicating file";
+    }
+    if(close(0)<0) {
+      plumed_error()<<"error closing file";
+    }
+    if(dup(pc[0])<0) {
+      plumed_error()<<"error duplicating file";
+    }
+    if(close(pc[1])<0) {
+      plumed_error()<<"error closing file";
+    }
+    if(close(cp[0])<0) {
+      plumed_error()<<"error closing file";
+    }
     auto err=execv(arr[0],arr);
     plumed_error()<<"error in script file " << cmd << ", execv returned "<<err;
   }
 // PARENT::
   default:
     this->pid=Tools::make_unique<SubprocessPid>(pid);
-    if(close(pc[0])<0) plumed_error()<<"error closing file";
-    if(close(cp[1])<0) plumed_error()<<"error closing file";
+    if(close(pc[0])<0) {
+      plumed_error()<<"error closing file";
+    }
+    if(close(cp[1])<0) {
+      plumed_error()<<"error closing file";
+    }
     fpc=pc[1];
     fcp=cp[0];
     fppc=fdopen(fpc,"w");
@@ -159,29 +181,33 @@ void Subprocess::flush() {
 
 Subprocess & Subprocess::getline(std::string & line) {
   child_to_parent.getline(line);
-  if(!child_to_parent) plumed_error() <<"error reading subprocess";
+  if(!child_to_parent) {
+    plumed_error() <<"error reading subprocess";
+  }
   return (*this);
 }
 
 Subprocess::Handler::Handler(Subprocess *sp) noexcept:
-  sp(sp)
-{
+  sp(sp) {
   sp->cont();
 }
 
 Subprocess::Handler::~Handler() {
-  if(sp) sp->stop();
+  if(sp) {
+    sp->stop();
+  }
 }
 
 Subprocess::Handler::Handler(Handler && handler) noexcept :
-  sp(handler.sp)
-{
+  sp(handler.sp) {
   handler.sp=nullptr;
 }
 
 Subprocess::Handler & Subprocess::Handler::operator=(Handler && handler) noexcept {
   if(this!=&handler) {
-    if(sp) sp->stop();
+    if(sp) {
+      sp->stop();
+    }
     sp=handler.sp;
     handler.sp=nullptr;
   }
diff --git a/src/tools/SwitchingFunction.cpp b/src/tools/SwitchingFunction.cpp
index 99cf034a1f..a3f96b6bc0 100644
--- a/src/tools/SwitchingFunction.cpp
+++ b/src/tools/SwitchingFunction.cpp
@@ -221,10 +221,18 @@ double baseSwitch::calculateSqr(double distance2,double&dfunc) const {
   double res= calculate(std::sqrt(distance2),dfunc);//RVO!
   return res;
 }
-double baseSwitch::get_d0() const {return d0;}
-double baseSwitch::get_r0() const {return 1.0/invr0;}
-double baseSwitch::get_dmax() const {return dmax;}
-double baseSwitch::get_dmax2() const {return dmax_2;}
+double baseSwitch::get_d0() const {
+  return d0;
+}
+double baseSwitch::get_r0() const {
+  return 1.0/invr0;
+}
+double baseSwitch::get_dmax() const {
+  return dmax;
+}
+double baseSwitch::get_dmax2() const {
+  return dmax_2;
+}
 std::string baseSwitch::description() const {
   std::ostringstream ostr;
   ostr<<get_r0()
@@ -234,7 +242,9 @@ std::string baseSwitch::description() const {
       << specificDescription();
   return ostr.str();
 }
-std::string baseSwitch::specificDescription() const {return "";}
+std::string baseSwitch::specificDescription() const {
+  return "";
+}
 void baseSwitch::setupStretch() {
   if(dmax!=std::numeric_limits<double>::max()) {
     stretch=1.0;
@@ -322,7 +332,13 @@ class rational : public baseSwitch {
   rational(double D0,double DMAX, double R0, int N, int M)
     :baseSwitch(D0,DMAX,R0,"rational"),
      nn(N),
-     mm([](int m,int n) {if (m==0) {return n*2;} else {return m;}}(M,N)),
+     mm([](int m,int n) {
+    if (m==0) {
+      return n*2;
+    } else {
+      return m;
+    }
+  }(M,N)),
   preRes(static_cast<double>(nn)/mm),
   preDfunc(0.5*nn*(nn-mm)/static_cast<double>(mm)),
   //wolfram <3:lim_(x->1) d^2/(dx^2) (1 - x^N)/(1 - x^M) = (N (M^2 - 3 M (-1 + N) + N (-3 + 2 N)))/(6 M)
@@ -581,7 +597,9 @@ class nativeqSwitch: public baseSwitch {
     ostr<<" beta="<<beta<<" lambda="<<lambda<<" ref="<<ref;
     return ostr.str();
   }
-  inline double function(const double rdist,double&dfunc) const override {return 0.0;  }
+  inline double function(const double rdist,double&dfunc) const override {
+    return 0.0;
+  }
 public:
   nativeqSwitch(double D0, double DMAX, double R0, double BETA, double LAMBDA,double REF)
     :  baseSwitch(D0,DMAX,R0,"nativeq"),beta(BETA),lambda(LAMBDA),ref(REF) {}
@@ -758,7 +776,9 @@ class leptonSwitch: public baseSwitch {
     ostr<<" func=" << lepton_func;
     return ostr.str();
   }
-  inline double function(const double,double&) const override {return 0.0;}
+  inline double function(const double,double&) const override {
+    return 0.0;
+  }
 public:
   leptonSwitch(double D0, double DMAX, double R0, const std::string & func)
     :baseSwitch(D0,DMAX,R0,"lepton"),
@@ -852,8 +872,9 @@ void SwitchingFunction::set(const std::string & definition,std::string& errormsg
   dostretch=true;
   bool dontstretch=false;
   Tools::parseFlag(data,"NOSTRETCH",dontstretch); // this is ignored now
-  if(dontstretch)
+  if(dontstretch) {
     dostretch=false;
+  }
   if(name=="CUBIC") {
     //cubic is the only switch type that only uses d0 and dmax
     function = PLMD::Tools::make_unique<switchContainers::cubicSwitch>(d0,dmax);
@@ -910,7 +931,9 @@ void SwitchingFunction::set(const std::string & definition,std::string& errormsg
 
   if( !data.empty() ) {
     errormsg="found the following rogue keywords in switching function input : ";
-    for(unsigned i=0; i<data.size(); ++i) errormsg = errormsg + data[i] + " ";
+    for(unsigned i=0; i<data.size(); ++i) {
+      errormsg = errormsg + data[i] + " ";
+    }
   }
 
   if(dostretch && dmax!=std::numeric_limits<double>::max()) {
diff --git a/src/tools/Tensor.h b/src/tools/Tensor.h
index a4f53c8a9b..4ed456b3d7 100644
--- a/src/tools/Tensor.h
+++ b/src/tools/Tensor.h
@@ -85,8 +85,7 @@ int main(){
 */
 template <unsigned n,unsigned m>
 class TensorGeneric:
-  public MatrixSquareBracketsAccess<TensorGeneric<n,m>,double>
-{
+  public MatrixSquareBracketsAccess<TensorGeneric<n,m>,double> {
   std::array<double,n*m> d;
 /// Auxiliary private function for constructor
   void auxiliaryConstructor();
@@ -212,16 +211,14 @@ void TensorGeneric<n,m>::auxiliaryConstructor()
 
 template <unsigned n,unsigned m>
 template<typename... Args>
-void TensorGeneric<n,m>::auxiliaryConstructor(double first,Args... arg)
-{
+void TensorGeneric<n,m>::auxiliaryConstructor(double first,Args... arg) {
   d[n*m-(sizeof...(Args))-1]=first;
   auxiliaryConstructor(arg...);
 }
 
 template <unsigned n,unsigned m>
 template<typename... Args>
-TensorGeneric<n,m>::TensorGeneric(double first,Args... arg)
-{
+TensorGeneric<n,m>::TensorGeneric(double first,Args... arg) {
   static_assert((sizeof...(Args))+1==n*m,"you are trying to initialize a Tensor with the wrong number of arguments");
   auxiliaryConstructor(first,arg...);
 }
@@ -233,7 +230,10 @@ TensorGeneric<n,m>::TensorGeneric() {
 
 template<unsigned n,unsigned m>
 TensorGeneric<n,m>::TensorGeneric(const VectorGeneric<n>&v1,const VectorGeneric<m>&v2) {
-  for(unsigned i=0; i<n; i++)for(unsigned j=0; j<m; j++)d[i*m+j]=v1[i]*v2[j];
+  for(unsigned i=0; i<n; i++)
+    for(unsigned j=0; j<m; j++) {
+      d[i*m+j]=v1[i]*v2[j];
+    }
 }
 
 template<unsigned n,unsigned m>
@@ -297,27 +297,35 @@ TensorGeneric<n,m> TensorGeneric<n,m>::operator-()const {
 
 template<unsigned n,unsigned m>
 TensorGeneric<n,m>& TensorGeneric<n,m>::setCol(unsigned j,const VectorGeneric<n> & c) {
-  for(unsigned i=0; i<n; ++i) (*this)(i,j)=c(i);
+  for(unsigned i=0; i<n; ++i) {
+    (*this)(i,j)=c(i);
+  }
   return *this;
 }
 
 template<unsigned n,unsigned m>
 TensorGeneric<n,m>& TensorGeneric<n,m>::setRow(unsigned i,const VectorGeneric<m> & r) {
-  for(unsigned j=0; j<m; ++j) (*this)(i,j)=r(j);
+  for(unsigned j=0; j<m; ++j) {
+    (*this)(i,j)=r(j);
+  }
   return *this;
 }
 
 template<unsigned n,unsigned m>
 VectorGeneric<n> TensorGeneric<n,m>::getCol(unsigned j)const {
   VectorGeneric<n> v;
-  for(unsigned i=0; i<n; ++i) v(i)=(*this)(i,j);
+  for(unsigned i=0; i<n; ++i) {
+    v(i)=(*this)(i,j);
+  }
   return v;
 }
 
 template<unsigned n,unsigned m>
 VectorGeneric<m> TensorGeneric<n,m>::getRow(unsigned i)const {
   VectorGeneric<m> v;
-  for(unsigned j=0; j<m; ++j) v(j)=(*this)(i,j);
+  for(unsigned j=0; j<m; ++j) {
+    v(j)=(*this)(i,j);
+  }
   return v;
 }
 
@@ -368,14 +376,19 @@ template<unsigned n,unsigned m>
 inline
 TensorGeneric<n,n> TensorGeneric<n,m>::identity() {
   TensorGeneric<n,n> t;
-  for(unsigned i=0; i<n; i++) t(i,i)=1.0;
+  for(unsigned i=0; i<n; i++) {
+    t(i,i)=1.0;
+  }
   return t;
 }
 
 template<unsigned n,unsigned m>
 TensorGeneric<m,n> TensorGeneric<n,m>::transpose()const {
   TensorGeneric<m,n> t;
-  for(unsigned i=0; i<m; i++)for(unsigned j=0; j<n; j++) t(i,j)=(*this)(j,i);
+  for(unsigned i=0; i<m; i++)
+    for(unsigned j=0; j<n; j++) {
+      t(i,j)=(*this)(j,i);
+    }
   return t;
 }
 
@@ -384,7 +397,8 @@ inline
 TensorGeneric<3,3> TensorGeneric<3,3>::inverse()const {
   TensorGeneric t;
   double invdet=1.0/determinant();
-  for(unsigned i=0; i<3; i++) for(unsigned j=0; j<3; j++)
+  for(unsigned i=0; i<3; i++)
+    for(unsigned j=0; j<3; j++)
       t(j,i)=invdet*(   (*this)((i+1)%3,(j+1)%3)*(*this)((i+2)%3,(j+2)%3)
                         -(*this)((i+1)%3,(j+2)%3)*(*this)((i+2)%3,(j+1)%3));
   return t;
@@ -393,7 +407,9 @@ TensorGeneric<3,3> TensorGeneric<3,3>::inverse()const {
 template<unsigned n,unsigned m,unsigned l>
 TensorGeneric<n,l> matmul(const TensorGeneric<n,m>&a,const TensorGeneric<m,l>&b) {
   TensorGeneric<n,l> t;
-  for(unsigned i=0; i<n; i++) for(unsigned j=0; j<l; j++) for(unsigned k=0; k<m; k++) {
+  for(unsigned i=0; i<n; i++)
+    for(unsigned j=0; j<l; j++)
+      for(unsigned k=0; k<m; k++) {
         t(i,j)+=a(i,k)*b(k,j);
       }
   return t;
@@ -402,14 +418,20 @@ TensorGeneric<n,l> matmul(const TensorGeneric<n,m>&a,const TensorGeneric<m,l>&b)
 template<unsigned n,unsigned m>
 VectorGeneric<n> matmul(const TensorGeneric<n,m>&a,const VectorGeneric<m>&b) {
   VectorGeneric<n> t;
-  for(unsigned i=0; i<n; i++) for(unsigned j=0; j<m; j++) t(i)+=a(i,j)*b(j);
+  for(unsigned i=0; i<n; i++)
+    for(unsigned j=0; j<m; j++) {
+      t(i)+=a(i,j)*b(j);
+    }
   return t;
 }
 
 template<unsigned n,unsigned m>
 VectorGeneric<n> matmul(const VectorGeneric<m>&a,const TensorGeneric<m,n>&b) {
   VectorGeneric<n> t;
-  for(unsigned i=0; i<n; i++) for(unsigned j=0; j<m; j++) t(i)+=a(j)*b(j,i);
+  for(unsigned i=0; i<n; i++)
+    for(unsigned j=0; j<m; j++) {
+      t(i)+=a(j)*b(j,i);
+    }
   return t;
 }
 
@@ -478,9 +500,13 @@ TensorGeneric<3,3> dcrossDv2(const VectorGeneric<3>&v1,const VectorGeneric<3>&v2
 
 template<unsigned n,unsigned m>
 std::ostream & operator<<(std::ostream &os, const TensorGeneric<n,m>& t) {
-  for(unsigned i=0; i<n; i++)for(unsigned j=0; j<m; j++) {
-      if(i!=(n-1) || j!=(m-1)) os<<t(i,j)<<" ";
-      else os<<t(i,j);
+  for(unsigned i=0; i<n; i++)
+    for(unsigned j=0; j<m; j++) {
+      if(i!=(n-1) || j!=(m-1)) {
+        os<<t(i,j)<<" ";
+      } else {
+        os<<t(i,j);
+      }
     }
   return os;
 }
@@ -550,19 +576,29 @@ void diagMatSym(const TensorGeneric<n,n>&mat,VectorGeneric<m>&evals,TensorGeneri
   TensorGenericAux::local_dsyevr("V", (n==m?"A":"I"), "U", &nn, const_cast<double*>(&mat_copy[0][0]), &nn, &vl, &vu, &one, &mm,
                                  &abstol, &mout, &evals_tmp[0], &evec[0][0], &nn,
                                  isup.data(), work.data(), &lwork, iwork.data(), &liwork, &info);
-  if(info!=0) plumed_error()<<"Error diagonalizing matrix\n"
-                              <<"Matrix:\n"<<mat<<"\n"
-                              <<"Info: "<<info<<"\n";
+  if(info!=0)
+    plumed_error()<<"Error diagonalizing matrix\n"
+                  <<"Matrix:\n"<<mat<<"\n"
+                  <<"Info: "<<info<<"\n";
   plumed_assert(mout==m);
-  for(unsigned i=0; i<m; i++) evals[i]=evals_tmp[i];
+  for(unsigned i=0; i<m; i++) {
+    evals[i]=evals_tmp[i];
+  }
   // This changes eigenvectors so that the first non-null element
   // of each of them is positive
   // We can do it because the phase is arbitrary, and helps making
   // the result reproducible
   for(unsigned i=0; i<m; ++i) {
     unsigned j=0;
-    for(j=0; j<n; j++) if(evec(i,j)*evec(i,j)>1e-14) break;
-    if(j<n) if(evec(i,j)<0.0) for(j=0; j<n; j++) evec(i,j)*=-1;
+    for(j=0; j<n; j++)
+      if(evec(i,j)*evec(i,j)>1e-14) {
+        break;
+      }
+    if(j<n)
+      if(evec(i,j)<0.0)
+        for(j=0; j<n; j++) {
+          evec(i,j)*=-1;
+        }
   }
 }
 
diff --git a/src/tools/Tools.cpp b/src/tools/Tools.cpp
index b427e4fac7..63a982ef30 100644
--- a/src/tools/Tools.cpp
+++ b/src/tools/Tools.cpp
@@ -36,7 +36,9 @@ template<class T>
 bool Tools::convertToAny(const std::string & str,T & t) {
   std::istringstream istr(str.c_str());
   bool ok=static_cast<bool>(istr>>t);
-  if(!ok) return false;
+  if(!ok) {
+    return false;
+  }
   std::string remaining;
   istr>>remaining;
   return remaining.length()==0;
@@ -71,14 +73,18 @@ bool Tools::convertNoexcept(const std::string & str,AtomNumber &a) {
   // avoid using lepton conversions.
   unsigned i;
   bool r=convertToAny(str,i);
-  if(r) a.setSerial(i);
+  if(r) {
+    a.setSerial(i);
+  }
   return r;
 }
 
 template<class T>
 bool Tools::convertToInt(const std::string & str,T & t) {
   // First try standard conversion
-  if(convertToAny(str,t)) return true;
+  if(convertToAny(str,t)) {
+    return true;
+  }
   // Then use lepton
   try {
     double r=lepton::Parser::parse(str).evaluate(lepton::Constants());
@@ -87,20 +93,30 @@ bool Tools::convertToInt(const std::string & str,T & t) {
 
     // it should not overflow the requested int type:
     // (see https://stackoverflow.com/a/526092)
-    if(r>std::nextafter(std::numeric_limits<T>::max(), 0)) return false;
-    if(r<std::nextafter(std::numeric_limits<T>::min(), 0)) return false;
+    if(r>std::nextafter(std::numeric_limits<T>::max(), 0)) {
+      return false;
+    }
+    if(r<std::nextafter(std::numeric_limits<T>::min(), 0)) {
+      return false;
+    }
 
     // do the actual conversion
     auto tmp=static_cast<T>(std::round(r));
 
     // it should be *very close* to itself if converted back to double
     double diff= r-static_cast<double>(tmp);
-    if(diff*diff > 1e-20) return false;
+    if(diff*diff > 1e-20) {
+      return false;
+    }
     // this is to accomodate small numerical errors and allow e.g. exp(log(7)) to be integer
 
     // it should be change if incremented or decremented by one (see https://stackoverflow.com/a/43656140)
-    if(r == static_cast<double>(tmp-1)) return false;
-    if(r == static_cast<double>(tmp+1)) return false;
+    if(r == static_cast<double>(tmp-1)) {
+      return false;
+    }
+    if(r == static_cast<double>(tmp+1)) {
+      return false;
+    }
 
     // everything is fine, then store in t
     t=tmp;
@@ -113,11 +129,15 @@ bool Tools::convertToInt(const std::string & str,T & t) {
 
 template<class T>
 bool Tools::convertToReal(const std::string & str,T & t) {
-  if(convertToAny(str,t)) return true;
+  if(convertToAny(str,t)) {
+    return true;
+  }
   if(str=="PI" || str=="+PI" || str=="+pi" || str=="pi") {
-    t=pi; return true;
+    t=pi;
+    return true;
   } else if(str=="-PI" || str=="-pi") {
-    t=-pi; return true;
+    t=-pi;
+    return true;
   }
   try {
     t=lepton::Parser::parse(str).evaluate(lepton::Constants());
@@ -126,21 +146,33 @@ bool Tools::convertToReal(const std::string & str,T & t) {
   }
   if( str.find("PI")!=std::string::npos ) {
     std::size_t pi_start=str.find_first_of("PI");
-    if(str.substr(pi_start)!="PI") return false;
+    if(str.substr(pi_start)!="PI") {
+      return false;
+    }
     std::istringstream nstr(str.substr(0,pi_start));
-    T ff=0.0; bool ok=static_cast<bool>(nstr>>ff);
-    if(!ok) return false;
+    T ff=0.0;
+    bool ok=static_cast<bool>(nstr>>ff);
+    if(!ok) {
+      return false;
+    }
     t=ff*pi;
-    std::string remains; nstr>>remains;
+    std::string remains;
+    nstr>>remains;
     return remains.length()==0;
   } else if( str.find("pi")!=std::string::npos ) {
     std::size_t pi_start=str.find_first_of("pi");
-    if(str.substr(pi_start)!="pi") return false;
+    if(str.substr(pi_start)!="pi") {
+      return false;
+    }
     std::istringstream nstr(str.substr(0,pi_start));
-    T ff=0.0; bool ok=static_cast<bool>(nstr>>ff);
-    if(!ok) return false;
+    T ff=0.0;
+    bool ok=static_cast<bool>(nstr>>ff);
+    if(!ok) {
+      return false;
+    }
     t=ff*pi;
-    std::string remains; nstr>>remains;
+    std::string remains;
+    nstr>>remains;
     return remains.length()==0;
   } else if(str=="NAN") {
     t=std::numeric_limits<double>::quiet_NaN();
@@ -170,41 +202,67 @@ std::vector<std::string> Tools::getWords(std::string_view line,const char* separ
   plumed_massert(std::strlen(parenthesis)==1,"multiple parenthesis type not available");
   plumed_massert(parenthesis[0]=='(' || parenthesis[0]=='[' || parenthesis[0]=='{',
                  "only ( [ { allowed as parenthesis");
-  if(!separators) separators=" \t\n";
+  if(!separators) {
+    separators=" \t\n";
+  }
   const std::string sep(separators);
   char openpar=parenthesis[0];
   char closepar;
-  if(openpar=='(') closepar=')';
-  if(openpar=='[') closepar=']';
-  if(openpar=='{') closepar='}';
+  if(openpar=='(') {
+    closepar=')';
+  }
+  if(openpar=='[') {
+    closepar=']';
+  }
+  if(openpar=='{') {
+    closepar='}';
+  }
   std::vector<std::string> words;
   std::string word;
   int parenthesisLevel=0;
-  if(parlevel) parenthesisLevel=*parlevel;
+  if(parlevel) {
+    parenthesisLevel=*parlevel;
+  }
   for(unsigned i=0; i<line.length(); i++) {
     bool found=false;
     bool onParenthesis=false;
-    if( (line[i]==openpar || line[i]==closepar) && delete_parenthesis ) onParenthesis=true;
+    if( (line[i]==openpar || line[i]==closepar) && delete_parenthesis ) {
+      onParenthesis=true;
+    }
     if(line[i]==closepar) {
       parenthesisLevel--;
       plumed_assert(parenthesisLevel>=0) << "Extra closed parenthesis in '" << line << "'";
     }
-    if(parenthesisLevel==0) for(unsigned j=0; j<sep.length(); j++) if(line[i]==sep[j]) found=true;
+    if(parenthesisLevel==0)
+      for(unsigned j=0; j<sep.length(); j++)
+        if(line[i]==sep[j]) {
+          found=true;
+        }
 // If at parenthesis level zero (outer)
-    if(!(parenthesisLevel==0 && (found||onParenthesis))) word.push_back(line[i]);
+    if(!(parenthesisLevel==0 && (found||onParenthesis))) {
+      word.push_back(line[i]);
+    }
     //if(onParenthesis) word.push_back(' ');
-    if(line[i]==openpar) parenthesisLevel++;
+    if(line[i]==openpar) {
+      parenthesisLevel++;
+    }
     if(found && word.length()>0) {
-      if(!parlevel) plumed_assert(parenthesisLevel==0) << "Unmatching parenthesis in '" << line << "'";
+      if(!parlevel) {
+        plumed_assert(parenthesisLevel==0) << "Unmatching parenthesis in '" << line << "'";
+      }
       words.push_back(word);
       word.clear();
     }
   }
   if(word.length()>0) {
-    if(!parlevel) plumed_assert(parenthesisLevel==0) << "Unmatching parenthesis in '" << line << "'";
+    if(!parlevel) {
+      plumed_assert(parenthesisLevel==0) << "Unmatching parenthesis in '" << line << "'";
+    }
     words.push_back(word);
   }
-  if(parlevel) *parlevel=parenthesisLevel;
+  if(parlevel) {
+    *parlevel=parenthesisLevel;
+  }
   return words;
 }
 
@@ -237,16 +295,25 @@ bool Tools::getParsedLine(IFile& ifile,std::vector<std::string> & words, bool tr
   int parlevel=0;
   bool mergenext=false;
   while((stat=ifile.getline(line))) {
-    if(trimcomments) trimComments(line);
+    if(trimcomments) {
+      trimComments(line);
+    }
     trim(line);
-    if(line.length()==0) continue;
+    if(line.length()==0) {
+      continue;
+    }
     std::vector<std::string> w=getWords(line,NULL,&parlevel,"{",trimcomments);
     if(!w.empty()) {
       if(inside && *(w.begin())=="...") {
         inside=false;
-        if(w.size()==2) plumed_massert(w[1]==words[0],"second word in terminating \"...\" "+w[1]+" line, if present, should be equal to first word of directive: "+words[0]);
+        if(w.size()==2) {
+          plumed_massert(w[1]==words[0],"second word in terminating \"...\" "+w[1]+" line, if present, should be equal to first word of directive: "+words[0]);
+        }
         plumed_massert(w.size()<=2,"terminating \"...\" lines cannot consist of more than two words");
-        w.clear(); if(!trimcomments) words.push_back("...");
+        w.clear();
+        if(!trimcomments) {
+          words.push_back("...");
+        }
       } else if(*(w.end()-1)=="...") {
         inside=true;
         w.erase(w.end()-1);
@@ -256,15 +323,24 @@ bool Tools::getParsedLine(IFile& ifile,std::vector<std::string> & words, bool tr
         words[words.size()-1]+=" "+w[0];
         i0=1;
       }
-      for(unsigned i=i0; i<w.size(); ++i) words.push_back(w[i]);
+      for(unsigned i=i0; i<w.size(); ++i) {
+        words.push_back(w[i]);
+      }
     }
     mergenext=(parlevel>0);
-    if(!inside)break;
-    if(!trimcomments && parlevel==0) words.push_back("@newline");
-    else if(!trimcomments) words[words.size()-1] += " @newline";
+    if(!inside) {
+      break;
+    }
+    if(!trimcomments && parlevel==0) {
+      words.push_back("@newline");
+    } else if(!trimcomments) {
+      words[words.size()-1] += " @newline";
+    }
   }
   plumed_massert(parlevel==0,"non matching parenthesis");
-  if(words.size()>0) return true;
+  if(words.size()>0) {
+    return true;
+  }
   return stat;
 }
 
@@ -274,20 +350,33 @@ bool Tools::getline(FILE* fp,std::string & line) {
   const int bufferlength=1024;
   char buffer[bufferlength];
   bool ret;
-  for(int i=0; i<bufferlength; i++) buffer[i]='\0';
+  for(int i=0; i<bufferlength; i++) {
+    buffer[i]='\0';
+  }
   while((ret=fgets(buffer,bufferlength,fp))) {
     line.append(buffer);
     unsigned ss=std::strlen(buffer);
-    if(ss>0) if(buffer[ss-1]=='\n') break;
+    if(ss>0)
+      if(buffer[ss-1]=='\n') {
+        break;
+      }
   };
-  if(line.length()>0) if(*(line.end()-1)=='\n') line.erase(line.end()-1);
-  if(line.length()>0) if(*(line.end()-1)=='\r') line.erase(line.end()-1);
+  if(line.length()>0)
+    if(*(line.end()-1)=='\n') {
+      line.erase(line.end()-1);
+    }
+  if(line.length()>0)
+    if(*(line.end()-1)=='\r') {
+      line.erase(line.end()-1);
+    }
   return ret;
 }
 
 void Tools::trim(std::string & s) {
   auto n=s.find_last_not_of(" \t");
-  if(n!=std::string::npos) s.resize(n+1);
+  if(n!=std::string::npos) {
+    s.resize(n+1);
+  }
 }
 
 void Tools::ltrim(std::string & s) {
@@ -300,11 +389,12 @@ void Tools::ltrim(std::string & s) {
 
 void Tools::trimComments(std::string & s) {
   auto n=s.find_first_of("#");
-  if(n!=std::string::npos) s.resize(n);
+  if(n!=std::string::npos) {
+    s.resize(n);
+  }
 }
 
-bool Tools::caseInSensStringCompare(const std::string & str1, const std::string &str2)
-{
+bool Tools::caseInSensStringCompare(const std::string & str1, const std::string &str2) {
   return ((str1.size() == str2.size()) && std::equal(str1.begin(), str1.end(), str2.begin(), [](char c1, char c2) {
     return (c1 == c2 || std::toupper(c1) == std::toupper(c2));
   }));
@@ -313,10 +403,14 @@ bool Tools::caseInSensStringCompare(const std::string & str1, const std::string
 bool Tools::getKey(std::vector<std::string>& line,const std::string & key,std::string & s,int rep) {
   s.clear();
   for(auto p=line.begin(); p!=line.end(); ++p) {
-    if((*p).length()==0) continue;
+    if((*p).length()==0) {
+      continue;
+    }
     std::string x=(*p).substr(0,key.length());
     if(caseInSensStringCompare(x,key)) {
-      if((*p).length()==key.length())return false;
+      if((*p).length()==key.length()) {
+        return false;
+      }
       std::string tmp=(*p).substr(key.length(),(*p).length());
       line.erase(p);
       s=tmp;
@@ -338,17 +432,25 @@ void Tools::interpretRanges(std::vector<std::string>&s) {
   for(const auto & p :s) {
     news.push_back(p);
     size_t dash=p.find("-");
-    if(dash==std::string::npos) continue;
+    if(dash==std::string::npos) {
+      continue;
+    }
     int first;
-    if(!Tools::convertToAny(p.substr(0,dash),first)) continue;
+    if(!Tools::convertToAny(p.substr(0,dash),first)) {
+      continue;
+    }
     int stride=1;
     int second;
     size_t colon=p.substr(dash+1).find(":");
     if(colon!=std::string::npos) {
       if(!Tools::convertToAny(p.substr(dash+1).substr(0,colon),second) ||
-          !Tools::convertToAny(p.substr(dash+1).substr(colon+1),stride)) continue;
+          !Tools::convertToAny(p.substr(dash+1).substr(colon+1),stride)) {
+        continue;
+      }
     } else {
-      if(!Tools::convertToAny(p.substr(dash+1),second)) continue;
+      if(!Tools::convertToAny(p.substr(dash+1),second)) {
+        continue;
+      }
     }
     news.resize(news.size()-1);
     if(first<=second) {
@@ -371,10 +473,14 @@ void Tools::interpretRanges(std::vector<std::string>&s) {
 }
 
 void Tools::interpretLabel(std::vector<std::string>&s) {
-  if(s.size()<2)return;
+  if(s.size()<2) {
+    return;
+  }
   std::string s0=s[0];
   unsigned l=s0.length();
-  if(l<1) return;
+  if(l<1) {
+    return;
+  }
   if(s0[l-1]==':') {
     s[0]=s[1];
     s[1]="LABEL="+s0.substr(0,l-1);
@@ -393,7 +499,9 @@ std::vector<std::string> Tools::ls(const std::string&d) {
 void Tools::stripLeadingAndTrailingBlanks( std::string& str ) {
   std::size_t first=str.find_first_not_of(' ');
   std::size_t last=str.find_last_not_of(' ');
-  if( first<=last && first!=std::string::npos) str=str.substr(first,last+1);
+  if( first<=last && first!=std::string::npos) {
+    str=str.substr(first,last+1);
+  }
 }
 
 std::string Tools::extension(const std::string&s) {
@@ -401,10 +509,16 @@ std::string Tools::extension(const std::string&s) {
   std::string ext;
   if(n!=std::string::npos && n+1<s.length() && n+5>=s.length()) {
     ext=s.substr(n+1);
-    if(ext.find("/")!=std::string::npos) ext="";
+    if(ext.find("/")!=std::string::npos) {
+      ext="";
+    }
     std::string base=s.substr(0,n);
-    if(base.length()==0) ext="";
-    if(base.length()>0 && base[base.length()-1]=='/') ext="";
+    if(base.length()==0) {
+      ext="";
+    }
+    if(base.length()>0 && base[base.length()-1]=='/') {
+      ext="";
+    }
   }
   return ext;
 }
@@ -426,16 +540,21 @@ bool Tools::startWith(const std::string & full,const std::string &start) {
 bool Tools::findKeyword(const std::vector<std::string>&line,const std::string&key) {
   const std::string search(key+"=");
   for(const auto & p : line) {
-    if(startWith(p,search)) return true;
+    if(startWith(p,search)) {
+      return true;
+    }
   }
   return false;
 }
 
 Tools::DirectoryChanger::DirectoryChanger(const char*path):
-  path(std::filesystem::current_path())
-{
-  if(!path) return;
-  if(std::strlen(path)==0) return;
+  path(std::filesystem::current_path()) {
+  if(!path) {
+    return;
+  }
+  if(std::strlen(path)==0) {
+    return;
+  }
   std::filesystem::current_path(path);
 }
 
@@ -459,7 +578,9 @@ class process_one_exception {
   std::string & msg;
   bool first=true;
   void update() {
-    if(!first) msg+="\n\nThe above exception was the direct cause of the following exception:\n";
+    if(!first) {
+      msg+="\n\nThe above exception was the direct cause of the following exception:\n";
+    }
     first=false;
   }
 public:
@@ -494,7 +615,9 @@ static void process_all_exceptions(T&& f) {
       process_all_exceptions(f);
     }
     auto d=dynamic_cast<const std::exception*>(&e);
-    if(d) f(*d);
+    if(d) {
+      f(*d);
+    }
   } catch(const std::exception &e) {
     // If not nested, we end recursion
     f(e);
diff --git a/src/tools/Tools.h b/src/tools/Tools.h
index 26e9d9eae9..84fd4d1482 100644
--- a/src/tools/Tools.h
+++ b/src/tools/Tools.h
@@ -237,20 +237,26 @@ class Tools {
   }
 
   static void set_to_zero(double*ptr,unsigned n) {
-    for(unsigned i=0; i<n; i++) ptr[i]=0.0;
+    for(unsigned i=0; i<n; i++) {
+      ptr[i]=0.0;
+    }
   }
 
   template<unsigned n>
   static void set_to_zero(std::vector<VectorGeneric<n>> & vec) {
     unsigned s=vec.size();
-    if(s==0) return;
+    if(s==0) {
+      return;
+    }
     set_to_zero(&vec[0][0],s*n);
   }
 
   template<unsigned n,unsigned m>
   static void set_to_zero(std::vector<TensorGeneric<n,m>> & vec) {
     unsigned s=vec.size();
-    if(s==0) return;
+    if(s==0) {
+      return;
+    }
     set_to_zero(&vec[0](0,0),s*n*m);
   }
 
@@ -288,7 +294,9 @@ class Tools {
 
     T& operator[]( const std::string_view & key ) {
       auto f=map.find(key);
-      if(f!=map.end()) return f->second;
+      if(f!=map.end()) {
+        return f->second;
+      }
       keys.push_back(conv(key));
       return map[keys.back().get()];
     }
@@ -342,8 +350,7 @@ class Tools {
       Key key;
       Handler(CriticalSectionWithKey* section,const Key& key):
         section(section),
-        key(key)
-      {
+        key(key) {
         section->start(key);
       }
       friend class CriticalSectionWithKey;
@@ -357,14 +364,15 @@ class Tools {
       /// Move constructor.
       Handler(Handler && handler) noexcept :
         section(handler.section),
-        key(std::move(handler.key))
-      {
+        key(std::move(handler.key)) {
         handler.section=nullptr;
       };
       /// Move assignment.
       Handler & operator=(Handler && handler) noexcept {
         if(this!=&handler) {
-          if(section) section->stop(key);
+          if(section) {
+            section->stop(key);
+          }
           section=handler.section;
           key=std::move(handler.key);
         }
@@ -373,7 +381,9 @@ class Tools {
       }
       /// Destructor
       ~Handler() {
-        if(section) section->stop(key);
+        if(section) {
+          section->stop(key);
+        }
       }
     };
 
@@ -388,15 +398,21 @@ class Tools {
 template <class T>
 bool Tools::parse(std::vector<std::string>&line,const std::string&key,T&val,int rep) {
   std::string s;
-  if(!getKey(line,key+"=",s,rep)) return false;
-  if(s.length()>0 && !convertNoexcept(s,val))return false;
+  if(!getKey(line,key+"=",s,rep)) {
+    return false;
+  }
+  if(s.length()>0 && !convertNoexcept(s,val)) {
+    return false;
+  }
   return true;
 }
 
 template <class T>
 bool Tools::parseVector(std::vector<std::string>&line,const std::string&key,std::vector<T>&val,int rep) {
   std::string s;
-  if(!getKey(line,key+"=",s,rep)) return false;
+  if(!getKey(line,key+"=",s,rep)) {
+    return false;
+  }
   val.clear();
   std::vector<std::string> words=getWords(s,"\t\n ,");
   for(unsigned i=0; i<words.size(); ++i) {
@@ -409,15 +425,16 @@ bool Tools::parseVector(std::vector<std::string>&line,const std::string&key,std:
       plumed_assert(rep<static_cast<int>(words.size()));
       s=words[rep];
     }
-    if(!convertNoexcept(s,v))return false;
+    if(!convertNoexcept(s,v)) {
+      return false;
+    }
     val.push_back(v);
   }
   return true;
 }
 
 template<typename T>
-void Tools::removeDuplicates(std::vector<T>& vec)
-{
+void Tools::removeDuplicates(std::vector<T>& vec) {
   std::sort(vec.begin(), vec.end());
   vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
 }
@@ -438,18 +455,27 @@ bool Tools::parseFlag(std::vector<std::string>&line,const std::string&key,bool&v
 inline
 double Tools::pbc(double x) {
 #ifdef __PLUMED_PBC_WHILE
-  while (x>0.5) x-=1.0;
-  while (x<-0.5) x+=1.0;
+  while (x>0.5) {
+    x-=1.0;
+  }
+  while (x<-0.5) {
+    x+=1.0;
+  }
   return x;
 #else
   if constexpr (std::numeric_limits<int>::round_style == std::round_toward_zero) {
     constexpr double offset=100.0;
     const double y=x+offset;
-    if(y>=0) return y-int(y+0.5);
-    else     return y-int(y-0.5);
+    if(y>=0) {
+      return y-int(y+0.5);
+    } else {
+      return y-int(y-0.5);
+    }
   } else if constexpr (std::numeric_limits<int>::round_style == std::round_to_nearest) {
     return x-int(x);
-  } else return x-floor(x+0.5);
+  } else {
+    return x-floor(x+0.5);
+  }
 #endif
 }
 
@@ -462,17 +488,16 @@ bool Tools::convertNoexcept(T i,std::string & str) {
 }
 
 inline
-double Tools::fastpow(double base, int exp)
-{
+double Tools::fastpow(double base, int exp) {
   if(exp<0) {
     exp=-exp;
     base=1.0/base;
   }
   double result = 1.0;
-  while (exp)
-  {
-    if (exp & 1)
+  while (exp) {
+    if (exp & 1) {
       result *= base;
+    }
     exp >>= 1;
     base *= base;
   }
@@ -503,14 +528,18 @@ inline T Tools::fastpow(T const base) {
 template<typename T>
 std::vector<T*> Tools::unique2raw(const std::vector<std::unique_ptr<T>> & x) {
   std::vector<T*> v(x.size());
-  for(unsigned i=0; i<x.size(); i++) v[i]=x[i].get();
+  for(unsigned i=0; i<x.size(); i++) {
+    v[i]=x[i].get();
+  }
   return v;
 }
 
 template<typename T>
 std::vector<const T*> Tools::unique2raw(const std::vector<std::unique_ptr<const T>> & x) {
   std::vector<const T*> v(x.size());
-  for(unsigned i=0; i<x.size(); i++) v[i]=x[i].get();
+  for(unsigned i=0; i<x.size(); i++) {
+    v[i]=x[i].get();
+  }
   return v;
 }
 
diff --git a/src/tools/Tree.cpp b/src/tools/Tree.cpp
index 2dc6ddc801..c644bf37ae 100644
--- a/src/tools/Tree.cpp
+++ b/src/tools/Tree.cpp
@@ -34,13 +34,16 @@ Tree::Tree(GenericMolInfo* moldat) {
 // initialize class
   moldat_ = moldat;
 // check if molinfo present
-  if(!moldat_) plumed_merror("MOLINFO DATA not found");
+  if(!moldat_) {
+    plumed_merror("MOLINFO DATA not found");
+  }
 // check if reference structure is whole
-  if(!moldat_->isWhole()) plumed_merror("Check that reference structure in PDB file is not broken by pbc and set WHOLE in MOLINFO line");
+  if(!moldat_->isWhole()) {
+    plumed_merror("Check that reference structure in PDB file is not broken by pbc and set WHOLE in MOLINFO line");
+  }
 }
 
-std::vector<AtomNumber> Tree::getTree(std::vector<AtomNumber> atoms)
-{
+std::vector<AtomNumber> Tree::getTree(std::vector<AtomNumber> atoms) {
   // Implementation inspired from:
   // https://mayanknatani.wordpress.com/2013/05/31/euclidean-minimummaximum-spanning-tree-emst/
   //
@@ -58,7 +61,9 @@ std::vector<AtomNumber> Tree::getTree(std::vector<AtomNumber> atoms)
   positions.reserve(atoms.size());
   tree.reserve(atoms.size());
   root_.reserve(atoms.size());
-  if(!moldat_->checkForAtom(atoms[0])) plumed_merror("The first atom in the list should be present in the PDB file");
+  if(!moldat_->checkForAtom(atoms[0])) {
+    plumed_merror("The first atom in the list should be present in the PDB file");
+  }
   // store first atom
   newatoms.push_back(atoms[0]);
   positions.push_back(moldat_->getPosition(atoms[0]));
@@ -84,8 +89,9 @@ std::vector<AtomNumber> Tree::getTree(std::vector<AtomNumber> atoms)
   for(unsigned i=0; i<atoms.size(); ++i) {
     int selected_vertex = -1;
     for(unsigned j=0; j<atoms.size(); ++j) {
-      if( !intree[j] && (selected_vertex==-1 || mindist[j] < mindist[selected_vertex]) )
+      if( !intree[j] && (selected_vertex==-1 || mindist[j] < mindist[selected_vertex]) ) {
         selected_vertex = j;
+      }
     }
     // add to tree
     plumed_assert(selected_vertex>=0);
@@ -96,14 +102,18 @@ std::vector<AtomNumber> Tree::getTree(std::vector<AtomNumber> atoms)
     int iroot = -1;
     for(unsigned j=0; j<atoms.size(); ++j) {
       double dist = delta(positions[selected_vertex], positions[j]).modulo2();
-      if(dist < mindist[j]) mindist[j] = dist;
+      if(dist < mindist[j]) {
+        mindist[j] = dist;
+      }
       if(dist < minroot && intree[j] && dist>0.0) {
         minroot = dist;
         iroot = j;
       }
     }
     // add to root vector
-    if(iroot>=0) root_.push_back(atoms[iroot]);
+    if(iroot>=0) {
+      root_.push_back(atoms[iroot]);
+    }
   }
 
   // now re-add atoms not present in the PDB
@@ -116,8 +126,7 @@ std::vector<AtomNumber> Tree::getTree(std::vector<AtomNumber> atoms)
   return tree;
 }
 
-std::vector<AtomNumber> Tree::getRoot() const
-{
+std::vector<AtomNumber> Tree::getRoot() const {
   return root_;
 }
 
diff --git a/src/tools/Tree.h b/src/tools/Tree.h
index c0551e82b1..8338d5d1f1 100644
--- a/src/tools/Tree.h
+++ b/src/tools/Tree.h
@@ -31,8 +31,7 @@ namespace PLMD {
 
 
 /// \ingroup TOOLBOX
-class Tree
-{
+class Tree {
 
 private:
   GenericMolInfo* moldat_;
diff --git a/src/tools/TypesafePtr.cpp b/src/tools/TypesafePtr.cpp
index f019381ea8..2ec705fcf1 100644
--- a/src/tools/TypesafePtr.cpp
+++ b/src/tools/TypesafePtr.cpp
@@ -33,9 +33,13 @@ TypesafePtr TypesafePtr::fromSafePtr(void* safe) {
 
 TypesafePtr TypesafePtr::copy() const {
   auto passbyvalue=((flags>>25)&0x7)==1;
-  if(passbyvalue) throw ExceptionTypeError()<<"PLUMED is trying to copy the pointer of an object passed by value";
+  if(passbyvalue) {
+    throw ExceptionTypeError()<<"PLUMED is trying to copy the pointer of an object passed by value";
+  }
   auto forbidstore=flags&0x10000000;
-  if(forbidstore) throw ExceptionTypeError()<<"PLUMED is trying to copy the pointer of an object for which this was forbidden";
+  if(forbidstore) {
+    throw ExceptionTypeError()<<"PLUMED is trying to copy the pointer of an object for which this was forbidden";
+  }
   TypesafePtr ret;
   ret.ptr=ptr;
   ret.flags=flags;
diff --git a/src/tools/TypesafePtr.h b/src/tools/TypesafePtr.h
index f1545964fd..6b123da407 100644
--- a/src/tools/TypesafePtr.h
+++ b/src/tools/TypesafePtr.h
@@ -88,12 +88,16 @@ class TypesafePtr {
       unsigned i=0;
       for(i=0; i<this->shape.size(); i++) {
         this->shape[i]=*shape;
-        if(*shape==0) break;
+        if(*shape==0) {
+          break;
+        }
         nelem_*=*shape;
         shape++;
       }
       plumed_assert(i<this->shape.size()); // check that last element is actually zero
-      if(nelem==0) nelem=nelem_;
+      if(nelem==0) {
+        nelem=nelem_;
+      }
       plumed_assert(nelem==nelem_) << "Inconsistent shape/nelem";
     }
   }
@@ -105,8 +109,7 @@ class TypesafePtr {
   TypesafePtr(void* ptr, std::size_t nelem, const std::size_t* shape, std::size_t flags):
     ptr(ptr),
     nelem(nelem),
-    flags(flags)
-  {
+    flags(flags) {
     buffer[0]='\0';
     init_shape(shape);
   }
@@ -128,8 +131,7 @@ class TypesafePtr {
     buffer[0]='\0';
   }
 
-  TypesafePtr(std::nullptr_t)
-  {
+  TypesafePtr(std::nullptr_t) {
     shape[0]=0;
     buffer[0]='\0';
   }
@@ -210,8 +212,7 @@ class TypesafePtr {
     ptr(other.ptr==&other.buffer[0] ? &buffer[0] : other.ptr),
     nelem(other.nelem),
     shape(other.shape),
-    flags(other.flags)
-  {
+    flags(other.flags) {
     other.ptr=nullptr;
   }
 
@@ -229,12 +230,24 @@ class TypesafePtr {
 
   std::string type_str() const {
     auto type=(flags>>16)&0xff;
-    if(type==0) return "wildcard";
-    if(type==1) return "void";
-    if(type==2) return "integral";
-    if(type==3) return "integral";
-    if(type==4) return "floating point";
-    if(type==5) return "FILE";
+    if(type==0) {
+      return "wildcard";
+    }
+    if(type==1) {
+      return "void";
+    }
+    if(type==2) {
+      return "integral";
+    }
+    if(type==3) {
+      return "integral";
+    }
+    if(type==4) {
+      return "floating point";
+    }
+    if(type==5) {
+      return "FILE";
+    }
     return "unknown";
   }
 
@@ -243,9 +256,13 @@ class TypesafePtr {
   template<typename T>
   T* get_priv(std::size_t nelem, const std::size_t* shape, bool byvalue) const {
 
-    if(typesafePtrSkipCheck()) return (T*) ptr;
+    if(typesafePtrSkipCheck()) {
+      return (T*) ptr;
+    }
     typedef typename std::remove_pointer<T>::type T_noptr;
-    if(flags==0) return (T*) ptr; // no check
+    if(flags==0) {
+      return (T*) ptr;  // no check
+    }
     auto size=flags&0xffff;
     auto type=(flags>>16)&0xff;
     // auto unsi=(flags>>24)&0x1; // ignored
@@ -269,7 +286,8 @@ class TypesafePtr {
       throw ExceptionTypeError() << "This command expects a type with size " << typesafePtrSizeof<T_noptr>() << ". Received type has size " << size << " instead"<<extra_msg();
     }
 
-    if(!byvalue) if(cons==1) {
+    if(!byvalue)
+      if(cons==1) {
         throw ExceptionTypeError() << "This command is trying to take the address of an argument that was passed by value"<<extra_msg();
       }
 
@@ -294,16 +312,26 @@ class TypesafePtr {
         }
       } else {
         if(!std::is_const<T>::value) {
-          if(cons==1) throw ExceptionTypeError() << "This command expects a pointer-to-pointer. It received a value intead"<<extra_msg();
-          if(cons==2 || cons==3) throw ExceptionTypeError() << "This command expects a pointer-to-pointer. It received a pointer intead"<<extra_msg();
+          if(cons==1) {
+            throw ExceptionTypeError() << "This command expects a pointer-to-pointer. It received a value intead"<<extra_msg();
+          }
+          if(cons==2 || cons==3) {
+            throw ExceptionTypeError() << "This command expects a pointer-to-pointer. It received a pointer intead"<<extra_msg();
+          }
           if(!std::is_const<T_noptr>::value) {
-            if(cons!=4) throw ExceptionTypeError() << "This command expects a modifiable pointer-to-pointer (T**)"<<extra_msg();
+            if(cons!=4) {
+              throw ExceptionTypeError() << "This command expects a modifiable pointer-to-pointer (T**)"<<extra_msg();
+            }
           } else {
-            if(cons!=6) throw ExceptionTypeError() << "This command expects a modifiable pointer to unmodifiable pointer (const T**)"<<extra_msg();
+            if(cons!=6) {
+              throw ExceptionTypeError() << "This command expects a modifiable pointer to unmodifiable pointer (const T**)"<<extra_msg();
+            }
           }
         } else {
           if(!std::is_const<T_noptr>::value) {
-            if(cons!=4 && cons!=5) throw ExceptionTypeError() << "This command expects T*const* pointer, and can only receive T**  or T*const* pointers"<<extra_msg();
+            if(cons!=4 && cons!=5) {
+              throw ExceptionTypeError() << "This command expects T*const* pointer, and can only receive T**  or T*const* pointers"<<extra_msg();
+            }
           }
         }
       }
@@ -317,7 +345,9 @@ class TypesafePtr {
         if(shape[i]!=0 && this->shape[i]==0) {
           throw ExceptionTypeError() << "Incorrect number of axis (requested greater than passed)"<<extra_msg();
         }
-        if(shape[i]==0) break;
+        if(shape[i]==0) {
+          break;
+        }
         if((shape[i]>this->shape[i])) {
           throw ExceptionTypeError() << "This command wants " << shape[i] << " elements on axis " << i <<" of this pointer, but " << this->shape[i] << " have been passed"<<extra_msg();
         }
@@ -329,12 +359,15 @@ class TypesafePtr {
     if(nelem==0 && shape && shape[0]>0) {
       nelem=1;
       for(unsigned i=0; i<this->shape.size(); i++) {
-        if(shape[i]==0) break;
+        if(shape[i]==0) {
+          break;
+        }
         nelem*=shape[i];
       }
     }
     // check number of elements
-    if(nelem>0 && this->nelem>0) if(!(nelem<=this->nelem)) {
+    if(nelem>0 && this->nelem>0)
+      if(!(nelem<=this->nelem)) {
         throw ExceptionTypeError() << "This command wants to access " << nelem << " from this pointer, but only " << this->nelem << " have been passed"<<extra_msg();
       }
     return (T*) ptr;
@@ -363,8 +396,13 @@ class TypesafePtr {
     const char* ptr=get_priv<const char>(0,nullptr,false);
     if(!typesafePtrSkipCheck() && this->nelem>0 && this->nelem<std::numeric_limits<std::size_t>::max()) {
       std::size_t i=0;
-      for(; i<this->nelem; i++) if(ptr[i]==0) break;
-      if(i==this->nelem) throw ExceptionTypeError() << "PLUMED is expecting a null terminated string, but no null character was found";
+      for(; i<this->nelem; i++)
+        if(ptr[i]==0) {
+          break;
+        }
+      if(i==this->nelem) {
+        throw ExceptionTypeError() << "PLUMED is expecting a null terminated string, but no null character was found";
+      }
     }
     return ptr;
   }
diff --git a/src/tools/Units.cpp b/src/tools/Units.cpp
index 660071c4b0..b9a9068b16 100644
--- a/src/tools/Units.cpp
+++ b/src/tools/Units.cpp
@@ -34,8 +34,7 @@ Units::Units():
   charge(1.0),
   chargeString("e"),
   mass(1.0),
-  massString("amu")
-{
+  massString("amu") {
 }
 
 void Units::setEnergy(const std::string &s) {
diff --git a/src/tools/Vector.h b/src/tools/Vector.h
index cbebc64b21..0f585be328 100644
--- a/src/tools/Vector.h
+++ b/src/tools/Vector.h
@@ -160,16 +160,14 @@ void VectorGeneric<n>::auxiliaryConstructor()
 
 template <unsigned n>
 template<typename... Args>
-void VectorGeneric<n>::auxiliaryConstructor(double first,Args... arg)
-{
+void VectorGeneric<n>::auxiliaryConstructor(double first,Args... arg) {
   d[n-(sizeof...(Args))-1]=first;
   auxiliaryConstructor(arg...);
 }
 
 template <unsigned n>
 template<typename... Args>
-VectorGeneric<n>::VectorGeneric(double first,Args... arg)
-{
+VectorGeneric<n>::VectorGeneric(double first,Args... arg) {
   static_assert((sizeof...(Args))+1==n,"you are trying to initialize a Vector with the wrong number of arguments");
   auxiliaryConstructor(first,arg...);
 }
@@ -308,7 +306,9 @@ double modulo(const VectorGeneric<n>&v) {
 
 template<unsigned n>
 std::ostream & operator<<(std::ostream &os, const VectorGeneric<n>& v) {
-  for(unsigned i=0; i<n-1; i++) os<<v(i)<<" ";
+  for(unsigned i=0; i<n-1; i++) {
+    os<<v(i)<<" ";
+  }
   os<<v(n-1);
   return os;
 }
diff --git a/src/tools/h36.cpp b/src/tools/h36.cpp
index b9b1d689a4..647799f7bc 100644
--- a/src/tools/h36.cpp
+++ b/src/tools/h36.cpp
@@ -58,26 +58,35 @@ namespace h36 {
 
 static
 const char*
-digits_upper() { return "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; }
+digits_upper() {
+  return "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+}
 
 static
 const char*
-digits_lower() { return "0123456789abcdefghijklmnopqrstuvwxyz"; }
+digits_lower() {
+  return "0123456789abcdefghijklmnopqrstuvwxyz";
+}
 
 static
 const char*
-value_out_of_range() { return "value out of range."; }
+value_out_of_range() {
+  return "value out of range.";
+}
 
 static
-const char* invalid_number_literal() { return "invalid number literal."; }
+const char* invalid_number_literal() {
+  return "invalid number literal.";
+}
 
 static
-const char* unsupported_width() { return "unsupported width."; }
+const char* unsupported_width() {
+  return "unsupported width.";
+}
 
 static
 void
-fill_with_stars(unsigned width, char* result)
-{
+fill_with_stars(unsigned width, char* result) {
   while (width) {
     *result++ = '*';
     width--;
@@ -92,8 +101,7 @@ encode_pure(
   unsigned digits_size,
   unsigned width,
   int value,
-  char* result)
-{
+  char* result) {
   char buf[16];
   int rest;
   unsigned i, j;
@@ -106,12 +114,20 @@ encode_pure(
   while (1) {
     rest = value / digits_size;
     buf[i++] = digits[value - rest * digits_size];
-    if (rest == 0) break;
+    if (rest == 0) {
+      break;
+    }
     value = rest;
   }
-  if (j) buf[i++] = '-';
-  for(j=i; j<width; j++) *result++ = ' ';
-  while (i != 0) *result++ = buf[--i];
+  if (j) {
+    buf[i++] = '-';
+  }
+  for(j=i; j<width; j++) {
+    *result++ = ' ';
+  }
+  while (i != 0) {
+    *result++ = buf[--i];
+  }
   *result = '\0';
 }
 
@@ -122,8 +138,7 @@ decode_pure(
   unsigned digits_size,
   const char* s,
   unsigned s_size,
-  int* result)
-{
+  int* result) {
   int si, dv;
   int have_minus = 0;
   int have_non_blank = 0;
@@ -136,10 +151,11 @@ decode_pure(
       return invalid_number_literal();
     }
     if (si == ' ') {
-      if (!have_non_blank) continue;
+      if (!have_non_blank) {
+        continue;
+      }
       value *= digits_size;
-    }
-    else if (si == '-') {
+    } else if (si == '-') {
       if (have_non_blank) {
         *result = 0;
         return invalid_number_literal();
@@ -147,8 +163,7 @@ decode_pure(
       have_non_blank = 1;
       have_minus = 1;
       continue;
-    }
-    else {
+    } else {
       have_non_blank = 1;
       dv = digits_values[si];
       if (dv < 0 || dv >= digits_size) {
@@ -159,7 +174,9 @@ decode_pure(
       value += dv;
     }
   }
-  if (have_minus) value = -value;
+  if (have_minus) {
+    value = -value;
+  }
   *result = value;
   return 0;
 }
@@ -183,8 +200,7 @@ decode_pure(
       if (errmsg) throw std::runtime_error(errmsg);
  */
 const char*
-hy36encode(unsigned width, int value, char* result)
-{
+hy36encode(unsigned width, int value, char* result) {
   int i = value;
   if (width == 4U) {
     if (i >= -999) {
@@ -205,8 +221,7 @@ hy36encode(unsigned width, int value, char* result)
         return 0;
       }
     }
-  }
-  else if (width == 5U) {
+  } else if (width == 5U) {
     if (i >= -9999) {
       if (i < 100000) {
         encode_pure(digits_upper(), 10U, 5U, i, result);
@@ -225,8 +240,7 @@ hy36encode(unsigned width, int value, char* result)
         return 0;
       }
     }
-  }
-  else {
+  } else {
     fill_with_stars(width, result);
     return unsupported_width();
   }
@@ -257,8 +271,7 @@ hy36encode(unsigned width, int value, char* result)
       if (errmsg) throw std::runtime_error(errmsg);
  */
 const char*
-hy36decode(unsigned width, const char* s, unsigned s_size, int* result)
-{
+hy36decode(unsigned width, const char* s, unsigned s_size, int* result) {
   static const std::vector<int> digits_values_upper_vector([]() {
     std::vector<int> ret(128U,-1);
     for(unsigned i=0; i<36U; i++) {
@@ -269,7 +282,8 @@ hy36decode(unsigned width, const char* s, unsigned s_size, int* result)
       ret[di] = i;
     }
     return ret;
-  }());
+  }
+  ());
   static const int* digits_values_upper=digits_values_upper_vector.data();
   static const std::vector<int> digits_values_lower_vector([]() {
     std::vector<int> ret(128U,-1);
@@ -281,7 +295,8 @@ hy36decode(unsigned width, const char* s, unsigned s_size, int* result)
       ret[di] = i;
     }
     return ret;
-  }());
+  }
+  ());
   static const int* digits_values_lower=digits_values_lower_vector.data();
   int di;
   const char* errmsg;
@@ -292,31 +307,35 @@ hy36decode(unsigned width, const char* s, unsigned s_size, int* result)
         errmsg = decode_pure(digits_values_upper, 36U, s, s_size, result);
         if (errmsg == 0) {
           /* result - 10*36**(width-1) + 10**width */
-          if      (width == 4U) (*result) -= 456560;
-          else if (width == 5U) (*result) -= 16696160;
-          else {
+          if      (width == 4U) {
+            (*result) -= 456560;
+          } else if (width == 5U) {
+            (*result) -= 16696160;
+          } else {
             *result = 0;
             return unsupported_width();
           }
           return 0;
         }
-      }
-      else if (digits_values_lower[di] >= 10) {
+      } else if (digits_values_lower[di] >= 10) {
         errmsg = decode_pure(digits_values_lower, 36U, s, s_size, result);
         if (errmsg == 0) {
           /* result + 16*36**(width-1) + 10**width */
-          if      (width == 4U) (*result) += 756496;
-          else if (width == 5U) (*result) += 26973856;
-          else {
+          if      (width == 4U) {
+            (*result) += 756496;
+          } else if (width == 5U) {
+            (*result) += 26973856;
+          } else {
             *result = 0;
             return unsupported_width();
           }
           return 0;
         }
-      }
-      else {
+      } else {
         errmsg = decode_pure(digits_values_upper, 10U, s, s_size, result);
-        if (errmsg) return errmsg;
+        if (errmsg) {
+          return errmsg;
+        }
         if (!(width == 4U || width == 5U)) {
           *result = 0;
           return unsupported_width();
diff --git a/src/valtools/Concatenate.cpp b/src/valtools/Concatenate.cpp
index 8235762fdc..3073c5e0a9 100644
--- a/src/valtools/Concatenate.cpp
+++ b/src/valtools/Concatenate.cpp
@@ -47,7 +47,9 @@ class Concatenate :
 /// Constructor
   explicit Concatenate(const ActionOptions&);
 /// Get the number of derivatives
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
 /// Do the calculation
   void calculate() override;
 ///
@@ -57,76 +59,146 @@ class Concatenate :
 PLUMED_REGISTER_ACTION(Concatenate,"CONCATENATE")
 
 void Concatenate::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys ); ActionWithArguments::registerKeywords( keys ); keys.use("ARG");
-  keys.add("numbered","MATRIX","specify the matrices that you wish to join together into a single matrix"); keys.reset_style("MATRIX","compulsory");
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  keys.use("ARG");
+  keys.add("numbered","MATRIX","specify the matrices that you wish to join together into a single matrix");
+  keys.reset_style("MATRIX","compulsory");
   keys.setValueDescription("the concatenated vector/matrix that was constructed from the input values");
 }
 
 Concatenate::Concatenate(const ActionOptions& ao):
   Action(ao),
   ActionWithValue(ao),
-  ActionWithArguments(ao)
-{
+  ActionWithArguments(ao) {
   if( getNumberOfArguments()>0 ) {
-    vectors=true; std::vector<unsigned> shape(1); shape[0]=0;
+    vectors=true;
+    std::vector<unsigned> shape(1);
+    shape[0]=0;
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-      if( getPntrToArgument(i)->getRank()>1 ) error("cannot concatenate matrix with vectors");
-      getPntrToArgument(i)->buildDataStore(); shape[0] += getPntrToArgument(i)->getNumberOfValues();
+      if( getPntrToArgument(i)->getRank()>1 ) {
+        error("cannot concatenate matrix with vectors");
+      }
+      getPntrToArgument(i)->buildDataStore();
+      shape[0] += getPntrToArgument(i)->getNumberOfValues();
     }
     log.printf("  creating vector with %d elements \n", shape[0] );
-    addValue( shape ); bool period=getPntrToArgument(0)->isPeriodic();
-    std::string min, max; if( period ) getPntrToArgument(0)->getDomain( min, max );
+    addValue( shape );
+    bool period=getPntrToArgument(0)->isPeriodic();
+    std::string min, max;
+    if( period ) {
+      getPntrToArgument(0)->getDomain( min, max );
+    }
     for(unsigned i=1; i<getNumberOfArguments(); ++i) {
-      if( period!=getPntrToArgument(i)->isPeriodic() ) error("periods of input arguments should match");
+      if( period!=getPntrToArgument(i)->isPeriodic() ) {
+        error("periods of input arguments should match");
+      }
       if( period ) {
-        std::string min0, max0; getPntrToArgument(i)->getDomain( min0, max0 );
-        if( min0!=min || max0!=max ) error("domains of input arguments should match");
+        std::string min0, max0;
+        getPntrToArgument(i)->getDomain( min0, max0 );
+        if( min0!=min || max0!=max ) {
+          error("domains of input arguments should match");
+        }
       }
     }
-    if( period ) setPeriodic( min, max ); else setNotPeriodic();
+    if( period ) {
+      setPeriodic( min, max );
+    } else {
+      setNotPeriodic();
+    }
     getPntrToComponent(0)->buildDataStore();
-    if( getPntrToComponent(0)->getRank()==2 ) getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+    if( getPntrToComponent(0)->getRank()==2 ) {
+      getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+    }
   } else {
-    unsigned nrows=0, ncols=0; std::vector<Value*> arglist; vectors=false;
+    unsigned nrows=0, ncols=0;
+    std::vector<Value*> arglist;
+    vectors=false;
     for(unsigned i=1;; i++) {
-      unsigned nt_cols=0; unsigned size_b4 = arglist.size();
+      unsigned nt_cols=0;
+      unsigned size_b4 = arglist.size();
       for(unsigned j=1;; j++) {
-        if( j==10 ) error("cannot combine more than 9 matrices");
-        std::vector<Value*> argn; parseArgumentList("MATRIX", i*10+j, argn);
-        if( argn.size()==0 ) break;
-        if( argn.size()>1 ) error("should only be one argument to each matrix keyword");
-        if( argn[0]->getRank()!=0 && argn[0]->getRank()!=2 ) error("input arguments for this action should be matrices");
-        argn[0]->buildDataStore(); arglist.push_back( argn[0] ); nt_cols++;
-        if( argn[0]->getRank()==0 ) log.printf("  %d %d component of composed matrix is scalar labelled %s\n", i, j, argn[0]->getName().c_str() );
-        else log.printf("  %d %d component of composed matrix is %d by %d matrix labelled %s\n", i, j, argn[0]->getShape()[0], argn[0]->getShape()[1], argn[0]->getName().c_str() );
+        if( j==10 ) {
+          error("cannot combine more than 9 matrices");
+        }
+        std::vector<Value*> argn;
+        parseArgumentList("MATRIX", i*10+j, argn);
+        if( argn.size()==0 ) {
+          break;
+        }
+        if( argn.size()>1 ) {
+          error("should only be one argument to each matrix keyword");
+        }
+        if( argn[0]->getRank()!=0 && argn[0]->getRank()!=2 ) {
+          error("input arguments for this action should be matrices");
+        }
+        argn[0]->buildDataStore();
+        arglist.push_back( argn[0] );
+        nt_cols++;
+        if( argn[0]->getRank()==0 ) {
+          log.printf("  %d %d component of composed matrix is scalar labelled %s\n", i, j, argn[0]->getName().c_str() );
+        } else {
+          log.printf("  %d %d component of composed matrix is %d by %d matrix labelled %s\n", i, j, argn[0]->getShape()[0], argn[0]->getShape()[1], argn[0]->getName().c_str() );
+        }
+      }
+      if( arglist.size()==size_b4 ) {
+        break;
+      }
+      if( i==1 ) {
+        ncols=nt_cols;
+      } else if( nt_cols!=ncols ) {
+        error("should be joining same number of matrices in each row");
       }
-      if( arglist.size()==size_b4 ) break;
-      if( i==1 ) ncols=nt_cols;
-      else if( nt_cols!=ncols ) error("should be joining same number of matrices in each row");
       nrows++;
     }
 
-    std::vector<unsigned> shape(2); shape[0]=0; unsigned k=0;
-    row_starts.resize( arglist.size() ); col_starts.resize( arglist.size() );
+    std::vector<unsigned> shape(2);
+    shape[0]=0;
+    unsigned k=0;
+    row_starts.resize( arglist.size() );
+    col_starts.resize( arglist.size() );
     for(unsigned i=0; i<nrows; ++i) {
-      unsigned cstart = 0, nr = 1; if( arglist[k]->getRank()==2 ) nr=arglist[k]->getShape()[0];
+      unsigned cstart = 0, nr = 1;
+      if( arglist[k]->getRank()==2 ) {
+        nr=arglist[k]->getShape()[0];
+      }
       for(unsigned j=0; j<ncols; ++j) {
         if( arglist[k]->getRank()==0 ) {
-          if( nr!=1 ) error("mismatched matrix sizes");
-        } else if( nrows>1 && arglist[k]->getShape()[0]!=nr ) error("mismatched matrix sizes");
-        row_starts[k] = shape[0]; col_starts[k] = cstart;
-        if( arglist[k]->getRank()==0 ) cstart += 1;
-        else cstart += arglist[k]->getShape()[1];
+          if( nr!=1 ) {
+            error("mismatched matrix sizes");
+          }
+        } else if( nrows>1 && arglist[k]->getShape()[0]!=nr ) {
+          error("mismatched matrix sizes");
+        }
+        row_starts[k] = shape[0];
+        col_starts[k] = cstart;
+        if( arglist[k]->getRank()==0 ) {
+          cstart += 1;
+        } else {
+          cstart += arglist[k]->getShape()[1];
+        }
         k++;
       }
-      if( i==0 ) shape[1]=cstart;
-      else if( cstart!=shape[1] ) error("mismatched matrix sizes");
-      if( arglist[k-1]->getRank()==0 ) shape[0] += 1;
-      else shape[0] += arglist[k-1]->getShape()[0];
+      if( i==0 ) {
+        shape[1]=cstart;
+      } else if( cstart!=shape[1] ) {
+        error("mismatched matrix sizes");
+      }
+      if( arglist[k-1]->getRank()==0 ) {
+        shape[0] += 1;
+      } else {
+        shape[0] += arglist[k-1]->getShape()[0];
+      }
     }
     // Now request the arguments to make sure we store things we need
-    requestArguments(arglist); addValue( shape ); setNotPeriodic(); getPntrToComponent(0)->buildDataStore();
-    if( getPntrToComponent(0)->getRank()==2 ) getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+    requestArguments(arglist);
+    addValue( shape );
+    setNotPeriodic();
+    getPntrToComponent(0)->buildDataStore();
+    if( getPntrToComponent(0)->getRank()==2 ) {
+      getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+    }
   }
 }
 
@@ -135,8 +207,12 @@ void Concatenate::calculate() {
   if( vectors ) {
     unsigned k=0;
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-      Value* myarg=getPntrToArgument(i); unsigned nvals=myarg->getNumberOfValues();
-      for(unsigned j=0; j<nvals; ++j) { myval->set( k, myarg->get(j) ); k++; }
+      Value* myarg=getPntrToArgument(i);
+      unsigned nvals=myarg->getNumberOfValues();
+      for(unsigned j=0; j<nvals; ++j) {
+        myval->set( k, myarg->get(j) );
+        k++;
+      }
     }
   } else {
     // Retrieve the matrix from input
@@ -146,13 +222,17 @@ void Concatenate::calculate() {
       if( argn->getRank()==0 ) {
         myval->set( ncols*row_starts[k]+col_starts[k], argn->get() );
       } else {
-        std::vector<double> vals; std::vector<std::pair<unsigned,unsigned> > pairs;
+        std::vector<double> vals;
+        std::vector<std::pair<unsigned,unsigned> > pairs;
         bool symmetric=getPntrToArgument(k)->isSymmetric();
-        unsigned nedge=0; getPntrToArgument(k)->retrieveEdgeList( nedge, pairs, vals );
+        unsigned nedge=0;
+        getPntrToArgument(k)->retrieveEdgeList( nedge, pairs, vals );
         for(unsigned l=0; l<nedge; ++l ) {
           unsigned i=pairs[l].first, j=pairs[l].second;
           myval->set( ncols*(row_starts[k]+i)+col_starts[k]+j, vals[l] );
-          if( symmetric ) myval->set( ncols*(row_starts[k]+j)+col_starts[k]+i, vals[l] );
+          if( symmetric ) {
+            myval->set( ncols*(row_starts[k]+j)+col_starts[k]+i, vals[l] );
+          }
         }
       }
     }
@@ -160,26 +240,35 @@ void Concatenate::calculate() {
 }
 
 void Concatenate::apply() {
-  if( doNotCalculateDerivatives() || !getPntrToComponent(0)->forcesWereAdded() ) return;
+  if( doNotCalculateDerivatives() || !getPntrToComponent(0)->forcesWereAdded() ) {
+    return;
+  }
 
   Value* val=getPntrToComponent(0);
   if( vectors ) {
     unsigned k=0;
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-      Value* myarg=getPntrToArgument(i); unsigned nvals=myarg->getNumberOfValues();
-      for(unsigned j=0; j<nvals; ++j) { myarg->addForce( j, val->getForce(k) ); k++; }
+      Value* myarg=getPntrToArgument(i);
+      unsigned nvals=myarg->getNumberOfValues();
+      for(unsigned j=0; j<nvals; ++j) {
+        myarg->addForce( j, val->getForce(k) );
+        k++;
+      }
     }
   } else {
     unsigned ncols=val->getShape()[1];
     for(unsigned k=0; k<getNumberOfArguments(); ++k) {
       Value* argn=getPntrToArgument(k);
-      if( argn->getRank()==0 ) argn->addForce( 0, val->getForce(ncols*row_starts[k]+col_starts[k]) );
-      else {
+      if( argn->getRank()==0 ) {
+        argn->addForce( 0, val->getForce(ncols*row_starts[k]+col_starts[k]) );
+      } else {
         unsigned val_ncols=val->getNumberOfColumns();
         unsigned arg_ncols=argn->getNumberOfColumns();
         for(unsigned i=0; i<argn->getShape()[0]; ++i) {
           unsigned ncol = argn->getRowLength(i);
-          for(unsigned j=0; j<ncol; ++j) argn->addForce( i*arg_ncols+j, val->getForce( val_ncols*(row_starts[k]+i)+col_starts[k]+argn->getRowIndex(i,j) ), false );
+          for(unsigned j=0; j<ncol; ++j) {
+            argn->addForce( i*arg_ncols+j, val->getForce( val_ncols*(row_starts[k]+i)+col_starts[k]+argn->getRowIndex(i,j) ), false );
+          }
         }
       }
     }
diff --git a/src/valtools/Flatten.cpp b/src/valtools/Flatten.cpp
index d1c9f488d4..1e52e8ca81 100644
--- a/src/valtools/Flatten.cpp
+++ b/src/valtools/Flatten.cpp
@@ -44,7 +44,9 @@ class Flatten :
 /// Constructor
   explicit Flatten(const ActionOptions&);
 /// Get the number of derivatives
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
 /// Do the calculation
   void calculate() override;
 ///
@@ -54,41 +56,60 @@ class Flatten :
 PLUMED_REGISTER_ACTION(Flatten,"FLATTEN")
 
 void Flatten::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.use("ARG");
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  keys.use("ARG");
   keys.setValueDescription("a vector containing all the elements of the input matrix");
 }
 
 Flatten::Flatten(const ActionOptions& ao):
   Action(ao),
   ActionWithValue(ao),
-  ActionWithArguments(ao)
-{
-  if( getNumberOfArguments()!=1 ) error("should only be one argument for this action");
-  if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) error("input to this action should be a matrix");
+  ActionWithArguments(ao) {
+  if( getNumberOfArguments()!=1 ) {
+    error("should only be one argument for this action");
+  }
+  if( getPntrToArgument(0)->getRank()!=2 || getPntrToArgument(0)->hasDerivatives() ) {
+    error("input to this action should be a matrix");
+  }
   getPntrToArgument(0)->buildDataStore(true);
   std::vector<unsigned> inshape( getPntrToArgument(0)->getShape() );
-  std::vector<unsigned> shape( 1 ); shape[0]=inshape[0]*inshape[1];
-  addValue( shape ); setNotPeriodic(); getPntrToComponent(0)->buildDataStore();
+  std::vector<unsigned> shape( 1 );
+  shape[0]=inshape[0]*inshape[1];
+  addValue( shape );
+  setNotPeriodic();
+  getPntrToComponent(0)->buildDataStore();
 }
 
 void Flatten::calculate() {
-  Value* myval = getPntrToComponent(0); unsigned ss=getPntrToArgument(0)->getShape()[1];
-  std::vector<double> vals; std::vector<std::pair<unsigned,unsigned> > pairs;
+  Value* myval = getPntrToComponent(0);
+  unsigned ss=getPntrToArgument(0)->getShape()[1];
+  std::vector<double> vals;
+  std::vector<std::pair<unsigned,unsigned> > pairs;
   bool symmetric=getPntrToArgument(0)->isSymmetric();
-  unsigned nedge=0; getPntrToArgument(0)->retrieveEdgeList( nedge, pairs, vals );
+  unsigned nedge=0;
+  getPntrToArgument(0)->retrieveEdgeList( nedge, pairs, vals );
   for(unsigned l=0; l<nedge; ++l ) {
     unsigned i=pairs[l].first, j=pairs[l].second;
     myval->set( i*ss + j, vals[l] );
-    if( symmetric ) myval->set( j*ss + i, vals[l] );
+    if( symmetric ) {
+      myval->set( j*ss + i, vals[l] );
+    }
   }
 }
 
 void Flatten::apply() {
-  if( doNotCalculateDerivatives() || !getPntrToComponent(0)->forcesWereAdded() ) return;
+  if( doNotCalculateDerivatives() || !getPntrToComponent(0)->forcesWereAdded() ) {
+    return;
+  }
 
-  Value* myval=getPntrToComponent(0); Value* myarg=getPntrToArgument(0);
-  unsigned nvals=myval->getNumberOfValues(); for(unsigned j=0; j<nvals; ++j) myarg->addForce( j, myval->getForce(j) );
+  Value* myval=getPntrToComponent(0);
+  Value* myarg=getPntrToArgument(0);
+  unsigned nvals=myval->getNumberOfValues();
+  for(unsigned j=0; j<nvals; ++j) {
+    myarg->addForce( j, myval->getForce(j) );
+  }
 }
 
 }
diff --git a/src/valtools/SelectComponents.cpp b/src/valtools/SelectComponents.cpp
index a421ea4ae0..d8018e2568 100644
--- a/src/valtools/SelectComponents.cpp
+++ b/src/valtools/SelectComponents.cpp
@@ -50,40 +50,68 @@ void SelectComponents::registerKeywords( Keywords& keys ) {
   ActionShortcut::registerKeywords( keys );
   keys.add("compulsory","ARG","the argument we are using to build the shortcut");
   keys.add("compulsory","COMPONENTS","the components in the input value that you woul like to build a new vector from");
-  keys.needsAction("FLATTEN"); keys.needsAction("CONSTANT"); keys.needsAction("SELECT_WITH_MASK");
+  keys.needsAction("FLATTEN");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("SELECT_WITH_MASK");
   keys.setValueDescription("a vector containing the selected components");
 }
 
 SelectComponents::SelectComponents(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::vector<std::string> argn; parseVector("ARG",argn); std::vector<Value*> theargs;
+  ActionShortcut(ao) {
+  std::vector<std::string> argn;
+  parseVector("ARG",argn);
+  std::vector<Value*> theargs;
   ActionWithArguments::interpretArgumentList( argn, plumed.getActionSet(), this, theargs );
-  if( theargs.size()!=1 ) error("should only be one argument input to this action");
+  if( theargs.size()!=1 ) {
+    error("should only be one argument input to this action");
+  }
   // Create an array that will eventually hold the mask
   std::vector<double> mask( theargs[0]->getNumberOfValues(), 1 );
-  std::vector<std::string> elements; parseVector("COMPONENTS",elements);
+  std::vector<std::string> elements;
+  parseVector("COMPONENTS",elements);
   if( theargs[0]->getRank()==1 ) {
-    for(unsigned i=0; i<elements.size(); ++i) { unsigned sel; Tools::convert( elements[i], sel ); mask[sel-1]=0; }
+    for(unsigned i=0; i<elements.size(); ++i) {
+      unsigned sel;
+      Tools::convert( elements[i], sel );
+      mask[sel-1]=0;
+    }
   } else if( theargs[0]->getRank()==2 ) {
     for(unsigned i=0; i<elements.size(); ++i) {
       std::size_t dot = elements[i].find_first_of(".");
-      if( dot==std::string::npos ) error("found no dot in specification of required matrix element");
+      if( dot==std::string::npos ) {
+        error("found no dot in specification of required matrix element");
+      }
       std::string istr=elements[i].substr(0,dot), jstr=elements[i].substr(dot+1);
-      unsigned ival, jval; Tools::convert( istr, ival ); Tools::convert( jstr, jval );
+      unsigned ival, jval;
+      Tools::convert( istr, ival );
+      Tools::convert( jstr, jval );
       mask[(ival-1)*theargs[0]->getShape()[1] + jval - 1] = 0;
     }
     readInputLine( getShortcutLabel() + "_flat: FLATTEN ARG=" + theargs[0]->getName() );
-  } else error("input to this argument should be a vector/matrix");
+  } else {
+    error("input to this argument should be a vector/matrix");
+  }
   // Now create the mask action
-  std::string mask_str; Tools::convert( mask[0], mask_str ); unsigned check_mask=mask[0];
-  for(unsigned i=1; i<mask.size(); ++i) { std::string num; Tools::convert( mask[i], num ); mask_str += "," + num; check_mask +=mask[i]; }
-  if( mask.size()-check_mask!=elements.size() ) error("found repeated indexes in COMPONENTS");
+  std::string mask_str;
+  Tools::convert( mask[0], mask_str );
+  unsigned check_mask=mask[0];
+  for(unsigned i=1; i<mask.size(); ++i) {
+    std::string num;
+    Tools::convert( mask[i], num );
+    mask_str += "," + num;
+    check_mask +=mask[i];
+  }
+  if( mask.size()-check_mask!=elements.size() ) {
+    error("found repeated indexes in COMPONENTS");
+  }
   readInputLine( getShortcutLabel() + "_mask: CONSTANT VALUES=" + mask_str );
   // And finally create the selector
-  if( theargs[0]->getRank()==1 ) readInputLine( getShortcutLabel() + ": SELECT_WITH_MASK ARG=" + theargs[0]->getName() + " MASK=" + getShortcutLabel() + "_mask");
-  else if( theargs[0]->getRank()==2 ) readInputLine( getShortcutLabel() + ": SELECT_WITH_MASK ARG=" + getShortcutLabel() + "_flat MASK=" + getShortcutLabel() + "_mask");
+  if( theargs[0]->getRank()==1 ) {
+    readInputLine( getShortcutLabel() + ": SELECT_WITH_MASK ARG=" + theargs[0]->getName() + " MASK=" + getShortcutLabel() + "_mask");
+  } else if( theargs[0]->getRank()==2 ) {
+    readInputLine( getShortcutLabel() + ": SELECT_WITH_MASK ARG=" + getShortcutLabel() + "_flat MASK=" + getShortcutLabel() + "_mask");
+  }
 }
 
 }
diff --git a/src/valtools/SelectWithMask.cpp b/src/valtools/SelectWithMask.cpp
index ac480f15b7..507c811a48 100644
--- a/src/valtools/SelectWithMask.cpp
+++ b/src/valtools/SelectWithMask.cpp
@@ -47,7 +47,9 @@ class SelectWithMask :
 /// Constructor
   explicit SelectWithMask(const ActionOptions&);
 /// Get the number of derivatives
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
 ///
   void getMatrixColumnTitles( std::vector<std::string>& argnames ) const override ;
 ///
@@ -61,8 +63,10 @@ class SelectWithMask :
 PLUMED_REGISTER_ACTION(SelectWithMask,"SELECT_WITH_MASK")
 
 void SelectWithMask::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.use("ARG");
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  keys.use("ARG");
   keys.add("optional","ROW_MASK","an array with ones in the rows of the matrix that you want to discard");
   keys.add("optional","COLUMN_MASK","an array with ones in the columns of the matrix that you want to discard");
   keys.add("compulsory","MASK","an array with ones in the components that you want to discard");
@@ -72,97 +76,155 @@ void SelectWithMask::registerKeywords( Keywords& keys ) {
 SelectWithMask::SelectWithMask(const ActionOptions& ao):
   Action(ao),
   ActionWithValue(ao),
-  ActionWithArguments(ao)
-{
-  if( getNumberOfArguments()!=1 ) error("should only be one argument for this action");
-  getPntrToArgument(0)->buildDataStore(); std::vector<unsigned> shape;
+  ActionWithArguments(ao) {
+  if( getNumberOfArguments()!=1 ) {
+    error("should only be one argument for this action");
+  }
+  getPntrToArgument(0)->buildDataStore();
+  std::vector<unsigned> shape;
   if( getPntrToArgument(0)->getRank()==1 ) {
-    std::vector<Value*> mask; parseArgumentList("MASK",mask);
-    if( mask.size()!=1 ) error("should only be one input for mask");
-    if( mask[0]->getNumberOfValues()!=getPntrToArgument(0)->getNumberOfValues() ) error("mismatch between size of mask and input vector");
+    std::vector<Value*> mask;
+    parseArgumentList("MASK",mask);
+    if( mask.size()!=1 ) {
+      error("should only be one input for mask");
+    }
+    if( mask[0]->getNumberOfValues()!=getPntrToArgument(0)->getNumberOfValues() ) {
+      error("mismatch between size of mask and input vector");
+    }
     log.printf("  creating vector from elements of %s who have a corresponding element in %s that is zero\n", getPntrToArgument(0)->getName().c_str(), mask[0]->getName().c_str() );
-    std::vector<Value*> args( getArguments() ); args.push_back( mask[0] ); requestArguments( args );
-    shape.resize(1,0); if( (mask[0]->getPntrToAction())->getName()=="CONSTANT" ) shape[0]=getOutputVectorLength(mask[0]);
+    std::vector<Value*> args( getArguments() );
+    args.push_back( mask[0] );
+    requestArguments( args );
+    shape.resize(1,0);
+    if( (mask[0]->getPntrToAction())->getName()=="CONSTANT" ) {
+      shape[0]=getOutputVectorLength(mask[0]);
+    }
   } else if( getPntrToArgument(0)->getRank()==2 ) {
-    std::vector<Value*> rmask, cmask; parseArgumentList("ROW_MASK",rmask); parseArgumentList("COLUMN_MASK",cmask);
+    std::vector<Value*> rmask, cmask;
+    parseArgumentList("ROW_MASK",rmask);
+    parseArgumentList("COLUMN_MASK",cmask);
     if( rmask.size()==0 && cmask.size()==0 ) {
       error("no mask elements have been specified");
     } else if( cmask.size()==0 ) {
-      std::string con="0"; for(unsigned i=1; i<getPntrToArgument(0)->getShape()[1]; ++i) con += ",0";
-      plumed.readInputLine( getLabel() + "_colmask: CONSTANT VALUES=" + con ); std::vector<std::string> labs(1, getLabel() + "_colmask");
+      std::string con="0";
+      for(unsigned i=1; i<getPntrToArgument(0)->getShape()[1]; ++i) {
+        con += ",0";
+      }
+      plumed.readInputLine( getLabel() + "_colmask: CONSTANT VALUES=" + con );
+      std::vector<std::string> labs(1, getLabel() + "_colmask");
       ActionWithArguments::interpretArgumentList( labs, plumed.getActionSet(), this, cmask );
     } else if( rmask.size()==0 ) {
-      std::string con="0"; for(unsigned i=1; i<getPntrToArgument(0)->getShape()[0]; ++i) con += ",0";
-      plumed.readInputLine( getLabel() + "_rowmask: CONSTANT VALUES=" + con ); std::vector<std::string> labs(1, getLabel() + "_rowmask");
+      std::string con="0";
+      for(unsigned i=1; i<getPntrToArgument(0)->getShape()[0]; ++i) {
+        con += ",0";
+      }
+      plumed.readInputLine( getLabel() + "_rowmask: CONSTANT VALUES=" + con );
+      std::vector<std::string> labs(1, getLabel() + "_rowmask");
       ActionWithArguments::interpretArgumentList( labs, plumed.getActionSet(), this, rmask );
     }
     shape.resize(2);
-    rmask[0]->buildDataStore(); shape[0] = getOutputVectorLength( rmask[0] );
-    cmask[0]->buildDataStore(); shape[1] = getOutputVectorLength( cmask[0] );
-    std::vector<Value*> args( getArguments() ); args.push_back( rmask[0] );
-    args.push_back( cmask[0] ); requestArguments( args );
-  } else error("input should be vector or matrix");
+    rmask[0]->buildDataStore();
+    shape[0] = getOutputVectorLength( rmask[0] );
+    cmask[0]->buildDataStore();
+    shape[1] = getOutputVectorLength( cmask[0] );
+    std::vector<Value*> args( getArguments() );
+    args.push_back( rmask[0] );
+    args.push_back( cmask[0] );
+    requestArguments( args );
+  } else {
+    error("input should be vector or matrix");
+  }
 
-  addValue( shape ); getPntrToComponent(0)->buildDataStore();
+  addValue( shape );
+  getPntrToComponent(0)->buildDataStore();
   if( getPntrToArgument(0)->isPeriodic() ) {
-    std::string min, max; getPntrToArgument(0)->getDomain( min, max ); setPeriodic( min, max );
-  } else setNotPeriodic();
-  if( getPntrToComponent(0)->getRank()==2 ) getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+    std::string min, max;
+    getPntrToArgument(0)->getDomain( min, max );
+    setPeriodic( min, max );
+  } else {
+    setNotPeriodic();
+  }
+  if( getPntrToComponent(0)->getRank()==2 ) {
+    getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+  }
 }
 
 unsigned SelectWithMask::getOutputVectorLength( const Value* mask ) const  {
   unsigned l=0;
   for(unsigned i=0; i<mask->getNumberOfValues(); ++i) {
-    if( fabs(mask->get(i))>0 ) continue;
+    if( fabs(mask->get(i))>0 ) {
+      continue;
+    }
     l++;
   }
   return l;
 }
 
 void SelectWithMask::getMatrixColumnTitles( std::vector<std::string>& argnames ) const {
-  std::vector<std::string> alltitles; (getPntrToArgument(0)->getPntrToAction())->getMatrixColumnTitles( alltitles );
+  std::vector<std::string> alltitles;
+  (getPntrToArgument(0)->getPntrToAction())->getMatrixColumnTitles( alltitles );
   for(unsigned i=0; i<alltitles.size(); ++i) {
-    if( fabs(getPntrToArgument(2)->get(i))>0 ) continue;
+    if( fabs(getPntrToArgument(2)->get(i))>0 ) {
+      continue;
+    }
     argnames.push_back( alltitles[i] );
   }
 }
 
 void SelectWithMask::prepare() {
-  Value* arg = getPntrToArgument(0); Value* out = getPntrToComponent(0);
+  Value* arg = getPntrToArgument(0);
+  Value* out = getPntrToComponent(0);
   if( arg->getRank()==1 ) {
     Value* mask = getPntrToArgument(1);
-    std::vector<unsigned> shape(1); shape[0]=getOutputVectorLength( mask );
+    std::vector<unsigned> shape(1);
+    shape[0]=getOutputVectorLength( mask );
     if( out->getNumberOfValues()!=shape[0] ) {
-      if( shape[0]==1 ) shape.resize(0);
+      if( shape[0]==1 ) {
+        shape.resize(0);
+      }
       out->setShape(shape);
     }
   } else if( arg->getRank()==2 ) {
     std::vector<unsigned> outshape(2);
-    Value* rmask = getPntrToArgument(1); outshape[0] = getOutputVectorLength( rmask );
-    Value* cmask = getPntrToArgument(2); outshape[1] = getOutputVectorLength( cmask );
+    Value* rmask = getPntrToArgument(1);
+    outshape[0] = getOutputVectorLength( rmask );
+    Value* cmask = getPntrToArgument(2);
+    outshape[1] = getOutputVectorLength( cmask );
     if( out->getShape()[0]!=outshape[0] || out->getShape()[1]!=outshape[1] ) {
-      out->setShape(outshape); out->reshapeMatrixStore( outshape[1] );
+      out->setShape(outshape);
+      out->reshapeMatrixStore( outshape[1] );
     }
   }
 }
 
 void SelectWithMask::calculate() {
-  Value* arg = getPntrToArgument(0); Value* out = getPntrToComponent(0);
+  Value* arg = getPntrToArgument(0);
+  Value* out = getPntrToComponent(0);
   if( arg->getRank()==1 ) {
-    Value* mask = getPntrToArgument(1); unsigned n=0;
+    Value* mask = getPntrToArgument(1);
+    unsigned n=0;
     for(unsigned i=0; i<mask->getNumberOfValues(); ++i) {
-      if( fabs(mask->get(i))>0 ) continue;
-      out->set(n, arg->get(i) ); n++;
+      if( fabs(mask->get(i))>0 ) {
+        continue;
+      }
+      out->set(n, arg->get(i) );
+      n++;
     }
   } else if ( arg->getRank()==2 ) {
     std::vector<unsigned> outshape( out->getShape() );
-    unsigned n = 0; std::vector<unsigned> inshape( arg->getShape() );
-    Value* rmask = getPntrToArgument(1); Value* cmask = getPntrToArgument(2);
+    unsigned n = 0;
+    std::vector<unsigned> inshape( arg->getShape() );
+    Value* rmask = getPntrToArgument(1);
+    Value* cmask = getPntrToArgument(2);
     for(unsigned i=0; i<inshape[0]; ++i) {
-      if( fabs(rmask->get(i))>0 ) continue;
+      if( fabs(rmask->get(i))>0 ) {
+        continue;
+      }
       unsigned m = 0;
       for(unsigned j=0; j<inshape[1]; ++j) {
-        if( fabs(cmask->get(j))>0 ) continue;
+        if( fabs(cmask->get(j))>0 ) {
+          continue;
+        }
         out->set( n*outshape[1] + m, arg->get(i*inshape[1] + j) );
         m++;
       }
@@ -172,25 +234,37 @@ void SelectWithMask::calculate() {
 }
 
 void SelectWithMask::apply() {
-  if( doNotCalculateDerivatives() || !getPntrToComponent(0)->forcesWereAdded() ) return ;
+  if( doNotCalculateDerivatives() || !getPntrToComponent(0)->forcesWereAdded() ) {
+    return ;
+  }
 
-  Value* arg = getPntrToArgument(0); Value* out = getPntrToComponent(0);
+  Value* arg = getPntrToArgument(0);
+  Value* out = getPntrToComponent(0);
   if( arg->getRank()==1 ) {
-    unsigned n=0; Value* mask = getPntrToArgument(1);
+    unsigned n=0;
+    Value* mask = getPntrToArgument(1);
     for(unsigned i=0; i<mask->getNumberOfValues(); ++i) {
-      if( fabs(mask->get(i))>0 ) continue;
-      arg->addForce(i, out->getForce(n) ); n++;
+      if( fabs(mask->get(i))>0 ) {
+        continue;
+      }
+      arg->addForce(i, out->getForce(n) );
+      n++;
     }
   } else if( arg->getRank()==2 ) {
     unsigned n = 0;
     std::vector<unsigned> inshape( arg->getShape() );
     std::vector<unsigned> outshape( out->getShape() );
-    Value* rmask = getPntrToArgument(1); Value* cmask = getPntrToArgument(2);
+    Value* rmask = getPntrToArgument(1);
+    Value* cmask = getPntrToArgument(2);
     for(unsigned i=0; i<inshape[0]; ++i) {
-      if( fabs(rmask->get(i))>0 ) continue;
+      if( fabs(rmask->get(i))>0 ) {
+        continue;
+      }
       unsigned m = 0;
       for(unsigned j=0; j<inshape[1]; ++j) {
-        if( fabs(cmask->get(j))>0 ) continue;
+        if( fabs(cmask->get(j))>0 ) {
+          continue;
+        }
         arg->addForce( i*inshape[1] + j, out->getForce(n*outshape[1] + m) );
         m++;
       }
diff --git a/src/valtools/VStack.cpp b/src/valtools/VStack.cpp
index 209e817e93..1f13c6b55c 100644
--- a/src/valtools/VStack.cpp
+++ b/src/valtools/VStack.cpp
@@ -42,11 +42,15 @@ class VStack : public ActionWithMatrix {
 /// Constructor
   explicit VStack(const ActionOptions&);
 /// Get the number of derivatives
-  unsigned getNumberOfDerivatives() override { return 0; }
+  unsigned getNumberOfDerivatives() override {
+    return 0;
+  }
 ///
   void prepare() override ;
 ///
-  unsigned getNumberOfColumns() const override { return getNumberOfArguments(); }
+  unsigned getNumberOfColumns() const override {
+    return getNumberOfArguments();
+  }
 ///
   void setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const override ;
 ///
@@ -60,99 +64,169 @@ class VStack : public ActionWithMatrix {
 PLUMED_REGISTER_ACTION(VStack,"VSTACK")
 
 void VStack::registerKeywords( Keywords& keys ) {
-  ActionWithMatrix::registerKeywords( keys ); keys.use("ARG");
+  ActionWithMatrix::registerKeywords( keys );
+  keys.use("ARG");
   keys.setValueDescription("a matrix that contains the input vectors in its columns");
 }
 
 VStack::VStack(const ActionOptions& ao):
   Action(ao),
-  ActionWithMatrix(ao)
-{
-  if( getNumberOfArguments()==0 ) error("no arguments were specificed");
-  if( getPntrToArgument(0)->getRank()>1 ) error("all arguments should be vectors");
-  unsigned nvals=1; bool periodic=false; std::string smin, smax;
-  if( getPntrToArgument(0)->getRank()==1 ) nvals = getPntrToArgument(0)->getShape()[0];
-  if( getPntrToArgument(0)->isPeriodic() ) { periodic=true; getPntrToArgument(0)->getDomain( smin, smax ); }
+  ActionWithMatrix(ao) {
+  if( getNumberOfArguments()==0 ) {
+    error("no arguments were specificed");
+  }
+  if( getPntrToArgument(0)->getRank()>1 ) {
+    error("all arguments should be vectors");
+  }
+  unsigned nvals=1;
+  bool periodic=false;
+  std::string smin, smax;
+  if( getPntrToArgument(0)->getRank()==1 ) {
+    nvals = getPntrToArgument(0)->getShape()[0];
+  }
+  if( getPntrToArgument(0)->isPeriodic() ) {
+    periodic=true;
+    getPntrToArgument(0)->getDomain( smin, smax );
+  }
 
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    if( getPntrToArgument(i)->getRank()>1 || (getPntrToArgument(i)->getRank()==1 && getPntrToArgument(i)->hasDerivatives()) ) error("all arguments should be vectors");
+    if( getPntrToArgument(i)->getRank()>1 || (getPntrToArgument(i)->getRank()==1 && getPntrToArgument(i)->hasDerivatives()) ) {
+      error("all arguments should be vectors");
+    }
     if( getPntrToArgument(i)->getRank()==0 ) {
-      if( nvals!=1 ) error("all input vector should have same number of elements");
-    } else if( getPntrToArgument(i)->getShape()[0]!=nvals ) error("all input vector should have same number of elements");
+      if( nvals!=1 ) {
+        error("all input vector should have same number of elements");
+      }
+    } else if( getPntrToArgument(i)->getShape()[0]!=nvals ) {
+      error("all input vector should have same number of elements");
+    }
     if( periodic ) {
-      if( !getPntrToArgument(i)->isPeriodic() ) error("one argument is periodic but " + getPntrToArgument(i)->getName() + " is not periodic");
-      std::string tmin, tmax; getPntrToArgument(i)->getDomain( tmin, tmax );
-      if( tmin!=smin || tmax!=smax ) error("domain of argument " + getPntrToArgument(i)->getName() + " is different from domain for all other arguments");
-    } else if( getPntrToArgument(i)->isPeriodic() ) error("one argument is not periodic but " + getPntrToArgument(i)->getName() + " is periodic");
+      if( !getPntrToArgument(i)->isPeriodic() ) {
+        error("one argument is periodic but " + getPntrToArgument(i)->getName() + " is not periodic");
+      }
+      std::string tmin, tmax;
+      getPntrToArgument(i)->getDomain( tmin, tmax );
+      if( tmin!=smin || tmax!=smax ) {
+        error("domain of argument " + getPntrToArgument(i)->getName() + " is different from domain for all other arguments");
+      }
+    } else if( getPntrToArgument(i)->isPeriodic() ) {
+      error("one argument is not periodic but " + getPntrToArgument(i)->getName() + " is periodic");
+    }
   }
   // And create a value to hold the matrix
-  std::vector<unsigned> shape(2); shape[0]=nvals; shape[1]=getNumberOfArguments(); addValue( shape );
-  if( periodic ) setPeriodic( smin, smax ); else setNotPeriodic();
+  std::vector<unsigned> shape(2);
+  shape[0]=nvals;
+  shape[1]=getNumberOfArguments();
+  addValue( shape );
+  if( periodic ) {
+    setPeriodic( smin, smax );
+  } else {
+    setNotPeriodic();
+  }
   // And store this value
-  getPntrToComponent(0)->buildDataStore(); getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+  getPntrToComponent(0)->buildDataStore();
+  getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
   // Setup everything so we can build the store
-  done_in_chain=true; ActionWithVector* av=dynamic_cast<ActionWithVector*>( getPntrToArgument(0)->getPntrToAction() );
+  done_in_chain=true;
+  ActionWithVector* av=dynamic_cast<ActionWithVector*>( getPntrToArgument(0)->getPntrToAction() );
   if( av ) {
     const ActionWithVector* head0 = av->getFirstActionInChain();
     for(unsigned i=0; i<getNumberOfArguments(); ++i) {
       ActionWithVector* avv=dynamic_cast<ActionWithVector*>( getPntrToArgument(i)->getPntrToAction() );
-      if( !avv ) continue;
-      if( head0!=avv->getFirstActionInChain() ) { done_in_chain=false; break; }
+      if( !avv ) {
+        continue;
+      }
+      if( head0!=avv->getFirstActionInChain() ) {
+        done_in_chain=false;
+        break;
+      }
     }
-  } else done_in_chain=false;
+  } else {
+    done_in_chain=false;
+  }
   unsigned nder = buildArgumentStore(0);
   // This checks which values have been stored
-  stored.resize( getNumberOfArguments() ); std::string headstr=getFirstActionInChain()->getLabel();
-  for(unsigned i=0; i<stored.size(); ++i) stored[i] = getPntrToArgument(i)->ignoreStoredValue( headstr );
+  stored.resize( getNumberOfArguments() );
+  std::string headstr=getFirstActionInChain()->getLabel();
+  for(unsigned i=0; i<stored.size(); ++i) {
+    stored[i] = getPntrToArgument(i)->ignoreStoredValue( headstr );
+  }
 }
 
 void VStack::getMatrixColumnTitles( std::vector<std::string>& argnames ) const {
   for(unsigned j=0; j<getNumberOfArguments(); ++j) {
     if( (getPntrToArgument(j)->getPntrToAction())->getName()=="COLLECT" ) {
       ActionWithArguments* aa = dynamic_cast<ActionWithArguments*>( getPntrToArgument(j)->getPntrToAction() );
-      plumed_assert( aa && aa->getNumberOfArguments()==1 ); argnames.push_back( (aa->getPntrToArgument(0))->getName() );
-    } else argnames.push_back( getPntrToArgument(j)->getName() );
+      plumed_assert( aa && aa->getNumberOfArguments()==1 );
+      argnames.push_back( (aa->getPntrToArgument(0))->getName() );
+    } else {
+      argnames.push_back( getPntrToArgument(j)->getName() );
+    }
   }
 }
 
 void VStack::prepare() {
   ActionWithVector::prepare();
-  if( getPntrToArgument(0)->getRank()==0 || getPntrToArgument(0)->getShape()[0]==getPntrToComponent(0)->getShape()[0] ) return ;
-  std::vector<unsigned> shape(2); shape[0] = getPntrToArgument(0)->getShape()[0]; shape[1] = getNumberOfArguments();
-  getPntrToComponent(0)->setShape(shape); getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
+  if( getPntrToArgument(0)->getRank()==0 || getPntrToArgument(0)->getShape()[0]==getPntrToComponent(0)->getShape()[0] ) {
+    return ;
+  }
+  std::vector<unsigned> shape(2);
+  shape[0] = getPntrToArgument(0)->getShape()[0];
+  shape[1] = getNumberOfArguments();
+  getPntrToComponent(0)->setShape(shape);
+  getPntrToComponent(0)->reshapeMatrixStore( shape[1] );
 }
 
 void VStack::setupForTask( const unsigned& task_index, std::vector<unsigned>& indices, MultiValue& myvals ) const {
-  unsigned nargs = getNumberOfArguments(); unsigned nvals = getConstPntrToComponent(0)->getShape()[0];
-  if( indices.size()!=nargs+1 ) indices.resize( nargs+1 );
-  for(unsigned i=0; i<nargs; ++i) indices[i+1] = nvals + i;
+  unsigned nargs = getNumberOfArguments();
+  unsigned nvals = getConstPntrToComponent(0)->getShape()[0];
+  if( indices.size()!=nargs+1 ) {
+    indices.resize( nargs+1 );
+  }
+  for(unsigned i=0; i<nargs; ++i) {
+    indices[i+1] = nvals + i;
+  }
   myvals.setSplitIndex( nargs + 1 );
 }
 
 void VStack::performTask( const std::string& controller, const unsigned& index1, const unsigned& index2, MultiValue& myvals ) const {
-  unsigned ind2 = index2; if( index2>=getConstPntrToComponent(0)->getShape()[0] ) ind2 = index2 - getConstPntrToComponent(0)->getShape()[0];
+  unsigned ind2 = index2;
+  if( index2>=getConstPntrToComponent(0)->getShape()[0] ) {
+    ind2 = index2 - getConstPntrToComponent(0)->getShape()[0];
+  }
   myvals.addValue( getConstPntrToComponent(0)->getPositionInStream(), getArgumentElement( ind2, index1, myvals ) );
 
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
   addDerivativeOnVectorArgument( stored[ind2], 0, ind2, index1, 1.0, myvals );
 }
 
 void VStack::runEndOfRowJobs( const unsigned& ival, const std::vector<unsigned> & indices, MultiValue& myvals ) const {
-  if( doNotCalculateDerivatives() || !matrixChainContinues() ) return ;
+  if( doNotCalculateDerivatives() || !matrixChainContinues() ) {
+    return ;
+  }
 
   unsigned nmat = getConstPntrToComponent(0)->getPositionInMatrixStash(), nmat_ind = myvals.getNumberOfMatrixRowDerivatives( nmat );
   std::vector<unsigned>& matrix_indices( myvals.getMatrixRowDerivativeIndices( nmat ) );
   plumed_assert( nmat_ind<matrix_indices.size() );
   for(unsigned i=0; i<getNumberOfArguments(); ++i) {
-    bool found=false; ActionWithValue* iav = getPntrToArgument(i)->getPntrToAction();
+    bool found=false;
+    ActionWithValue* iav = getPntrToArgument(i)->getPntrToAction();
     for(unsigned j=0; j<i; ++j) {
-      if( iav==getPntrToArgument(j)->getPntrToAction() ) { found=true; break; }
+      if( iav==getPntrToArgument(j)->getPntrToAction() ) {
+        found=true;
+        break;
+      }
+    }
+    if( found ) {
+      continue ;
     }
-    if( found ) continue ;
 
     unsigned istrn = getPntrToArgument(i)->getPositionInStream();
     for(unsigned k=0; k<myvals.getNumberActive(istrn); ++k) {
-      matrix_indices[nmat_ind] = myvals.getActiveIndex(istrn,k); nmat_ind++;
+      matrix_indices[nmat_ind] = myvals.getActiveIndex(istrn,k);
+      nmat_ind++;
     }
   }
   myvals.setNumberOfMatrixRowDerivatives( nmat, nmat_ind );
diff --git a/src/vatom/ArgsToVatom.cpp b/src/vatom/ArgsToVatom.cpp
index da8147730e..7d9d5dbf28 100644
--- a/src/vatom/ArgsToVatom.cpp
+++ b/src/vatom/ArgsToVatom.cpp
@@ -50,7 +50,9 @@ class ArgsToVatom :
 /// Constructor
   explicit ArgsToVatom(const ActionOptions&);
 /// Get the number of derivatives
-  unsigned getNumberOfDerivatives() override { return getNumberOfArguments(); }
+  unsigned getNumberOfDerivatives() override {
+    return getNumberOfArguments();
+  }
 /// Do the calculation
   void calculate() override;
 ///
@@ -60,7 +62,9 @@ class ArgsToVatom :
 PLUMED_REGISTER_ACTION(ArgsToVatom,"ARGS2VATOM")
 
 void ArgsToVatom::registerKeywords( Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys ); ActionWithArguments::registerKeywords( keys );
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
   keys.add("compulsory","XPOS","the x position of the atom");
   keys.add("compulsory","YPOS","the y position of the atom");
   keys.add("compulsory","ZPOS","the z position of the atom");
@@ -80,81 +84,146 @@ void ArgsToVatom::registerKeywords( Keywords& keys ) {
 ArgsToVatom::ArgsToVatom(const ActionOptions& ao):
   Action(ao),
   ActionWithValue(ao),
-  ActionWithArguments(ao)
-{
+  ActionWithArguments(ao) {
   parseFlag("FRACTIONAL",fractional);
-  std::vector<Value*> xpos; parseArgumentList("XPOS",xpos);
-  if( xpos.size()!=1 && xpos[0]->getRank()!=0 ) error("invalid input argument for XPOS");
-  std::vector<Value*> ypos; parseArgumentList("YPOS",ypos);
-  if( ypos.size()!=1 && ypos[0]->getRank()!=0 ) error("invalid input argument for YPOS");
-  std::vector<Value*> zpos; parseArgumentList("ZPOS",zpos);
-  if( zpos.size()!=1 && zpos[0]->getRank()!=0 ) error("invalid input argument for ZPOS");
-  std::vector<Value*> mass; parseArgumentList("MASS",mass);
-  if( mass.size()!=1 && mass[0]->getRank()!=0 ) error("invalid input argument for MASS");
-  std::vector<Value*> charge; parseArgumentList("CHARGE",charge);
-  if( charge.size()!=1 && charge[0]->getRank()!=0 ) error("invalid input argument for CHARGE");
+  std::vector<Value*> xpos;
+  parseArgumentList("XPOS",xpos);
+  if( xpos.size()!=1 && xpos[0]->getRank()!=0 ) {
+    error("invalid input argument for XPOS");
+  }
+  std::vector<Value*> ypos;
+  parseArgumentList("YPOS",ypos);
+  if( ypos.size()!=1 && ypos[0]->getRank()!=0 ) {
+    error("invalid input argument for YPOS");
+  }
+  std::vector<Value*> zpos;
+  parseArgumentList("ZPOS",zpos);
+  if( zpos.size()!=1 && zpos[0]->getRank()!=0 ) {
+    error("invalid input argument for ZPOS");
+  }
+  std::vector<Value*> mass;
+  parseArgumentList("MASS",mass);
+  if( mass.size()!=1 && mass[0]->getRank()!=0 ) {
+    error("invalid input argument for MASS");
+  }
+  std::vector<Value*> charge;
+  parseArgumentList("CHARGE",charge);
+  if( charge.size()!=1 && charge[0]->getRank()!=0 ) {
+    error("invalid input argument for CHARGE");
+  }
   // Make sure we have requested everything that we need in xpos
-  xpos.push_back(ypos[0]); xpos.push_back(zpos[0]); xpos.push_back(mass[0]); xpos.push_back(charge[0]);
+  xpos.push_back(ypos[0]);
+  xpos.push_back(zpos[0]);
+  xpos.push_back(mass[0]);
+  xpos.push_back(charge[0]);
   if( fractional ) {
     log.printf("  creating atom from fractional pos a=%s, b=%s and c=%s \n", xpos[0]->getName().c_str(), ypos[0]->getName().c_str(), zpos[0]->getName().c_str() );
-    std::vector<Value*> xbkp; parseArgumentList("XBKP",xbkp);
+    std::vector<Value*> xbkp;
+    parseArgumentList("XBKP",xbkp);
     if( xbkp.size()>0 ) {
-      if( xbkp.size()!=1 && xbkp[0]->getRank()!=0 ) error("invalid input argument for XBKP");
-      std::vector<Value*> ybkp; parseArgumentList("YBKP",ybkp);
-      if( ybkp.size()!=1 && ybkp[0]->getRank()!=0 ) error("invalid input argument for YBKP");
-      std::vector<Value*> zbkp; parseArgumentList("ZBKP",zbkp);
-      if( zbkp.size()!=1 && zpos[0]->getRank()!=0 ) error("invalid input argument for ZBKP");
+      if( xbkp.size()!=1 && xbkp[0]->getRank()!=0 ) {
+        error("invalid input argument for XBKP");
+      }
+      std::vector<Value*> ybkp;
+      parseArgumentList("YBKP",ybkp);
+      if( ybkp.size()!=1 && ybkp[0]->getRank()!=0 ) {
+        error("invalid input argument for YBKP");
+      }
+      std::vector<Value*> zbkp;
+      parseArgumentList("ZBKP",zbkp);
+      if( zbkp.size()!=1 && zpos[0]->getRank()!=0 ) {
+        error("invalid input argument for ZBKP");
+      }
       // Store backup for NOPBC
-      xpos.push_back(xbkp[0]); xpos.push_back(ybkp[0]); xpos.push_back(zbkp[0]);
+      xpos.push_back(xbkp[0]);
+      xpos.push_back(ybkp[0]);
+      xpos.push_back(zbkp[0]);
       log.printf("  using x=%s, y=%s and z=%s if PBC not set \n", xbkp[0]->getName().c_str(), ybkp[0]->getName().c_str(), zbkp[0]->getName().c_str() );
     }
-  } else log.printf("  creating atom at x=%s, y=%s and z=%s \n", xpos[0]->getName().c_str(), ypos[0]->getName().c_str(), zpos[0]->getName().c_str() );
+  } else {
+    log.printf("  creating atom at x=%s, y=%s and z=%s \n", xpos[0]->getName().c_str(), ypos[0]->getName().c_str(), zpos[0]->getName().c_str() );
+  }
   log.printf("  mass of atom is %s and charge is %s \n", mass[0]->getName().c_str(), charge[0]->getName().c_str() );
   // Request the arguments
   requestArguments(xpos);
   // Create the components to hold the atom
-  addComponentWithDerivatives("x"); componentIsNotPeriodic("x");
-  addComponentWithDerivatives("y"); componentIsNotPeriodic("y");
-  addComponentWithDerivatives("z"); componentIsNotPeriodic("z");
-  addComponent("mass"); componentIsNotPeriodic("mass"); if( mass[0]->isConstant() ) getPntrToComponent(3)->setConstant();
-  addComponent("charge"); componentIsNotPeriodic("charge"); if( charge[0]->isConstant() ) getPntrToComponent(4)->setConstant();
+  addComponentWithDerivatives("x");
+  componentIsNotPeriodic("x");
+  addComponentWithDerivatives("y");
+  componentIsNotPeriodic("y");
+  addComponentWithDerivatives("z");
+  componentIsNotPeriodic("z");
+  addComponent("mass");
+  componentIsNotPeriodic("mass");
+  if( mass[0]->isConstant() ) {
+    getPntrToComponent(3)->setConstant();
+  }
+  addComponent("charge");
+  componentIsNotPeriodic("charge");
+  if( charge[0]->isConstant() ) {
+    getPntrToComponent(4)->setConstant();
+  }
   pbc_action = plumed.getActionSet().selectWithLabel<PbcAction*>("Box");
-  for(unsigned i=0; i<3; ++i) getPntrToComponent(i)->resizeDerivatives( getNumberOfArguments() );
+  for(unsigned i=0; i<3; ++i) {
+    getPntrToComponent(i)->resizeDerivatives( getNumberOfArguments() );
+  }
 }
 
 void ArgsToVatom::calculate() {
   if( fractional ) {
     if( pbc_action->getPbc().isSet() ) {
       // Get the position in fractional coordinates
-      Vector fpos; for(unsigned i=0; i<3; ++i) fpos[i] = getPntrToArgument(i)->get();
+      Vector fpos;
+      for(unsigned i=0; i<3; ++i) {
+        fpos[i] = getPntrToArgument(i)->get();
+      }
       // Convert fractioanl coordinates to cartesian coordinates
-      Tensor box=pbc_action->getPbc().getBox(); Vector cpos=matmul(fpos,box);
+      Tensor box=pbc_action->getPbc().getBox();
+      Vector cpos=matmul(fpos,box);
       // Set the final position and derivatives
       for(unsigned i=0; i<3; ++i) {
-        Value* vv=getPntrToComponent(i); vv->set( cpos[i] );
-        for(unsigned j=0; j<3; ++j) vv->addDerivative( j, box[j][i] );
+        Value* vv=getPntrToComponent(i);
+        vv->set( cpos[i] );
+        for(unsigned j=0; j<3; ++j) {
+          vv->addDerivative( j, box[j][i] );
+        }
       }
     } else {
-      if( getNumberOfArguments()<8 ) error("cannot use PHASES option if box is not set");
+      if( getNumberOfArguments()<8 ) {
+        error("cannot use PHASES option if box is not set");
+      }
       // Set the values
-      for(unsigned i=0; i<3; ++i) getPntrToComponent(i)->set( getPntrToArgument(5+i)->get() );
+      for(unsigned i=0; i<3; ++i) {
+        getPntrToComponent(i)->set( getPntrToArgument(5+i)->get() );
+      }
       // And the derivatives
-      for(unsigned i=0; i<3; ++i) getPntrToComponent(i)->addDerivative( 5+i, 1.0 );
+      for(unsigned i=0; i<3; ++i) {
+        getPntrToComponent(i)->addDerivative( 5+i, 1.0 );
+      }
     }
     // Set the mass and charge
-    for(unsigned i=3; i<5; ++i) getPntrToComponent(i)->set( getPntrToArgument(i)->get() );
+    for(unsigned i=3; i<5; ++i) {
+      getPntrToComponent(i)->set( getPntrToArgument(i)->get() );
+    }
   } else {
     // Set the values
-    for(unsigned i=0; i<5; ++i) getPntrToComponent(i)->set( getPntrToArgument(i)->get() );
+    for(unsigned i=0; i<5; ++i) {
+      getPntrToComponent(i)->set( getPntrToArgument(i)->get() );
+    }
     // And the derivatives
-    for(unsigned i=0; i<3; ++i) getPntrToComponent(i)->addDerivative( i, 1.0 );
+    for(unsigned i=0; i<3; ++i) {
+      getPntrToComponent(i)->addDerivative( i, 1.0 );
+    }
   }
 }
 
 void ArgsToVatom::apply() {
-  if( !checkForForces() ) return ;
+  if( !checkForForces() ) {
+    return ;
+  }
 
-  unsigned start=0; addForcesOnArguments( 0, getForcesToApply(), start, getLabel() );
+  unsigned start=0;
+  addForcesOnArguments( 0, getForcesToApply(), start, getLabel() );
 }
 
 }
diff --git a/src/vatom/Center.cpp b/src/vatom/Center.cpp
index 10ce5169f8..fe03ff4ece 100644
--- a/src/vatom/Center.cpp
+++ b/src/vatom/Center.cpp
@@ -126,8 +126,7 @@ PRINT ARG=d1
 
 
 class Center:
-  public ActionWithVirtualAtom
-{
+  public ActionWithVirtualAtom {
   std::vector<double> weights;
   std::vector<Tensor> dcenter_sin;
   std::vector<Tensor> dcenter_cos;
@@ -149,7 +148,9 @@ PLUMED_REGISTER_ACTION(Center,"COM")
 
 void Center::registerKeywords(Keywords& keys) {
   ActionWithVirtualAtom::registerKeywords(keys);
-  if( keys.getDisplayName()!="COM" ) keys.setDisplayName("CENTER");
+  if( keys.getDisplayName()!="COM" ) {
+    keys.setDisplayName("CENTER");
+  }
   keys.add("optional","WEIGHTS","Center is computed as a weighted average.");
   keys.add("optional","SET_CHARGE","Set the charge of the virtual atom to a given value.");
   keys.add("optional","SET_MASS","Set the mass of the virtual atom to a given value.");
@@ -166,41 +167,64 @@ Center::Center(const ActionOptions&ao):
   weight_mass(false),
   nopbc(false),
   first(true),
-  phases(false)
-{
+  phases(false) {
   std::vector<AtomNumber> atoms;
   parseAtomList("ATOMS",atoms);
-  if(atoms.size()==0) error("at least one atom should be specified");
+  if(atoms.size()==0) {
+    error("at least one atom should be specified");
+  }
   parseVector("WEIGHTS",weights);
   parseFlag("MASS",weight_mass);
   parseFlag("NOPBC",nopbc);
   parseFlag("PHASES",phases);
-  double charge_=std::numeric_limits<double>::lowest(); parse("SET_CHARGE",charge_); setCharge(charge_);
-  if(charge_!=std::numeric_limits<double>::lowest()) isChargeSet_=true;
-  double mass_=-1; parse("SET_MASS",mass_); setMass(mass_);
-  if(mass_>0.) isMassSet_=true;
-  if(mass_==0.) error("SETMASS must be greater than 0");
-  if( getName()=="COM") weight_mass=true;
+  double charge_=std::numeric_limits<double>::lowest();
+  parse("SET_CHARGE",charge_);
+  setCharge(charge_);
+  if(charge_!=std::numeric_limits<double>::lowest()) {
+    isChargeSet_=true;
+  }
+  double mass_=-1;
+  parse("SET_MASS",mass_);
+  setMass(mass_);
+  if(mass_>0.) {
+    isMassSet_=true;
+  }
+  if(mass_==0.) {
+    error("SETMASS must be greater than 0");
+  }
+  if( getName()=="COM") {
+    weight_mass=true;
+  }
   checkRead();
   log.printf("  of atoms:");
   for(unsigned i=0; i<atoms.size(); ++i) {
-    if(i%25==0) log<<"\n";
+    if(i%25==0) {
+      log<<"\n";
+    }
     log.printf(" %d",atoms[i].serial());
   }
   log<<"\n";
   if(weight_mass) {
     log<<"  mass weighted\n";
-    if(weights.size()!=0) error("WEIGHTS and MASS keywords cannot not be used simultaneously");
+    if(weights.size()!=0) {
+      error("WEIGHTS and MASS keywords cannot not be used simultaneously");
+    }
   } else {
     if( weights.size()==0) {
       log<<" using the geometric center\n";
       weights.resize( atoms.size() );
-      for(unsigned i=0; i<atoms.size(); i++) weights[i] = 1.;
+      for(unsigned i=0; i<atoms.size(); i++) {
+        weights[i] = 1.;
+      }
     } else {
       log<<" with weights:";
-      if( weights.size()!=atoms.size() ) error("number of elements in weight vector does not match the number of atoms");
+      if( weights.size()!=atoms.size() ) {
+        error("number of elements in weight vector does not match the number of atoms");
+      }
       for(unsigned i=0; i<weights.size(); ++i) {
-        if(i%25==0) log<<"\n";
+        if(i%25==0) {
+          log<<"\n";
+        }
         log.printf(" %f",weights[i]);
       }
       log.printf("\n");
@@ -220,7 +244,9 @@ void Center::calculate() {
   Vector pos;
   const bool dophases=(getPbc().isSet() ? phases : false);
 
-  if(!nopbc && !dophases) makeWhole();
+  if(!nopbc && !dophases) {
+    makeWhole();
+  }
 
   if( first ) {
     if( weight_mass ) {
@@ -234,23 +260,35 @@ void Center::calculate() {
       }
     }
     double mass(0.0);
-    for(unsigned i=0; i<getNumberOfAtoms(); i++) mass+=getMass(i);
+    for(unsigned i=0; i<getNumberOfAtoms(); i++) {
+      mass+=getMass(i);
+    }
     if( chargesWereSet && !isChargeSet_) {
       double charge(0.0);
-      for(unsigned i=0; i<getNumberOfAtoms(); i++) charge+=getCharge(i);
+      for(unsigned i=0; i<getNumberOfAtoms(); i++) {
+        charge+=getCharge(i);
+      }
       setCharge(charge);
     } else if( !isChargeSet_ ) {
       setCharge(0.0);
     }
-    if(!isMassSet_) setMass(mass);
+    if(!isMassSet_) {
+      setMass(mass);
+    }
 
     if( weight_mass ) {
       weights.resize( getNumberOfAtoms() );
-      for(unsigned i=0; i<weights.size(); i++) weights[i] = getMass(i) / mass;
+      for(unsigned i=0; i<weights.size(); i++) {
+        weights[i] = getMass(i) / mass;
+      }
     } else {
       double wtot=0.0;
-      for(unsigned i=0; i<weights.size(); i++) wtot+=weights[i];
-      for(unsigned i=0; i<weights.size(); i++) weights[i]=weights[i]/wtot;
+      for(unsigned i=0; i<weights.size(); i++) {
+        wtot+=weights[i];
+      }
+      for(unsigned i=0; i<weights.size(); i++) {
+        weights[i]=weights[i]/wtot;
+      }
       first=false;
     }
   }
@@ -281,7 +319,8 @@ void Center::calculate() {
       );
       center_cos+=ccos;
       center_sin+=csin;
-      for(unsigned l=0; l<3; l++) for(unsigned k=0; k<3; k++) {
+      for(unsigned l=0; l<3; l++)
+        for(unsigned k=0; k<3; k++) {
           // k over real coordinates
           // l over scaled coordinates
           dcenter_sin[i][l][k]=ccos[l]*invbox2pi[k][l];
@@ -303,7 +342,8 @@ void Center::calculate() {
 
     for(unsigned i=0; i<getNumberOfAtoms(); ++i) {
       Tensor dd;
-      for(unsigned l=0; l<3; l++) for(unsigned k=0; k<3; k++) {
+      for(unsigned l=0; l<3; l++)
+        for(unsigned k=0; k<3; k++) {
           // k over real coordinates
           // l over scaled coordinates
           dd[l][k]= (center_cos[l]*dcenter_sin[i][l][k] - center_sin[l]*dcenter_cos[i][l][k]);
diff --git a/src/vatom/CenterShortcut.cpp b/src/vatom/CenterShortcut.cpp
index 169fe5048d..2971a5b5a1 100644
--- a/src/vatom/CenterShortcut.cpp
+++ b/src/vatom/CenterShortcut.cpp
@@ -44,31 +44,46 @@ void CenterShortcut::registerKeywords( Keywords& keys ) {
   keys.addFlag("PHASES",false,"use trigonometric phases when computing position of center");
   keys.addFlag("SAFE_PHASES",false,"use trignomentric phases when computing position of center but also compute the center in ths usual way and use this when the pbc are not set. "
                "There are two reasons for using this option (1) you are doing something that you know is really weird or (2) you are an idiot");
-  keys.addFlag("MASS",false,"calculate the center of mass"); keys.addActionNameSuffix("_FAST");
+  keys.addFlag("MASS",false,"calculate the center of mass");
+  keys.addActionNameSuffix("_FAST");
   keys.setValueDescription("the position of the center of mass");
-  keys.needsAction("MASS"); keys.needsAction("SUM"); keys.needsAction("CHARGE"); keys.needsAction("CONSTANT");
-  keys.needsAction("CUSTOM"); keys.needsAction("POSITION"); keys.needsAction("ARGS2VATOM");
+  keys.needsAction("MASS");
+  keys.needsAction("SUM");
+  keys.needsAction("CHARGE");
+  keys.needsAction("CONSTANT");
+  keys.needsAction("CUSTOM");
+  keys.needsAction("POSITION");
+  keys.needsAction("ARGS2VATOM");
 }
 
 CenterShortcut::CenterShortcut(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Read in what we are doing with the weights
-  bool usemass; parseFlag("MASS",usemass);
-  std::vector<std::string> str_weights; parseVector("WEIGHTS",str_weights);
+  bool usemass;
+  parseFlag("MASS",usemass);
+  std::vector<std::string> str_weights;
+  parseVector("WEIGHTS",str_weights);
   if( usemass || str_weights.size()==0 || str_weights.size()>1 || (str_weights.size()==1 && str_weights[0]=="@Masses") ) {
-    if( usemass && str_weights.size()!=0 ) error("WEIGHTS and MASS keywords cannot not be used simultaneously");
+    if( usemass && str_weights.size()!=0 ) {
+      error("WEIGHTS and MASS keywords cannot not be used simultaneously");
+    }
     std::string wt_str;
     if( str_weights.size()>0 ) {
-      wt_str="WEIGHTS=" + str_weights[0]; for(unsigned i=1; i<str_weights.size(); ++i) wt_str += "," + str_weights[i];
+      wt_str="WEIGHTS=" + str_weights[0];
+      for(unsigned i=1; i<str_weights.size(); ++i) {
+        wt_str += "," + str_weights[i];
+      }
+    }
+    if( usemass || (str_weights.size()==1 && str_weights[0]=="@Masses") ) {
+      wt_str = "MASS";
     }
-    if( usemass || (str_weights.size()==1 && str_weights[0]=="@Masses") ) wt_str = "MASS";
     readInputLine( getShortcutLabel() + ": CENTER_FAST " + wt_str + " " + convertInputLineToString() );
     return;
   }
   // Read in the atoms
-  std::string atlist; parse("ATOMS",atlist);
+  std::string atlist;
+  parse("ATOMS",atlist);
   // Calculate the mass of the vatom
   readInputLine( getShortcutLabel() + "_m: MASS ATOMS=" + atlist );
   readInputLine( getShortcutLabel() + "_mass: SUM PERIODIC=NO ARG=" + getShortcutLabel() + "_m" );
@@ -82,19 +97,36 @@ CenterShortcut::CenterShortcut(const ActionOptions& ao):
   std::string wlab = getShortcutLabel() + "_w";
   if( str_weights.size()>0 ) {
     if( str_weights.size()==1 ) {
-      if( str_weights[0]=="@Charges" ) wlab = getShortcutLabel() + "_q";
-      else wlab=str_weights[0];
+      if( str_weights[0]=="@Charges" ) {
+        wlab = getShortcutLabel() + "_q";
+      } else {
+        wlab=str_weights[0];
+      }
     } else if( str_weights.size()==nat ) {
-      std::string vals=str_weights[0]; for(unsigned i=1; i<str_weights.size(); ++i) vals += "," + str_weights[i];
+      std::string vals=str_weights[0];
+      for(unsigned i=1; i<str_weights.size(); ++i) {
+        vals += "," + str_weights[i];
+      }
       readInputLine( getShortcutLabel() + "_w: CONSTANT VALUES=" + vals );
-    } else error("invalid input for WEIGHTS keyword " + str_weights[0] );
+    } else {
+      error("invalid input for WEIGHTS keyword " + str_weights[0] );
+    }
   } else {
-    std::string ones="1"; for(unsigned i=1; i<nat; ++i) ones += ",1";
+    std::string ones="1";
+    for(unsigned i=1; i<nat; ++i) {
+      ones += ",1";
+    }
     readInputLine( getShortcutLabel() + "_w: CONSTANT VALUES=" + ones );
   }
   // Read in the instructions on how to compute the center of mass
-  bool safe_phases, phases, nopbc; parseFlag("SAFE_PHASES",safe_phases); parseFlag("NOPBC",nopbc);
-  if( safe_phases ) phases=true; else parseFlag("PHASES",phases);
+  bool safe_phases, phases, nopbc;
+  parseFlag("SAFE_PHASES",safe_phases);
+  parseFlag("NOPBC",nopbc);
+  if( safe_phases ) {
+    phases=true;
+  } else {
+    parseFlag("PHASES",phases);
+  }
   // This computes a center in the conventional way
   if( !phases || safe_phases ) {
     // Calculate the sum of the weights
@@ -102,8 +134,11 @@ CenterShortcut::CenterShortcut(const ActionOptions& ao):
     // Compute the normalised weights
     readInputLine( getShortcutLabel() + "_weights: CUSTOM ARG=" + getShortcutLabel() + "_wnorm," + wlab + " FUNC=y/x PERIODIC=NO");
     // Get the positions into a multicolvar
-    if( phases || nopbc ) readInputLine( getShortcutLabel() + "_pos: POSITION NOPBC ATOMS=" + atlist );
-    else readInputLine( getShortcutLabel() + "_pos: POSITION WHOLEMOLECULES ATOMS=" + atlist );
+    if( phases || nopbc ) {
+      readInputLine( getShortcutLabel() + "_pos: POSITION NOPBC ATOMS=" + atlist );
+    } else {
+      readInputLine( getShortcutLabel() + "_pos: POSITION WHOLEMOLECULES ATOMS=" + atlist );
+    }
     // Multiply each vector of positions by the weight
     readInputLine( getShortcutLabel() + "_xwvec: CUSTOM ARG=" + getShortcutLabel() + "_weights," + getShortcutLabel() + "_pos.x FUNC=x*y PERIODIC=NO");
     readInputLine( getShortcutLabel() + "_ywvec: CUSTOM ARG=" + getShortcutLabel() + "_weights," + getShortcutLabel() + "_pos.y FUNC=x*y PERIODIC=NO");
diff --git a/src/vatom/FixedAtom.cpp b/src/vatom/FixedAtom.cpp
index fe2482cd66..6ec0ab7bbb 100644
--- a/src/vatom/FixedAtom.cpp
+++ b/src/vatom/FixedAtom.cpp
@@ -83,8 +83,7 @@ END
 
 
 class FixedAtom:
-  public ActionWithVirtualAtom
-{
+  public ActionWithVirtualAtom {
   Vector coord;
   std::vector<Tensor> deriv;
   double mass,charge;
@@ -107,17 +106,20 @@ void FixedAtom::registerKeywords(Keywords& keys) {
 
 FixedAtom::FixedAtom(const ActionOptions&ao):
   Action(ao),
-  ActionWithVirtualAtom(ao)
-{
+  ActionWithVirtualAtom(ao) {
   std::vector<AtomNumber> atoms;
   parseAtomList("ATOMS",atoms);
-  if(atoms.size()!=0) error("ATOMS should be empty");
+  if(atoms.size()!=0) {
+    error("ATOMS should be empty");
+  }
 
   parseFlag("SCALED_COMPONENTS",scaled_components);
 
   std::vector<double> at;
   parseVector("AT",at);
-  if(at.size()!=3) error("AT should be a list of three real numbers");
+  if(at.size()!=3) {
+    error("AT should be a list of three real numbers");
+  }
 
   parse("SET_MASS",mass);
   parse("SET_CHARGE",charge);
@@ -128,7 +130,9 @@ FixedAtom::FixedAtom(const ActionOptions&ao):
 
   checkRead();
   log<<"  AT position "<<coord[0]<<" "<<coord[1]<<" "<<coord[2]<<"\n";
-  if(scaled_components) log<<"  position is in scaled components\n";
+  if(scaled_components) {
+    log<<"  position is in scaled components\n";
+  }
 }
 
 void FixedAtom::calculate() {
@@ -142,7 +146,9 @@ void FixedAtom::calculate() {
   setCharge(charge);
   setAtomsDerivatives(deriv);
 // Virial contribution
-  if(!scaled_components) setBoxDerivativesNoPbc();
+  if(!scaled_components) {
+    setBoxDerivativesNoPbc();
+  }
 // notice that with scaled components there is no additional virial contribution
 }
 
diff --git a/src/vatom/Ghost.cpp b/src/vatom/Ghost.cpp
index adedc4c223..bbb2159d6c 100644
--- a/src/vatom/Ghost.cpp
+++ b/src/vatom/Ghost.cpp
@@ -62,8 +62,7 @@ PRINT ARG=d1
 
 
 class Ghost:
-  public ActionWithVirtualAtom
-{
+  public ActionWithVirtualAtom {
   std::vector<double> coord;
   std::vector<Tensor> deriv;
   bool nopbc=false;
@@ -83,20 +82,25 @@ void Ghost::registerKeywords(Keywords& keys) {
 
 Ghost::Ghost(const ActionOptions&ao):
   Action(ao),
-  ActionWithVirtualAtom(ao)
-{
+  ActionWithVirtualAtom(ao) {
   std::vector<AtomNumber> atoms;
   parseAtomList("ATOMS",atoms);
-  if(atoms.size()!=3) error("ATOMS should contain a list of three atoms");
+  if(atoms.size()!=3) {
+    error("ATOMS should contain a list of three atoms");
+  }
 
   parseVector("COORDINATES",coord);
-  if(coord.size()!=3) error("COORDINATES should be a list of three real numbers");
+  if(coord.size()!=3) {
+    error("COORDINATES should be a list of three real numbers");
+  }
 
   parseFlag("NOPBC",nopbc);
 
   checkRead();
   log.printf("  of atoms");
-  for(unsigned i=0; i<atoms.size(); ++i) log.printf(" %d",atoms[i].serial());
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf(" %d",atoms[i].serial());
+  }
   log.printf("\n");
 
   if(nopbc) {
@@ -109,7 +113,9 @@ Ghost::Ghost(const ActionOptions&ao):
 
 void Ghost::calculate() {
 
-  if(!nopbc) makeWhole();
+  if(!nopbc) {
+    makeWhole();
+  }
 
   Vector pos;
   deriv.resize(getNumberOfAtoms());
diff --git a/src/ves/BF_Chebyshev.cpp b/src/ves/BF_Chebyshev.cpp
index c520969b9d..890ca86e9b 100644
--- a/src/ves/BF_Chebyshev.cpp
+++ b/src/ves/BF_Chebyshev.cpp
@@ -104,8 +104,7 @@ void BF_Chebyshev::registerKeywords(Keywords& keys) {
 }
 
 BF_Chebyshev::BF_Chebyshev(const ActionOptions&ao):
-  PLUMED_VES_BASISFUNCTIONS_INIT(ao)
-{
+  PLUMED_VES_BASISFUNCTIONS_INIT(ao) {
   setNumberOfBasisFunctions(getOrder()+1);
   setIntrinsicInterval("-1.0","+1.0");
   setNonPeriodic();
@@ -136,7 +135,11 @@ void BF_Chebyshev::getAllValues(const double arg, double& argT, bool& inside_ran
     derivsT[i+1] = 2.0*values[i]+2.0*argT*derivsT[i]-derivsT[i-1];
     derivs[i+1]  = intervalDerivf()*derivsT[i+1];
   }
-  if(!inside_range) {for(unsigned int i=0; i<derivs.size(); i++) {derivs[i]=0.0;}}
+  if(!inside_range) {
+    for(unsigned int i=0; i<derivs.size(); i++) {
+      derivs[i]=0.0;
+    }
+  }
 }
 
 
diff --git a/src/ves/BF_Combined.cpp b/src/ves/BF_Combined.cpp
index 450acd8af3..f28e1b3065 100644
--- a/src/ves/BF_Combined.cpp
+++ b/src/ves/BF_Combined.cpp
@@ -90,16 +90,18 @@ void BF_Combined::registerKeywords(Keywords& keys) {
 
 BF_Combined::BF_Combined(const ActionOptions&ao):
   PLUMED_VES_BASISFUNCTIONS_INIT(ao),
-  basisf_pntrs_(0)
-{
+  basisf_pntrs_(0) {
   std::vector<std::string> basisf_labels;
-  parseVector("BASIS_FUNCTIONS",basisf_labels); addKeywordToList("BASIS_FUNCTIONS",basisf_labels);
+  parseVector("BASIS_FUNCTIONS",basisf_labels);
+  addKeywordToList("BASIS_FUNCTIONS",basisf_labels);
   if(basisf_labels.size()==1) {
     plumed_merror("using only one basis function in BF_COMBINED does not make sense");
   }
   std::string error_msg = "";
   basisf_pntrs_ = VesTools::getPointersFromLabels<BasisFunctions*>(basisf_labels,plumed.getActionSet(),error_msg);
-  if(error_msg.size()>0) {plumed_merror("Error in keyword BASIS_FUNCTIONS of "+getName()+": "+error_msg);}
+  if(error_msg.size()>0) {
+    plumed_merror("Error in keyword BASIS_FUNCTIONS of "+getName()+": "+error_msg);
+  }
 
   unsigned int nbasisf_total_ = 1;
   bool periodic = true;
@@ -108,14 +110,19 @@ BF_Combined::BF_Combined(const ActionOptions&ao):
     if(basisf_pntrs_[i]->intervalMinStr()!=basisf_pntrs_[0]->intervalMinStr() || basisf_pntrs_[i]->intervalMaxStr()!=basisf_pntrs_[0]->intervalMaxStr()) {
       plumed_merror("all the basis functions to be combined should have same MINIMUM and MAXIMUM");
     }
-    if(!basisf_pntrs_[i]->arePeriodic()) {periodic=false;}
+    if(!basisf_pntrs_[i]->arePeriodic()) {
+      periodic=false;
+    }
   }
   setOrder(nbasisf_total_-1);
   setNumberOfBasisFunctions(nbasisf_total_);
   setInterval(basisf_pntrs_[0]->intervalMinStr(),basisf_pntrs_[0]->intervalMaxStr());
   setIntrinsicInterval("-1.0","+1.0");
-  if(periodic) {setPeriodic();}
-  else {setNonPeriodic();}
+  if(periodic) {
+    setPeriodic();
+  } else {
+    setNonPeriodic();
+  }
   setIntervalBounded();
   setType("combined");
   setDescription("Combined");
@@ -162,7 +169,8 @@ void BF_Combined::getAllValues(const double arg, double& argT, bool& inside_rang
   for(unsigned int i=1; i<basisf_pntrs_.size(); i++) {
     values_tmp.assign(basisf_pntrs_[i]->numberOfBasisFunctions(),0.0);
     derivs_tmp.assign(basisf_pntrs_[i]->numberOfBasisFunctions(),0.0);
-    double dummy_dbl; bool dummy_bool=true;
+    double dummy_dbl;
+    bool dummy_bool=true;
     basisf_pntrs_[i]->getAllValues(arg,dummy_dbl,dummy_bool,values_tmp,derivs_tmp);
     for(unsigned int l=1; l<basisf_pntrs_[i]->numberOfBasisFunctions(); l++) {
       values[r] = values_tmp[l];
diff --git a/src/ves/BF_Cosine.cpp b/src/ves/BF_Cosine.cpp
index f7e15b547d..c9b069a3d1 100644
--- a/src/ves/BF_Cosine.cpp
+++ b/src/ves/BF_Cosine.cpp
@@ -100,8 +100,7 @@ void BF_Cosine::registerKeywords(Keywords& keys) {
 
 
 BF_Cosine::BF_Cosine(const ActionOptions&ao):
-  PLUMED_VES_BASISFUNCTIONS_INIT(ao)
-{
+  PLUMED_VES_BASISFUNCTIONS_INIT(ao) {
   setNumberOfBasisFunctions(getOrder()+1);
   setIntrinsicInterval("-pi","+pi");
   setPeriodic();
@@ -128,7 +127,9 @@ void BF_Cosine::getAllValues(const double arg, double& argT, bool& inside_range,
     derivs[i] = -io*sin_tmp*intervalDerivf();
   }
   if(!inside_range) {
-    for(unsigned int i=0; i<derivs.size(); i++) {derivs[i]=0.0;}
+    for(unsigned int i=0; i<derivs.size(); i++) {
+      derivs[i]=0.0;
+    }
   }
 }
 
@@ -136,7 +137,8 @@ void BF_Cosine::getAllValues(const double arg, double& argT, bool& inside_range,
 void BF_Cosine::setupLabels() {
   setLabel(0,"1");
   for(unsigned int i=1; i < getOrder()+1; i++) {
-    std::string is; Tools::convert(i,is);
+    std::string is;
+    Tools::convert(i,is);
     setLabel(i,"cos("+is+"*s)");
   }
 }
diff --git a/src/ves/BF_CubicBsplines.cpp b/src/ves/BF_CubicBsplines.cpp
index 669b9e886c..7eb07f06d3 100644
--- a/src/ves/BF_CubicBsplines.cpp
+++ b/src/ves/BF_CubicBsplines.cpp
@@ -109,8 +109,7 @@ void BF_CubicBsplines::registerKeywords(Keywords& keys) {
 }
 
 BF_CubicBsplines::BF_CubicBsplines(const ActionOptions&ao):
-  PLUMED_VES_BASISFUNCTIONS_INIT(ao)
-{
+  PLUMED_VES_BASISFUNCTIONS_INIT(ao) {
   log.printf("  Cubic B spline basis functions, see and cite ");
   log << plumed.cite("Pampel and Valsson, J. Chem. Theory Comput. 18, 4127-4141 (2022) - DOI:10.1021/acs.jctc.2c00197");
 
@@ -120,7 +119,9 @@ BF_CubicBsplines::BF_CubicBsplines(const ActionOptions&ao):
 
   bool periodic = false;
   parseFlag("PERIODIC",periodic);
-  if (periodic) {addKeywordToList("PERIODIC",periodic);}
+  if (periodic) {
+    addKeywordToList("PERIODIC",periodic);
+  }
 
   // 1 constant, getOrder() on interval, 1 (left) + 2 (right) at boundaries if not periodic
   unsigned int num_BFs = periodic ? getOrder()+1U : getOrder()+4U;
@@ -128,7 +129,9 @@ BF_CubicBsplines::BF_CubicBsplines(const ActionOptions&ao):
 
   double normfactor_=2.0;
   parse("NORMALIZATION",normfactor_);
-  if(normfactor_!=2.0) {addKeywordToList("NORMALIZATION",normfactor_);}
+  if(normfactor_!=2.0) {
+    addKeywordToList("NORMALIZATION",normfactor_);
+  }
   inv_normfactor_=1.0/normfactor_;
 
   periodic ? setPeriodic() : setNonPeriodic();
@@ -161,7 +164,11 @@ void BF_CubicBsplines::getAllValues(const double arg, double& argT, bool& inside
     values[i] = spline(argx, derivs[i]);
     derivs[i] *= inv_spacing_;
   }
-  if(!inside_range) {for(unsigned int i=0; i<derivs.size(); i++) {derivs[i]=0.0;}}
+  if(!inside_range) {
+    for(unsigned int i=0; i<derivs.size(); i++) {
+      derivs[i]=0.0;
+    }
+  }
 }
 
 
@@ -178,14 +185,12 @@ double BF_CubicBsplines::spline(const double arg, double& deriv) const {
   if(x > 2) {
     value=0.0;
     deriv=0.0;
-  }
-  else if(x >= 1) {
+  } else if(x >= 1) {
     value = ((2.0-x)*(2.0-x)*(2.0-x));
     deriv = dx*(-3.0*(2.0-x)*(2.0-x));
     // value=((2.0-x)*(2.0-x)*(2.0-x))/6.0;
     // deriv=-x*x*(2.0-x)*(2.0-x);
-  }
-  else {
+  } else {
     value = 4.0-6.0*x*x+3.0*x*x*x;
     deriv = dx*(-12.0*x+9.0*x*x);
     // value=x*x*x*0.5-x*x+2.0/3.0;
diff --git a/src/ves/BF_Custom.cpp b/src/ves/BF_Custom.cpp
index 627736c728..87dd2a4962 100644
--- a/src/ves/BF_Custom.cpp
+++ b/src/ves/BF_Custom.cpp
@@ -147,28 +147,36 @@ BF_Custom::BF_Custom(const ActionOptions&ao):
   variable_str_("x"),
   transf_variable_str_("t"),
   do_transf_(false),
-  check_nan_inf_(false)
-{
+  check_nan_inf_(false) {
   std::vector<std::string> bf_str;
   std::string str_t1="1";
   bf_str.push_back(str_t1);
   for(int i=1;; i++) {
     std::string str_t2;
-    if(!parseNumbered("FUNC",i,str_t2)) {break;}
-    std::string is; Tools::convert(i,is);
+    if(!parseNumbered("FUNC",i,str_t2)) {
+      break;
+    }
+    std::string is;
+    Tools::convert(i,is);
     addKeywordToList("FUNC"+is,str_t2);
     bf_str.push_back(str_t2);
   }
   //
-  if(bf_str.size()==1) {plumed_merror(getName()+" with label "+getLabel()+": No FUNC keywords given");}
+  if(bf_str.size()==1) {
+    plumed_merror(getName()+" with label "+getLabel()+": No FUNC keywords given");
+  }
 
   setOrder(bf_str.size()-1);
   setNumberOfBasisFunctions(getOrder()+1);
   setIntrinsicInterval(intervalMin(),intervalMax());
   bool periodic = false;
-  parseFlag("PERIODIC",periodic); addKeywordToList("PERIODIC",periodic);
-  if(periodic) {setPeriodic();}
-  else {setNonPeriodic();}
+  parseFlag("PERIODIC",periodic);
+  addKeywordToList("PERIODIC",periodic);
+  if(periodic) {
+    setPeriodic();
+  } else {
+    setNonPeriodic();
+  }
   setIntervalBounded();
   setType("custom_functions");
   setDescription("Custom Functions");
@@ -184,14 +192,15 @@ BF_Custom::BF_Custom(const ActionOptions&ao):
   bf_derivs_lepton_ref_.resize(getNumberOfBasisFunctions());
   //
   for(unsigned int i=1; i<getNumberOfBasisFunctions(); i++) {
-    std::string is; Tools::convert(i,is);
+    std::string is;
+    Tools::convert(i,is);
     try {
       lepton::ParsedExpression pe_value = lepton::Parser::parse(bf_str[i]).optimize(lepton::Constants());
-      std::ostringstream tmp_stream; tmp_stream << pe_value;
+      std::ostringstream tmp_stream;
+      tmp_stream << pe_value;
       bf_values_parsed[i] = tmp_stream.str();
       bf_values_expressions_[i] = pe_value.createCompiledExpression();
-    }
-    catch(PLMD::lepton::Exception& exc) {
+    } catch(PLMD::lepton::Exception& exc) {
       plumed_merror("There was some problem in parsing the function "+bf_str[i]+" given in FUNC"+is + " with lepton");
     }
 
@@ -208,11 +217,11 @@ BF_Custom::BF_Custom(const ActionOptions&ao):
 
     try {
       lepton::ParsedExpression pe_deriv = lepton::Parser::parse(bf_str[i]).differentiate(variable_str_).optimize(lepton::Constants());
-      std::ostringstream tmp_stream2; tmp_stream2 << pe_deriv;
+      std::ostringstream tmp_stream2;
+      tmp_stream2 << pe_deriv;
       bf_derivs_parsed[i] = tmp_stream2.str();
       bf_derivs_expressions_[i] = pe_deriv.createCompiledExpression();
-    }
-    catch(PLMD::lepton::Exception& exc) {
+    } catch(PLMD::lepton::Exception& exc) {
       plumed_merror("There was some problem in parsing the derivative of the function "+bf_str[i]+" given in FUNC"+is + " with lepton");
     }
 
@@ -234,21 +243,27 @@ BF_Custom::BF_Custom(const ActionOptions&ao):
     do_transf_ = true;
     addKeywordToList("TRANSFORM",transf_str);
     for(unsigned int k=0;; k++) {
-      if(transf_str.find("min")!=std::string::npos) {transf_str.replace(transf_str.find("min"), std::string("min").length(),intervalMinStr());}
-      else {break;}
+      if(transf_str.find("min")!=std::string::npos) {
+        transf_str.replace(transf_str.find("min"), std::string("min").length(),intervalMinStr());
+      } else {
+        break;
+      }
     }
     for(unsigned int k=0;; k++) {
-      if(transf_str.find("max")!=std::string::npos) {transf_str.replace(transf_str.find("max"), std::string("max").length(),intervalMaxStr());}
-      else {break;}
+      if(transf_str.find("max")!=std::string::npos) {
+        transf_str.replace(transf_str.find("max"), std::string("max").length(),intervalMaxStr());
+      } else {
+        break;
+      }
     }
 
     try {
       lepton::ParsedExpression pe_value = lepton::Parser::parse(transf_str).optimize(lepton::Constants());;
-      std::ostringstream tmp_stream; tmp_stream << pe_value;
+      std::ostringstream tmp_stream;
+      tmp_stream << pe_value;
       transf_value_parsed = tmp_stream.str();
       transf_value_expression_ = pe_value.createCompiledExpression();
-    }
-    catch(PLMD::lepton::Exception& exc) {
+    } catch(PLMD::lepton::Exception& exc) {
       plumed_merror("There was some problem in parsing the function "+transf_str+" given in TRANSFORM with lepton");
     }
 
@@ -265,11 +280,11 @@ BF_Custom::BF_Custom(const ActionOptions&ao):
 
     try {
       lepton::ParsedExpression pe_deriv = lepton::Parser::parse(transf_str).differentiate(transf_variable_str_).optimize(lepton::Constants());;
-      std::ostringstream tmp_stream2; tmp_stream2 << pe_deriv;
+      std::ostringstream tmp_stream2;
+      tmp_stream2 << pe_deriv;
       transf_deriv_parsed = tmp_stream2.str();
       transf_deriv_expression_ = pe_deriv.createCompiledExpression();
-    }
-    catch(PLMD::lepton::Exception& exc) {
+    } catch(PLMD::lepton::Exception& exc) {
       plumed_merror("There was some problem in parsing the derivative of the function "+transf_str+" given in TRANSFORM with lepton");
     }
 
@@ -292,17 +307,16 @@ BF_Custom::BF_Custom(const ActionOptions&ao):
   if(do_transf_) {
     log.printf("  Arguments are transformed using the following function [lepton parsed function and derivative]:\n");
     log.printf("   %s   [   %s   |   %s   ] \n",transf_str.c_str(),transf_value_parsed.c_str(),transf_deriv_parsed.c_str());
-  }
-  else {
+  } else {
     log.printf("  Arguments are not transformed\n");
   }
   //
 
-  parseFlag("CHECK_NAN_INF",check_nan_inf_); addKeywordToList("CHECK_NAN_INF",check_nan_inf_);
+  parseFlag("CHECK_NAN_INF",check_nan_inf_);
+  addKeywordToList("CHECK_NAN_INF",check_nan_inf_);
   if(check_nan_inf_) {
     log.printf("  The code will check that values given are numercially stable, e.g. do not result in a not a number (nan) or infinity (inf).\n");
-  }
-  else {
+  } else {
     log.printf("  The code will NOT check that values given are numercially stable, e.g. do not result in a not a number (nan) or infinity (inf).\n");
   }
 
@@ -318,19 +332,25 @@ void BF_Custom::getAllValues(const double arg, double& argT, bool& inside_range,
   //
   if(do_transf_) {
 
-    if(transf_value_lepton_ref_) {*transf_value_lepton_ref_ = argT;}
-    if(transf_deriv_lepton_ref_) {*transf_deriv_lepton_ref_ = argT;}
+    if(transf_value_lepton_ref_) {
+      *transf_value_lepton_ref_ = argT;
+    }
+    if(transf_deriv_lepton_ref_) {
+      *transf_deriv_lepton_ref_ = argT;
+    }
 
     argT = transf_value_expression_.evaluate();
     transf_derivf = transf_deriv_expression_.evaluate();
 
     if(check_nan_inf_ && (std::isnan(argT) || std::isinf(argT)) ) {
-      std::string vs; Tools::convert(argT,vs);
+      std::string vs;
+      Tools::convert(argT,vs);
       plumed_merror(getName()+" with label "+getLabel()+": problem with the transform function, it gives " + vs);
     }
 
     if(check_nan_inf_ && (std::isnan(transf_derivf) || std::isinf(transf_derivf)) ) {
-      std::string vs; Tools::convert(transf_derivf,vs);
+      std::string vs;
+      Tools::convert(transf_derivf,vs);
       plumed_merror(getName()+" with label "+getLabel()+": problem with the transform function, its derivative gives " + vs);
     }
   }
@@ -339,27 +359,41 @@ void BF_Custom::getAllValues(const double arg, double& argT, bool& inside_range,
   derivs[0]=0.0;
   for(unsigned int i=1; i < getNumberOfBasisFunctions(); i++) {
 
-    if(bf_values_lepton_ref_[i]) {*bf_values_lepton_ref_[i] = argT;}
-    if(bf_derivs_lepton_ref_[i]) {*bf_derivs_lepton_ref_[i] = argT;}
+    if(bf_values_lepton_ref_[i]) {
+      *bf_values_lepton_ref_[i] = argT;
+    }
+    if(bf_derivs_lepton_ref_[i]) {
+      *bf_derivs_lepton_ref_[i] = argT;
+    }
 
     values[i] = bf_values_expressions_[i].evaluate();
     derivs[i] = bf_derivs_expressions_[i].evaluate();
 
-    if(do_transf_) {derivs[i]*=transf_derivf;}
+    if(do_transf_) {
+      derivs[i]*=transf_derivf;
+    }
     // NaN checks
     if(check_nan_inf_ && (std::isnan(values[i]) || std::isinf(values[i])) ) {
-      std::string vs; Tools::convert(values[i],vs);
-      std::string is; Tools::convert(i,is);
+      std::string vs;
+      Tools::convert(values[i],vs);
+      std::string is;
+      Tools::convert(i,is);
       plumed_merror(getName()+" with label "+getLabel()+": problem with the basis function given in FUNC"+is+", it gives "+vs);
     }
     //
     if(check_nan_inf_ && (std::isnan(derivs[i])|| std::isinf(derivs[i])) ) {
-      std::string vs; Tools::convert(derivs[i],vs);
-      std::string is; Tools::convert(i,is);
+      std::string vs;
+      Tools::convert(derivs[i],vs);
+      std::string is;
+      Tools::convert(i,is);
       plumed_merror(getName()+" with label "+getLabel()+": problem with derivative of the basis function given in FUNC"+is+", it gives "+vs);
     }
   }
-  if(!inside_range) {for(unsigned int i=0; i<derivs.size(); i++) {derivs[i]=0.0;}}
+  if(!inside_range) {
+    for(unsigned int i=0; i<derivs.size(); i++) {
+      derivs[i]=0.0;
+    }
+  }
 }
 
 
diff --git a/src/ves/BF_Fourier.cpp b/src/ves/BF_Fourier.cpp
index 19ba0d1005..ef2c982ec1 100644
--- a/src/ves/BF_Fourier.cpp
+++ b/src/ves/BF_Fourier.cpp
@@ -101,8 +101,7 @@ void BF_Fourier::registerKeywords(Keywords& keys) {
 
 
 BF_Fourier::BF_Fourier(const ActionOptions&ao):
-  PLUMED_VES_BASISFUNCTIONS_INIT(ao)
-{
+  PLUMED_VES_BASISFUNCTIONS_INIT(ao) {
   setNumberOfBasisFunctions(2*getOrder()+1);
   setIntrinsicInterval("-pi","+pi");
   setPeriodic();
@@ -131,7 +130,9 @@ void BF_Fourier::getAllValues(const double arg, double& argT, bool& inside_range
     derivs[2*i] = io*cos_tmp*intervalDerivf();
   }
   if(!inside_range) {
-    for(unsigned int i=0; i<derivs.size(); i++) {derivs[i]=0.0;}
+    for(unsigned int i=0; i<derivs.size(); i++) {
+      derivs[i]=0.0;
+    }
   }
 }
 
@@ -139,7 +140,8 @@ void BF_Fourier::getAllValues(const double arg, double& argT, bool& inside_range
 void BF_Fourier::setupLabels() {
   setLabel(0,"1");
   for(unsigned int i=1; i < getOrder()+1; i++) {
-    std::string is; Tools::convert(i,is);
+    std::string is;
+    Tools::convert(i,is);
     setLabel(2*i-1,"cos("+is+"*s)");
     setLabel(2*i,"sin("+is+"*s)");
   }
diff --git a/src/ves/BF_Gaussians.cpp b/src/ves/BF_Gaussians.cpp
index 2454d8c1ce..0c16e12cfd 100644
--- a/src/ves/BF_Gaussians.cpp
+++ b/src/ves/BF_Gaussians.cpp
@@ -122,8 +122,7 @@ void BF_Gaussians::registerKeywords(Keywords& keys) {
 }
 
 BF_Gaussians::BF_Gaussians(const ActionOptions&ao):
-  PLUMED_VES_BASISFUNCTIONS_INIT(ao)
-{
+  PLUMED_VES_BASISFUNCTIONS_INIT(ao) {
   log.printf("  Gaussian basis functions, see and cite ");
   log << plumed.cite("Pampel and Valsson, J. Chem. Theory Comput. 18, 4127-4141 (2022) - DOI:10.1021/acs.jctc.2c00197");
 
@@ -131,13 +130,19 @@ BF_Gaussians::BF_Gaussians(const ActionOptions&ao):
 
   double width = (intervalMax()-intervalMin()) / getOrder();
   parse("WIDTH",width);
-  if(width <= 0.0) {plumed_merror("WIDTH should be larger than 0");}
-  if(width != (intervalMax()-intervalMin())/getOrder()) {addKeywordToList("WIDTH",width);}
+  if(width <= 0.0) {
+    plumed_merror("WIDTH should be larger than 0");
+  }
+  if(width != (intervalMax()-intervalMin())/getOrder()) {
+    addKeywordToList("WIDTH",width);
+  }
   inv_sigma_ = 1/(width);
 
   bool periodic = false;
   parseFlag("PERIODIC",periodic);
-  if (periodic) {addKeywordToList("PERIODIC",periodic);}
+  if (periodic) {
+    addKeywordToList("PERIODIC",periodic);
+  }
 
   // 1 constant, getOrder() on interval, 1 (left) + 2 (right) at boundaries if not periodic
   unsigned int num_BFs = periodic ? getOrder()+1U : getOrder()+4U;
@@ -172,7 +177,11 @@ void BF_Gaussians::getAllValues(const double arg, double& argT, bool& inside_ran
     values[i] = exp(-0.5*pow(dist*inv_sigma_,2.0));
     derivs[i] = -values[i] * (dist)*pow(inv_sigma_,2.0);
   }
-  if(!inside_range) {for (auto& d: derivs) {d=0.0;}}
+  if(!inside_range) {
+    for (auto& d: derivs) {
+      d=0.0;
+    }
+  }
 }
 
 
@@ -180,7 +189,8 @@ void BF_Gaussians::getAllValues(const double arg, double& argT, bool& inside_ran
 void BF_Gaussians::setupLabels() {
   setLabel(0,"const");
   for(unsigned int i=1; i < getNumberOfBasisFunctions(); i++) {
-    std::string is; Tools::convert(centers_[i],is);
+    std::string is;
+    Tools::convert(centers_[i],is);
     setLabel(i,"m="+is);
   }
 }
diff --git a/src/ves/BF_Legendre.cpp b/src/ves/BF_Legendre.cpp
index a17526f14c..bcecf0e3f8 100644
--- a/src/ves/BF_Legendre.cpp
+++ b/src/ves/BF_Legendre.cpp
@@ -113,9 +113,9 @@ void BF_Legendre::registerKeywords(Keywords& keys) {
 
 BF_Legendre::BF_Legendre(const ActionOptions&ao):
   PLUMED_VES_BASISFUNCTIONS_INIT(ao),
-  scaled_(false)
-{
-  parseFlag("SCALED",scaled_); addKeywordToList("SCALED",scaled_);
+  scaled_(false) {
+  parseFlag("SCALED",scaled_);
+  addKeywordToList("SCALED",scaled_);
   setNumberOfBasisFunctions(getOrder()+1);
   setIntrinsicInterval("-1.0","+1.0");
   setNonPeriodic();
@@ -156,14 +156,20 @@ void BF_Legendre::getAllValues(const double arg, double& argT, bool& inside_rang
       derivs[i] *= sf;
     }
   }
-  if(!inside_range) {for(unsigned int i=0; i<derivs.size(); i++) {derivs[i]=0.0;}}
+  if(!inside_range) {
+    for(unsigned int i=0; i<derivs.size(); i++) {
+      derivs[i]=0.0;
+    }
+  }
 }
 
 
 void BF_Legendre::setupUniformIntegrals() {
   setAllUniformIntegralsToZero();
   double L0_int = 1.0;
-  if(scaled_) {L0_int = sqrt(0.5);}
+  if(scaled_) {
+    L0_int = sqrt(0.5);
+  }
   setUniformIntegral(0,L0_int);
 }
 
diff --git a/src/ves/BF_Powers.cpp b/src/ves/BF_Powers.cpp
index 2a7377d820..d988e28229 100644
--- a/src/ves/BF_Powers.cpp
+++ b/src/ves/BF_Powers.cpp
@@ -97,13 +97,14 @@ void BF_Powers::registerKeywords(Keywords& keys) {
 }
 
 BF_Powers::BF_Powers(const ActionOptions&ao):
-  PLUMED_VES_BASISFUNCTIONS_INIT(ao)
-{
+  PLUMED_VES_BASISFUNCTIONS_INIT(ao) {
   setNumberOfBasisFunctions(getOrder()+1);
   setIntrinsicInterval(intervalMin(),intervalMax());
   double normfactor_=1.0;
   parse("NORMALIZATION",normfactor_);
-  if(normfactor_!=1.0) {addKeywordToList("NORMALIZATION",normfactor_);}
+  if(normfactor_!=1.0) {
+    addKeywordToList("NORMALIZATION",normfactor_);
+  }
   inv_normfactor_=1.0/normfactor_;
   setNonPeriodic();
   setIntervalBounded();
@@ -129,14 +130,19 @@ void BF_Powers::getAllValues(const double arg, double& argT, bool& inside_range,
     values[i] = argT*values[i-1];
     derivs[i]=values[i-1]+argT*derivs[i-1];
   }
-  if(!inside_range) {for(unsigned int i=0; i<derivs.size(); i++) {derivs[i]=0.0;}}
+  if(!inside_range) {
+    for(unsigned int i=0; i<derivs.size(); i++) {
+      derivs[i]=0.0;
+    }
+  }
 }
 
 
 void BF_Powers::setupLabels() {
   setLabel(0,"1");
   for(unsigned int i=1; i < getOrder()+1; i++) {
-    std::string is; Tools::convert(i,is);
+    std::string is;
+    Tools::convert(i,is);
     setLabel(i,"s^"+is);
   }
 }
diff --git a/src/ves/BF_Sine.cpp b/src/ves/BF_Sine.cpp
index 93fd9c6557..6dba5b4da7 100644
--- a/src/ves/BF_Sine.cpp
+++ b/src/ves/BF_Sine.cpp
@@ -99,8 +99,7 @@ void BF_Sine::registerKeywords(Keywords& keys) {
 
 
 BF_Sine::BF_Sine(const ActionOptions&ao):
-  PLUMED_VES_BASISFUNCTIONS_INIT(ao)
-{
+  PLUMED_VES_BASISFUNCTIONS_INIT(ao) {
   setNumberOfBasisFunctions(getOrder()+1);
   setIntrinsicInterval("-pi","+pi");
   setPeriodic();
@@ -127,7 +126,9 @@ void BF_Sine::getAllValues(const double arg, double& argT, bool& inside_range, s
     derivs[i] = io*cos_tmp*intervalDerivf();
   }
   if(!inside_range) {
-    for(unsigned int i=0; i<derivs.size(); i++) {derivs[i]=0.0;}
+    for(unsigned int i=0; i<derivs.size(); i++) {
+      derivs[i]=0.0;
+    }
   }
 }
 
@@ -135,7 +136,8 @@ void BF_Sine::getAllValues(const double arg, double& argT, bool& inside_range, s
 void BF_Sine::setupLabels() {
   setLabel(0,"1");
   for(unsigned int i=1; i < getOrder()+1; i++) {
-    std::string is; Tools::convert(i,is);
+    std::string is;
+    Tools::convert(i,is);
     setLabel(i,"sin("+is+"*s)");
   }
 }
diff --git a/src/ves/BF_Wavelets.cpp b/src/ves/BF_Wavelets.cpp
index cca0c79154..c35f61013e 100644
--- a/src/ves/BF_Wavelets.cpp
+++ b/src/ves/BF_Wavelets.cpp
@@ -236,8 +236,7 @@ void BF_Wavelets::registerKeywords(Keywords& keys) {
 BF_Wavelets::BF_Wavelets(const ActionOptions& ao):
   PLUMED_VES_BASISFUNCTIONS_INIT(ao),
   waveletGrid_(nullptr),
-  scale_(0.0)
-{
+  scale_(0.0) {
   log.printf("  Wavelet basis functions, see and cite ");
   log << plumed.cite("Pampel and Valsson, J. Chem. Theory Comput. 18, 4127-4141 (2022) - DOI:10.1021/acs.jctc.2c00197");
 
@@ -251,7 +250,9 @@ BF_Wavelets::BF_Wavelets(const ActionOptions& ao):
 
   unsigned min_grid_size = 1000;
   parse("MIN_GRID_SIZE", min_grid_size);
-  if(min_grid_size != 1000) {addKeywordToList("MIN_GRID_SIZE",min_grid_size);}
+  if(min_grid_size != 1000) {
+    addKeywordToList("MIN_GRID_SIZE",min_grid_size);
+  }
 
   waveletGrid_ = WaveletGrid::setupGrid(getOrder(), min_grid_size, use_mother_wavelet, WaveletGrid::stringToType(wavelet_type_str));
   bool dump_wavelet_grid=false;
@@ -269,7 +270,9 @@ BF_Wavelets::BF_Wavelets(const ActionOptions& ao):
 
   bool periodic = false;
   parseFlag("PERIODIC",periodic);
-  if (periodic) {addKeywordToList("PERIODIC",periodic);}
+  if (periodic) {
+    addKeywordToList("PERIODIC",periodic);
+  }
 
   // now set up properties of basis set
   unsigned intrinsic_length = 2*getOrder() - 1; // length of unscaled wavelet
@@ -282,8 +285,7 @@ BF_Wavelets::BF_Wavelets(const ActionOptions& ao):
   plumed_massert(threshold < 1, "TAILS_THRESHOLD should be significantly smaller than 1.");
   if(threshold == 0.0) {
     cutoffpoints = {0.0, static_cast<double>(intrinsic_length)};
-  }
-  else {
+  } else {
     plumed_massert(!periodic, "TAILS_THRESHOLD can't be used with the periodic wavelet variant");
     addKeywordToList("TAILS_THRESHOLD",threshold);
     cutoffpoints = getCutoffPoints(threshold);
@@ -307,14 +309,12 @@ BF_Wavelets::BF_Wavelets(const ActionOptions& ao):
     if (periodic) {
       // this is the same value as num_shifts above + constant
       num_BFs = static_cast<unsigned>(bias_length * scale_) + 1;
-    }
-    else {
+    } else {
       num_BFs = 1; // constant one
       // left shifts (w/o left cutoff) + right shifts - right cutoff - 1
       num_BFs += static_cast<unsigned>(ceil(cutoffpoints[1] + (bias_length)*scale_ - cutoffpoints[0]) - 1);
     }
-  }
-  else {
+  } else {
     plumed_massert(num_BFs > 0, "The number of basis functions has to be positive (NUM_BF > 0)");
     // check does not work if function length was given as intrinsic length, but can't check for keyword use directly
     plumed_massert(function_length==bias_length,"The keywords \"NUM_BF\" and \"FUNCTION_LENGTH\" cannot be used at the same time");
@@ -322,8 +322,7 @@ BF_Wavelets::BF_Wavelets(const ActionOptions& ao):
 
     if (periodic) {  // inverted num_BFs calculation from where FUNCTION_LENGTH is specified
       scale_ = (num_BFs  - 1) / bias_length ;
-    }
-    else {
+    } else {
       double cutoff_length = cutoffpoints[1] - cutoffpoints [0];
       double intrinsic_bias_length = num_BFs - cutoff_length + 1; // length of bias in intrinsic scale of wavelets
       scale_ = intrinsic_bias_length / bias_length;
@@ -364,15 +363,19 @@ void BF_Wavelets::getAllValues(const double arg, double& argT, bool& inside_rang
     }
 
     if (x < 0 || x >= intrinsicIntervalMax()) { // Wavelets are 0 outside the defined range
-      values[i] = 0.0; derivs[i] = 0.0;
-    }
-    else {
+      values[i] = 0.0;
+      derivs[i] = 0.0;
+    } else {
       std::vector<double> temp_deriv (1);
       values[i] = GridLinearInterpolation::getGridValueAndDerivativesWithLinearInterpolation(waveletGrid_.get(), {x}, temp_deriv);
       derivs[i] = temp_deriv[0] * scale_; // scale derivative
     }
   }
-  if(!inside_range) {for(auto& deriv : derivs) {deriv=0.0;}}
+  if(!inside_range) {
+    for(auto& deriv : derivs) {
+      deriv=0.0;
+    }
+  }
 }
 
 
@@ -408,7 +411,8 @@ void BF_Wavelets::setupLabels() {
     if (arePeriodic()) {
       pos = pos - floor((pos-intervalMin())/intervalRange())*intervalRange();
     }
-    std::string is; Tools::convert(pos, is);
+    std::string is;
+    Tools::convert(pos, is);
     setLabel(i,"i="+is);
   }
 }
diff --git a/src/ves/BasisFunctions.cpp b/src/ves/BasisFunctions.cpp
index 4da5223078..51d7d4a0cb 100644
--- a/src/ves/BasisFunctions.cpp
+++ b/src/ves/BasisFunctions.cpp
@@ -73,20 +73,22 @@ BasisFunctions::BasisFunctions(const ActionOptions&ao):
   nbins_(1001),
   uniform_integrals_(nbasis_,0.0),
   vesbias_pntr_(NULL),
-  action_pntr_(NULL)
-{
+  action_pntr_(NULL) {
   bf_keywords_.push_back(getName());
   if(keywords.exists("ORDER")) {
-    parse("ORDER",norder_); addKeywordToList("ORDER",norder_);
+    parse("ORDER",norder_);
+    addKeywordToList("ORDER",norder_);
   }
   nbasis_=norder_+1;
   //
-  std::string str_imin; std::string str_imax;
+  std::string str_imin;
+  std::string str_imax;
   if(keywords.exists("MINIMUM") && keywords.exists("MAXIMUM")) {
-    parse("MINIMUM",str_imin); addKeywordToList("MINIMUM",str_imin);
-    parse("MAXIMUM",str_imax); addKeywordToList("MAXIMUM",str_imax);
-  }
-  else {
+    parse("MINIMUM",str_imin);
+    addKeywordToList("MINIMUM",str_imin);
+    parse("MAXIMUM",str_imax);
+    addKeywordToList("MAXIMUM",str_imax);
+  } else {
     str_imin = "-1.0";
     str_imax = "1.0";
   }
@@ -98,7 +100,9 @@ BasisFunctions::BasisFunctions(const ActionOptions&ao):
   if(!Tools::convertNoexcept(str_imax,interval_max_)) {
     plumed_merror(getName()+": cannot convert the value given in MAXIMUM to a double");
   }
-  if(interval_min_>interval_max_) {plumed_merror(getName()+": MINIMUM and MAXIMUM are not correctly defined");}
+  if(interval_min_>interval_max_) {
+    plumed_merror(getName()+": MINIMUM and MAXIMUM are not correctly defined");
+  }
   //
   parseFlag("DEBUG_INFO",print_debug_info_);
   if(keywords.exists("NUMERICAL_INTEGRALS")) {
@@ -168,7 +172,8 @@ void BasisFunctions::setupInterval() {
 
 void BasisFunctions::setupLabels() {
   for(unsigned int i=0; i < nbasis_; i++) {
-    std::string is; Tools::convert(i,is);
+    std::string is;
+    Tools::convert(i,is);
     bf_labels_[i]=bf_label_prefix_+is+"(s)";
   }
 }
@@ -181,32 +186,51 @@ void BasisFunctions::setupUniformIntegrals() {
 
 
 void BasisFunctions::setupBF() {
-  if(interval_intrinsic_min_>interval_intrinsic_max_) {plumed_merror("setupBF: default intervals are not correctly set");}
+  if(interval_intrinsic_min_>interval_intrinsic_max_) {
+    plumed_merror("setupBF: default intervals are not correctly set");
+  }
   setupInterval();
   setupLabels();
-  if(bf_labels_.size()==1) {plumed_merror("setupBF: the labels of the basis functions are not correct.");}
-  if(!numerical_uniform_integrals_) {setupUniformIntegrals();}
-  else {numericalUniformIntegrals();}
-  if(uniform_integrals_.size()==1) {plumed_merror("setupBF: the integrals of the basis functions is not correct.");}
-  if(type_=="Undefined") {plumed_merror("setupBF: the type of the basis function is not defined.");}
-  if(description_=="Undefined") {plumed_merror("setupBF: the description of the basis function is not defined.");}
+  if(bf_labels_.size()==1) {
+    plumed_merror("setupBF: the labels of the basis functions are not correct.");
+  }
+  if(!numerical_uniform_integrals_) {
+    setupUniformIntegrals();
+  } else {
+    numericalUniformIntegrals();
+  }
+  if(uniform_integrals_.size()==1) {
+    plumed_merror("setupBF: the integrals of the basis functions is not correct.");
+  }
+  if(type_=="Undefined") {
+    plumed_merror("setupBF: the type of the basis function is not defined.");
+  }
+  if(description_=="Undefined") {
+    plumed_merror("setupBF: the description of the basis function is not defined.");
+  }
   has_been_set=true;
   printInfo();
 }
 
 
 void BasisFunctions::printInfo() const {
-  if(!has_been_set) {plumed_merror("the basis set has not be setup correctly");}
+  if(!has_been_set) {
+    plumed_merror("the basis set has not be setup correctly");
+  }
   log.printf("  One-dimensional basis set\n");
   log.printf("   Description: %s\n",description_.c_str());
   log.printf("   Type: %s\n",type_.c_str());
-  if(periodic_) {log.printf("   The basis functions are periodic\n");}
+  if(periodic_) {
+    log.printf("   The basis functions are periodic\n");
+  }
   log.printf("   Order of basis set: %u\n",norder_);
   log.printf("   Number of basis functions: %u\n",nbasis_);
   // log.printf("   Interval of basis set: %f to %f\n",interval_min_,interval_max_);
   log.printf("   Interval of basis set: %s to %s\n",interval_min_str_.c_str(),interval_max_str_.c_str());
   log.printf("   Description of basis functions:\n");
-  for(unsigned int i=0; i < nbasis_; i++) {log.printf("    %2u       %10s\n",i,bf_labels_[i].c_str());}
+  for(unsigned int i=0; i < nbasis_; i++) {
+    log.printf("    %2u       %10s\n",i,bf_labels_[i].c_str());
+  }
   //
   if(print_debug_info_) {
     log.printf("  Debug information:\n");
@@ -218,8 +242,12 @@ void BasisFunctions::printInfo() const {
     log.printf("   Defined interval of basis set: range=%f,  mean=%f\n",interval_range_,interval_mean_);
     log.printf("   Derivative factor due to interval translation: %f\n",argT_derivf_);
     log.printf("   Integral of basis functions over the interval:\n");
-    if(numerical_uniform_integrals_) {log.printf("   Note: calculated numerically\n");}
-    for(unsigned int i=0; i < nbasis_; i++) {log.printf("    %2u       %16.10f\n",i,uniform_integrals_[i]);}
+    if(numerical_uniform_integrals_) {
+      log.printf("   Note: calculated numerically\n");
+    }
+    for(unsigned int i=0; i < nbasis_; i++) {
+      log.printf("    %2u       %16.10f\n",i,uniform_integrals_[i]);
+    }
     log.printf("   --------------------------\n");
   }
 }
@@ -237,12 +265,19 @@ void BasisFunctions::linkAction(Action* action_pntr_in) {
 
 
 void BasisFunctions::numericalUniformIntegrals() {
-  std::vector<std::string> grid_min(1); grid_min[0]=intervalMinStr();
-  std::vector<std::string> grid_max(1); grid_max[0]=intervalMaxStr();
-  std::vector<unsigned int> grid_bins(1); grid_bins[0]=nbins_;
-  std::vector<std::unique_ptr<Value>> arguments(1); arguments[0]= Tools::make_unique<Value>(nullptr,"arg",false);
-  if(arePeriodic()) {arguments[0]->setDomain(intervalMinStr(),intervalMaxStr());}
-  else {arguments[0]->setNotPeriodic();}
+  std::vector<std::string> grid_min(1);
+  grid_min[0]=intervalMinStr();
+  std::vector<std::string> grid_max(1);
+  grid_max[0]=intervalMaxStr();
+  std::vector<unsigned int> grid_bins(1);
+  grid_bins[0]=nbins_;
+  std::vector<std::unique_ptr<Value>> arguments(1);
+  arguments[0]= Tools::make_unique<Value>(nullptr,"arg",false);
+  if(arePeriodic()) {
+    arguments[0]->setDomain(intervalMinStr(),intervalMaxStr());
+  } else {
+    arguments[0]->setNotPeriodic();
+  }
   auto uniform_grid = Tools::make_unique<Grid>("uniform",Tools::unique2raw(arguments),grid_min,grid_max,grid_bins,false,false);
   //
   double inverse_normalization = 1.0/(intervalMax()-intervalMin());
@@ -282,8 +317,7 @@ std::vector<double> BasisFunctions::numericalTargetDistributionIntegralsFromGrid
 std::vector<double> BasisFunctions::getTargetDistributionIntegrals(const TargetDistribution* targetdist_pntr) const {
   if(targetdist_pntr==NULL) {
     return getUniformIntegrals();
-  }
-  else {
+  } else {
     Grid* targetdist_grid = targetdist_pntr->getTargetDistGridPntr();
     return numericalTargetDistributionIntegralsFromGrid(targetdist_grid);
   }
@@ -292,7 +326,9 @@ std::vector<double> BasisFunctions::getTargetDistributionIntegrals(const TargetD
 
 std::string BasisFunctions::getKeywordString() const {
   std::string str_keywords=bf_keywords_[0];
-  for(unsigned int i=1; i<bf_keywords_.size(); i++) {str_keywords+=" "+bf_keywords_[i];}
+  for(unsigned int i=1; i<bf_keywords_.size(); i++) {
+    str_keywords+=" "+bf_keywords_[i];
+  }
   return str_keywords;
 }
 
@@ -344,13 +380,19 @@ void BasisFunctions::getMultipleValue(const std::vector<double>& args, std::vect
 
 
 void BasisFunctions::writeBasisFunctionsToFile(OFile& ofile_values, OFile& ofile_derivs, const std::string& min_in, const std::string& max_in, unsigned int nbins_in, const bool ignore_periodicity, const std::string& output_fmt_values, const std::string& output_fmt_derivs, const bool numerical_deriv) const {
-  std::vector<std::string> min(1); min[0]=min_in;
-  std::vector<std::string> max(1); max[0]=max_in;
-  std::vector<unsigned int> nbins(1); nbins[0]=nbins_in;
+  std::vector<std::string> min(1);
+  min[0]=min_in;
+  std::vector<std::string> max(1);
+  max[0]=max_in;
+  std::vector<unsigned int> nbins(1);
+  nbins[0]=nbins_in;
   std::vector<std::unique_ptr<Value>> value_pntr(1);
   value_pntr[0]= Tools::make_unique<Value>(nullptr,"arg",false);
-  if(arePeriodic() && !ignore_periodicity) {value_pntr[0]->setDomain(intervalMinStr(),intervalMaxStr());}
-  else {value_pntr[0]->setNotPeriodic();}
+  if(arePeriodic() && !ignore_periodicity) {
+    value_pntr[0]->setDomain(intervalMinStr(),intervalMaxStr());
+  } else {
+    value_pntr[0]->setNotPeriodic();
+  }
   Grid args_grid = Grid("grid",Tools::unique2raw(value_pntr),min,max,nbins,false,false);
 
   std::vector<double> args(args_grid.getSize(),0.0);
@@ -376,8 +418,7 @@ void BasisFunctions::writeBasisFunctionsToFile(OFile& ofile_values, OFile& ofile
   if(arePeriodic()) {
     ofile_values.addConstantField("periodic").printField("periodic","true");
     ofile_derivs.addConstantField("periodic").printField("periodic","true");
-  }
-  else {
+  } else {
     ofile_values.addConstantField("periodic").printField("periodic","false");
     ofile_derivs.addConstantField("periodic").printField("periodic","false");
   }
diff --git a/src/ves/BasisFunctions.h b/src/ves/BasisFunctions.h
index cb12994c45..05231e3396 100644
--- a/src/ves/BasisFunctions.h
+++ b/src/ves/BasisFunctions.h
@@ -47,8 +47,7 @@ class VesBias;
 class TargetDistribution;
 
 class BasisFunctions :
-  public Action
-{
+  public Action {
 private:
   // print extra info about the basis set
   bool print_debug_info_;
@@ -103,7 +102,9 @@ class BasisFunctions :
   // setup various stuff
   void setupBF();
   void setupInterval();
-  void setNumericalIntegrationBins(const unsigned int nbins) {nbins_=nbins;}
+  void setNumericalIntegrationBins(const unsigned int nbins) {
+    nbins_=nbins;
+  }
   void numericalUniformIntegrals();
   std::vector<double> numericalTargetDistributionIntegralsFromGrid(const Grid*) const ;
   virtual void setupLabels();
@@ -114,24 +115,46 @@ class BasisFunctions :
   void addKeywordToList(const std::string&, const std::vector<T>&);
   void addKeywordToList(const std::string&, const bool);
   //
-  void setPeriodic() {periodic_=true;}
-  void setNonPeriodic() {periodic_=false;}
-  void setIntervalBounded() {interval_bounded_=true;}
-  void setIntervalNonBounded() {interval_bounded_=false;}
-  void setType(const std::string& type_in) {type_=type_in;}
-  void setDescription(const std::string& description_in) {description_=description_in;}
+  void setPeriodic() {
+    periodic_=true;
+  }
+  void setNonPeriodic() {
+    periodic_=false;
+  }
+  void setIntervalBounded() {
+    interval_bounded_=true;
+  }
+  void setIntervalNonBounded() {
+    interval_bounded_=false;
+  }
+  void setType(const std::string& type_in) {
+    type_=type_in;
+  }
+  void setDescription(const std::string& description_in) {
+    description_=description_in;
+  }
   //
   void setNumberOfBasisFunctions(const unsigned int);
-  void setOrder(const unsigned int norder_in) {norder_=norder_in;}
+  void setOrder(const unsigned int norder_in) {
+    norder_=norder_in;
+  }
   void setIntrinsicInterval(const double, const double);
   void setIntrinsicInterval(const std::string&, const std::string&);
   void setInterval(const double, const double);
   void setInterval(const std::string&, const std::string&);
   //
-  double intrinsicIntervalMin() const {return interval_intrinsic_min_;}
-  double intrinsicIntervalMax() const {return interval_intrinsic_max_;}
-  std::string intrinsicIntervalMinStr() const {return interval_intrinsic_min_str_;}
-  std::string intrinsicIntervalMaxStr() const {return interval_intrinsic_max_str_;}
+  double intrinsicIntervalMin() const {
+    return interval_intrinsic_min_;
+  }
+  double intrinsicIntervalMax() const {
+    return interval_intrinsic_max_;
+  }
+  std::string intrinsicIntervalMinStr() const {
+    return interval_intrinsic_min_str_;
+  }
+  std::string intrinsicIntervalMaxStr() const {
+    return interval_intrinsic_max_str_;
+  }
   //
   void setUniformIntegral(const unsigned int, const double);
   void setUniformIntegrals(const std::vector<double>&);
@@ -144,30 +167,70 @@ class BasisFunctions :
 public:
   static void registerKeywords(Keywords&);
   explicit BasisFunctions(const ActionOptions&ao);
-  bool hasBeenSet() const {return has_been_set;}
-  std::string getType() const {return type_;}
-  std::string getDescription() const {return description_;}
-  unsigned int getOrder() const {return norder_;}
-  unsigned int getNumberOfBasisFunctions() const {return nbasis_;}
-  unsigned int numberOfBasisFunctions() const {return nbasis_;}
-  unsigned int getSize() const {return nbasis_;}
-  bool arePeriodic() const {return periodic_;}
-  bool intervalBounded() const {return interval_bounded_;}
-  double intervalMin() const {return interval_min_;}
-  double intervalMax() const {return interval_max_;}
-  double intervalRange() const {return interval_range_;}
-  double intervalMean() const {return interval_mean_;}
-  double intervalDerivf() const {return argT_derivf_;}
-  std::string intervalMinStr() const {return interval_min_str_;}
-  std::string intervalMaxStr() const {return interval_max_str_;}
-  std::vector<double> getUniformIntegrals() const {return uniform_integrals_;}
+  bool hasBeenSet() const {
+    return has_been_set;
+  }
+  std::string getType() const {
+    return type_;
+  }
+  std::string getDescription() const {
+    return description_;
+  }
+  unsigned int getOrder() const {
+    return norder_;
+  }
+  unsigned int getNumberOfBasisFunctions() const {
+    return nbasis_;
+  }
+  unsigned int numberOfBasisFunctions() const {
+    return nbasis_;
+  }
+  unsigned int getSize() const {
+    return nbasis_;
+  }
+  bool arePeriodic() const {
+    return periodic_;
+  }
+  bool intervalBounded() const {
+    return interval_bounded_;
+  }
+  double intervalMin() const {
+    return interval_min_;
+  }
+  double intervalMax() const {
+    return interval_max_;
+  }
+  double intervalRange() const {
+    return interval_range_;
+  }
+  double intervalMean() const {
+    return interval_mean_;
+  }
+  double intervalDerivf() const {
+    return argT_derivf_;
+  }
+  std::string intervalMinStr() const {
+    return interval_min_str_;
+  }
+  std::string intervalMaxStr() const {
+    return interval_max_str_;
+  }
+  std::vector<double> getUniformIntegrals() const {
+    return uniform_integrals_;
+  }
   std::vector<double> getTargetDistributionIntegrals(const TargetDistribution*) const;
   //
-  std::vector<std::string> getKeywordList() const {return bf_keywords_;}
+  std::vector<std::string> getKeywordList() const {
+    return bf_keywords_;
+  }
   std::string getKeywordString() const;
   //
-  std::string getBasisFunctionLabel(const unsigned int index) const {return bf_labels_[index];}
-  std::vector<std::string> getBasisFunctionLabels() const {return bf_labels_;}
+  std::string getBasisFunctionLabel(const unsigned int index) const {
+    return bf_labels_[index];
+  }
+  std::vector<std::string> getBasisFunctionLabels() const {
+    return bf_labels_;
+  }
   //
   void linkVesBias(VesBias*);
   void linkAction(Action*);
@@ -257,8 +320,7 @@ double BasisFunctions::translateArgument(const double arg, bool& inside_interval
   if(argT < interval_intrinsic_min_) {
     inside_interval=false;
     argT=interval_intrinsic_min_;
-  }
-  else if(argT > interval_intrinsic_max_) {
+  } else if(argT > interval_intrinsic_max_) {
     inside_interval=false;
     argT=interval_intrinsic_max_;
   }
@@ -273,8 +335,7 @@ double BasisFunctions::checkIfArgumentInsideInterval(const double arg, bool& ins
   if(arg < interval_min_) {
     inside_interval=false;
     argT=interval_min_;
-  }
-  else if(arg > interval_max_) {
+  } else if(arg > interval_max_) {
     inside_interval=false;
     argT=interval_max_;
   }
@@ -307,7 +368,9 @@ void BasisFunctions::addKeywordToList(const std::string& keyword, const std::vec
 
 inline
 void BasisFunctions::addKeywordToList(const std::string& keyword, const bool value) {
-  if(value) {bf_keywords_.push_back(keyword);}
+  if(value) {
+    bf_keywords_.push_back(keyword);
+  }
 }
 
 
diff --git a/src/ves/CoeffsBase.cpp b/src/ves/CoeffsBase.cpp
index 05e6ad05c1..0840cb6363 100644
--- a/src/ves/CoeffsBase.cpp
+++ b/src/ves/CoeffsBase.cpp
@@ -66,8 +66,7 @@ CoeffsBase::CoeffsBase(
   field_shape_prefix_("shape_"),
   field_time_("time"),
   field_iteration_("iteration"),
-  output_fmt_("%30.16e")
-{
+  output_fmt_("%30.16e") {
   initializeIndices(indices_shape,dimension_labels);
   setAllCoeffsDescriptions();
 }
@@ -103,8 +102,7 @@ CoeffsBase::CoeffsBase(
   field_shape_prefix_("shape_"),
   field_time_("time"),
   field_iteration_("iteration"),
-  output_fmt_("%30.16e")
-{
+  output_fmt_("%30.16e") {
   plumed_massert(args_.size()==basisf_.size(),"CoeffsBase: number of arguments do not match number of basis functions");
   std::vector<std::string> dimension_labels(args_.size());
   std::vector<unsigned int> indices_shape(args_.size());
@@ -148,8 +146,7 @@ CoeffsBase::CoeffsBase(
   field_shape_prefix_("shape_"),
   field_time_("time"),
   field_iteration_("iteration"),
-  output_fmt_("%30.16e")
-{
+  output_fmt_("%30.16e") {
   plumed_massert(multicoeffs_args.size()==multicoeffs_basisf.size(),"Multi Coeffs: number of arguments vectors does not match number of basis functions vectors");
   unsigned int num_args = multicoeffs_args[0].size();
   unsigned int dim = num_args+1;
@@ -216,8 +213,7 @@ void CoeffsBase::setupBasisFunctionsInfo() {
       }
       setCoeffDescription(i,desc);
     }
-  }
-  else if(coeffs_type_==MultiCoeffs_LinearBasisSet) {
+  } else if(coeffs_type_==MultiCoeffs_LinearBasisSet) {
     for(unsigned int i=0; i<numberOfCoeffs(); i++) {
       std::vector<unsigned int> indices=getIndices(i);
       unsigned int mc_id = indices[ndimensions_-1];
@@ -298,11 +294,9 @@ std::string CoeffsBase::getTypeStr() const {
   std::string type_str="";
   if(coeffs_type_==Generic) {
     type_str = "Generic";
-  }
-  else if(coeffs_type_==LinearBasisSet) {
+  } else if(coeffs_type_==LinearBasisSet) {
     type_str = "LinearBasisSet";
-  }
-  else if(coeffs_type_==MultiCoeffs_LinearBasisSet) {
+  } else if(coeffs_type_==MultiCoeffs_LinearBasisSet) {
     type_str = "MultiCoeffs_LinearBasisSet";
   }
   return type_str;
@@ -349,10 +343,12 @@ void CoeffsBase::setCoeffDescription(const std::vector<unsigned int>& indices, c
 void CoeffsBase::setAllCoeffsDescriptions(const std::string& description_prefix) {
   for(size_t i=0; i<numberOfCoeffs(); i++) {
     std::vector<unsigned int> indices=getIndices(i);
-    std::string is; Tools::convert(indices[0],is);
+    std::string is;
+    Tools::convert(indices[0],is);
     std::string desc=description_prefix+"("+is;
     for(unsigned int k=1; k<numberOfDimensions(); k++) {
-      Tools::convert(indices[k],is); desc+=","+is;
+      Tools::convert(indices[k],is);
+      desc+=","+is;
     }
     desc+=")";
     coeffs_descriptions_[i]=desc;
@@ -376,7 +372,8 @@ void CoeffsBase::setDimensionLabel(const unsigned int dim_index, const std::stri
 
 void CoeffsBase::setAllDimensionLabels(const std::string& label_prefix) {
   for(unsigned int i=0; i<numberOfDimensions(); i++) {
-    std::string is; Tools::convert(i,is);
+    std::string is;
+    Tools::convert(i,is);
     dimension_labels_[i]=label_prefix + is;
   }
 }
@@ -406,24 +403,21 @@ void CoeffsBase::getCoeffsInfoFromFile(IFile& ifile, const bool ignore_coeffs_in
   std::string coeffs_type_f;
   if(ifile.scanField(field_type_,coeffs_type_f)) {
     // empty for now
-  }
-  else {
+  } else {
     return;
   }
   // number of dimensions
   unsigned int ndimensions_f = 0;
   if(ifile.scanField(field_ndimensions_,int_tmp)) {
     ndimensions_f=(unsigned int) int_tmp;
-  }
-  else {
+  } else {
     return;
   }
   // total number of coeffs
   size_t ncoeffs_total_f = 0;
   if(ifile.scanField(field_ncoeffs_total_,int_tmp)) {
     ncoeffs_total_f=(size_t) int_tmp;
-  }
-  else {
+  } else {
     return;
   }
   // shape of indices
@@ -431,8 +425,7 @@ void CoeffsBase::getCoeffsInfoFromFile(IFile& ifile, const bool ignore_coeffs_in
   for(unsigned int k=0; k<numberOfDimensions(); k++) {
     if(ifile.scanField(field_shape_prefix_+getDimensionLabel(k),int_tmp)) {
       indices_shape_f[k]=(unsigned int) int_tmp;
-    }
-    else {
+    } else {
       return;
     }
   }
@@ -450,21 +443,27 @@ void CoeffsBase::checkCoeffsInfo(const std::string& msg_header, const std::strin
     plumed_merror(msg);
   }
   if(ndimensions_f != numberOfDimensions() ) {
-    std::string s1; Tools::convert(ndimensions_f,s1);
-    std::string s2; Tools::convert(numberOfDimensions(),s2);
+    std::string s1;
+    Tools::convert(ndimensions_f,s1);
+    std::string s2;
+    Tools::convert(numberOfDimensions(),s2);
     std::string msg = msg_header + " the number of dimensions " + s1 + " in file doesn't match the defined value " + s2;
     plumed_merror(msg);
   }
   if(ncoeffs_total_f != numberOfCoeffs() ) {
-    std::string s1; Tools::convert(ncoeffs_total_f,s1);
-    std::string s2; Tools::convert(numberOfCoeffs(),s2);
+    std::string s1;
+    Tools::convert(ncoeffs_total_f,s1);
+    std::string s2;
+    Tools::convert(numberOfCoeffs(),s2);
     std::string msg = msg_header + " the number of coeffs " + s1 + " in file doesn't match the defined value " + s2;
     plumed_merror(msg);
   }
   for(unsigned int k=0; k<numberOfDimensions(); k++) {
     if(indices_shape_f[k] != shapeOfIndices(k) ) {
-      std::string s1; Tools::convert(indices_shape_f[k],s1);
-      std::string s2; Tools::convert(shapeOfIndices(k),s2);
+      std::string s1;
+      Tools::convert(indices_shape_f[k],s1);
+      std::string s2;
+      Tools::convert(shapeOfIndices(k),s2);
       std::string msg = msg_header + " for dimension labeled " + getDimensionLabel(k) + " the shape of indices " + s1 + " in file doesn't match defined value " + s2;
       plumed_merror(msg);
     }
@@ -505,8 +504,7 @@ void CoeffsBase::replaceLabelString(const std::string& oldstring, const std::str
   std::string label = getLabel();
   if(label.find(oldstring)!=std::string::npos) {
     label.replace(label.find(oldstring), std::string(oldstring).length(), newstring);
-  }
-  else {
+  } else {
     label += "_" + newstring;
   }
   setLabels(label);
diff --git a/src/ves/CoeffsBase.h b/src/ves/CoeffsBase.h
index 8d940cdc21..2fc0c48da4 100644
--- a/src/ves/CoeffsBase.h
+++ b/src/ves/CoeffsBase.h
@@ -39,8 +39,7 @@ class BasisFunctions;
 class VesBias;
 
 /// \ingroup TOOLBOX
-class CoeffsBase
-{
+class CoeffsBase {
 public:
   // the type of 1D index
   // typedef size_t index_t;
@@ -112,47 +111,83 @@ class CoeffsBase
   //
   ~CoeffsBase();
   //
-  std::string getLabel() const {return label_;}
+  std::string getLabel() const {
+    return label_;
+  }
   void setLabel(const std::string&);
-  std::string getDataLabel() const {return data_label_;};
+  std::string getDataLabel() const {
+    return data_label_;
+  };
   void setDataLabel(const std::string&);
   void setLabels(const std::string&);
   void setLabels(const std::string&, const std::string&);
   //
-  CoeffsType getType() const {return coeffs_type_;}
+  CoeffsType getType() const {
+    return coeffs_type_;
+  }
   std::string getTypeStr() const;
   void setType(const CoeffsType coeffs_type);
   void linkVesBias(VesBias*);
   void linkAction(Action*);
-  VesBias* getPntrToVesBias() const {return vesbias_pntr_;}
-  Action* getPntrToAction() const {return action_pntr_;}
-  bool isGenericCoeffs() const {return coeffs_type_==Generic;}
-  bool isLinearBasisSetCoeffs() const {return coeffs_type_==LinearBasisSet;}
-  bool isMultiLinearBasisSetCoeffs() const {return coeffs_type_==MultiCoeffs_LinearBasisSet;}
+  VesBias* getPntrToVesBias() const {
+    return vesbias_pntr_;
+  }
+  Action* getPntrToAction() const {
+    return action_pntr_;
+  }
+  bool isGenericCoeffs() const {
+    return coeffs_type_==Generic;
+  }
+  bool isLinearBasisSetCoeffs() const {
+    return coeffs_type_==LinearBasisSet;
+  }
+  bool isMultiLinearBasisSetCoeffs() const {
+    return coeffs_type_==MultiCoeffs_LinearBasisSet;
+  }
   //
-  std::vector<unsigned int> shapeOfIndices() const {return indices_shape_;}
-  unsigned int shapeOfIndices(const unsigned int dim_index) const {return indices_shape_[dim_index];}
-  size_t numberOfCoeffs() const {return ncoeffs_;}
-  unsigned int numberOfDimensions() const {return ndimensions_;}
+  std::vector<unsigned int> shapeOfIndices() const {
+    return indices_shape_;
+  }
+  unsigned int shapeOfIndices(const unsigned int dim_index) const {
+    return indices_shape_[dim_index];
+  }
+  size_t numberOfCoeffs() const {
+    return ncoeffs_;
+  }
+  unsigned int numberOfDimensions() const {
+    return ndimensions_;
+  }
   //
-  bool isActive() const {return active;}
-  void activate() {active=true;}
-  void deactivate() {active=false;}
+  bool isActive() const {
+    return active;
+  }
+  void activate() {
+    active=true;
+  }
+  void deactivate() {
+    active=false;
+  }
   //
   size_t getIndex(const std::vector<unsigned int>&) const;
   std::vector<unsigned int> getIndices(const size_t) const;
   bool indicesExist(const std::vector<unsigned int>&) const;
   //
-  std::string getCoeffDescription(const size_t index) const {return coeffs_descriptions_[index];}
+  std::string getCoeffDescription(const size_t index) const {
+    return coeffs_descriptions_[index];
+  }
   std::string getCoeffDescription(const std::vector<unsigned int>&) const;
-  std::vector<std::string> getAllCoeffsDescriptions() const {return coeffs_descriptions_;}
+  std::vector<std::string> getAllCoeffsDescriptions() const {
+    return coeffs_descriptions_;
+  }
   void setCoeffDescription(const size_t, const std::string&);
   void setCoeffDescription(const std::vector<unsigned int>&, const std::string&);
   void setAllCoeffsDescriptions(const std::string& description_prefix="C");
   void setAllCoeffsDescriptions(const std::vector<std::string>&);
   //
   std::string getDimensionLabel(const unsigned int) const;
-  std::vector<std::string> getAllDimensionLabels() const {return dimension_labels_;}
+  std::vector<std::string> getAllDimensionLabels() const {
+    return dimension_labels_;
+  }
   void setDimensionLabel(const unsigned int, const std::string&);
   void setAllDimensionLabels(const std::string&);
   void setAllDimensionLabels(const std::vector<std::string>&);
@@ -161,18 +196,34 @@ class CoeffsBase
   void getCoeffsInfoFromFile(IFile&, const bool ignore_coeffs_info=false);
   void checkCoeffsInfo(const std::string&, const std::string&, const unsigned int, const size_t, const std::vector<unsigned int>&);
   //
-  void turnOnIterationCounter() {iteration_and_time_active_=true;}
-  void turnOffIterationCounter() {iteration_and_time_active_=false;}
-  bool isIterationCounterActive() const {return iteration_and_time_active_;}
+  void turnOnIterationCounter() {
+    iteration_and_time_active_=true;
+  }
+  void turnOffIterationCounter() {
+    iteration_and_time_active_=false;
+  }
+  bool isIterationCounterActive() const {
+    return iteration_and_time_active_;
+  }
   void setIterationCounter(const unsigned int);
   void setTime(const double);
   void setIterationCounterAndTime(const unsigned int, const double);
-  unsigned int getIterationCounter() const {return iteration_opt;}
-  double getTimeValue() const {return time_md;}
+  unsigned int getIterationCounter() const {
+    return iteration_opt;
+  }
+  double getTimeValue() const {
+    return time_md;
+  }
   //
-  void setOutputFmt(const std::string& ss) { output_fmt_=ss; }
-  void resetOutputFmt() {output_fmt_="%30.16e";}
-  std::string getOutputFmt() const {return output_fmt_;}
+  void setOutputFmt(const std::string& ss) {
+    output_fmt_=ss;
+  }
+  void resetOutputFmt() {
+    output_fmt_="%30.16e";
+  }
+  std::string getOutputFmt() const {
+    return output_fmt_;
+  }
   //
   void replaceLabelString(const std::string&, const std::string&);
 protected:
diff --git a/src/ves/CoeffsMatrix.cpp b/src/ves/CoeffsMatrix.cpp
index 4531e94c94..a5048ed060 100644
--- a/src/ves/CoeffsMatrix.cpp
+++ b/src/ves/CoeffsMatrix.cpp
@@ -57,8 +57,7 @@ CoeffsMatrix::CoeffsMatrix(
   diagonal_(diagonal),
   averaging_counter(0),
   averaging_exp_decay_(0),
-  mycomm(cc)
-{
+  mycomm(cc) {
   setupMatrix();
 }
 
@@ -78,8 +77,7 @@ CoeffsMatrix::CoeffsMatrix(
   diagonal_(diagonal),
   averaging_counter(0),
   averaging_exp_decay_(0),
-  mycomm(cc)
-{
+  mycomm(cc) {
   setupMatrix();
 }
 
@@ -100,8 +98,7 @@ CoeffsMatrix::CoeffsMatrix(
   diagonal_(diagonal),
   averaging_counter(0),
   averaging_exp_decay_(0),
-  mycomm(cc)
-{
+  mycomm(cc) {
   setupMatrix();
 }
 
@@ -119,8 +116,7 @@ CoeffsMatrix::CoeffsMatrix(
   diagonal_(diagonal),
   averaging_counter(0),
   averaging_exp_decay_(0),
-  mycomm(cc)
-{
+  mycomm(cc) {
   setLabels(label);
   setupMatrix();
 }
@@ -134,8 +130,7 @@ void CoeffsMatrix::setupMatrix() {
   ncolumns_=nrows_;
   if(diagonal_) {
     size_=nrows_;
-  }
-  else {
+  } else {
     size_=(nrows_*nrows_-nrows_)/2+nrows_;
   }
   clear();
@@ -204,11 +199,9 @@ size_t CoeffsMatrix::getMatrixIndex(const size_t index1, const size_t index2) co
   if(diagonal_) {
     // plumed_massert(index1==index2,"CoeffsMatrix: you trying to access a off-diagonal element of a diagonal coeffs matrix");
     matrix_idx=index1;
-  }
-  else if (index1<=index2) {
+  } else if (index1<=index2) {
     matrix_idx=index2+index1*(nrows_-1)-index1*(index1-1)/2;
-  }
-  else {
+  } else {
     matrix_idx=index1+index2*(nrows_-1)-index2*(index2-1)/2;
   }
   return matrix_idx;
@@ -279,8 +272,7 @@ CoeffsVector operator*(const CoeffsMatrix& coeffs_matrix, const CoeffsVector& co
     for(size_t i=0; i<numcoeffs; i++) {
       new_coeffs_vector(i) = coeffs_matrix(i,i)*coeffs_vector(i);
     }
-  }
-  else {
+  } else {
     for(size_t i=0; i<numcoeffs; i++) {
       for(size_t j=0; j<numcoeffs; j++) {
         new_coeffs_vector(i) += coeffs_matrix(i,j)*coeffs_vector(j);
@@ -572,7 +564,9 @@ double CoeffsMatrix::getMaxValue() const {
 
 void CoeffsMatrix::randomizeValuesGaussian(int randomSeed) {
   Random rnd;
-  if (randomSeed<0) {randomSeed = -randomSeed;}
+  if (randomSeed<0) {
+    randomSeed = -randomSeed;
+  }
   rnd.setSeed(-randomSeed);
   for(size_t i=0; i<data.size(); i++) {
     data[i]=rnd.Gaussian();
@@ -611,11 +605,12 @@ void CoeffsMatrix::writeToFile(const std::string& filepath, const bool append_fi
   OFile file;
   if(action_pntr!=NULL) {
     file.link(*action_pntr);
-  }
-  else {
+  } else {
     file.link(mycomm);
   }
-  if(append_file) { file.enforceRestart(); }
+  if(append_file) {
+    file.enforceRestart();
+  }
   file.open(filepath);
   writeToFile(file);
   file.close();
@@ -641,8 +636,7 @@ void CoeffsMatrix::writeHeaderToFile(OFile& ofile) {
 void CoeffsMatrix::writeDataToFile(OFile& ofile) {
   if(diagonal_) {
     writeDataDiagonalToFile(ofile);
-  }
-  else {
+  } else {
     writeDataFullToFile(ofile);
   }
 }
@@ -671,7 +665,8 @@ void CoeffsMatrix::writeDataDiagonalToFile(OFile& ofile) {
       ofile.printField(ilabels[k],s1.data());
     }
     ofile.fmtField(" "+getOutputFmt()).printField(field_coeffs,getValue(i,i));
-    std::snprintf(s1.data(),s1.size(),int_fmt.c_str(),i); ofile.printField(field_index,s1.data());
+    std::snprintf(s1.data(),s1.size(),int_fmt.c_str(),i);
+    ofile.printField(field_index,s1.data());
     ofile.printField();
   }
   ofile.fmtField();
diff --git a/src/ves/CoeffsMatrix.h b/src/ves/CoeffsMatrix.h
index 4cd5ca83f5..52aae361ed 100644
--- a/src/ves/CoeffsMatrix.h
+++ b/src/ves/CoeffsMatrix.h
@@ -44,8 +44,7 @@ class CoeffsVector;
 
 
 class CoeffsMatrix:
-  public CoeffsBase
-{
+  public CoeffsBase {
 public:
 private:
   std::vector<double> data;
@@ -120,7 +119,9 @@ class CoeffsMatrix:
   void clear();
   void setAllValuesToZero();
   //
-  std::vector<double> getDataAsVector() const {return data;}
+  std::vector<double> getDataAsVector() const {
+    return data;
+  }
   // get value
   double getValue(const size_t, const size_t) const;
   double getValue(const std::vector<unsigned int>&, const std::vector<unsigned int>&) const;
@@ -184,9 +185,15 @@ class CoeffsMatrix:
   //
   void randomizeValuesGaussian(int);
   //
-  void resetAveragingCounter() {averaging_counter=0;}
-  void setupExponentiallyDecayingAveraging(const unsigned int averaging_exp_decay_in) {averaging_exp_decay_=averaging_exp_decay_in;}
-  void turnOffExponentiallyDecayingAveraging() { averaging_exp_decay_=0;}
+  void resetAveragingCounter() {
+    averaging_counter=0;
+  }
+  void setupExponentiallyDecayingAveraging(const unsigned int averaging_exp_decay_in) {
+    averaging_exp_decay_=averaging_exp_decay_in;
+  }
+  void turnOffExponentiallyDecayingAveraging() {
+    averaging_exp_decay_=0;
+  }
   void resetAveraging();
   void addToAverage(const CoeffsMatrix&);
   void addToAverage(const CoeffsMatrix&, const unsigned int);
@@ -201,7 +208,9 @@ class CoeffsMatrix:
   void writeDataDiagonalToFile(OFile&);
   void writeDataFullToFile(OFile&);
 public:
-  Communicator& getCommunicator() const {return mycomm;}
+  Communicator& getCommunicator() const {
+    return mycomm;
+  }
 
 };
 }
diff --git a/src/ves/CoeffsVector.cpp b/src/ves/CoeffsVector.cpp
index 62dde7ffa4..c3630611a1 100644
--- a/src/ves/CoeffsVector.cpp
+++ b/src/ves/CoeffsVector.cpp
@@ -52,8 +52,7 @@ CoeffsVector::CoeffsVector(
   data(0),
   averaging_counter(0),
   averaging_exp_decay_(0),
-  mycomm(cc)
-{
+  mycomm(cc) {
   clear();
 }
 
@@ -68,8 +67,7 @@ CoeffsVector::CoeffsVector(
   data(0),
   averaging_counter(0),
   averaging_exp_decay_(0),
-  mycomm(cc)
-{
+  mycomm(cc) {
   clear();
 }
 
@@ -85,8 +83,7 @@ CoeffsVector::CoeffsVector(
   data(0),
   averaging_counter(0),
   averaging_exp_decay_(0),
-  mycomm(cc)
-{
+  mycomm(cc) {
   clear();
 }
 
@@ -99,8 +96,7 @@ CoeffsVector::CoeffsVector(
   data(0),
   averaging_counter(0),
   averaging_exp_decay_(0),
-  mycomm(cc)
-{
+  mycomm(cc) {
   clear();
 }
 
@@ -645,7 +641,9 @@ void CoeffsVector::normalizeCoeffs() {
 
 void CoeffsVector::randomizeValuesGaussian(int randomSeed) {
   Random rnd;
-  if (randomSeed<0) {randomSeed = -randomSeed;}
+  if (randomSeed<0) {
+    randomSeed = -randomSeed;
+  }
   rnd.setSeed(-randomSeed);
   for(size_t i=0; i<data.size(); i++) {
     data[i]=rnd.Gaussian();
@@ -689,11 +687,12 @@ void CoeffsVector::writeToFile(const std::string& filepath, const bool print_coe
   OFile file;
   if(action_pntr!=NULL) {
     file.link(*action_pntr);
-  }
-  else {
+  } else {
     file.link(mycomm);
   }
-  if(append_file) { file.enforceRestart(); }
+  if(append_file) {
+    file.enforceRestart();
+  }
   file.open(filepath);
   writeToFile(file,print_coeffs_descriptions);
   file.close();
@@ -721,11 +720,12 @@ void CoeffsVector::writeToFile(const std::string& filepath, const std::vector<Co
   OFile file;
   if(action_pntr!=NULL) {
     file.link(*action_pntr);
-  }
-  else {
+  } else {
     file.link(coeffsvecSet[0]->getCommunicator());
   }
-  if(append_file) { file.enforceRestart(); }
+  if(append_file) {
+    file.enforceRestart();
+  }
   file.open(filepath);
   writeToFile(file,coeffsvecSet,print_coeffs_descriptions);
   file.close();
@@ -785,8 +785,11 @@ void CoeffsVector::writeDataToFile(OFile& ofile, const std::vector<CoeffsVector*
     for(unsigned int l=0; l<numvec; l++) {
       ofile.fmtField(" "+output_fmt).printField(coeffs_datalabels[l],coeffsvecSet[l]->getValue(i));
     }
-    std::snprintf(s1.data(),s1.size(),int_fmt.c_str(),i); ofile.printField(field_index,s1.data());
-    if(print_coeffs_descriptions) { ofile.printField(field_description,"  "+coeffs_descriptions[i]);}
+    std::snprintf(s1.data(),s1.size(),int_fmt.c_str(),i);
+    ofile.printField(field_index,s1.data());
+    if(print_coeffs_descriptions) {
+      ofile.printField(field_description,"  "+coeffs_descriptions[i]);
+    }
     ofile.printField();
   }
   ofile.fmtField();
@@ -801,7 +804,9 @@ size_t CoeffsVector::readFromFile(IFile& ifile, const bool ignore_missing_coeffs
   ifile.allowIgnoredFields();
   size_t ncoeffs_read=0;
   while(ifile) {
-    if(!ignore_header) {readHeaderFromFile(ifile);}
+    if(!ignore_header) {
+      readHeaderFromFile(ifile);
+    }
     if(ifile) {
       ncoeffs_read=readDataFromFile(ifile,ignore_missing_coeffs);
     }
@@ -814,8 +819,12 @@ size_t CoeffsVector::readOneSetFromFile(IFile& ifile, const bool ignore_header)
   ifile.allowIgnoredFields();
   size_t ncoeffs_read=0;
   if(ifile) {
-    if(!ignore_header) {readHeaderFromFile(ifile);}
-    if(ifile) {ncoeffs_read=readDataFromFile(ifile,false);}
+    if(!ignore_header) {
+      readHeaderFromFile(ifile);
+    }
+    if(ifile) {
+      ncoeffs_read=readDataFromFile(ifile,false);
+    }
   }
   return ncoeffs_read;
 }
@@ -867,11 +876,14 @@ size_t CoeffsVector::readDataFromFile(IFile& ifile, const bool ignore_missing_co
     data[getIndex(indices)] = coeff_tmp;
     ifile.scanField(field_index,idx_tmp);
     if(getIndex(indices)!=static_cast<unsigned int>(idx_tmp)) {
-      std::string is1; Tools::convert(idx_tmp,is1);
+      std::string is1;
+      Tools::convert(idx_tmp,is1);
       std::string msg="ERROR: problem with indices at index " + is1 + " when reading coefficients from file";
       plumed_merror(msg);
     }
-    if(ifile.FieldExist(field_description)) { ifile.scanField(field_description,str_tmp); }
+    if(ifile.FieldExist(field_description)) {
+      ifile.scanField(field_description,str_tmp);
+    }
     //
     ifile.scanField();
     ncoeffs_read++;
diff --git a/src/ves/CoeffsVector.h b/src/ves/CoeffsVector.h
index af77ad9816..0462b80973 100644
--- a/src/ves/CoeffsVector.h
+++ b/src/ves/CoeffsVector.h
@@ -45,8 +45,7 @@ class CoeffsMatrix;
 
 
 class CoeffsVector:
-  public CoeffsBase
-{
+  public CoeffsBase {
 public:
 private:
   std::vector<double> data;
@@ -87,12 +86,16 @@ class CoeffsVector:
   //
   ~CoeffsVector();
   //
-  size_t getSize() const {return numberOfCoeffs();}
+  size_t getSize() const {
+    return numberOfCoeffs();
+  }
   // clear coeffs
   void clear();
   void setAllValuesToZero();
   //
-  std::vector<double> getDataAsVector() const {return data;}
+  std::vector<double> getDataAsVector() const {
+    return data;
+  }
   //
   bool sameShape(CoeffsVector&) const;
   bool sameShape(CoeffsMatrix&) const;
@@ -191,9 +194,15 @@ class CoeffsVector:
   // Random values
   void randomizeValuesGaussian(int);
   //
-  void resetAveragingCounter() {averaging_counter=0;}
-  void setupExponentiallyDecayingAveraging(const unsigned int averaging_exp_decay_in) {averaging_exp_decay_=averaging_exp_decay_in;}
-  void turnOffExponentiallyDecayingAveraging() {averaging_exp_decay_=0;}
+  void resetAveragingCounter() {
+    averaging_counter=0;
+  }
+  void setupExponentiallyDecayingAveraging(const unsigned int averaging_exp_decay_in) {
+    averaging_exp_decay_=averaging_exp_decay_in;
+  }
+  void turnOffExponentiallyDecayingAveraging() {
+    averaging_exp_decay_=0;
+  }
   void resetAveraging();
   void addToAverage(const CoeffsVector&);
   //
@@ -216,7 +225,9 @@ class CoeffsVector:
   void readHeaderFromFile(IFile&, const bool ignore_coeffs_info=false);
   size_t readDataFromFile(IFile&, const bool ignore_missing_coeffs=false);
 public:
-  Communicator& getCommunicator() const {return mycomm;}
+  Communicator& getCommunicator() const {
+    return mycomm;
+  }
 };
 
 
diff --git a/src/ves/FermiSwitchingFunction.cpp b/src/ves/FermiSwitchingFunction.cpp
index 3e0f83061f..7c6d3a50e6 100644
--- a/src/ves/FermiSwitchingFunction.cpp
+++ b/src/ves/FermiSwitchingFunction.cpp
@@ -47,24 +47,34 @@ void FermiSwitchingFunction::set(const std::string& definition,std::string& erro
   }
   std::string name=data[0];
   data.erase(data.begin());
-  if(name!="FERMI") {errormsg="only FERMI is supported";}
+  if(name!="FERMI") {
+    errormsg="only FERMI is supported";
+  }
   type=fermi;
   //
   bool found_r0=Tools::parse(data,"R_0",r0_);
-  if(!found_r0) {errormsg="R_0 is required";}
+  if(!found_r0) {
+    errormsg="R_0 is required";
+  }
 
   //
   fermi_exp_max_=std::numeric_limits<double>::max();
   Tools::parse(data,"FERMI_EXP_MAX",fermi_exp_max_);
   //
   bool found_lambda=Tools::parse(data,"FERMI_LAMBDA",fermi_lambda_);
-  if(!found_lambda) {errormsg="FERMI_LAMBDA is required for FERMI";}
+  if(!found_lambda) {
+    errormsg="FERMI_LAMBDA is required for FERMI";
+  }
   if( !data.empty() ) {
     errormsg="found the following rogue keywords in switching function input : ";
-    for(unsigned i=0; i<data.size(); ++i) errormsg = errormsg + data[i] + " ";
+    for(unsigned i=0; i<data.size(); ++i) {
+      errormsg = errormsg + data[i] + " ";
+    }
   }
   init=true;
-  if(errormsg.size()>0) {init=false;}
+  if(errormsg.size()>0) {
+    init=false;
+  }
 }
 
 std::string FermiSwitchingFunction::description() const {
@@ -73,8 +83,7 @@ std::string FermiSwitchingFunction::description() const {
   if(type==fermi) {
     ostr<< "fermi switching function with parameter";
     ostr<< " lambda="<<fermi_lambda_;
-  }
-  else {
+  } else {
     plumed_merror("Unknown switching function type");
   }
   return ostr.str();
@@ -84,7 +93,9 @@ std::string FermiSwitchingFunction::description() const {
 double FermiSwitchingFunction::calculate(double distance, double& dfunc) const {
   plumed_massert(init,"you are trying to use an unset FermiSwitchingFunction");
   double rdist=fermi_lambda_*(distance-r0_);
-  if(rdist >= fermi_exp_max_) {rdist = fermi_exp_max_;}
+  if(rdist >= fermi_exp_max_) {
+    rdist = fermi_exp_max_;
+  }
   double result = 1.0/(1.0+exp(rdist));
   dfunc=-fermi_lambda_*exp(rdist)*result*result;
   // this is because calculate() sets dfunc to the derivative divided times the distance.
@@ -101,8 +112,7 @@ FermiSwitchingFunction::FermiSwitchingFunction():
   r0_(0.0),
   invr0_(0.0),
   fermi_lambda_(1.0),
-  fermi_exp_max_(100.0)
-{
+  fermi_exp_max_(100.0) {
 }
 
 FermiSwitchingFunction::FermiSwitchingFunction(const FermiSwitchingFunction&sf):
@@ -111,8 +121,7 @@ FermiSwitchingFunction::FermiSwitchingFunction(const FermiSwitchingFunction&sf):
   r0_(sf.r0_),
   invr0_(sf.invr0_),
   fermi_lambda_(sf.fermi_lambda_),
-  fermi_exp_max_(sf.fermi_exp_max_)
-{
+  fermi_exp_max_(sf.fermi_exp_max_) {
 }
 
 void FermiSwitchingFunction::set(const double r0, const double fermi_lambda, const double fermi_exp_max) {
@@ -122,8 +131,7 @@ void FermiSwitchingFunction::set(const double r0, const double fermi_lambda, con
   fermi_lambda_=fermi_lambda;
   if(fermi_exp_max>0.0) {
     fermi_exp_max_=fermi_exp_max;
-  }
-  else {
+  } else {
     fermi_exp_max_=100.0;
   }
 
diff --git a/src/ves/GridIntegrationWeights.cpp b/src/ves/GridIntegrationWeights.cpp
index dc2a832a3b..21176de20d 100644
--- a/src/ves/GridIntegrationWeights.cpp
+++ b/src/ves/GridIntegrationWeights.cpp
@@ -39,8 +39,7 @@ std::vector<double> GridIntegrationWeights::getIntegrationWeights(const Grid* gr
     std::vector<double> weights_tmp;
     if(weights_type=="trapezoidal") {
       weights_tmp = getOneDimensionalTrapezoidalWeights(nbins[k],dx[k],isPeriodic[k]);
-    }
-    else {
+    } else {
       plumed_merror("getIntegrationWeights: unknown weight type, the available type is trapezoidal");
     }
     weights_perdim.push_back(weights_tmp);
@@ -75,11 +74,12 @@ std::vector<double> GridIntegrationWeights::getIntegrationWeights(const Grid* gr
 void GridIntegrationWeights::getOneDimensionalIntegrationPointsAndWeights(std::vector<double>& points, std::vector<double>& weights, const unsigned int nbins, const double min, const double max, const std::string& weights_type) {
   double dx = (max-min)/(static_cast<double>(nbins)-1.0);
   points.resize(nbins);
-  for(unsigned int i=0; i<nbins; i++) {points[i] = min + i*dx;}
+  for(unsigned int i=0; i<nbins; i++) {
+    points[i] = min + i*dx;
+  }
   if(weights_type=="trapezoidal") {
     weights = getOneDimensionalTrapezoidalWeights(nbins,dx,false);
-  }
-  else {
+  } else {
     plumed_merror("getOneDimensionalIntegrationWeights: unknown weight type, the available type is trapezoidal");
   }
 }
@@ -93,8 +93,7 @@ std::vector<double> GridIntegrationWeights::getOneDimensionalTrapezoidalWeights(
   if(!periodic) {
     weights_1d[0]= 0.5*dx;
     weights_1d[(nbins-1)]= 0.5*dx;
-  }
-  else {
+  } else {
     // as for periodic arguments the first point should be counted twice as the
     // grid doesn't include its periodic copy
     weights_1d[0]= dx;
diff --git a/src/ves/GridLinearInterpolation.cpp b/src/ves/GridLinearInterpolation.cpp
index 2054a6db8d..f56223907e 100644
--- a/src/ves/GridLinearInterpolation.cpp
+++ b/src/ves/GridLinearInterpolation.cpp
@@ -38,9 +38,12 @@ double GridLinearInterpolation::getGridValueWithLinearInterpolation_1D(GridBase*
 
   double x = arg[0];
   double grid_dx = grid_pntr->getDx()[0];
-  double grid_min; Tools::convert( grid_pntr->getMin()[0], grid_min);
-  std::vector<unsigned int> i0(1); i0[0] = unsigned( std::floor( (x-grid_min)/grid_dx ) );
-  std::vector<unsigned int> i1(1); i1[0] = unsigned( std::ceil(  (x-grid_min)/grid_dx ) );
+  double grid_min;
+  Tools::convert( grid_pntr->getMin()[0], grid_min);
+  std::vector<unsigned int> i0(1);
+  i0[0] = unsigned( std::floor( (x-grid_min)/grid_dx ) );
+  std::vector<unsigned int> i1(1);
+  i1[0] = unsigned( std::ceil(  (x-grid_min)/grid_dx ) );
   //
   double x0 = grid_pntr->getPoint(i0)[0];
   double x1 = grid_pntr->getPoint(i1)[0];
@@ -122,11 +125,14 @@ double GridLinearInterpolation::getGridValueAndDerivativesWithLinearInterpolatio
 
   double x = arg[0];
   double grid_dx = grid_pntr->getDx()[0];
-  double grid_min; Tools::convert( grid_pntr->getMin()[0], grid_min);
+  double grid_min;
+  Tools::convert( grid_pntr->getMin()[0], grid_min);
 
   double xtoindex = (x-grid_min)/grid_dx;
-  std::vector<unsigned int> i0(1); i0[0] = unsigned(std::floor(xtoindex));
-  std::vector<unsigned int> i1(1); i1[0] = unsigned(std::ceil(xtoindex));
+  std::vector<unsigned int> i0(1);
+  i0[0] = unsigned(std::floor(xtoindex));
+  std::vector<unsigned int> i1(1);
+  i1[0] = unsigned(std::ceil(xtoindex));
   //
   std::vector<double> d0 (1), d1 (1);
   double x0 = grid_pntr->getPoint(i0)[0];
@@ -169,11 +175,9 @@ double GridLinearInterpolation::getGridValueWithLinearInterpolation(GridBase* gr
   unsigned int dim = grid_pntr->getDimension();
   if(dim==1) {
     return getGridValueWithLinearInterpolation_1D(grid_pntr,arg);
-  }
-  else if(dim==2) {
+  } else if(dim==2) {
     return getGridValueWithLinearInterpolation_2D(grid_pntr,arg);
-  }
-  else {
+  } else {
     return getGridValueWithLinearInterpolation_ND(grid_pntr,arg);
   }
 }
@@ -197,7 +201,8 @@ std::vector<std::vector<unsigned>> GridLinearInterpolation::getAdjacentIndices(G
     std::vector<unsigned> temp_indices(2);
     //
     double grid_dx = grid_pntr->getDx()[i];
-    double grid_min; Tools::convert( grid_pntr->getMin()[i], grid_min);
+    double grid_min;
+    Tools::convert( grid_pntr->getMin()[i], grid_min);
     double xtoindex = (arg[i]-grid_min)/grid_dx;
     temp_indices[0] = static_cast<unsigned>(std::floor(xtoindex));
     temp_indices[1] = static_cast<unsigned>(std::ceil(xtoindex));
diff --git a/src/ves/GridLinearInterpolation.h b/src/ves/GridLinearInterpolation.h
index 0b85ef7f10..e6e0f2bcf3 100644
--- a/src/ves/GridLinearInterpolation.h
+++ b/src/ves/GridLinearInterpolation.h
@@ -55,8 +55,7 @@ double GridLinearInterpolation::linearInterpolation(const double x, const double
   // https://en.wikipedia.org/wiki/Linear_interpolation
   if(x1!=x0) {
     return y0 + (x-x0) * ((y1-y0)/(x1-x0));
-  }
-  else {
+  } else {
     return y0;
   }
 }
diff --git a/src/ves/GridProjWeights.h b/src/ves/GridProjWeights.h
index be9679ce64..a1ffbbd4f1 100644
--- a/src/ves/GridProjWeights.h
+++ b/src/ves/GridProjWeights.h
@@ -32,16 +32,27 @@ namespace ves {
 class MarginalWeight:public WeightBase {
 public:
   explicit MarginalWeight() {}
-  double projectInnerLoop(double &input, double &v) {return  input+v;}
-  double projectOuterLoop(double &v) {return v;}
+  double projectInnerLoop(double &input, double &v) {
+    return  input+v;
+  }
+  double projectOuterLoop(double &v) {
+    return v;
+  }
 };
 
 class FesWeight:public WeightBase {
 public:
   double beta,invbeta;
-  explicit FesWeight(double v) {beta=v; invbeta=1./beta;}
-  double projectInnerLoop(double &input, double &v) {return  input+exp(-beta*v);}
-  double projectOuterLoop(double &v) {return -invbeta*std::log(v);}
+  explicit FesWeight(double v) {
+    beta=v;
+    invbeta=1./beta;
+  }
+  double projectInnerLoop(double &input, double &v) {
+    return  input+exp(-beta*v);
+  }
+  double projectOuterLoop(double &v) {
+    return -invbeta*std::log(v);
+  }
 };
 
 }
diff --git a/src/ves/LinearBasisSetExpansion.cpp b/src/ves/LinearBasisSetExpansion.cpp
index 5a1446dd6e..d0f5e5fceb 100644
--- a/src/ves/LinearBasisSetExpansion.cpp
+++ b/src/ves/LinearBasisSetExpansion.cpp
@@ -73,10 +73,11 @@ LinearBasisSetExpansion::LinearBasisSetExpansion(
   step_of_last_fesgrid_update(-1000),
   log_targetdist_grid_pntr_(NULL),
   targetdist_grid_pntr_(NULL),
-  targetdist_pntr_(NULL)
-{
+  targetdist_pntr_(NULL) {
   plumed_massert(args_pntrs_.size()==basisf_pntrs_.size(),"number of arguments and basis functions do not match");
-  for(unsigned int k=0; k<nargs_; k++) {nbasisf_[k]=basisf_pntrs_[k]->getNumberOfBasisFunctions();}
+  for(unsigned int k=0; k<nargs_; k++) {
+    nbasisf_[k]=basisf_pntrs_[k]->getNumberOfBasisFunctions();
+  }
   //
   if(bias_coeffs_pntr_==NULL) {
     bias_coeffs_pntr_ = new CoeffsVector(label_+".coeffs",args_pntrs_,basisf_pntrs_,mycomm_,true);
@@ -89,8 +90,7 @@ LinearBasisSetExpansion::LinearBasisSetExpansion(
   std::string targetdist_averages_label = bias_coeffs_pntr_->getLabel();
   if(targetdist_averages_label.find("coeffs")!=std::string::npos) {
     targetdist_averages_label.replace(targetdist_averages_label.find("coeffs"), std::string("coeffs").length(), "targetdist_averages");
-  }
-  else {
+  } else {
     targetdist_averages_label += "_targetdist_averages";
   }
   targetdist_averages_pntr_->setLabels(targetdist_averages_label);
@@ -148,7 +148,9 @@ std::unique_ptr<Grid> LinearBasisSetExpansion::setupGeneralGrid(const std::strin
 
 
 void LinearBasisSetExpansion::setupBiasGrid(const bool usederiv) {
-  if(bias_grid_pntr_) {return;}
+  if(bias_grid_pntr_) {
+    return;
+  }
   bias_grid_pntr_ = setupGeneralGrid("bias",usederiv);
   if(biasCutoffActive()) {
     bias_withoutcutoff_grid_pntr_ = setupGeneralGrid("bias_withoutcutoff",usederiv);
@@ -157,7 +159,9 @@ void LinearBasisSetExpansion::setupBiasGrid(const bool usederiv) {
 
 
 void LinearBasisSetExpansion::setupFesGrid() {
-  if(fes_grid_pntr_) {return;}
+  if(fes_grid_pntr_) {
+    return;
+  }
   if(!bias_grid_pntr_) {
     setupBiasGrid(true);
   }
@@ -189,8 +193,7 @@ void LinearBasisSetExpansion::updateBiasGrid() {
     //
     if(bias_grid_pntr_->hasDerivatives()) {
       bias_grid_pntr_->setValueAndDerivatives(l,bias,forces);
-    }
-    else {
+    } else {
       bias_grid_pntr_->setValue(l,bias);
     }
     //
@@ -219,8 +222,7 @@ void LinearBasisSetExpansion::updateBiasWithoutCutoffGrid() {
     double bias=getBiasAndForces(args,all_inside,forces);
     if(bias_withoutcutoff_grid_pntr_->hasDerivatives()) {
       bias_withoutcutoff_grid_pntr_->setValueAndDerivatives(l,bias,forces);
-    }
-    else {
+    } else {
       bias_withoutcutoff_grid_pntr_->setValue(l,bias);
     }
   }
@@ -248,8 +250,7 @@ void LinearBasisSetExpansion::updateBiasWithoutCutoffGrid() {
       if(bias_withoutcutoff_grid_pntr_->hasDerivatives()) {
         std::vector<double> zeros(nargs_,0.0);
         bias_withoutcutoff_grid_pntr_->addValueAndDerivatives(l,shift,zeros);
-      }
-      else {
+      } else {
         bias_withoutcutoff_grid_pntr_->addValue(l,shift);
       }
     }
@@ -287,21 +288,27 @@ void LinearBasisSetExpansion::updateFesGrid() {
 
 void LinearBasisSetExpansion::writeBiasGridToFile(OFile& ofile, const bool append_file) const {
   plumed_massert(bias_grid_pntr_,"the bias grid is not defined");
-  if(append_file) {ofile.enforceRestart();}
+  if(append_file) {
+    ofile.enforceRestart();
+  }
   bias_grid_pntr_->writeToFile(ofile);
 }
 
 
 void LinearBasisSetExpansion::writeBiasWithoutCutoffGridToFile(OFile& ofile, const bool append_file) const {
   plumed_massert(bias_withoutcutoff_grid_pntr_,"the bias without cutoff grid is not defined");
-  if(append_file) {ofile.enforceRestart();}
+  if(append_file) {
+    ofile.enforceRestart();
+  }
   bias_withoutcutoff_grid_pntr_->writeToFile(ofile);
 }
 
 
 void LinearBasisSetExpansion::writeFesGridToFile(OFile& ofile, const bool append_file) const {
   plumed_massert(fes_grid_pntr_!=NULL,"the FES grid is not defined");
-  if(append_file) {ofile.enforceRestart();}
+  if(append_file) {
+    ofile.enforceRestart();
+  }
   fes_grid_pntr_->writeToFile(ofile);
 }
 
@@ -311,44 +318,62 @@ void LinearBasisSetExpansion::writeFesProjGridToFile(const std::vector<std::stri
   auto Fw = Tools::make_unique<FesWeight>(beta_);
   Grid proj_grid = fes_grid_pntr_->project(proj_arg,Fw.get());
   proj_grid.setMinToZero();
-  if(append_file) {ofile.enforceRestart();}
+  if(append_file) {
+    ofile.enforceRestart();
+  }
   proj_grid.writeToFile(ofile);
 }
 
 
 void LinearBasisSetExpansion::writeTargetDistGridToFile(OFile& ofile, const bool append_file) const {
-  if(targetdist_grid_pntr_==NULL) {return;}
-  if(append_file) {ofile.enforceRestart();}
+  if(targetdist_grid_pntr_==NULL) {
+    return;
+  }
+  if(append_file) {
+    ofile.enforceRestart();
+  }
   targetdist_grid_pntr_->writeToFile(ofile);
 }
 
 
 void LinearBasisSetExpansion::writeLogTargetDistGridToFile(OFile& ofile, const bool append_file) const {
-  if(log_targetdist_grid_pntr_==NULL) {return;}
-  if(append_file) {ofile.enforceRestart();}
+  if(log_targetdist_grid_pntr_==NULL) {
+    return;
+  }
+  if(append_file) {
+    ofile.enforceRestart();
+  }
   log_targetdist_grid_pntr_->writeToFile(ofile);
 }
 
 
 void LinearBasisSetExpansion::writeTargetDistProjGridToFile(const std::vector<std::string>& proj_arg, OFile& ofile, const bool append_file) const {
-  if(targetdist_grid_pntr_==NULL) {return;}
-  if(append_file) {ofile.enforceRestart();}
+  if(targetdist_grid_pntr_==NULL) {
+    return;
+  }
+  if(append_file) {
+    ofile.enforceRestart();
+  }
   Grid proj_grid = TargetDistribution::getMarginalDistributionGrid(targetdist_grid_pntr_,proj_arg);
   proj_grid.writeToFile(ofile);
 }
 
 
 void LinearBasisSetExpansion::writeTargetDistributionToFile(const std::string& filename) const {
-  OFile of1; OFile of2;
+  OFile of1;
+  OFile of2;
   if(action_pntr_!=NULL) {
-    of1.link(*action_pntr_); of2.link(*action_pntr_);
+    of1.link(*action_pntr_);
+    of2.link(*action_pntr_);
   }
-  of1.enforceBackup(); of2.enforceBackup();
+  of1.enforceBackup();
+  of2.enforceBackup();
   of1.open(filename);
   of2.open(FileBase::appendSuffix(filename,".log"));
   writeTargetDistGridToFile(of1);
   writeLogTargetDistGridToFile(of2);
-  of1.close(); of2.close();
+  of1.close();
+  of2.close();
 }
 
 
@@ -372,14 +397,15 @@ double LinearBasisSetExpansion::getBiasAndForces(const std::vector<double>& args
     bool curr_inside=true;
     basisf_pntrs_in[k]->getAllValues(args_values[k],args_values_trsfrm[k],curr_inside,bf_values[k],bf_derivs[k]);
     // inside_interval[k]=curr_inside;
-    if(!curr_inside) {all_inside=false;}
+    if(!curr_inside) {
+      all_inside=false;
+    }
     forces[k]=0.0;
   }
   //
   size_t stride=1;
   size_t rank=0;
-  if(comm_in!=NULL)
-  {
+  if(comm_in!=NULL) {
     stride=comm_in->Get_size();
     rank=comm_in->Get_rank();
   }
@@ -397,8 +423,11 @@ double LinearBasisSetExpansion::getBiasAndForces(const std::vector<double>& args
     for(unsigned int k=0; k<nargs; k++) {
       double der = 1.0;
       for(unsigned int l=0; l<nargs; l++) {
-        if(l!=k) {der*=bf_values[l][indices[l]];}
-        else {der*=bf_derivs[l][indices[l]];}
+        if(l!=k) {
+          der*=bf_values[l][indices[l]];
+        } else {
+          der*=bf_derivs[l][indices[l]];
+        }
       }
       forces[k]-=coeff*der;
       // maybe faster but dangerous
@@ -433,8 +462,7 @@ void LinearBasisSetExpansion::getBasisSetValues(const std::vector<double>& args_
   //
   size_t stride=1;
   size_t rank=0;
-  if(comm_in!=NULL)
-  {
+  if(comm_in!=NULL) {
     stride=comm_in->Get_size();
     rank=comm_in->Get_rank();
   }
@@ -531,9 +559,15 @@ void LinearBasisSetExpansion::setupTargetDistribution(TargetDistribution* target
 void LinearBasisSetExpansion::updateTargetDistribution() {
   plumed_massert(targetdist_pntr_!=NULL,"the target distribution hasn't been setup!");
   plumed_massert(targetdist_pntr_->isDynamic(),"this should only be used for dynamically updated target distributions!");
-  if(targetdist_pntr_->biasGridNeeded()) {updateBiasGrid();}
-  if(biasCutoffActive()) {updateBiasWithoutCutoffGrid();}
-  if(targetdist_pntr_->fesGridNeeded()) {updateFesGrid();}
+  if(targetdist_pntr_->biasGridNeeded()) {
+    updateBiasGrid();
+  }
+  if(biasCutoffActive()) {
+    updateBiasWithoutCutoffGrid();
+  }
+  if(targetdist_pntr_->fesGridNeeded()) {
+    updateFesGrid();
+  }
   targetdist_pntr_->updateTargetDist();
   calculateTargetDistAveragesFromGrid(targetdist_grid_pntr_);
 }
@@ -541,14 +575,18 @@ void LinearBasisSetExpansion::updateTargetDistribution() {
 
 void LinearBasisSetExpansion::readInRestartTargetDistribution(const std::string& grid_fname) {
   targetdist_pntr_->readInRestartTargetDistGrid(grid_fname);
-  if(biasCutoffActive()) {targetdist_pntr_->clearLogTargetDistGrid();}
+  if(biasCutoffActive()) {
+    targetdist_pntr_->clearLogTargetDistGrid();
+  }
 }
 
 
 void LinearBasisSetExpansion::restartTargetDistribution() {
   plumed_massert(targetdist_pntr_!=NULL,"the target distribution hasn't been setup!");
   plumed_massert(targetdist_pntr_->isDynamic(),"this should only be used for dynamically updated target distributions!");
-  if(biasCutoffActive()) {updateBiasWithoutCutoffGrid();}
+  if(biasCutoffActive()) {
+    updateBiasWithoutCutoffGrid();
+  }
   calculateTargetDistAveragesFromGrid(targetdist_grid_pntr_);
 }
 
@@ -591,8 +629,11 @@ void LinearBasisSetExpansion::setBiasMaximumToZero() {
 
 
 bool LinearBasisSetExpansion::biasCutoffActive() const {
-  if(vesbias_pntr_!=NULL) {return vesbias_pntr_->biasCutoffActive();}
-  else {return false;}
+  if(vesbias_pntr_!=NULL) {
+    return vesbias_pntr_->biasCutoffActive();
+  } else {
+    return false;
+  }
 }
 
 
@@ -605,7 +646,9 @@ double LinearBasisSetExpansion::calculateReweightFactor() const {
   for(Grid::index_t l=0; l<targetdist_grid_pntr_->getSize(); l++) {
     sum += integration_weights[l] * targetdist_grid_pntr_->getValue(l) * exp(+beta_*bias_grid_pntr_->getValue(l));
   }
-  if(sum==0.0) sum=std::numeric_limits<double>::min();
+  if(sum==0.0) {
+    sum=std::numeric_limits<double>::min();
+  }
   return (1.0/beta_)*std::log(sum);
 }
 
diff --git a/src/ves/LinearBasisSetExpansion.h b/src/ves/LinearBasisSetExpansion.h
index d57fbae044..ad8fc74e7b 100644
--- a/src/ves/LinearBasisSetExpansion.h
+++ b/src/ves/LinearBasisSetExpansion.h
@@ -102,20 +102,42 @@ class LinearBasisSetExpansion {
 public:
   ~LinearBasisSetExpansion();
   //
-  std::vector<Value*> getPntrsToArguments() const {return args_pntrs_;}
-  std::vector<BasisFunctions*> getPntrsToBasisFunctions() const {return basisf_pntrs_;}
-  CoeffsVector* getPntrToBiasCoeffs() const {return bias_coeffs_pntr_;}
-  Grid* getPntrToBiasGrid() const {return bias_grid_pntr_.get();};
-  //
-  unsigned int getNumberOfArguments() const {return nargs_;};
-  std::vector<unsigned int> getNumberOfBasisFunctions() const {return nbasisf_;};
-  size_t getNumberOfCoeffs() const {return ncoeffs_;};
-  //
-  CoeffsVector& BiasCoeffs() const {return *bias_coeffs_pntr_;};
-  CoeffsVector& TargetDistAverages() const {return *targetdist_averages_pntr_;};
-  //
-  void setSerial() {serial_=true;}
-  void setParallel() {serial_=false;}
+  std::vector<Value*> getPntrsToArguments() const {
+    return args_pntrs_;
+  }
+  std::vector<BasisFunctions*> getPntrsToBasisFunctions() const {
+    return basisf_pntrs_;
+  }
+  CoeffsVector* getPntrToBiasCoeffs() const {
+    return bias_coeffs_pntr_;
+  }
+  Grid* getPntrToBiasGrid() const {
+    return bias_grid_pntr_.get();
+  };
+  //
+  unsigned int getNumberOfArguments() const {
+    return nargs_;
+  };
+  std::vector<unsigned int> getNumberOfBasisFunctions() const {
+    return nbasisf_;
+  };
+  size_t getNumberOfCoeffs() const {
+    return ncoeffs_;
+  };
+  //
+  CoeffsVector& BiasCoeffs() const {
+    return *bias_coeffs_pntr_;
+  };
+  CoeffsVector& TargetDistAverages() const {
+    return *targetdist_averages_pntr_;
+  };
+  //
+  void setSerial() {
+    serial_=true;
+  }
+  void setParallel() {
+    serial_=false;
+  }
   //
   void linkVesBias(VesBias*);
   void linkAction(Action*);
@@ -134,15 +156,27 @@ class LinearBasisSetExpansion {
   // Bias grid and output stuff
   void setupBiasGrid(const bool usederiv=false);
   void updateBiasGrid();
-  void resetStepOfLastBiasGridUpdate() {step_of_last_biasgrid_update = -1000;}
-  void setStepOfLastBiasGridUpdate(long long int step) {step_of_last_biasgrid_update = step;}
-  long long int getStepOfLastBiasGridUpdate() const {return step_of_last_biasgrid_update;}
+  void resetStepOfLastBiasGridUpdate() {
+    step_of_last_biasgrid_update = -1000;
+  }
+  void setStepOfLastBiasGridUpdate(long long int step) {
+    step_of_last_biasgrid_update = step;
+  }
+  long long int getStepOfLastBiasGridUpdate() const {
+    return step_of_last_biasgrid_update;
+  }
   void writeBiasGridToFile(OFile&, const bool append=false) const;
   //
   void updateBiasWithoutCutoffGrid();
-  void resetStepOfLastBiasWithoutCutoffGridUpdate() {step_of_last_biaswithoutcutoffgrid_update = -1000;}
-  void setStepOfLastBiasWithoutCutoffGridUpdate(long long int step) {step_of_last_biaswithoutcutoffgrid_update = step;}
-  long long int getStepOfLastBiasWithoutCutoffGridUpdate() const {return step_of_last_biaswithoutcutoffgrid_update;}
+  void resetStepOfLastBiasWithoutCutoffGridUpdate() {
+    step_of_last_biaswithoutcutoffgrid_update = -1000;
+  }
+  void setStepOfLastBiasWithoutCutoffGridUpdate(long long int step) {
+    step_of_last_biaswithoutcutoffgrid_update = step;
+  }
+  long long int getStepOfLastBiasWithoutCutoffGridUpdate() const {
+    return step_of_last_biaswithoutcutoffgrid_update;
+  }
   void writeBiasWithoutCutoffGridToFile(OFile&, const bool append=false) const;
   //
   void setBiasMinimumToZero();
@@ -150,9 +184,15 @@ class LinearBasisSetExpansion {
   //
   void setupFesGrid();
   void updateFesGrid();
-  void resetStepOfLastFesGridUpdate() {step_of_last_fesgrid_update = -1000;}
-  void setStepOfLastFesGridUpdate(long long int step) {step_of_last_fesgrid_update = step;}
-  long long int getStepOfLastFesGridUpdate() const {return step_of_last_fesgrid_update;}
+  void resetStepOfLastFesGridUpdate() {
+    step_of_last_fesgrid_update = -1000;
+  }
+  void setStepOfLastFesGridUpdate(long long int step) {
+    step_of_last_fesgrid_update = step;
+  }
+  long long int getStepOfLastFesGridUpdate() const {
+    return step_of_last_fesgrid_update;
+  }
   void writeFesGridToFile(OFile&, const bool append=false) const;
   //
   void setupFesProjGrid();
@@ -163,14 +203,24 @@ class LinearBasisSetExpansion {
   void writeTargetDistProjGridToFile(const std::vector<std::string>&, OFile&, const bool append=false) const;
   void writeTargetDistributionToFile(const std::string&) const;
   //
-  std::vector<unsigned int> getGridBins() const {return grid_bins_;}
+  std::vector<unsigned int> getGridBins() const {
+    return grid_bins_;
+  }
   void setGridBins(const std::vector<unsigned int>&);
   void setGridBins(const unsigned int);
   //
-  double getBeta() const {return beta_;}
-  double getKbT() const {return kbt_;}
-  double beta() const {return beta_;}
-  double kBT() const {return kbt_;}
+  double getBeta() const {
+    return beta_;
+  }
+  double getKbT() const {
+    return kbt_;
+  }
+  double beta() const {
+    return beta_;
+  }
+  double kBT() const {
+    return kbt_;
+  }
   //
   void setupUniformTargetDistribution();
   void setupTargetDistribution(TargetDistribution*);
@@ -212,8 +262,7 @@ double LinearBasisSetExpansion::getBias(const std::vector<double>& args_values,
   std::vector<double> coeffsderivs_values_dummy(ncoeffs_);
   if(parallel) {
     return getBiasAndForces(args_values,all_inside,forces_dummy,coeffsderivs_values_dummy,basisf_pntrs_, bias_coeffs_pntr_, &mycomm_);
-  }
-  else {
+  } else {
     return getBiasAndForces(args_values,all_inside,forces_dummy,coeffsderivs_values_dummy,basisf_pntrs_, bias_coeffs_pntr_, NULL);
   }
 }
@@ -223,8 +272,7 @@ inline
 void LinearBasisSetExpansion::getBasisSetValues(const std::vector<double>& args_values, std::vector<double>& basisset_values, const bool parallel) {
   if(parallel) {
     getBasisSetValues(args_values,basisset_values,basisf_pntrs_, bias_coeffs_pntr_, &mycomm_);
-  }
-  else {
+  } else {
     getBasisSetValues(args_values,basisset_values,basisf_pntrs_, bias_coeffs_pntr_, NULL);
   }
 }
diff --git a/src/ves/MD_LinearExpansionPES.cpp b/src/ves/MD_LinearExpansionPES.cpp
index 8d2c60b244..f3c3535236 100644
--- a/src/ves/MD_LinearExpansionPES.cpp
+++ b/src/ves/MD_LinearExpansionPES.cpp
@@ -134,7 +134,9 @@ PRINT ARG=p.x,p.y,ene FILE=colvar.data FMT=%8.4f
 
 class MD_LinearExpansionPES : public PLMD::CLTool {
 public:
-  std::string description() const override {return "MD of a one particle on a linear expansion PES";}
+  std::string description() const override {
+    return "MD of a one particle on a linear expansion PES";
+  }
   static void registerKeywords( Keywords& keys );
   explicit MD_LinearExpansionPES( const CLToolOptions& co );
   int main( FILE* in, FILE* out, PLMD::Communicator& pc) override;
@@ -177,8 +179,7 @@ void MD_LinearExpansionPES::registerKeywords( Keywords& keys ) {
 MD_LinearExpansionPES::MD_LinearExpansionPES( const CLToolOptions& co ):
   CLTool(co),
   dim(0),
-  dim_string_prefix("dim")
-{
+  dim_string_prefix("dim") {
   inputdata=ifile; //commandline;
 }
 
@@ -244,11 +245,9 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
   parseVector("temperature",temps_vec);
   if(temps_vec.size()==1) {
     temp = temps_vec[0];
-  }
-  else if(replicas > 1 && temps_vec.size()==replicas) {
+  } else if(replicas > 1 && temps_vec.size()==replicas) {
     temp = temps_vec[inter.Get_rank()];
-  }
-  else {
+  } else {
     error("problem with temperature keyword, you need to give either one value or a value for each replica.");
   }
   //
@@ -257,11 +256,9 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
   parseVector("friction",frictions_vec);
   if(frictions_vec.size()==1) {
     friction = frictions_vec[0];
-  }
-  else if(frictions_vec.size()==replicas) {
+  } else if(frictions_vec.size()==replicas) {
     friction = frictions_vec[inter.Get_rank()];
-  }
-  else {
+  } else {
     error("problem with friction keyword, you need to give either one value or a value for each replica.");
   }
   //
@@ -269,19 +266,24 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
   std::vector<int> seeds_vec(0);
   parseVector("random_seed",seeds_vec);
   for(unsigned int i=0; i<seeds_vec.size(); i++) {
-    if(seeds_vec[i]>0) {seeds_vec[i] = -seeds_vec[i];}
+    if(seeds_vec[i]>0) {
+      seeds_vec[i] = -seeds_vec[i];
+    }
   }
   if(replicas==1) {
-    if(seeds_vec.size()>1) {error("problem with random_seed keyword, for a single replica you should only give one value");}
+    if(seeds_vec.size()>1) {
+      error("problem with random_seed keyword, for a single replica you should only give one value");
+    }
     seed = seeds_vec[0];
-  }
-  else {
+  } else {
     if(seeds_vec.size()!=1 && seeds_vec.size()!=replicas) {
       error("problem with random_seed keyword, for multiple replicas you should give either one value or a separate value for each replica");
     }
     if(seeds_vec.size()==1) {
       seeds_vec.resize(replicas);
-      for(unsigned int i=1; i<seeds_vec.size(); i++) {seeds_vec[i] = seeds_vec[0] + i;}
+      for(unsigned int i=1; i<seeds_vec.size(); i++) {
+        seeds_vec[i] = seeds_vec[0] + i;
+      }
     }
     seed = seeds_vec[inter.Get_rank()];
   }
@@ -304,19 +306,19 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
         initPos[i][k]=initPosTmp[k];
       }
     }
-  }
-  else if(initPosTmp.size()==dim*replicas) {
+  } else if(initPosTmp.size()==dim*replicas) {
     for(unsigned int i=0; i<replicas; i++) {
       for(unsigned int k=0; k<dim; k++) {
         initPos[i][k]=initPosTmp[i*dim+k];
       }
     }
-  }
-  else {
+  } else {
     error("problem with initial_position keyword, you need to give either one value or a value for each replica.");
   }
 
-  auto deleter=[](FILE* f) { fclose(f); };
+  auto deleter=[](FILE* f) {
+    fclose(f);
+  };
   FILE* file_dummy = fopen("/dev/null","w+");
   plumed_assert(file_dummy);
   // call fclose when file_dummy_deleter goes out of scope
@@ -337,7 +339,8 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
   std::vector<double> interval_range(dim);
   for(unsigned int i=0; i<dim; i++) {
     std::string bf_keyword;
-    std::string is; Tools::convert(i+1,is);
+    std::string is;
+    Tools::convert(i+1,is);
     parse("basis_functions_"+is,bf_keyword);
     if(bf_keyword.size()==0) {
       error("basis_functions_"+is+" is needed");
@@ -377,12 +380,10 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
   bool diff_input_coeffs = false;
   if(input_coeffs_fnames.size()==1) {
     input_coeffs_fname = input_coeffs_fnames[0];
-  }
-  else if(replicas > 1 && input_coeffs_fnames.size()==replicas) {
+  } else if(replicas > 1 && input_coeffs_fnames.size()==replicas) {
     diff_input_coeffs = true;
     input_coeffs_fname = input_coeffs_fnames[inter.Get_rank()];
-  }
-  else {
+  } else {
     error("problem with coeffs_file keyword, you need to give either one value or a value for each replica.");
   }
   coeffs_pntr->readFromFile(input_coeffs_fname,true,true);
@@ -392,12 +393,10 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
     double coeffs_prefactor = 1.0;
     if(coeffs_prefactors.size()==1) {
       coeffs_prefactor = coeffs_prefactors[0];
-    }
-    else if(replicas > 1 && coeffs_prefactors.size()==replicas) {
+    } else if(replicas > 1 && coeffs_prefactors.size()==replicas) {
       diff_input_coeffs = true;
       coeffs_prefactor = coeffs_prefactors[inter.Get_rank()];
-    }
-    else {
+    } else {
       error("problem with coeffs_prefactor keyword, you need to give either one value or a value for each replica.");
     }
     coeffs_pntr->scaleAllValues(coeffs_prefactor);
@@ -425,7 +424,8 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
   ofile_potential.close();
   if(dim>1) {
     for(unsigned int i=0; i<dim; i++) {
-      std::string is; Tools::convert(i+1,is);
+      std::string is;
+      Tools::convert(i+1,is);
       std::vector<std::string> proj_arg(1);
       proj_arg[0] = dim_string_prefix+is;
       auto Fw = Tools::make_unique<FesWeight>(1/temp);
@@ -488,23 +488,33 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
     std::fprintf(out,"Number of steps                       %llu\n",nsteps);
     std::fprintf(out,"Timestep                              %f\n",tstep);
     std::fprintf(out,"Temperature                           %f",temps_vec[0]);
-    for(unsigned int i=1; i<temps_vec.size(); i++) {std::fprintf(out,",%f",temps_vec[i]);}
+    for(unsigned int i=1; i<temps_vec.size(); i++) {
+      std::fprintf(out,",%f",temps_vec[i]);
+    }
     std::fprintf(out,"\n");
     std::fprintf(out,"Friction                              %f",frictions_vec[0]);
-    for(unsigned int i=1; i<frictions_vec.size(); i++) {std::fprintf(out,",%f",frictions_vec[i]);}
+    for(unsigned int i=1; i<frictions_vec.size(); i++) {
+      std::fprintf(out,",%f",frictions_vec[i]);
+    }
     std::fprintf(out,"\n");
     std::fprintf(out,"Random seed                           %d",seeds_vec[0]);
-    for(unsigned int i=1; i<seeds_vec.size(); i++) {std::fprintf(out,",%d",seeds_vec[i]);}
+    for(unsigned int i=1; i<seeds_vec.size(); i++) {
+      std::fprintf(out,",%d",seeds_vec[i]);
+    }
     std::fprintf(out,"\n");
     std::fprintf(out,"Dimensions                            %zu\n",dim);
     for(unsigned int i=0; i<dim; i++) {
       std::fprintf(out,"Basis Function %u                      %s\n",i+1,basisf_keywords[i].c_str());
     }
     std::fprintf(out,"PLUMED input                          %s",plumed_inputfiles[0].c_str());
-    for(unsigned int i=1; i<plumed_inputfiles.size(); i++) {std::fprintf(out,",%s",plumed_inputfiles[i].c_str());}
+    for(unsigned int i=1; i<plumed_inputfiles.size(); i++) {
+      std::fprintf(out,",%s",plumed_inputfiles[i].c_str());
+    }
     std::fprintf(out,"\n");
     std::fprintf(out,"kBoltzmann taken as 1, use NATURAL_UNITS in the plumed input\n");
-    if(diff_input_coeffs) {std::fprintf(out,"using different coefficients for each replica\n");}
+    if(diff_input_coeffs) {
+      std::fprintf(out,"using different coefficients for each replica\n");
+    }
   }
 
 
@@ -527,7 +537,9 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
         error("More than 1 replica but no MPI");
       }
     } else {
-      if(Communicator::initialized()) plumed->cmd("setMPIComm",&pc.Get_comm());
+      if(Communicator::initialized()) {
+        plumed->cmd("setMPIComm",&pc.Get_comm());
+      }
     }
   }
 
@@ -561,16 +573,20 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
   // Setup random number generator
   random.setSeed(seed);
 
-  double potential, therm_eng=0; std::vector<double> masses(1,1);
+  double potential, therm_eng=0;
+  std::vector<double> masses(1,1);
   std::vector<Vector> positions(1), velocities(1), forces(1);
   for(unsigned int k=0; k<dim; k++) {
     positions[0][k] = initPos[inter.Get_rank()][k];
     if(periodic[k]) {
       positions[0][k] = positions[0][k] - floor((positions[0][k]-interval_min[k])/interval_range[k])*interval_range[k];
-    }
-    else {
-      if(positions[0][k]>interval_max[k]) {positions[0][k]=interval_max[k];}
-      if(positions[0][k]<interval_min[k]) {positions[0][k]=interval_min[k];}
+    } else {
+      if(positions[0][k]>interval_max[k]) {
+        positions[0][k]=interval_max[k];
+      }
+      if(positions[0][k]<interval_min[k]) {
+        positions[0][k]=interval_min[k];
+      }
     }
   }
 
@@ -579,7 +595,8 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
     velocities[0][k]=random.Gaussian() * sqrt( temp );
   }
 
-  potential=calc_energy(positions,forces); double ttt=calc_temp(velocities);
+  potential=calc_energy(positions,forces);
+  double ttt=calc_temp(velocities);
 
   FILE* fp=fopen(stats_filename.c_str(),"w+");
   // call fclose when fp_deleter goes out of scope
@@ -620,8 +637,7 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
 
       if(periodic[k]) {
         positions[0][k] = positions[0][k] - floor((positions[0][k]-interval_min[k])/interval_range[k])*interval_range[k];
-      }
-      else {
+      } else {
         if(positions[0][k]>interval_max[k]) {
           positions[0][k]=interval_max[k];
           velocities[0][k]=-std::abs(velocities[0][k]);
@@ -646,7 +662,9 @@ int MD_LinearExpansionPES::main( FILE* in, FILE* out, PLMD::Communicator& pc) {
       plumed->cmd("setStopFlag",&plumedWantsToStop);
       plumed->cmd("calc");
       //if(istep%2000==0) plumed->cmd("writeCheckPointFile");
-      if(plumedWantsToStop) nsteps=istep;
+      if(plumedWantsToStop) {
+        nsteps=istep;
+      }
     }
 
     // Second step of velocity verlet
diff --git a/src/ves/Opt_Adam.cpp b/src/ves/Opt_Adam.cpp
index 636704e9fa..07a1293c7b 100644
--- a/src/ves/Opt_Adam.cpp
+++ b/src/ves/Opt_Adam.cpp
@@ -66,10 +66,14 @@ class Opt_Adam: public Optimizer {
 };
 
 inline
-CoeffsVector& Opt_Adam::VarCoeffs(const unsigned int coeffs_id) const {return *var_coeffs_pntrs_[coeffs_id];}
+CoeffsVector& Opt_Adam::VarCoeffs(const unsigned int coeffs_id) const {
+  return *var_coeffs_pntrs_[coeffs_id];
+}
 
 inline
-CoeffsVector& Opt_Adam::VarmaxCoeffs(const unsigned int coeffs_id) const {return *varmax_coeffs_pntrs_[coeffs_id];}
+CoeffsVector& Opt_Adam::VarmaxCoeffs(const unsigned int coeffs_id) const {
+  return *varmax_coeffs_pntrs_[coeffs_id];
+}
 
 
 PLUMED_REGISTER_ACTION(Opt_Adam,"OPT_ADAM")
@@ -98,8 +102,7 @@ Opt_Adam::Opt_Adam(const ActionOptions&ao):
   one_minus_weight_decay_(1.0),
   amsgrad_(false),
   adamw_(false),
-  var_coeffs_pntrs_(0)
-{
+  var_coeffs_pntrs_(0) {
   // add citation and print it to log
   log << "  Adam type stochastic gradient decent\n";
   parseFlag("AMSGRAD",amsgrad_);
@@ -173,8 +176,7 @@ void Opt_Adam::coeffsUpdate(const unsigned int c_id) {
     for (size_t i = 0; i< VarCoeffs(c_id).getSize(); ++i) {
       var_coeffs_sqrt.push_back(1 / (sqrt(VarCoeffs(c_id).getValue(i)) + epsilon));
     }
-  }
-  else { // use VarmaxCoffs instead of VarCoeffs
+  } else { // use VarmaxCoffs instead of VarCoeffs
     for (size_t i = 0; i< VarmaxCoeffs(c_id).getSize(); ++i) {
       var_coeffs_sqrt.push_back(1 / (sqrt(VarmaxCoeffs(c_id).getValue(i)) + epsilon));
     }
diff --git a/src/ves/Opt_BachAveragedSGD.cpp b/src/ves/Opt_BachAveragedSGD.cpp
index 6813729417..d015d909f7 100644
--- a/src/ves/Opt_BachAveragedSGD.cpp
+++ b/src/ves/Opt_BachAveragedSGD.cpp
@@ -187,7 +187,9 @@ class Opt_BachAveragedSGD : public Optimizer {
   std::vector<std::unique_ptr<OFile>> combinedgradientOFiles_;
   double decaying_aver_tau_;
 private:
-  CoeffsVector& CombinedGradient(const unsigned int c_id) const {return *combinedgradient_pntrs_[c_id];}
+  CoeffsVector& CombinedGradient(const unsigned int c_id) const {
+    return *combinedgradient_pntrs_[c_id];
+  }
   double getAverDecay() const;
 public:
   static void registerKeywords(Keywords&);
@@ -219,8 +221,7 @@ void Opt_BachAveragedSGD::registerKeywords(Keywords& keys) {
 Opt_BachAveragedSGD::Opt_BachAveragedSGD(const ActionOptions&ao):
   PLUMED_VES_OPTIMIZER_INIT(ao),
   combinedgradient_wstride_(100),
-  decaying_aver_tau_(0.0)
-{
+  decaying_aver_tau_(0.0) {
   log.printf("  Averaged stochastic gradient decent, see and cite ");
   log << plumed.cite("Bach and Moulines, NIPS 26, 773-781 (2013)");
   log.printf("\n");
@@ -245,8 +246,7 @@ Opt_BachAveragedSGD::Opt_BachAveragedSGD(const ActionOptions&ao):
       std::string label = getGradientPntrs()[i]->getLabel();
       if(label.find("gradient")!=std::string::npos) {
         label.replace(label.find("gradient"), std::string("gradient").length(), "combined_gradient");
-      }
-      else {
+      } else {
         label += "_combined";
       }
       combinedgradient_tmp->setLabels(label);
@@ -258,8 +258,7 @@ Opt_BachAveragedSGD::Opt_BachAveragedSGD(const ActionOptions&ao):
     //
     if(numberOfCoeffsSets()==1) {
       log.printf("  Combined gradient (gradient + Hessian term) will be written out to file %s every %u iterations\n",combinedgradientOFiles_[0]->getPath().c_str(),combinedgradient_wstride_);
-    }
-    else {
+    } else {
       log.printf("  Combined gradient (gradient + Hessian term) will be written out to the following files every %u iterations:\n",combinedgradient_wstride_);
       for(unsigned int i=0; i<combinedgradientOFiles_.size(); i++) {
         log.printf("   coefficient set %u: %s\n",i,combinedgradientOFiles_[i]->getPath().c_str());
diff --git a/src/ves/Opt_Dummy.cpp b/src/ves/Opt_Dummy.cpp
index 58fa53cd91..cbbab223b8 100644
--- a/src/ves/Opt_Dummy.cpp
+++ b/src/ves/Opt_Dummy.cpp
@@ -96,8 +96,7 @@ void Opt_Dummy::registerKeywords(Keywords& keys) {
 
 
 Opt_Dummy::Opt_Dummy(const ActionOptions&ao):
-  PLUMED_VES_OPTIMIZER_INIT(ao)
-{
+  PLUMED_VES_OPTIMIZER_INIT(ao) {
   log.printf("  fake optimizer that does not update coefficients\n");
   log.printf("  can be used to monitor gradient and Hessian for debugging purposes\n");
   bool monitor_hessian = false;
@@ -105,8 +104,7 @@ Opt_Dummy::Opt_Dummy(const ActionOptions&ao):
   if(monitor_hessian) {
     turnOnHessian();
     log.printf("  the Hessian will also be monitored\n");
-  }
-  else {
+  } else {
     turnOffHessian();
   }
   turnOffCoeffsOutputFiles();
diff --git a/src/ves/Opt_RobbinsMonroSGD.cpp b/src/ves/Opt_RobbinsMonroSGD.cpp
index e045b4d91a..86589dace4 100644
--- a/src/ves/Opt_RobbinsMonroSGD.cpp
+++ b/src/ves/Opt_RobbinsMonroSGD.cpp
@@ -68,8 +68,7 @@ void Opt_RobbinsMonroSGD::registerKeywords(Keywords& keys) {
 
 Opt_RobbinsMonroSGD::Opt_RobbinsMonroSGD(const ActionOptions&ao):
   PLUMED_VES_OPTIMIZER_INIT(ao),
-  decay_constant_(1.0)
-{
+  decay_constant_(1.0) {
   parse("DECAY_CONSTANT",decay_constant_);
   if(decay_constant_<1.0) {
     plumed_merror("the value given in DECAY_CONSTANT doesn't make sense, it should be larger than 1.0");
diff --git a/src/ves/Optimizer.cpp b/src/ves/Optimizer.cpp
index a34c62fa26..f3acfd3c06 100644
--- a/src/ves/Optimizer.cpp
+++ b/src/ves/Optimizer.cpp
@@ -82,8 +82,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
   targetdist_output_stride_(0),
   targetdist_proj_output_active_(false),
   targetdist_proj_output_stride_(0),
-  isFirstStep(true)
-{
+  isFirstStep(true) {
   std::vector<std::string> bias_labels(0);
   parseVector("BIAS",bias_labels);
   plumed_massert(bias_labels.size()>0,"problem with BIAS keyword");
@@ -91,7 +90,9 @@ Optimizer::Optimizer(const ActionOptions&ao):
   //
   std::string error_msg = "";
   bias_pntrs_ = VesTools::getPointersFromLabels<VesBias*>(bias_labels,plumed.getActionSet(),error_msg);
-  if(error_msg.size()>0) {plumed_merror("Error in keyword BIAS of "+getName()+": "+error_msg);}
+  if(error_msg.size()>0) {
+    plumed_merror("Error in keyword BIAS of "+getName()+": "+error_msg);
+  }
 
   for(unsigned int i=0; i<bias_pntrs_.size(); i++) {
     bias_pntrs_[i]->linkOptimizer(this);
@@ -116,8 +117,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
       std::string aux_label = pntrs_coeffs[k]->getLabel();
       if(aux_label.find("coeffs")!=std::string::npos) {
         aux_label.replace(aux_label.find("coeffs"), std::string("coeffs").length(), "aux_coeffs");
-      }
-      else {
+      } else {
         aux_label += "_aux";
       }
       aux_coeffs_tmp->setLabels(aux_label);
@@ -158,11 +158,13 @@ Optimizer::Optimizer(const ActionOptions&ao):
     log.printf("   KbT: %f\n",bias_pntrs_[0]->getKbT());
     log.printf("  number of coefficients: %zu\n",coeffs_pntrs_[0]->numberOfCoeffs());
     if(stepsizes_.size()>0) {
-      if(fixed_stepsize_) {log.printf("  using a constant step size of %f\n",stepsizes_[0]);}
-      else {log.printf("  using an initial step size of %f\n",stepsizes_[0]);}
+      if(fixed_stepsize_) {
+        log.printf("  using a constant step size of %f\n",stepsizes_[0]);
+      } else {
+        log.printf("  using an initial step size of %f\n",stepsizes_[0]);
+      }
     }
-  }
-  else {
+  } else {
     log.printf("  optimizing %u coefficient sets from following %u VES biases:\n",ncoeffssets_,nbiases_);
     for(unsigned int i=0; i<nbiases_; i++) {
       log.printf("   %s of type %s (KbT: %f) \n",bias_pntrs_[i]->getLabel().c_str(),bias_pntrs_[i]->getName().c_str(),bias_pntrs_[i]->getKbT());
@@ -173,16 +175,18 @@ Optimizer::Optimizer(const ActionOptions&ao):
       log.printf("   used in bias %s (type %s)\n",coeffs_pntrs_[i]->getPntrToAction()->getLabel().c_str(),coeffs_pntrs_[i]->getPntrToAction()->getName().c_str());
       log.printf("   number of coefficients: %zu\n",coeffs_pntrs_[i]->numberOfCoeffs());
       if(stepsizes_.size()>0) {
-        if(fixed_stepsize_) {log.printf("   using a constant step size of %f\n",stepsizes_[i]);}
-        else {log.printf("   using an initial step size of %f\n",stepsizes_[i]);}
+        if(fixed_stepsize_) {
+          log.printf("   using a constant step size of %f\n",stepsizes_[i]);
+        } else {
+          log.printf("   using an initial step size of %f\n",stepsizes_[i]);
+        }
       }
       tot_ncoeffs += coeffs_pntrs_[i]->numberOfCoeffs();
     }
     log.printf("  total number of coefficients: %zu\n",tot_ncoeffs);
     if(identical_coeffs_shape_) {
       log.printf("  the indices shape is identical for all coefficient sets\n");
-    }
-    else {
+    } else {
       log.printf("  the indices shape differs between coefficient sets\n");
     }
   }
@@ -227,7 +231,9 @@ Optimizer::Optimizer(const ActionOptions&ao):
     bool need_stride = false;
     for(unsigned int i=0; i<nbiases_; i++) {
       dynamic_targetdists_[i] = bias_pntrs_[i]->dynamicTargetDistribution();
-      if(dynamic_targetdists_[i]) {need_stride = true;}
+      if(dynamic_targetdists_[i]) {
+        need_stride = true;
+      }
     }
     parse("TARGETDIST_STRIDE",ustride_targetdist_);
     if(need_stride && ustride_targetdist_==0) {
@@ -239,8 +245,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
     if(ustride_targetdist_>0) {
       if(nbiases_==1) {
         log.printf("  the target distribution will be updated very %u coefficient iterations\n",ustride_targetdist_);
-      }
-      else {
+      } else {
         log.printf("  the target distribution will be updated very %u coefficient iterations for the following biases\n   ",ustride_targetdist_);
         for(unsigned int i=0; i<nbiases_; i++) {
           log.printf("%s ",bias_pntrs_[i]->getLabel().c_str());
@@ -287,8 +292,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
         std::string aver_grad_label = aver_gradient_tmp->getLabel();
         if(aver_grad_label.find("gradient")!=std::string::npos) {
           aver_grad_label.replace(aver_grad_label.find("gradient"), std::string("gradient").length(), "aver_gradient");
-        }
-        else {
+        } else {
           aver_grad_label += "_aver";
         }
         aver_gradient_tmp->setLabels(aver_grad_label);
@@ -306,8 +310,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
     if(keywords.exists("COEFFS_SET_ID_PREFIX")) {
       parse("COEFFS_SET_ID_PREFIX",coeffssetid_prefix_);
     }
-  }
-  else {
+  } else {
     coeffssetid_prefix_="";
     if(keywords.exists("COEFFS_SET_ID_PREFIX")) {
       parse("COEFFS_SET_ID_PREFIX",coeffssetid_prefix_);
@@ -345,7 +348,9 @@ Optimizer::Optimizer(const ActionOptions&ao):
       for(unsigned int i=0; i<coeffs_fnames.size(); i++) {
         IFile ifile;
         ifile.link(*this);
-        if(use_mwalkers_mpi_) {ifile.enforceSuffix("");}
+        if(use_mwalkers_mpi_) {
+          ifile.enforceSuffix("");
+        }
         bool file_exist = ifile.FileExist(coeffs_fnames[i]);
         if(!file_exist) {
           std::string fname = FileBase::appendSuffix(coeffs_fnames[i],ifile.getSuffix());
@@ -367,8 +372,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
         for(unsigned int i=0; i<ncoeffssets_; i++) {
           AuxCoeffs(i).setValues( Coeffs(i) );
         }
-      }
-      else {
+      } else {
         setIterationCounter(coeffs_pntrs_[0]->getIterationCounter());
         log.printf("  Optimization restarted at iteration %u\n",getIterationCounter());
       }
@@ -398,15 +402,13 @@ Optimizer::Optimizer(const ActionOptions&ao):
     if(coeffs_fnames.size()>0) {
       if(ncoeffssets_==1) {
         log.printf("  Coefficients will be written out to file %s every %u iterations\n",coeffsOFiles_[0]->getPath().c_str(),coeffs_wstride_);
-      }
-      else {
+      } else {
         log.printf("  Coefficients will be written out to the following files every %u iterations:\n",coeffs_wstride_);
         for(unsigned int i=0; i<coeffs_fnames.size(); i++) {
           log.printf("   coefficient set %u: %s\n",i,coeffsOFiles_[i]->getPath().c_str());
         }
       }
-    }
-    else {
+    } else {
       log.printf("  Output of coefficients to file has been disabled\n");
     }
   }
@@ -432,8 +434,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
     if(gradient_fnames.size()>0) {
       if(ncoeffssets_==1) {
         log.printf("  Gradient will be written out to file %s every %u iterations\n",gradientOFiles_[0]->getPath().c_str(),gradient_wstride_);
-      }
-      else {
+      } else {
         log.printf("  Gradient will be written out to the following files every %u iterations:\n",gradient_wstride_);
         for(unsigned int i=0; i<gradient_fnames.size(); i++) {
           log.printf("   coefficient set %u: %s\n",i,gradientOFiles_[i]->getPath().c_str());
@@ -463,8 +464,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
     if(hessian_fnames.size()>0) {
       if(ncoeffssets_==1) {
         log.printf("  Hessian will be written out to file %s every %u iterations\n",hessianOFiles_[0]->getPath().c_str(),hessian_wstride_);
-      }
-      else {
+      } else {
         log.printf("  Hessian will be written out to the following files every %u iterations:\n",hessian_wstride_);
         for(unsigned int i=0; i<hessian_fnames.size(); i++) {
           log.printf("   coefficient set %u: %s\n",i,hessianOFiles_[i]->getPath().c_str());
@@ -479,8 +479,11 @@ Optimizer::Optimizer(const ActionOptions&ao):
     std::vector<std::string> mask_fnames_in;
     parseVector("MASK_FILE",mask_fnames_in);
     if(mask_fnames_in.size()==1 && ncoeffssets_>1) {
-      if(identical_coeffs_shape_) {mask_fnames_in.resize(ncoeffssets_,mask_fnames_in[0]);}
-      else {plumed_merror("the coefficients indices shape differs between biases so you need to give a separate file for each coefficient set\n");}
+      if(identical_coeffs_shape_) {
+        mask_fnames_in.resize(ncoeffssets_,mask_fnames_in[0]);
+      } else {
+        plumed_merror("the coefficients indices shape differs between biases so you need to give a separate file for each coefficient set\n");
+      }
     }
     if(mask_fnames_in.size()>0 && mask_fnames_in.size()!=ncoeffssets_) {
       plumed_merror("Error in MASK_FILE keyword: either give one value for all biases or a separate value for each coefficient set");
@@ -500,8 +503,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
         log.printf("  read %zu values from mask file %s\n",nread,mask_fnames_in[0].c_str());
         size_t ndeactived = coeffs_mask_pntrs_[0]->countValues(0.0);
         log.printf("  deactived optimization of %zu coefficients\n",ndeactived);
-      }
-      else {
+      } else {
         for(unsigned int i=0; i<ncoeffssets_; i++) {
           size_t nread = coeffs_mask_pntrs_[i]->readFromFile(mask_fnames_in[i],true,true);
           log.printf("  mask for coefficient set %u:\n",i);
@@ -524,9 +526,13 @@ Optimizer::Optimizer(const ActionOptions&ao):
       maskOFile.enforceBackup();
       if(use_mwalkers_mpi_ && mwalkers_mpi_single_files_) {
         unsigned int r=0;
-        if(comm.Get_rank()==0) {r=multi_sim_comm.Get_rank();}
+        if(comm.Get_rank()==0) {
+          r=multi_sim_comm.Get_rank();
+        }
         comm.Bcast(r,0);
-        if(r>0) {mask_fnames_out[i]="/dev/null";}
+        if(r>0) {
+          mask_fnames_out[i]="/dev/null";
+        }
         maskOFile.enforceSuffix("");
       }
       maskOFile.open(mask_fnames_out[i]);
@@ -583,8 +589,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
     if(targetdist_averages_fnames.size()>0 && targetdist_averages_wstride_ > 0) {
       if(ncoeffssets_==1) {
         log.printf("  Target distribution averages will be written out to file %s every %u iterations\n",targetdist_averagesOFiles_[0]->getPath().c_str(),targetdist_averages_wstride_);
-      }
-      else {
+      } else {
         log.printf("  Target distribution averages will be written out to the following files every %u iterations:\n",targetdist_averages_wstride_);
         for(unsigned int i=0; i<targetdist_averages_fnames.size(); i++) {
           log.printf("   coefficient set %u: %s\n",i,targetdist_averagesOFiles_[i]->getPath().c_str());
@@ -603,8 +608,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
         bias_pntrs_[i]->setupBiasFileOutput();
         bias_pntrs_[i]->writeBiasToFile();
       }
-    }
-    else {
+    } else {
       bias_output_active_=false;
       bias_output_stride_=1000;
     }
@@ -619,8 +623,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
         bias_pntrs_[i]->setupFesFileOutput();
         bias_pntrs_[i]->writeFesToFile();
       }
-    }
-    else {
+    } else {
       fes_output_active_=false;
       fes_output_stride_=1000;
     }
@@ -635,8 +638,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
         bias_pntrs_[i]->setupFesProjFileOutput();
         bias_pntrs_[i]->writeFesProjToFile();
       }
-    }
-    else {
+    } else {
       fesproj_output_active_=false;
       fesproj_output_stride_=1000;
     }
@@ -672,8 +674,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
           bias_pntrs_[i]->writeTargetDistToFile();
         }
       }
-    }
-    else {
+    } else {
       targetdist_output_active_=false;
       targetdist_output_stride_=1000;
     }
@@ -697,8 +698,7 @@ Optimizer::Optimizer(const ActionOptions&ao):
           bias_pntrs_[i]->writeTargetDistProjToFile();
         }
       }
-    }
-    else {
+    } else {
       targetdist_proj_output_active_=false;
       targetdist_proj_output_stride_=1000;
     }
@@ -708,41 +708,52 @@ Optimizer::Optimizer(const ActionOptions&ao):
     log.printf("  Output Components:\n");
     log.printf(" ");
     if(monitor_instantaneous_gradient_) {
-      addComponent("gradrms"); componentIsNotPeriodic("gradrms");
+      addComponent("gradrms");
+      componentIsNotPeriodic("gradrms");
       log.printf(" ");
-      addComponent("gradmax"); componentIsNotPeriodic("gradmax");
+      addComponent("gradmax");
+      componentIsNotPeriodic("gradmax");
     }
     if(aver_gradient_pntrs_.size()>0) {
       log.printf(" ");
-      addComponent("avergradrms"); componentIsNotPeriodic("avergradrms");
+      addComponent("avergradrms");
+      componentIsNotPeriodic("avergradrms");
       log.printf(" ");
-      addComponent("avergradmax"); componentIsNotPeriodic("avergradmax");
+      addComponent("avergradmax");
+      componentIsNotPeriodic("avergradmax");
     }
     if(!fixed_stepsize_) {
       log.printf(" ");
-      addComponent("stepsize"); componentIsNotPeriodic("stepsize");
+      addComponent("stepsize");
+      componentIsNotPeriodic("stepsize");
       getPntrToComponent("stepsize")->set( getCurrentStepSize(0) );
     }
-  }
-  else {
+  } else {
     for(unsigned int i=0; i<ncoeffssets_; i++) {
       log.printf("  Output Components for coefficient set %u:\n",i);
-      std::string is=""; Tools::convert(i,is); is = "-" + coeffssetid_prefix_ + is;
+      std::string is="";
+      Tools::convert(i,is);
+      is = "-" + coeffssetid_prefix_ + is;
       log.printf(" ");
       if(monitor_instantaneous_gradient_) {
-        addComponent("gradrms"+is); componentIsNotPeriodic("gradrms"+is);
+        addComponent("gradrms"+is);
+        componentIsNotPeriodic("gradrms"+is);
         log.printf(" ");
-        addComponent("gradmax"+is); componentIsNotPeriodic("gradmax"+is);
+        addComponent("gradmax"+is);
+        componentIsNotPeriodic("gradmax"+is);
       }
       if(aver_gradient_pntrs_.size()>0) {
         log.printf(" ");
-        addComponent("avergradrms"+is); componentIsNotPeriodic("avergradrms"+is);
+        addComponent("avergradrms"+is);
+        componentIsNotPeriodic("avergradrms"+is);
         log.printf(" ");
-        addComponent("avergradmax"+is); componentIsNotPeriodic("avergradmax"+is);
+        addComponent("avergradmax"+is);
+        componentIsNotPeriodic("avergradmax"+is);
       }
       if(!fixed_stepsize_) {
         log.printf(" ");
-        addComponent("stepsize"+is); componentIsNotPeriodic("stepsize"+is);
+        addComponent("stepsize"+is);
+        componentIsNotPeriodic("stepsize"+is);
         getPntrToComponent("stepsize"+is)->set( getCurrentStepSize(i) );
       }
     }
@@ -926,8 +937,7 @@ void Optimizer::turnOnHessian() {
   plumed_massert(hessian_pntrs_.size()==ncoeffssets_,"problems in linking Hessians");
   if(diagonal_hessian_) {
     log.printf("  Optimization performed using diagonal Hessian matrix\n");
-  }
-  else {
+  } else {
     log.printf("  Optimization performed using full Hessian matrix\n");
   }
   //
@@ -991,8 +1001,9 @@ void Optimizer::update() {
       bias_pntrs_[i]->updateGradientAndHessian(use_mwalkers_mpi_);
     }
     for(unsigned int i=0; i<ncoeffssets_; i++) {
-      if(gradient_pntrs_[i]->isActive()) {coeffsUpdate(i);}
-      else {
+      if(gradient_pntrs_[i]->isActive()) {
+        coeffsUpdate(i);
+      } else {
         std::string msg = "iteration " + getIterationCounterStr(+1) +
                           " for " + bias_pntrs_[i]->getLabel() +
                           " - the coefficients are not updated as CV values are outside the bias intervals";
@@ -1049,8 +1060,7 @@ void Optimizer::update() {
     if(isTargetDistProjOutputActive() && getIterationCounter()%getTargetDistProjOutputStride()==0) {
       writeTargetDistProjOutputFiles();
     }
-  }
-  else {
+  } else {
     isFirstStep=false;
   }
 }
@@ -1071,10 +1081,11 @@ void Optimizer::updateOutputComponents() {
       size_t avergradient_maxabs_idx=0;
       getPntrToComponent("avergradmax")->set( aver_gradient_pntrs_[0]->getMaxAbsValue(avergradient_maxabs_idx) );
     }
-  }
-  else {
+  } else {
     for(unsigned int i=0; i<ncoeffssets_; i++) {
-      std::string is=""; Tools::convert(i,is); is = "-" + coeffssetid_prefix_ + is;
+      std::string is="";
+      Tools::convert(i,is);
+      is = "-" + coeffssetid_prefix_ + is;
       if(!fixed_stepsize_) {
         getPntrToComponent("stepsize"+is)->set( getCurrentStepSize(i) );
       }
@@ -1105,8 +1116,7 @@ void Optimizer::writeOutputFiles(const unsigned int coeffs_id) {
   if(gradientOFiles_.size()>0 && iter_counter%gradient_wstride_==0) {
     if(aver_gradient_pntrs_.size()==0) {
       gradient_pntrs_[coeffs_id]->writeToFile(*gradientOFiles_[coeffs_id],false);
-    }
-    else {
+    } else {
       gradient_pntrs_[coeffs_id]->writeToFile(*gradientOFiles_[coeffs_id],aver_gradient_pntrs_[coeffs_id].get(),false);
     }
   }
@@ -1127,9 +1137,13 @@ void Optimizer::setupOFiles(std::vector<std::string>& fnames, std::vector<std::u
     OFiles[i]->link(*this);
     if(multi_sim_single_files) {
       unsigned int r=0;
-      if(comm.Get_rank()==0) {r=multi_sim_comm.Get_rank();}
+      if(comm.Get_rank()==0) {
+        r=multi_sim_comm.Get_rank();
+      }
       comm.Bcast(r,0);
-      if(r>0) {fnames[i]="/dev/null";}
+      if(r>0) {
+        fnames[i]="/dev/null";
+      }
       OFiles[i]->enforceSuffix("");
     }
     OFiles[i]->open(fnames[i]);
@@ -1143,8 +1157,7 @@ void Optimizer::readCoeffsFromFiles(const std::vector<std::string>& fnames, cons
   plumed_assert(fnames.size()==ncoeffssets_);
   if(ncoeffssets_==1) {
     log.printf("  Read in coefficients from file ");
-  }
-  else {
+  } else {
     log.printf("  Read in coefficients from files:\n");
   }
   for(unsigned int i=0; i<ncoeffssets_; i++) {
@@ -1161,8 +1174,7 @@ void Optimizer::readCoeffsFromFiles(const std::vector<std::string>& fnames, cons
     size_t ncoeffs_read = coeffs_pntrs_[i]->readFromFile(ifile,false,false);
     if(ncoeffssets_==1) {
       log.printf("%s (read %zu of %zu values)\n", ifile.getPath().c_str(),ncoeffs_read,coeffs_pntrs_[i]->numberOfCoeffs());
-    }
-    else {
+    } else {
       log.printf("   coefficient set %u: %s (read %zu of %zu values)\n",i,ifile.getPath().c_str(),ncoeffs_read,coeffs_pntrs_[i]->numberOfCoeffs());
     }
     ifile.close();
@@ -1174,8 +1186,7 @@ void Optimizer::readCoeffsFromFiles(const std::vector<std::string>& fnames, cons
       }
       aux_coeffs_pntrs_[i]->readFromFile(ifile,false,false);
       ifile.close();
-    }
-    else {
+    } else {
       AuxCoeffs(i).setValues( Coeffs(i) );
     }
   }
@@ -1183,7 +1194,9 @@ void Optimizer::readCoeffsFromFiles(const std::vector<std::string>& fnames, cons
 
 
 void Optimizer::addCoeffsSetIDsToFilenames(std::vector<std::string>& fnames, std::string& coeffssetid_prefix) {
-  if(ncoeffssets_==1) {return;}
+  if(ncoeffssets_==1) {
+    return;
+  }
   //
   if(fnames.size()==1) {
     fnames.resize(ncoeffssets_,fnames[0]);
@@ -1191,7 +1204,8 @@ void Optimizer::addCoeffsSetIDsToFilenames(std::vector<std::string>& fnames, std
   plumed_assert(fnames.size()==ncoeffssets_);
   //
   for(unsigned int i=0; i<ncoeffssets_; i++) {
-    std::string is=""; Tools::convert(i,is);
+    std::string is="";
+    Tools::convert(i,is);
     fnames[i] = FileBase::appendSuffix(fnames[i],"."+coeffssetid_prefix_+is);
   }
 }
diff --git a/src/ves/Optimizer.h b/src/ves/Optimizer.h
index 90e745552e..c2ad9d9f14 100644
--- a/src/ves/Optimizer.h
+++ b/src/ves/Optimizer.h
@@ -52,8 +52,7 @@ class VesBias;
 
 class Optimizer :
   public ActionPilot,
-  public ActionWithValue
-{
+  public ActionWithValue {
 private:
   const std::string description_;
   const std::string type_;
@@ -170,11 +169,19 @@ class Optimizer :
   //
   explicit Optimizer(const ActionOptions&ao);
   ~Optimizer();
-  std::string getType() const {return type_;}
-  std::string getDescription() const {return description_;}
+  std::string getType() const {
+    return type_;
+  }
+  std::string getDescription() const {
+    return description_;
+  }
   //
-  unsigned int numberOfBiases() const {return nbiases_;}
-  unsigned int numberOfCoeffsSets() const {return ncoeffssets_;}
+  unsigned int numberOfBiases() const {
+    return nbiases_;
+  }
+  unsigned int numberOfCoeffsSets() const {
+    return ncoeffssets_;
+  }
   //
   std::vector<double> getStepSizes() const;
   std::vector<double> getCurrentStepSizes() const;
@@ -192,62 +199,126 @@ class Optimizer :
   void apply() override {};
   void calculate() override {};
   void update() override;
-  unsigned int getNumberOfDerivatives() override {return 0;}
+  unsigned int getNumberOfDerivatives() override {
+    return 0;
+  }
   //
-  bool fixedStepSize() const {return fixed_stepsize_;}
-  bool dynamicStepSize() const {return !fixed_stepsize_;}
+  bool fixedStepSize() const {
+    return fixed_stepsize_;
+  }
+  bool dynamicStepSize() const {
+    return !fixed_stepsize_;
+  }
   //
-  bool useHessian() const {return use_hessian_;}
-  bool diagonalHessian() const {return diagonal_hessian_;}
+  bool useHessian() const {
+    return use_hessian_;
+  }
+  bool diagonalHessian() const {
+    return diagonal_hessian_;
+  }
   //
-  bool useMultipleWalkers() const {return use_mwalkers_mpi_;}
+  bool useMultipleWalkers() const {
+    return use_mwalkers_mpi_;
+  }
   //
-  std::vector<VesBias*> getBiasPntrs() const {return bias_pntrs_;}
-  std::vector<CoeffsVector*> getCoeffsPntrs() const {return coeffs_pntrs_;}
-  std::vector<CoeffsVector*> getAuxCoeffsPntrs() const {return Tools::unique2raw(aux_coeffs_pntrs_);}
-  std::vector<CoeffsVector*> getGradientPntrs()const {return gradient_pntrs_;}
-  std::vector<CoeffsMatrix*> getHessianPntrs() const {return hessian_pntrs_;}
-  std::vector<CoeffsVector*> getCoeffsMaskPntrs() const {return Tools::unique2raw(coeffs_mask_pntrs_);}
-  std::vector<CoeffsVector*> getTargetDistAveragesPntrs() const {return targetdist_averages_pntrs_;}
+  std::vector<VesBias*> getBiasPntrs() const {
+    return bias_pntrs_;
+  }
+  std::vector<CoeffsVector*> getCoeffsPntrs() const {
+    return coeffs_pntrs_;
+  }
+  std::vector<CoeffsVector*> getAuxCoeffsPntrs() const {
+    return Tools::unique2raw(aux_coeffs_pntrs_);
+  }
+  std::vector<CoeffsVector*> getGradientPntrs()const {
+    return gradient_pntrs_;
+  }
+  std::vector<CoeffsMatrix*> getHessianPntrs() const {
+    return hessian_pntrs_;
+  }
+  std::vector<CoeffsVector*> getCoeffsMaskPntrs() const {
+    return Tools::unique2raw(coeffs_mask_pntrs_);
+  }
+  std::vector<CoeffsVector*> getTargetDistAveragesPntrs() const {
+    return targetdist_averages_pntrs_;
+  }
   //
-  bool isBiasOutputActive() const {return bias_output_active_;}
-  unsigned int getBiasOutputStride() const {return bias_output_stride_;}
-  void setBiasOutputStride(unsigned int stride) {bias_output_stride_=stride;}
+  bool isBiasOutputActive() const {
+    return bias_output_active_;
+  }
+  unsigned int getBiasOutputStride() const {
+    return bias_output_stride_;
+  }
+  void setBiasOutputStride(unsigned int stride) {
+    bias_output_stride_=stride;
+  }
   void writeBiasOutputFiles() const;
   //
-  bool isFesOutputActive() const {return fes_output_active_;}
-  unsigned int getFesOutputStride() const {return fes_output_stride_;}
-  void setFesOutputStride(unsigned int stride) {fes_output_stride_=stride;}
+  bool isFesOutputActive() const {
+    return fes_output_active_;
+  }
+  unsigned int getFesOutputStride() const {
+    return fes_output_stride_;
+  }
+  void setFesOutputStride(unsigned int stride) {
+    fes_output_stride_=stride;
+  }
   void writeFesOutputFiles() const;
   //
-  bool isFesProjOutputActive() const {return fesproj_output_active_;}
-  unsigned int getFesProjOutputStride() const {return fesproj_output_stride_;}
-  void setFesProjOutputStride(unsigned int stride) {fesproj_output_stride_=stride;}
+  bool isFesProjOutputActive() const {
+    return fesproj_output_active_;
+  }
+  unsigned int getFesProjOutputStride() const {
+    return fesproj_output_stride_;
+  }
+  void setFesProjOutputStride(unsigned int stride) {
+    fesproj_output_stride_=stride;
+  }
   void writeFesProjOutputFiles() const;
   //
-  bool isTargetDistOutputActive() const {return targetdist_output_active_;}
-  unsigned int getTargetDistOutputStride() const {return targetdist_output_stride_;}
-  void setTargetDistOutputStride(unsigned int stride) {targetdist_output_stride_=stride;}
+  bool isTargetDistOutputActive() const {
+    return targetdist_output_active_;
+  }
+  unsigned int getTargetDistOutputStride() const {
+    return targetdist_output_stride_;
+  }
+  void setTargetDistOutputStride(unsigned int stride) {
+    targetdist_output_stride_=stride;
+  }
   void writeTargetDistOutputFiles() const;
   //
-  bool isTargetDistProjOutputActive() const {return targetdist_proj_output_active_;}
-  unsigned int getTargetDistProjOutputStride() const {return targetdist_proj_output_stride_;}
-  void setTargetDistProjOutputStride(unsigned int stride) {targetdist_proj_output_stride_=stride;}
+  bool isTargetDistProjOutputActive() const {
+    return targetdist_proj_output_active_;
+  }
+  unsigned int getTargetDistProjOutputStride() const {
+    return targetdist_proj_output_stride_;
+  }
+  void setTargetDistProjOutputStride(unsigned int stride) {
+    targetdist_proj_output_stride_=stride;
+  }
   void writeTargetDistProjOutputFiles() const;
   //
 };
 
 inline
-double Optimizer::StepSize(const unsigned int coeffs_id) const {return stepsizes_[coeffs_id];}
+double Optimizer::StepSize(const unsigned int coeffs_id) const {
+  return stepsizes_[coeffs_id];
+}
 
 inline
-CoeffsVector& Optimizer::Coeffs(const unsigned int coeffs_id) const {return *coeffs_pntrs_[coeffs_id];}
+CoeffsVector& Optimizer::Coeffs(const unsigned int coeffs_id) const {
+  return *coeffs_pntrs_[coeffs_id];
+}
 
 inline
-CoeffsVector& Optimizer::AuxCoeffs(const unsigned int coeffs_id) const {return *aux_coeffs_pntrs_[coeffs_id];}
+CoeffsVector& Optimizer::AuxCoeffs(const unsigned int coeffs_id) const {
+  return *aux_coeffs_pntrs_[coeffs_id];
+}
 
 inline
-CoeffsVector& Optimizer::Gradient(const unsigned int coeffs_id) const {return *gradient_pntrs_[coeffs_id];}
+CoeffsVector& Optimizer::Gradient(const unsigned int coeffs_id) const {
+  return *gradient_pntrs_[coeffs_id];
+}
 
 inline
 CoeffsMatrix& Optimizer::Hessian(const unsigned int coeffs_id) const {
@@ -256,19 +327,29 @@ CoeffsMatrix& Optimizer::Hessian(const unsigned int coeffs_id) const {
 }
 
 inline
-CoeffsVector& Optimizer::CoeffsMask(const unsigned int coeffs_id) const {return *coeffs_mask_pntrs_[coeffs_id];}
+CoeffsVector& Optimizer::CoeffsMask(const unsigned int coeffs_id) const {
+  return *coeffs_mask_pntrs_[coeffs_id];
+}
 
 inline
-std::vector<double> Optimizer::getStepSizes() const {return stepsizes_;}
+std::vector<double> Optimizer::getStepSizes() const {
+  return stepsizes_;
+}
 
 inline
-std::vector<double> Optimizer::getCurrentStepSizes() const {return current_stepsizes;}
+std::vector<double> Optimizer::getCurrentStepSizes() const {
+  return current_stepsizes;
+}
 
 inline
-double Optimizer::getStepSize(const unsigned int coeffs_id) const {return stepsizes_[coeffs_id];}
+double Optimizer::getStepSize(const unsigned int coeffs_id) const {
+  return stepsizes_[coeffs_id];
+}
 
 inline
-double Optimizer::getCurrentStepSize(const unsigned int coeffs_id) const {return current_stepsizes[coeffs_id];}
+double Optimizer::getCurrentStepSize(const unsigned int coeffs_id) const {
+  return current_stepsizes[coeffs_id];
+}
 
 inline
 void Optimizer::setStepSizes(const std::vector<double>& stepsizes_in) {
@@ -293,16 +374,24 @@ void Optimizer::setCurrentStepSizes(const std::vector<double>& current_stepsizes
 }
 
 inline
-unsigned int Optimizer::getIterationCounter() const {return iter_counter;}
+unsigned int Optimizer::getIterationCounter() const {
+  return iter_counter;
+}
 
 inline
-double Optimizer::getIterationCounterDbl() const {return static_cast<double>(iter_counter);}
+double Optimizer::getIterationCounterDbl() const {
+  return static_cast<double>(iter_counter);
+}
 
 inline
-void Optimizer::increaseIterationCounter() {iter_counter++;}
+void Optimizer::increaseIterationCounter() {
+  iter_counter++;
+}
 
 inline
-void Optimizer::setIterationCounter(const unsigned int iter_counter_in) {iter_counter = iter_counter_in;}
+void Optimizer::setIterationCounter(const unsigned int iter_counter_in) {
+  iter_counter = iter_counter_in;
+}
 
 
 template<class T>
@@ -317,7 +406,8 @@ bool Optimizer::parseMultipleValues(const std::string& keyword, std::vector<T>&
     identical_values=true;
   }
   if(values.size()>0 && values.size()!=ncoeffssets_) {
-    std::string s1; Tools::convert(ncoeffssets_,s1);
+    std::string s1;
+    Tools::convert(ncoeffssets_,s1);
     plumed_merror("Error in " + keyword + " keyword: either give 1 common value for all coefficient sets or " + s1 + " separate value for each set");
   }
   return identical_values;
diff --git a/src/ves/OutputBasisFunctions.cpp b/src/ves/OutputBasisFunctions.cpp
index 0a4231581d..5f47f92f5f 100644
--- a/src/ves/OutputBasisFunctions.cpp
+++ b/src/ves/OutputBasisFunctions.cpp
@@ -81,8 +81,7 @@ plumed driver --plumed plumed.dat --igro configuration.gro
 
 
 class OutputBasisFunctions :
-  public Action
-{
+  public Action {
   std::vector<BasisFunctions*> bf_pntrs;
 public:
   explicit OutputBasisFunctions(const ActionOptions&);
@@ -116,15 +115,18 @@ void OutputBasisFunctions::registerKeywords(Keywords& keys) {
 
 OutputBasisFunctions::OutputBasisFunctions(const ActionOptions&ao):
   Action(ao),
-  bf_pntrs(0)
-{
+  bf_pntrs(0) {
   std::vector<std::string> basisset_labels(0);
   parseVector("BASIS_FUNCTIONS",basisset_labels);
-  if(basisset_labels.size()>1) {plumed_merror("Only one basis set label allowed in keyword BASIS_FUNCTIONS of "+getName());}
+  if(basisset_labels.size()>1) {
+    plumed_merror("Only one basis set label allowed in keyword BASIS_FUNCTIONS of "+getName());
+  }
 
   std::string error_msg = "";
   bf_pntrs = VesTools::getPointersFromLabels<BasisFunctions*>(basisset_labels,plumed.getActionSet(),error_msg);
-  if(error_msg.size()>0) {plumed_merror("Error in keyword BASIS_FUNCTIONS of "+getName()+": "+error_msg);}
+  if(error_msg.size()>0) {
+    plumed_merror("Error in keyword BASIS_FUNCTIONS of "+getName()+": "+error_msg);
+  }
 
   unsigned int nbins = 1000;
   parse("GRID_BINS",nbins);
@@ -163,10 +165,14 @@ OutputBasisFunctions::OutputBasisFunctions(const ActionOptions&ao):
   targetdist_pntrs.push_back(NULL);
   std::string targetdist_label="";
   for(int i=1;; i++) {
-    if(!parseNumbered("TARGET_DISTRIBUTION",i,targetdist_label)) {break;}
+    if(!parseNumbered("TARGET_DISTRIBUTION",i,targetdist_label)) {
+      break;
+    }
     std::string error_msg = "";
     TargetDistribution* pntr_tmp = VesTools::getPointerFromLabel<TargetDistribution*>(targetdist_label,plumed.getActionSet(),error_msg);
-    if(error_msg.size()>0) {plumed_merror("Error in keyword TARGET_DISTRIBUTION of "+getName()+": "+error_msg);}
+    if(error_msg.size()>0) {
+      plumed_merror("Error in keyword TARGET_DISTRIBUTION of "+getName()+": "+error_msg);
+    }
     targetdist_pntrs.push_back(pntr_tmp);
   }
   checkRead();
@@ -183,15 +189,17 @@ OutputBasisFunctions::OutputBasisFunctions(const ActionOptions&ao):
   ofile_values.close();
   ofile_derivs.close();
   //
-  std::vector<std::string> grid_min(1); grid_min[0]=bf_pntrs[0]->intervalMinStr();
-  std::vector<std::string> grid_max(1); grid_max[0]=bf_pntrs[0]->intervalMaxStr();
-  std::vector<unsigned int> grid_bins(1); grid_bins[0]=nbins;
+  std::vector<std::string> grid_min(1);
+  grid_min[0]=bf_pntrs[0]->intervalMinStr();
+  std::vector<std::string> grid_max(1);
+  grid_max[0]=bf_pntrs[0]->intervalMaxStr();
+  std::vector<unsigned int> grid_bins(1);
+  grid_bins[0]=nbins;
   std::vector<std::unique_ptr<Value>> arguments(1);
   arguments[0]= Tools::make_unique<Value>(nullptr,"arg",false);
   if(bf_pntrs[0]->arePeriodic() && !ignore_periodicity) {
     arguments[0]->setDomain(bf_pntrs[0]->intervalMinStr(),bf_pntrs[0]->intervalMaxStr());
-  }
-  else {
+  } else {
     arguments[0]->setNotPeriodic();
   }
 
@@ -201,7 +209,8 @@ OutputBasisFunctions::OutputBasisFunctions(const ActionOptions&ao):
   ofile_targetdist_aver.open(fname_targetdist_aver);
 
   for(unsigned int i=0; i<targetdist_pntrs.size(); i++) {
-    std::string is; Tools::convert(i,is);
+    std::string is;
+    Tools::convert(i,is);
     //
     if(targetdist_pntrs[i]!=NULL) {
       targetdist_pntrs[i]->setupGrids(Tools::unique2raw(arguments),grid_min,grid_max,grid_bins);
@@ -212,7 +221,9 @@ OutputBasisFunctions::OutputBasisFunctions(const ActionOptions&ao):
     std::vector<double> bf_integrals = bf_pntrs[0]->getTargetDistributionIntegrals(targetdist_pntrs[i]);
     CoeffsVector targetdist_averages = CoeffsVector("aver.targetdist-"+is,Tools::unique2raw(arguments),bf_pntrs,comm,false);
     targetdist_averages.setValues(bf_integrals);
-    if(fmt_targetdist_aver.size()>0) {targetdist_averages.setOutputFmt(fmt_targetdist_aver);}
+    if(fmt_targetdist_aver.size()>0) {
+      targetdist_averages.setOutputFmt(fmt_targetdist_aver);
+    }
     targetdist_averages.writeToFile(ofile_targetdist_aver,true);
     if(targetdist_pntrs[i]!=NULL) {
       Grid* targetdist_grid_pntr = targetdist_pntrs[i]->getTargetDistGridPntr();
diff --git a/src/ves/OutputFesBias.cpp b/src/ves/OutputFesBias.cpp
index 8a4160b7e1..33ed4c64f1 100644
--- a/src/ves/OutputFesBias.cpp
+++ b/src/ves/OutputFesBias.cpp
@@ -121,8 +121,7 @@ void OutputFesBias::registerKeywords(Keywords& keys) {
 
 
 OutputFesBias::OutputFesBias(const ActionOptions&ao):
-  Action(ao)
-{
+  Action(ao) {
 
   std::vector<std::string> bias_labels;
   parseVector("BIAS",bias_labels);
@@ -132,7 +131,9 @@ OutputFesBias::OutputFesBias(const ActionOptions&ao):
 
   std::string error_msg = "";
   std::vector<VesBias*> bias_pntrs = VesTools::getPointersFromLabels<VesBias*>(bias_labels,plumed.getActionSet(),error_msg);
-  if(error_msg.size()>0) {plumed_merror("Error in keyword BIAS of "+getName()+": "+error_msg);}
+  if(error_msg.size()>0) {
+    plumed_merror("Error in keyword BIAS of "+getName()+": "+error_msg);
+  }
 
   for(unsigned int i=0; i<bias_pntrs.size(); i++) {
     if(bias_pntrs[i]->numberOfCoeffsSets()>1) {
diff --git a/src/ves/OutputTargetDistribution.cpp b/src/ves/OutputTargetDistribution.cpp
index 8fced37e8e..e7d3286b8c 100644
--- a/src/ves/OutputTargetDistribution.cpp
+++ b/src/ves/OutputTargetDistribution.cpp
@@ -79,8 +79,7 @@ plumed driver --plumed plumed.dat --igro configuration.gro
 
 
 class OutputTargetDistribution :
-  public Action
-{
+  public Action {
 public:
   explicit OutputTargetDistribution(const ActionOptions&);
   void calculate() override {}
@@ -105,8 +104,7 @@ void OutputTargetDistribution::registerKeywords(Keywords& keys) {
 }
 
 OutputTargetDistribution::OutputTargetDistribution(const ActionOptions&ao):
-  Action(ao)
-{
+  Action(ao) {
 
   std::string targetdist_fname;
   parse("TARGETDIST_FILE",targetdist_fname);
@@ -127,7 +125,9 @@ OutputTargetDistribution::OutputTargetDistribution(const ActionOptions&ao):
 
   std::vector<std::string> grid_periodicity(nargs);
   parseVector("GRID_PERIODICITY",grid_periodicity);
-  if(grid_periodicity.size()==0) {grid_periodicity.assign(nargs,"NO");}
+  if(grid_periodicity.size()==0) {
+    grid_periodicity.assign(nargs,"NO");
+  }
 
   std::string fmt_grids="%14.9f";
   parse("FMT_GRIDS",fmt_grids);
@@ -148,23 +148,26 @@ OutputTargetDistribution::OutputTargetDistribution(const ActionOptions&ao):
   //
   std::vector<std::unique_ptr<Value>> arguments(nargs);
   for(unsigned int i=0; i < nargs; i++) {
-    std::string is; Tools::convert(i+1,is);
-    if(nargs==1) {is="";}
+    std::string is;
+    Tools::convert(i+1,is);
+    if(nargs==1) {
+      is="";
+    }
     arguments[i]= Tools::make_unique<Value>(nullptr,"arg"+is,false);
     if(grid_periodicity[i]=="YES") {
       arguments[i]->setDomain(grid_min[i],grid_max[i]);
-    }
-    else if(grid_periodicity[i]=="NO") {
+    } else if(grid_periodicity[i]=="NO") {
       arguments[i]->setNotPeriodic();
-    }
-    else {
+    } else {
       plumed_merror("wrong value given in GRID_PERIODICITY, either specify YES or NO");
     }
   }
 
   std::string error_msg = "";
   TargetDistribution* targetdist_pntr = VesTools::getPointerFromLabel<TargetDistribution*>(targetdist_label,plumed.getActionSet(),error_msg);
-  if(error_msg.size()>0) {plumed_merror("Error in keyword TARGET_DISTRIBUTION of "+getName()+": "+error_msg);}
+  if(error_msg.size()>0) {
+    plumed_merror("Error in keyword TARGET_DISTRIBUTION of "+getName()+": "+error_msg);
+  }
   //
   if(targetdist_pntr->isDynamic()) {
     plumed_merror(getName() + " only works for static target distributions");
diff --git a/src/ves/TD_Chi.cpp b/src/ves/TD_Chi.cpp
index c28b515141..679f02fa26 100644
--- a/src/ves/TD_Chi.cpp
+++ b/src/ves/TD_Chi.cpp
@@ -107,28 +107,39 @@ TD_Chi::TD_Chi(const ActionOptions& ao):
   minima_(0),
   sigma_(0),
   kappa_(0),
-  normalization_(0)
-{
+  normalization_(0) {
   parseVector("MINIMUM",minima_);
   parseVector("SIGMA",sigma_);
   for(unsigned int k=0; k<sigma_.size(); k++) {
-    if(sigma_[k] < 0.0) {plumed_merror(getName()+": the value given in SIGMA should be positive.");}
+    if(sigma_[k] < 0.0) {
+      plumed_merror(getName()+": the value given in SIGMA should be positive.");
+    }
   }
 
 
   std::vector<unsigned int> kappa_int(0);
   parseVector("KAPPA",kappa_int);
-  if(kappa_int.size()==0) {plumed_merror(getName()+": some problem with KAPPA keyword, should given as positive integer larger than 1");}
+  if(kappa_int.size()==0) {
+    plumed_merror(getName()+": some problem with KAPPA keyword, should given as positive integer larger than 1");
+  }
   kappa_.resize(kappa_int.size());
   for(unsigned int k=0; k<kappa_int.size(); k++) {
-    if(kappa_int[k] < 1) {plumed_merror(getName()+": KAPPA should be an integer 1 or higher");}
+    if(kappa_int[k] < 1) {
+      plumed_merror(getName()+": KAPPA should be an integer 1 or higher");
+    }
     kappa_[k] = static_cast<double>(kappa_int[k]);
   }
 
   setDimension(minima_.size());
-  if(getDimension()>1) {plumed_merror(getName()+": only defined for one dimension, for multiple dimensions it should be used in combination with the TD_PRODUCT_DISTRIBUTION action.");}
-  if(sigma_.size()!=getDimension()) {plumed_merror(getName()+": the SIGMA keyword does not match the given dimension in MINIMUM");}
-  if(kappa_.size()!=getDimension()) {plumed_merror(getName()+": the KAPPA keyword does not match the given dimension in MINIMUM");}
+  if(getDimension()>1) {
+    plumed_merror(getName()+": only defined for one dimension, for multiple dimensions it should be used in combination with the TD_PRODUCT_DISTRIBUTION action.");
+  }
+  if(sigma_.size()!=getDimension()) {
+    plumed_merror(getName()+": the SIGMA keyword does not match the given dimension in MINIMUM");
+  }
+  if(kappa_.size()!=getDimension()) {
+    plumed_merror(getName()+": the KAPPA keyword does not match the given dimension in MINIMUM");
+  }
 
   normalization_.resize(getDimension());
   for(unsigned int k=0; k<getDimension(); k++) {
@@ -142,7 +153,9 @@ double TD_Chi::getValue(const std::vector<double>& argument) const {
   double value = 1.0;
   for(unsigned int k=0; k<argument.size(); k++) {
     double arg=(argument[k]-minima_[k])/sigma_[k];
-    if(arg<0.0) {plumed_merror(getName()+": the chi distribution is not defined for values less that ones given in MINIMUM");}
+    if(arg<0.0) {
+      plumed_merror(getName()+": the chi distribution is not defined for values less that ones given in MINIMUM");
+    }
     value *= normalization_[k] * pow(arg,kappa_[k]-1.0) * exp(-0.5*arg*arg);
   }
   return value;
diff --git a/src/ves/TD_ChiSquared.cpp b/src/ves/TD_ChiSquared.cpp
index 4f21902f1f..063d1b9030 100644
--- a/src/ves/TD_ChiSquared.cpp
+++ b/src/ves/TD_ChiSquared.cpp
@@ -107,27 +107,38 @@ TD_ChiSquared::TD_ChiSquared(const ActionOptions& ao):
   minima_(0),
   sigma_(0),
   kappa_(0),
-  normalization_(0)
-{
+  normalization_(0) {
   parseVector("MINIMUM",minima_);
   parseVector("SIGMA",sigma_);
   for(unsigned int k=0; k<sigma_.size(); k++) {
-    if(sigma_[k] < 0.0) {plumed_merror(getName()+": the value given in SIGMA should be positive.");}
+    if(sigma_[k] < 0.0) {
+      plumed_merror(getName()+": the value given in SIGMA should be positive.");
+    }
   }
 
   std::vector<unsigned int> kappa_int(0);
   parseVector("KAPPA",kappa_int);
-  if(kappa_int.size()==0) {plumed_merror(getName()+": some problem with KAPPA keyword, should given as positive integer larger than 2");}
+  if(kappa_int.size()==0) {
+    plumed_merror(getName()+": some problem with KAPPA keyword, should given as positive integer larger than 2");
+  }
   kappa_.resize(kappa_int.size());
   for(unsigned int k=0; k<kappa_int.size(); k++) {
-    if(kappa_int[k] < 2) {plumed_merror(getName()+": KAPPA should be an integer 2 or higher");}
+    if(kappa_int[k] < 2) {
+      plumed_merror(getName()+": KAPPA should be an integer 2 or higher");
+    }
     kappa_[k] = static_cast<double>(kappa_int[k]);
   }
 
   setDimension(minima_.size());
-  if(getDimension()>1) {plumed_merror(getName()+": only defined for one dimension, for multiple dimensions it should be used in combination with the TD_PRODUCT_DISTRIBUTION action.");}
-  if(sigma_.size()!=getDimension()) {plumed_merror(getName()+": the SIGMA keyword does not match the given dimension in MINIMUM");}
-  if(kappa_.size()!=getDimension()) {plumed_merror(getName()+": the KAPPA keyword does not match the given dimension in MINIMUM");}
+  if(getDimension()>1) {
+    plumed_merror(getName()+": only defined for one dimension, for multiple dimensions it should be used in combination with the TD_PRODUCT_DISTRIBUTION action.");
+  }
+  if(sigma_.size()!=getDimension()) {
+    plumed_merror(getName()+": the SIGMA keyword does not match the given dimension in MINIMUM");
+  }
+  if(kappa_.size()!=getDimension()) {
+    plumed_merror(getName()+": the KAPPA keyword does not match the given dimension in MINIMUM");
+  }
 
   normalization_.resize(getDimension());
   for(unsigned int k=0; k<getDimension(); k++) {
@@ -141,7 +152,9 @@ double TD_ChiSquared::getValue(const std::vector<double>& argument) const {
   double value = 1.0;
   for(unsigned int k=0; k<argument.size(); k++) {
     double arg=(argument[k]-minima_[k])/sigma_[k];
-    if(arg<0.0) {plumed_merror(getName()+": the chi-squared istribution is not defined for values less that ones given in MINIMUM");}
+    if(arg<0.0) {
+      plumed_merror(getName()+": the chi-squared istribution is not defined for values less that ones given in MINIMUM");
+    }
     value *= normalization_[k] * pow(arg,0.5*kappa_[k]-1.0) * exp(-0.5*arg);
   }
   return value;
diff --git a/src/ves/TD_Custom.cpp b/src/ves/TD_Custom.cpp
index d71d72193b..337fb7fb1f 100644
--- a/src/ves/TD_Custom.cpp
+++ b/src/ves/TD_Custom.cpp
@@ -172,8 +172,7 @@ TD_Custom::TD_Custom(const ActionOptions& ao):
 //
   use_fes_(false),
   use_kbt_(false),
-  use_beta_(false)
-{
+  use_beta_(false) {
   std::string func_str;
   parse("FUNCTION",func_str);
   checkRead();
@@ -182,8 +181,7 @@ TD_Custom::TD_Custom(const ActionOptions& ao):
     lepton::ParsedExpression pe=lepton::Parser::parse(func_str).optimize(lepton::Constants());
     log<<"  function as parsed by lepton: "<<pe<<"\n";
     expression=pe.createCompiledExpression();
-  }
-  catch(PLMD::lepton::Exception& exc) {
+  } catch(PLMD::lepton::Exception& exc) {
     plumed_merror("There was some problem in parsing the function "+func_str+" given in FUNCTION with lepton");
   }
 
@@ -192,19 +190,15 @@ TD_Custom::TD_Custom(const ActionOptions& ao):
     unsigned int cv_idx;
     if(curr_var.substr(0,cv_var_prefix_str_.size())==cv_var_prefix_str_ && Tools::convertNoexcept(curr_var.substr(cv_var_prefix_str_.size()),cv_idx) && cv_idx>0) {
       cv_var_idx_.push_back(cv_idx-1);
-    }
-    else if(curr_var==fes_var_str_) {
+    } else if(curr_var==fes_var_str_) {
       use_fes_=true;
       setDynamic();
       setFesGridNeeded();
-    }
-    else if(curr_var==kbt_var_str_) {
+    } else if(curr_var==kbt_var_str_) {
       use_kbt_=true;
-    }
-    else if(curr_var==beta_var_str_) {
+    } else if(curr_var==beta_var_str_) {
       use_beta_=true;
-    }
-    else {
+    } else {
       plumed_merror(getName()+": problem with parsing formula with lepton, cannot recognise the variable "+curr_var);
     }
   }
@@ -213,7 +207,8 @@ TD_Custom::TD_Custom(const ActionOptions& ao):
   cv_var_str_.resize(cv_var_idx_.size());
   cv_var_lepton_refs_.resize(cv_var_str_.size());
   for(unsigned int j=0; j<cv_var_idx_.size(); j++) {
-    std::string str1; Tools::convert(cv_var_idx_[j]+1,str1);
+    std::string str1;
+    Tools::convert(cv_var_idx_[j]+1,str1);
     cv_var_str_[j] = cv_var_prefix_str_+str1;
     try {
       cv_var_lepton_refs_[j] = &expression.getVariableReference(cv_var_str_[j]);
@@ -257,10 +252,14 @@ void TD_Custom::updateGrid() {
     plumed_massert(getFesGridPntr()!=NULL,"the FES grid has to be linked to the free energy in the target distribution");
   }
   if(use_kbt_) {
-    if(kbt_var_lepton_ref_) {*kbt_var_lepton_ref_= 1.0/getBeta();}
+    if(kbt_var_lepton_ref_) {
+      *kbt_var_lepton_ref_= 1.0/getBeta();
+    }
   }
   if(use_beta_) {
-    if(beta_var_lepton_ref_) {*beta_var_lepton_ref_= getBeta();}
+    if(beta_var_lepton_ref_) {
+      *beta_var_lepton_ref_= getBeta();
+    }
   }
   //
   std::vector<double> integration_weights = GridIntegrationWeights::getIntegrationWeights(getTargetDistGridPntr());
@@ -269,22 +268,27 @@ void TD_Custom::updateGrid() {
   for(Grid::index_t l=0; l<targetDistGrid().getSize(); l++) {
     std::vector<double> point = targetDistGrid().getPoint(l);
     for(unsigned int k=0; k<cv_var_str_.size() ; k++) {
-      if(cv_var_lepton_refs_[k]) {*cv_var_lepton_refs_[k] = point[cv_var_idx_[k]];}
+      if(cv_var_lepton_refs_[k]) {
+        *cv_var_lepton_refs_[k] = point[cv_var_idx_[k]];
+      }
     }
     if(use_fes_) {
-      if(fes_var_lepton_ref_) {*fes_var_lepton_ref_ = getFesGridPntr()->getValue(l);}
+      if(fes_var_lepton_ref_) {
+        *fes_var_lepton_ref_ = getFesGridPntr()->getValue(l);
+      }
     }
     double value = expression.evaluate();
 
-    if(value<0.0 && !isTargetDistGridShiftedToZero()) {plumed_merror(getName()+": The target distribution function gives negative values. You should change the definition of the function used for the target distribution to avoid this. You can also use the SHIFT_TO_ZERO keyword to avoid this problem.");}
+    if(value<0.0 && !isTargetDistGridShiftedToZero()) {
+      plumed_merror(getName()+": The target distribution function gives negative values. You should change the definition of the function used for the target distribution to avoid this. You can also use the SHIFT_TO_ZERO keyword to avoid this problem.");
+    }
     targetDistGrid().setValue(l,value);
     norm += integration_weights[l]*value;
     logTargetDistGrid().setValue(l,-std::log(value));
   }
   if(norm>0.0) {
     targetDistGrid().scaleAllValuesAndDerivatives(1.0/norm);
-  }
-  else if(!isTargetDistGridShiftedToZero()) {
+  } else if(!isTargetDistGridShiftedToZero()) {
     plumed_merror(getName()+": The target distribution function cannot be normalized proberly. You should change the definition of the function used for the target distribution to avoid this. You can also use the SHIFT_TO_ZERO keyword to avoid this problem.");
   }
   logTargetDistGrid().setMinToZero();
diff --git a/src/ves/TD_Exponential.cpp b/src/ves/TD_Exponential.cpp
index e3b1f5107a..58920949d6 100644
--- a/src/ves/TD_Exponential.cpp
+++ b/src/ves/TD_Exponential.cpp
@@ -97,18 +97,23 @@ void TD_Exponential::registerKeywords(Keywords& keys) {
 TD_Exponential::TD_Exponential(const ActionOptions& ao):
   PLUMED_VES_TARGETDISTRIBUTION_INIT(ao),
   minima_(0),
-  lambda_(0)
-{
+  lambda_(0) {
   parseVector("MINIMUM",minima_);
   parseVector("LAMBDA",lambda_);
   for(unsigned int k=0; k<lambda_.size(); k++) {
-    if(lambda_[k] < 0.0) {plumed_merror(getName()+": the value given in LAMBDA should be positive.");}
+    if(lambda_[k] < 0.0) {
+      plumed_merror(getName()+": the value given in LAMBDA should be positive.");
+    }
   }
 
 
   setDimension(minima_.size());
-  if(getDimension()>1) {plumed_merror(getName()+": only defined for one dimension, for multiple dimensions it should be used in combination with the TD_PRODUCT_DISTRIBUTION action.");}
-  if(lambda_.size()!=getDimension()) {plumed_merror(getName()+": the LAMBDA keyword does not match the given dimension in MINIMUM");}
+  if(getDimension()>1) {
+    plumed_merror(getName()+": only defined for one dimension, for multiple dimensions it should be used in combination with the TD_PRODUCT_DISTRIBUTION action.");
+  }
+  if(lambda_.size()!=getDimension()) {
+    plumed_merror(getName()+": the LAMBDA keyword does not match the given dimension in MINIMUM");
+  }
   checkRead();
 }
 
@@ -117,7 +122,9 @@ double TD_Exponential::getValue(const std::vector<double>& argument) const {
   double value = 1.0;
   for(unsigned int k=0; k<argument.size(); k++) {
     double arg = (argument[k]-minima_[k])*lambda_[k];
-    if(arg<0.0) {plumed_merror(getName()+": the exponential distribution is not defined for values less that ones given in MINIMUM");}
+    if(arg<0.0) {
+      plumed_merror(getName()+": the exponential distribution is not defined for values less that ones given in MINIMUM");
+    }
     value *= lambda_[k]*exp(-arg);
   }
   return value;
diff --git a/src/ves/TD_ExponentiallyModifiedGaussian.cpp b/src/ves/TD_ExponentiallyModifiedGaussian.cpp
index d6cdf455ca..3921c15be1 100644
--- a/src/ves/TD_ExponentiallyModifiedGaussian.cpp
+++ b/src/ves/TD_ExponentiallyModifiedGaussian.cpp
@@ -137,26 +137,35 @@ TD_ExponentiallyModifiedGaussian::TD_ExponentiallyModifiedGaussian(const ActionO
   sigmas_(0),
   lambdas_(0),
   weights_(0),
-  ncenters_(0)
-{
+  ncenters_(0) {
   for(unsigned int i=1;; i++) {
     std::vector<double> tmp_center;
-    if(!parseNumberedVector("CENTER",i,tmp_center) ) {break;}
+    if(!parseNumberedVector("CENTER",i,tmp_center) ) {
+      break;
+    }
     centers_.push_back(tmp_center);
   }
   for(unsigned int i=1;; i++) {
     std::vector<double> tmp_sigma;
-    if(!parseNumberedVector("SIGMA",i,tmp_sigma) ) {break;}
+    if(!parseNumberedVector("SIGMA",i,tmp_sigma) ) {
+      break;
+    }
     for(unsigned int k=0; k<tmp_sigma.size(); k++) {
-      if(tmp_sigma[k]<=0.0) {plumed_merror(getName()+": the values given in SIGMA should be positive");}
+      if(tmp_sigma[k]<=0.0) {
+        plumed_merror(getName()+": the values given in SIGMA should be positive");
+      }
     }
     sigmas_.push_back(tmp_sigma);
   }
   for(unsigned int i=1;; i++) {
     std::vector<double> tmp_lambda;
-    if(!parseNumberedVector("LAMBDA",i,tmp_lambda) ) {break;}
+    if(!parseNumberedVector("LAMBDA",i,tmp_lambda) ) {
+      break;
+    }
     for(unsigned int k=0; k<tmp_lambda.size(); k++) {
-      if(tmp_lambda[k]<=0.0) {plumed_merror(getName()+": the values given in LAMBDA should be positive");}
+      if(tmp_lambda[k]<=0.0) {
+        plumed_merror(getName()+": the values given in LAMBDA should be positive");
+      }
     }
     lambdas_.push_back(tmp_lambda);
   }
@@ -186,14 +195,20 @@ TD_ExponentiallyModifiedGaussian::TD_ExponentiallyModifiedGaussian(const ActionO
   }
   //
   parseVector("WEIGHTS",weights_);
-  if(weights_.size()==0) {weights_.assign(centers_.size(),1.0);}
+  if(weights_.size()==0) {
+    weights_.assign(centers_.size(),1.0);
+  }
   if(centers_.size()!=weights_.size()) {
     plumed_merror(getName()+": there has to be as many weights given in WEIGHTS as numbered CENTER keywords");
   }
   //
   double sum_weights=0.0;
-  for(unsigned int i=0; i<weights_.size(); i++) {sum_weights+=weights_[i];}
-  for(unsigned int i=0; i<weights_.size(); i++) {weights_[i]/=sum_weights;}
+  for(unsigned int i=0; i<weights_.size(); i++) {
+    sum_weights+=weights_[i];
+  }
+  for(unsigned int i=0; i<weights_.size(); i++) {
+    weights_[i]/=sum_weights;
+  }
   //
   checkRead();
 }
diff --git a/src/ves/TD_Gaussian.cpp b/src/ves/TD_Gaussian.cpp
index a54084d85d..3e8251be2a 100644
--- a/src/ves/TD_Gaussian.cpp
+++ b/src/ves/TD_Gaussian.cpp
@@ -195,16 +195,19 @@ TD_Gaussian::TD_Gaussian(const ActionOptions& ao):
   correlation_(0),
   weights_(0),
   diagonal_(true),
-  ncenters_(0)
-{
+  ncenters_(0) {
   for(unsigned int i=1;; i++) {
     std::vector<double> tmp_center;
-    if(!parseNumberedVector("CENTER",i,tmp_center) ) {break;}
+    if(!parseNumberedVector("CENTER",i,tmp_center) ) {
+      break;
+    }
     centers_.push_back(tmp_center);
   }
   for(unsigned int i=1;; i++) {
     std::vector<double> tmp_sigma;
-    if(!parseNumberedVector("SIGMA",i,tmp_sigma) ) {break;}
+    if(!parseNumberedVector("SIGMA",i,tmp_sigma) ) {
+      break;
+    }
     sigmas_.push_back(tmp_sigma);
   }
 
@@ -235,8 +238,7 @@ TD_Gaussian::TD_Gaussian(const ActionOptions& ao):
     parseNumberedVector("CORRELATION",(i+1),corr);
     if(corr.size()>0) {
       diagonal_ = false;
-    }
-    else {
+    } else {
       corr.assign(1,0.0);
     }
     correlation_[i] = corr;
@@ -257,14 +259,20 @@ TD_Gaussian::TD_Gaussian(const ActionOptions& ao):
   }
   //
   parseVector("WEIGHTS",weights_);
-  if(weights_.size()==0) {weights_.assign(centers_.size(),1.0);}
+  if(weights_.size()==0) {
+    weights_.assign(centers_.size(),1.0);
+  }
   if(centers_.size()!=weights_.size()) {
     plumed_merror(getName()+": there has to be as many weights given in WEIGHTS as numbered CENTER keywords");
   }
   //
   double sum_weights=0.0;
-  for(unsigned int i=0; i<weights_.size(); i++) {sum_weights+=weights_[i];}
-  for(unsigned int i=0; i<weights_.size(); i++) {weights_[i]/=sum_weights;}
+  for(unsigned int i=0; i<weights_.size(); i++) {
+    sum_weights+=weights_[i];
+  }
+  for(unsigned int i=0; i<weights_.size(); i++) {
+    weights_[i]/=sum_weights;
+  }
   //
   checkRead();
 }
@@ -276,8 +284,7 @@ double TD_Gaussian::getValue(const std::vector<double>& argument) const {
     for(unsigned int i=0; i<ncenters_; i++) {
       value+=weights_[i]*GaussianDiagonal(argument, centers_[i], sigmas_[i]);
     }
-  }
-  else if(!diagonal_ && getDimension()==2) {
+  } else if(!diagonal_ && getDimension()==2) {
     for(unsigned int i=0; i<ncenters_; i++) {
       value+=weights_[i]*Gaussian2D(argument, centers_[i], sigmas_[i],correlation_[i]);
     }
@@ -291,7 +298,9 @@ double TD_Gaussian::GaussianDiagonal(const std::vector<double>& argument, const
   for(unsigned int k=0; k<argument.size(); k++) {
     double arg=(argument[k]-center[k])/sigma[k];
     double tmp_exp = exp(-0.5*arg*arg);
-    if(normalize) {tmp_exp/=(sigma[k]*sqrt(2.0*pi));}
+    if(normalize) {
+      tmp_exp/=(sigma[k]*sqrt(2.0*pi));
+    }
     value*=tmp_exp;
   }
   return value;
diff --git a/src/ves/TD_GeneralizedExtremeValue.cpp b/src/ves/TD_GeneralizedExtremeValue.cpp
index db48ac4f65..0c6857557e 100644
--- a/src/ves/TD_GeneralizedExtremeValue.cpp
+++ b/src/ves/TD_GeneralizedExtremeValue.cpp
@@ -128,20 +128,27 @@ TD_GeneralizedExtremeValue::TD_GeneralizedExtremeValue(const ActionOptions& ao):
   center_(0),
   scale_(0),
   shape_(0),
-  normalization_(0)
-{
+  normalization_(0) {
   parseVector("LOCATION",center_);
   parseVector("SCALE",scale_);
   parseVector("SHAPE",shape_);
 
   setDimension(center_.size());
-  if(getDimension()>1) {plumed_merror(getName()+": only defined for one dimension, for multiple dimensions it should be used in combination with the TD_PRODUCT_DISTRIBUTION action.");}
-  if(scale_.size()!=getDimension()) {plumed_merror(getName()+": the SCALE keyword does not match the given dimension in MINIMA");}
-  if(shape_.size()!=getDimension()) {plumed_merror(getName()+": the SHAPE keyword does not match the given dimension in MINIMA");}
+  if(getDimension()>1) {
+    plumed_merror(getName()+": only defined for one dimension, for multiple dimensions it should be used in combination with the TD_PRODUCT_DISTRIBUTION action.");
+  }
+  if(scale_.size()!=getDimension()) {
+    plumed_merror(getName()+": the SCALE keyword does not match the given dimension in MINIMA");
+  }
+  if(shape_.size()!=getDimension()) {
+    plumed_merror(getName()+": the SHAPE keyword does not match the given dimension in MINIMA");
+  }
 
   normalization_.resize(getDimension());
   for(unsigned int k=0; k<getDimension(); k++) {
-    if(scale_[k]<0.0) {plumed_merror(getName()+": the value given for the scale parameter in SCALE should be larger than 0.0");}
+    if(scale_[k]<0.0) {
+      plumed_merror(getName()+": the value given for the scale parameter in SCALE should be larger than 0.0");
+    }
     normalization_[k] = 1.0/scale_[k];
   }
   checkRead();
@@ -159,11 +166,14 @@ double TD_GeneralizedExtremeValue::GEVdiagonal(const std::vector<double>& argume
     double arg=(argument[k]-center[k])/scale[k];
     double tx;
     if(shape_[k]!=0.0) {
-      if( shape_[k]>0 && argument[k] <= (center[k]-scale[k]/shape[k]) ) {return 0.0;}
-      if( shape_[k]<0 && argument[k] > (center[k]-scale[k]/shape[k]) ) {return 0.0;}
+      if( shape_[k]>0 && argument[k] <= (center[k]-scale[k]/shape[k]) ) {
+        return 0.0;
+      }
+      if( shape_[k]<0 && argument[k] > (center[k]-scale[k]/shape[k]) ) {
+        return 0.0;
+      }
       tx = pow( (1.0+arg*shape[k]), -1.0/shape[k] );
-    }
-    else {
+    } else {
       tx = exp(-arg);
     }
     value *= normalization[k] * pow(tx,shape[k]+1.0) * exp(-tx);
diff --git a/src/ves/TD_GeneralizedNormal.cpp b/src/ves/TD_GeneralizedNormal.cpp
index 29925c27ab..3b373e3dda 100644
--- a/src/ves/TD_GeneralizedNormal.cpp
+++ b/src/ves/TD_GeneralizedNormal.cpp
@@ -133,26 +133,35 @@ TD_GeneralizedNormal::TD_GeneralizedNormal(const ActionOptions& ao):
   betas_(0),
   normalization_(0),
   weights_(0),
-  ncenters_(0)
-{
+  ncenters_(0) {
   for(unsigned int i=1;; i++) {
     std::vector<double> tmp_center;
-    if(!parseNumberedVector("CENTER",i,tmp_center) ) {break;}
+    if(!parseNumberedVector("CENTER",i,tmp_center) ) {
+      break;
+    }
     centers_.push_back(tmp_center);
   }
   for(unsigned int i=1;; i++) {
     std::vector<double> tmp_alpha;
-    if(!parseNumberedVector("ALPHA",i,tmp_alpha) ) {break;}
+    if(!parseNumberedVector("ALPHA",i,tmp_alpha) ) {
+      break;
+    }
     for(unsigned int k=0; k<tmp_alpha.size(); k++) {
-      if(tmp_alpha[k]<=0.0) {plumed_merror(getName()+": the values given in ALPHA should be positive");}
+      if(tmp_alpha[k]<=0.0) {
+        plumed_merror(getName()+": the values given in ALPHA should be positive");
+      }
     }
     alphas_.push_back(tmp_alpha);
   }
   for(unsigned int i=1;; i++) {
     std::vector<double> tmp_beta;
-    if(!parseNumberedVector("BETA",i,tmp_beta) ) {break;}
+    if(!parseNumberedVector("BETA",i,tmp_beta) ) {
+      break;
+    }
     for(unsigned int k=0; k<tmp_beta.size(); k++) {
-      if(tmp_beta[k]<=0.0) {plumed_merror(getName()+": the values given in BETA should be positive");}
+      if(tmp_beta[k]<=0.0) {
+        plumed_merror(getName()+": the values given in BETA should be positive");
+      }
     }
     betas_.push_back(tmp_beta);
   }
@@ -182,14 +191,20 @@ TD_GeneralizedNormal::TD_GeneralizedNormal(const ActionOptions& ao):
   }
   //
   parseVector("WEIGHTS",weights_);
-  if(weights_.size()==0) {weights_.assign(centers_.size(),1.0);}
+  if(weights_.size()==0) {
+    weights_.assign(centers_.size(),1.0);
+  }
   if(centers_.size()!=weights_.size()) {
     plumed_merror(getName()+": there has to be as many weights given in WEIGHTS as numbered CENTER keywords");
   }
   //
   double sum_weights=0.0;
-  for(unsigned int i=0; i<weights_.size(); i++) {sum_weights+=weights_[i];}
-  for(unsigned int i=0; i<weights_.size(); i++) {weights_[i]/=sum_weights;}
+  for(unsigned int i=0; i<weights_.size(); i++) {
+    sum_weights+=weights_[i];
+  }
+  for(unsigned int i=0; i<weights_.size(); i++) {
+    weights_[i]/=sum_weights;
+  }
   //
   normalization_.resize(ncenters_);
   for(unsigned int i=0; i<ncenters_; i++) {
diff --git a/src/ves/TD_Grid.cpp b/src/ves/TD_Grid.cpp
index 82d73cf073..b6f86691e9 100644
--- a/src/ves/TD_Grid.cpp
+++ b/src/ves/TD_Grid.cpp
@@ -132,20 +132,25 @@ TD_Grid::TD_Grid(const ActionOptions& ao):
   minima_(0),
   maxima_(0),
   zero_outside_(false),
-  shift_(0.0)
-{
+  shift_(0.0) {
   std::string filename;
   parse("FILE",filename);
   parse("SHIFT",shift_);
   if(shift_!=0.0) {
-    if(isTargetDistGridShiftedToZero()) {plumed_merror(getName() + ": using both SHIFT and SHIFT_TO_ZERO is not allowed.");}
+    if(isTargetDistGridShiftedToZero()) {
+      plumed_merror(getName() + ": using both SHIFT and SHIFT_TO_ZERO is not allowed.");
+    }
   }
   parseFlag("ZERO_OUTSIDE",zero_outside_);
 
   bool do_not_normalize=false;
   parseFlag("DO_NOT_NORMALIZE",do_not_normalize);
-  if(do_not_normalize && shift_!=0.0) {plumed_merror(getName() + ": using both SHIFT and DO_NOT_NORMALIZE is not allowed.");}
-  if(!do_not_normalize) {setForcedNormalization();}
+  if(do_not_normalize && shift_!=0.0) {
+    plumed_merror(getName() + ": using both SHIFT and DO_NOT_NORMALIZE is not allowed.");
+  }
+  if(!do_not_normalize) {
+    setForcedNormalization();
+  }
 
   checkRead();
 
@@ -167,17 +172,16 @@ TD_Grid::TD_Grid(const ActionOptions& ao):
     arguments[i]= Tools::make_unique<Value>(nullptr,arglabels[i],false);
     if(argperiodic[i]) {
       arguments[i]->setDomain(argmin[i],argmax[i]);
-    }
-    else {
+    } else {
       arguments[i]->setNotPeriodic();
     }
   }
 
-  IFile gridfile; gridfile.open(filename);
+  IFile gridfile;
+  gridfile.open(filename);
   if(has_deriv) {
     distGrid_=GridBase::create(gridlabel,Tools::unique2raw(arguments),gridfile,false,true,true);
-  }
-  else {
+  } else {
     distGrid_=GridBase::create(gridlabel,Tools::unique2raw(arguments),gridfile,false,false,false);
   }
   gridfile.close();
@@ -190,7 +194,9 @@ TD_Grid::TD_Grid(const ActionOptions& ao):
     Tools::convert(distGrid_->getMin()[i],minima_[i]);
     Tools::convert(distGrid_->getMax()[i],maxima_[i]);
     periodic_[i] = argperiodic[i];
-    if(periodic_[i]) {maxima_[i]-=distGrid_->getDx()[i];}
+    if(periodic_[i]) {
+      maxima_[i]-=distGrid_->getDx()[i];
+    }
   }
 
 }
@@ -202,11 +208,9 @@ double TD_Grid::getValue(const std::vector<double>& argument) const {
   for(unsigned int k=0; k<getDimension(); k++) {
     if(zero_outside_ && (argument[k] < minima_[k] || argument[k] > maxima_[k])) {
       return outside;
-    }
-    else if(argument[k] < minima_[k]) {
+    } else if(argument[k] < minima_[k]) {
       arg[k] = minima_[k];
-    }
-    else if(argument[k] > maxima_[k]) {
+    } else if(argument[k] > maxima_[k]) {
       arg[k] =maxima_[k];
     }
   }
diff --git a/src/ves/TD_LinearCombination.cpp b/src/ves/TD_LinearCombination.cpp
index 3ba559433f..d9072f5add 100644
--- a/src/ves/TD_LinearCombination.cpp
+++ b/src/ves/TD_LinearCombination.cpp
@@ -166,35 +166,52 @@ TD_LinearCombination::TD_LinearCombination(const ActionOptions& ao):
   distribution_pntrs_(0),
   grid_pntrs_(0),
   weights_(0),
-  ndist_(0)
-{
+  ndist_(0) {
   std::vector<std::string> targetdist_labels;
   parseVector("DISTRIBUTIONS",targetdist_labels);
 
   std::string error_msg = "";
   distribution_pntrs_ = VesTools::getPointersFromLabels<TargetDistribution*>(targetdist_labels,plumed.getActionSet(),error_msg);
-  if(error_msg.size()>0) {plumed_merror("Error in keyword DISTRIBUTIONS of "+getName()+": "+error_msg);}
+  if(error_msg.size()>0) {
+    plumed_merror("Error in keyword DISTRIBUTIONS of "+getName()+": "+error_msg);
+  }
 
   for(unsigned int i=0; i<distribution_pntrs_.size(); i++) {
-    if(distribution_pntrs_[i]->isDynamic()) {setDynamic();}
-    if(distribution_pntrs_[i]->fesGridNeeded()) {setFesGridNeeded();}
-    if(distribution_pntrs_[i]->biasGridNeeded()) {setBiasGridNeeded();}
+    if(distribution_pntrs_[i]->isDynamic()) {
+      setDynamic();
+    }
+    if(distribution_pntrs_[i]->fesGridNeeded()) {
+      setFesGridNeeded();
+    }
+    if(distribution_pntrs_[i]->biasGridNeeded()) {
+      setBiasGridNeeded();
+    }
   }
 
   ndist_ = distribution_pntrs_.size();
   grid_pntrs_.assign(ndist_,NULL);
-  if(ndist_==0) {plumed_merror(getName()+ ": no distributions are given.");}
-  if(ndist_==1) {plumed_merror(getName()+ ": giving only one distribution does not make sense.");}
+  if(ndist_==0) {
+    plumed_merror(getName()+ ": no distributions are given.");
+  }
+  if(ndist_==1) {
+    plumed_merror(getName()+ ": giving only one distribution does not make sense.");
+  }
   //
   parseVector("WEIGHTS",weights_);
-  if(weights_.size()==0) {weights_.assign(distribution_pntrs_.size(),1.0);}
+  if(weights_.size()==0) {
+    weights_.assign(distribution_pntrs_.size(),1.0);
+  }
   if(distribution_pntrs_.size()!=weights_.size()) {
     plumed_merror(getName()+ ": there has to be as many weights given in WEIGHTS as the number of target distribution labels given in DISTRIBUTIONS");
   }
   //
   double sum_weights=0.0;
-  for(unsigned int i=0; i<weights_.size(); i++) {sum_weights+=weights_[i];}
-  for(unsigned int i=0; i<weights_.size(); i++) {weights_[i]/=sum_weights;}
+  for(unsigned int i=0; i<weights_.size(); i++) {
+    sum_weights+=weights_[i];
+  }
+  for(unsigned int i=0; i<weights_.size(); i++) {
+    weights_[i]/=sum_weights;
+  }
   checkRead();
 }
 
@@ -225,7 +242,9 @@ void TD_LinearCombination::updateGrid() {
     for(unsigned int i=0; i<ndist_; i++) {
       value += weights_[i]*grid_pntrs_[i]->getValue(l);
     }
-    if(value==0.0) value=std::numeric_limits<double>::denorm_min();
+    if(value==0.0) {
+      value=std::numeric_limits<double>::denorm_min();
+    }
     targetDistGrid().setValue(l,value);
     logTargetDistGrid().setValue(l,-std::log(value));
   }
diff --git a/src/ves/TD_Multicanonical.cpp b/src/ves/TD_Multicanonical.cpp
index 823e2d37a1..bce46dcbd5 100644
--- a/src/ves/TD_Multicanonical.cpp
+++ b/src/ves/TD_Multicanonical.cpp
@@ -178,8 +178,7 @@ TD_Multicanonical::TD_Multicanonical(const ActionOptions& ao):
   sigma_(0.0),
   steps_temp_(20),
   epsilon_(10.0),
-  smoothening_(true)
-{
+  smoothening_(true) {
   log.printf("  Multicanonical target distribution");
   log.printf("\n");
   log.printf("  Please read and cite ");
@@ -197,11 +196,17 @@ TD_Multicanonical::TD_Multicanonical(const ActionOptions& ao):
   parse("MAX_TEMP",max_temp_);
   log.printf("  temperatures between %f and %f will be explored \n",min_temp_,max_temp_);
   parseVector("SIGMA",sigma_);
-  if(sigma_.size()==0) smoothening_=false;
-  if(smoothening_ && (sigma_.size()<1 || sigma_.size()>2) ) plumed_merror(getName()+": SIGMA takes 1 or 2 values as input.");
+  if(sigma_.size()==0) {
+    smoothening_=false;
+  }
+  if(smoothening_ && (sigma_.size()<1 || sigma_.size()>2) ) {
+    plumed_merror(getName()+": SIGMA takes 1 or 2 values as input.");
+  }
   if (smoothening_) {
     log.printf("  the target distribution will be smoothed using sigma values");
-    for(unsigned i=0; i<sigma_.size(); ++i) log.printf(" %f",sigma_[i]);
+    for(unsigned i=0; i<sigma_.size(); ++i) {
+      log.printf(" %f",sigma_[i]);
+    }
     log.printf("\n");
   }
 
@@ -229,8 +234,12 @@ double TD_Multicanonical::getValue(const std::vector<double>& argument) const {
 
 void TD_Multicanonical::updateGrid() {
   if (getStep() == 0) {
-    if(targetDistGrid().getDimension()>2 || targetDistGrid().getDimension()<1) plumed_merror(getName()+" works only with 1 or 2 arguments, i.e. energy, or energy and CV");
-    if(smoothening_ && sigma_.size()!=targetDistGrid().getDimension()) plumed_merror(getName()+": mismatch between SIGMA dimension and number of arguments");
+    if(targetDistGrid().getDimension()>2 || targetDistGrid().getDimension()<1) {
+      plumed_merror(getName()+" works only with 1 or 2 arguments, i.e. energy, or energy and CV");
+    }
+    if(smoothening_ && sigma_.size()!=targetDistGrid().getDimension()) {
+      plumed_merror(getName()+": mismatch between SIGMA dimension and number of arguments");
+    }
     // Use uniform TD
     std::vector<double> integration_weights = GridIntegrationWeights::getIntegrationWeights(getTargetDistGridPntr());
     double norm = 0.0;
@@ -342,14 +351,18 @@ void TD_Multicanonical::updateGrid() {
         double value = 1.0;
         double tmp;
         if(argument < minimum) {
-          if (smoothening_) tmp = GaussianSwitchingFunc(argument,minimum,sigma_[0]);
-          else tmp = exp(-1.0*epsilon_);
-        }
-        else if(argument > maximum) {
-          if (smoothening_) tmp = GaussianSwitchingFunc(argument,maximum,sigma_[0]);
-          else tmp = exp(-1.0*epsilon_);
-        }
-        else {
+          if (smoothening_) {
+            tmp = GaussianSwitchingFunc(argument,minimum,sigma_[0]);
+          } else {
+            tmp = exp(-1.0*epsilon_);
+          }
+        } else if(argument > maximum) {
+          if (smoothening_) {
+            tmp = GaussianSwitchingFunc(argument,maximum,sigma_[0]);
+          } else {
+            tmp = exp(-1.0*epsilon_);
+          }
+        } else {
           tmp = 1.0;
         }
         value *= tmp;
@@ -415,16 +428,28 @@ void TD_Multicanonical::updateGrid() {
               deltaBin[1]=std::floor(6*sigma_[1]/dx[1]);;
               // For energy
               minBin[0]=i - deltaBin[0];
-              if (minBin[0] < 0) minBin[0]=0;
-              if (minBin[0] > (nbin[0]-1)) minBin[0]=nbin[0]-1;
+              if (minBin[0] < 0) {
+                minBin[0]=0;
+              }
+              if (minBin[0] > (nbin[0]-1)) {
+                minBin[0]=nbin[0]-1;
+              }
               maxBin[0]=i +  deltaBin[0];
-              if (maxBin[0] > (nbin[0]-1)) maxBin[0]=nbin[0]-1;
+              if (maxBin[0] > (nbin[0]-1)) {
+                maxBin[0]=nbin[0]-1;
+              }
               // For volume
               minBin[1]=j - deltaBin[1];
-              if (minBin[1] < 0) minBin[1]=0;
-              if (minBin[1] > (nbin[1]-1)) minBin[1]=nbin[1]-1;
+              if (minBin[1] < 0) {
+                minBin[1]=0;
+              }
+              if (minBin[1] > (nbin[1]-1)) {
+                minBin[1]=nbin[1]-1;
+              }
               maxBin[1]=j +  deltaBin[1];
-              if (maxBin[1] > (nbin[1]-1)) maxBin[1]=nbin[1]-1;
+              if (maxBin[1] > (nbin[1]-1)) {
+                maxBin[1]=nbin[1]-1;
+              }
               for(unsigned l=minBin[0]; l<maxBin[0]+1; l++) {
                 for(unsigned m=minBin[1]; m<maxBin[1]+1; m++) {
                   std::vector<unsigned> indices_prime(2);
@@ -453,7 +478,9 @@ void TD_Multicanonical::updateGrid() {
         norm += integration_weights[l]*value;
       }
       targetDistGrid().scaleAllValuesAndDerivatives(1.0/norm);
-    } else plumed_merror(getName()+": Number of arguments for this target distribution must be 1 or 2");
+    } else {
+      plumed_merror(getName()+": Number of arguments for this target distribution must be 1 or 2");
+    }
   }
   updateLogTargetDistGrid();
 }
@@ -463,8 +490,7 @@ double TD_Multicanonical::GaussianSwitchingFunc(const double argument, const dou
   if(sigma>0.0) {
     double arg=(argument-center)/sigma;
     return exp(-0.5*arg*arg);
-  }
-  else {
+  } else {
     return 0.0;
   }
 }
diff --git a/src/ves/TD_MultithermalMultibaric.cpp b/src/ves/TD_MultithermalMultibaric.cpp
index a060c6df24..5c031eb10c 100644
--- a/src/ves/TD_MultithermalMultibaric.cpp
+++ b/src/ves/TD_MultithermalMultibaric.cpp
@@ -256,8 +256,7 @@ TD_MultithermalMultibaric::TD_MultithermalMultibaric(const ActionOptions& ao):
   epsilon_(10.0),
   smoothening_(true),
   steps_temp_(20),
-  steps_pressure_(20)
-{
+  steps_pressure_(20) {
   log.printf("  Multithermal-multibaric target distribution");
   log.printf("\n");
 
@@ -282,11 +281,17 @@ TD_MultithermalMultibaric::TD_MultithermalMultibaric(const ActionOptions& ao):
   parse("PRESSURE",press_);
   log.printf("  pressure of the barostat should have been set to %f. Please check this in the MD engine \n",press_);
   parseVector("SIGMA",sigma_);
-  if(sigma_.size()==0) smoothening_=false;
-  if(smoothening_ && (sigma_.size()<2 || sigma_.size()>3) ) plumed_merror(getName()+": SIGMA takes 2 or 3 values as input.");
+  if(sigma_.size()==0) {
+    smoothening_=false;
+  }
+  if(smoothening_ && (sigma_.size()<2 || sigma_.size()>3) ) {
+    plumed_merror(getName()+": SIGMA takes 2 or 3 values as input.");
+  }
   if (smoothening_) {
     log.printf("  the target distribution will be smoothed using sigma values");
-    for(unsigned i=0; i<sigma_.size(); ++i) log.printf(" %f",sigma_[i]);
+    for(unsigned i=0; i<sigma_.size(); ++i) {
+      log.printf(" %f",sigma_[i]);
+    }
     log.printf("\n");
   }
   parse("STEPS_TEMP",steps_temp_);
@@ -313,8 +318,12 @@ double TD_MultithermalMultibaric::getValue(const std::vector<double>& argument)
 
 void TD_MultithermalMultibaric::updateGrid() {
   if (getStep() == 0) {
-    if(targetDistGrid().getDimension()>3 || targetDistGrid().getDimension()<2) plumed_merror(getName()+" works only with 2 or 3 arguments, i.e. energy and volume, or energy, volume, and CV");
-    if(smoothening_ && sigma_.size()!=targetDistGrid().getDimension()) plumed_merror(getName()+": mismatch between SIGMA dimension and number of arguments");
+    if(targetDistGrid().getDimension()>3 || targetDistGrid().getDimension()<2) {
+      plumed_merror(getName()+" works only with 2 or 3 arguments, i.e. energy and volume, or energy, volume, and CV");
+    }
+    if(smoothening_ && sigma_.size()!=targetDistGrid().getDimension()) {
+      plumed_merror(getName()+": mismatch between SIGMA dimension and number of arguments");
+    }
     // Use uniform TD
     std::vector<double> integration_weights = GridIntegrationWeights::getIntegrationWeights(getTargetDistGridPntr());
     double norm = 0.0;
@@ -379,10 +388,16 @@ void TD_MultithermalMultibaric::updateGrid() {
           for(unsigned k=0; k<dim; k++) {
             int deltaBin=std::floor(6*sigma_[k]/dx[k]);
             minBin[k]=indices[k] - deltaBin;
-            if (minBin[k] < 0) minBin[k]=0;
-            if (minBin[k] > (nbin[k]-1)) minBin[k]=nbin[k]-1;
+            if (minBin[k] < 0) {
+              minBin[k]=0;
+            }
+            if (minBin[k] > (nbin[k]-1)) {
+              minBin[k]=nbin[k]-1;
+            }
             maxBin[k]=indices[k] + deltaBin;
-            if (maxBin[k] > (nbin[k]-1)) maxBin[k]=nbin[k]-1;
+            if (maxBin[k] > (nbin[k]-1)) {
+              maxBin[k]=nbin[k]-1;
+            }
           }
           if (dim==2) {
             for(unsigned l=minBin[0]; l<maxBin[0]+1; l++) {
@@ -446,8 +461,7 @@ double TD_MultithermalMultibaric::GaussianSwitchingFunc(const double argument, c
   if(sigma>0.0) {
     double arg=(argument-center)/sigma;
     return exp(-0.5*arg*arg);
-  }
-  else {
+  } else {
     return 0.0;
   }
 }
diff --git a/src/ves/TD_ProductCombination.cpp b/src/ves/TD_ProductCombination.cpp
index 746a28d73c..0ab72722cb 100644
--- a/src/ves/TD_ProductCombination.cpp
+++ b/src/ves/TD_ProductCombination.cpp
@@ -152,25 +152,36 @@ TD_ProductCombination::TD_ProductCombination(const ActionOptions& ao):
   PLUMED_VES_TARGETDISTRIBUTION_INIT(ao),
   distribution_pntrs_(0),
   grid_pntrs_(0),
-  ndist_(0)
-{
+  ndist_(0) {
   std::vector<std::string> targetdist_labels;
   parseVector("DISTRIBUTIONS",targetdist_labels);
 
   std::string error_msg = "";
   distribution_pntrs_ = VesTools::getPointersFromLabels<TargetDistribution*>(targetdist_labels,plumed.getActionSet(),error_msg);
-  if(error_msg.size()>0) {plumed_merror("Error in keyword DISTRIBUTIONS of "+getName()+": "+error_msg);}
+  if(error_msg.size()>0) {
+    plumed_merror("Error in keyword DISTRIBUTIONS of "+getName()+": "+error_msg);
+  }
 
   for(unsigned int i=0; i<distribution_pntrs_.size(); i++) {
-    if(distribution_pntrs_[i]->isDynamic()) {setDynamic();}
-    if(distribution_pntrs_[i]->fesGridNeeded()) {setFesGridNeeded();}
-    if(distribution_pntrs_[i]->biasGridNeeded()) {setBiasGridNeeded();}
+    if(distribution_pntrs_[i]->isDynamic()) {
+      setDynamic();
+    }
+    if(distribution_pntrs_[i]->fesGridNeeded()) {
+      setFesGridNeeded();
+    }
+    if(distribution_pntrs_[i]->biasGridNeeded()) {
+      setBiasGridNeeded();
+    }
   }
 
   ndist_ = distribution_pntrs_.size();
   grid_pntrs_.assign(ndist_,NULL);
-  if(ndist_==0) {plumed_merror(getName()+ ": no distributions are given.");}
-  if(ndist_==1) {plumed_merror(getName()+ ": giving only one distribution does not make sense.");}
+  if(ndist_==0) {
+    plumed_merror(getName()+ ": no distributions are given.");
+  }
+  if(ndist_==1) {
+    plumed_merror(getName()+ ": giving only one distribution does not make sense.");
+  }
   //
   checkRead();
 }
@@ -204,7 +215,9 @@ void TD_ProductCombination::updateGrid() {
     for(unsigned int i=0; i<ndist_; i++) {
       value *= grid_pntrs_[i]->getValue(l);
     }
-    if(value<0.0 && !isTargetDistGridShiftedToZero()) {plumed_merror(getName()+": The target distribution function gives negative values. You should change the definition of the target distribution to avoid this. You can also use the SHIFT_TO_ZERO keyword to avoid this problem.");}
+    if(value<0.0 && !isTargetDistGridShiftedToZero()) {
+      plumed_merror(getName()+": The target distribution function gives negative values. You should change the definition of the target distribution to avoid this. You can also use the SHIFT_TO_ZERO keyword to avoid this problem.");
+    }
     norm += integration_weights[l]*value;
     targetDistGrid().setValue(l,value);
     logTargetDistGrid().setValue(l,-std::log(value));
@@ -212,8 +225,7 @@ void TD_ProductCombination::updateGrid() {
 
   if(norm>0.0) {
     targetDistGrid().scaleAllValuesAndDerivatives(1.0/norm);
-  }
-  else if(!isTargetDistGridShiftedToZero()) {
+  } else if(!isTargetDistGridShiftedToZero()) {
     plumed_merror(getName()+": The target distribution function cannot be normalized proberly. You should change the definition of the target distribution to avoid this. You can also use the SHIFT_TO_ZERO keyword to avoid this problem.");
   }
   logTargetDistGrid().setMinToZero();
diff --git a/src/ves/TD_ProductDistribution.cpp b/src/ves/TD_ProductDistribution.cpp
index 083538baa5..393c7a3b92 100644
--- a/src/ves/TD_ProductDistribution.cpp
+++ b/src/ves/TD_ProductDistribution.cpp
@@ -116,19 +116,26 @@ TD_ProductDistribution::TD_ProductDistribution(const ActionOptions& ao):
   PLUMED_VES_TARGETDISTRIBUTION_INIT(ao),
   distribution_pntrs_(0),
   grid_pntrs_(0),
-  ndist_(0)
-{
+  ndist_(0) {
   std::vector<std::string> targetdist_labels;
   parseVector("DISTRIBUTIONS",targetdist_labels);
 
   std::string error_msg = "";
   distribution_pntrs_ = VesTools::getPointersFromLabels<TargetDistribution*>(targetdist_labels,plumed.getActionSet(),error_msg);
-  if(error_msg.size()>0) {plumed_merror("Error in keyword DISTRIBUTIONS of "+getName()+": "+error_msg);}
+  if(error_msg.size()>0) {
+    plumed_merror("Error in keyword DISTRIBUTIONS of "+getName()+": "+error_msg);
+  }
 
   for(unsigned int i=0; i<distribution_pntrs_.size(); i++) {
-    if(distribution_pntrs_[i]->isDynamic()) {setDynamic();}
-    if(distribution_pntrs_[i]->fesGridNeeded()) {setFesGridNeeded();}
-    if(distribution_pntrs_[i]->biasGridNeeded()) {setBiasGridNeeded();}
+    if(distribution_pntrs_[i]->isDynamic()) {
+      setDynamic();
+    }
+    if(distribution_pntrs_[i]->fesGridNeeded()) {
+      setFesGridNeeded();
+    }
+    if(distribution_pntrs_[i]->biasGridNeeded()) {
+      setBiasGridNeeded();
+    }
   }
 
   ndist_ = distribution_pntrs_.size();
diff --git a/src/ves/TD_Uniform.cpp b/src/ves/TD_Uniform.cpp
index 8b40a63723..96373d2199 100644
--- a/src/ves/TD_Uniform.cpp
+++ b/src/ves/TD_Uniform.cpp
@@ -208,43 +208,53 @@ TD_Uniform::TD_Uniform(const ActionOptions& ao):
   minima_(0),
   maxima_(0),
   sigma_min_(0),
-  sigma_max_(0)
-{
+  sigma_max_(0) {
   parseVector("MINIMA",minima_);
   parseVector("MAXIMA",maxima_);
 
   parseVector("SIGMA_MINIMA",sigma_min_);
   parseVector("SIGMA_MAXIMA",sigma_max_);
-  if(minima_.size()==0 && sigma_min_.size()>0) {plumed_merror(getName()+": you cannot give SIGMA_MINIMA if MINIMA is not given");}
-  if(maxima_.size()==0 && sigma_max_.size()>0) {plumed_merror(getName()+": you cannot give SIGMA_MAXIMA if MAXIMA is not given");}
+  if(minima_.size()==0 && sigma_min_.size()>0) {
+    plumed_merror(getName()+": you cannot give SIGMA_MINIMA if MINIMA is not given");
+  }
+  if(maxima_.size()==0 && sigma_max_.size()>0) {
+    plumed_merror(getName()+": you cannot give SIGMA_MAXIMA if MAXIMA is not given");
+  }
 
   if(minima_.size()>0 && maxima_.size()>0) {
     // both MINIMA and MAXIMA given, do all checks
-    if(minima_.size()!=maxima_.size()) {plumed_merror(getName()+": MINIMA and MAXIMA do not have the same number of values.");}
+    if(minima_.size()!=maxima_.size()) {
+      plumed_merror(getName()+": MINIMA and MAXIMA do not have the same number of values.");
+    }
     setDimension(minima_.size());
     for(unsigned int k=0; k<getDimension(); k++) {
       if(minima_[k]>maxima_[k]) {
         plumed_merror(getName()+": error in MINIMA and MAXIMA keywords, one of the MINIMA values is larger than the corresponding MAXIMA values");
       }
     }
-  }
-  else if(minima_.size()>0 && maxima_.size()==0) {
+  } else if(minima_.size()>0 && maxima_.size()==0) {
     // only MINIMA given, MAXIMA assigned later on.
     setDimension(minima_.size());
-  }
-  else if(maxima_.size()>0 && minima_.size()==0) {
+  } else if(maxima_.size()>0 && minima_.size()==0) {
     // only MAXIMA given, MINIMA assigned later on.
     setDimension(maxima_.size());
-  }
-  else if(maxima_.size()==0 && minima_.size()==0) {
+  } else if(maxima_.size()==0 && minima_.size()==0) {
     // neither MAXIMA nor MINIMA givenm, both assigned later on.
     setDimension(0);
   }
 
-  if(sigma_min_.size()==0) {sigma_min_.assign(getDimension(),0.0);}
-  if(sigma_max_.size()==0) {sigma_max_.assign(getDimension(),0.0);}
-  if(sigma_min_.size()!=getDimension()) {plumed_merror(getName()+": SIGMA_MINIMA has the wrong number of values");}
-  if(sigma_max_.size()!=getDimension()) {plumed_merror(getName()+": SIGMA_MAXIMA has the wrong number of values");}
+  if(sigma_min_.size()==0) {
+    sigma_min_.assign(getDimension(),0.0);
+  }
+  if(sigma_max_.size()==0) {
+    sigma_max_.assign(getDimension(),0.0);
+  }
+  if(sigma_min_.size()!=getDimension()) {
+    plumed_merror(getName()+": SIGMA_MINIMA has the wrong number of values");
+  }
+  if(sigma_max_.size()!=getDimension()) {
+    plumed_merror(getName()+": SIGMA_MAXIMA has the wrong number of values");
+  }
   //
   setForcedNormalization();
   checkRead();
@@ -255,12 +265,16 @@ void TD_Uniform::setupAdditionalGrids(const std::vector<Value*>& arguments, cons
 
   if(minima_.size()==0) {
     minima_.assign(getDimension(),0.0);
-    for(unsigned int k=0; k<getDimension(); k++) {Tools::convert(min[k],minima_[k]);}
+    for(unsigned int k=0; k<getDimension(); k++) {
+      Tools::convert(min[k],minima_[k]);
+    }
   }
 
   if(maxima_.size()==0) {
     maxima_.assign(getDimension(),0.0);
-    for(unsigned int k=0; k<getDimension(); k++) {Tools::convert(max[k],maxima_[k]);}
+    for(unsigned int k=0; k<getDimension(); k++) {
+      Tools::convert(max[k],maxima_[k]);
+    }
   }
 
 }
@@ -273,11 +287,9 @@ double TD_Uniform::getValue(const std::vector<double>& argument) const {
     double tmp;
     if(argument[k] < minima_[k]) {
       tmp = GaussianSwitchingFunc(argument[k],minima_[k],sigma_min_[k]);
-    }
-    else if(argument[k] > maxima_[k]) {
+    } else if(argument[k] > maxima_[k]) {
       tmp = GaussianSwitchingFunc(argument[k],maxima_[k],sigma_max_[k]);
-    }
-    else {
+    } else {
       tmp = 1.0;
     }
     value *= tmp;
@@ -290,8 +302,7 @@ double TD_Uniform::GaussianSwitchingFunc(const double argument, const double cen
   if(sigma>0.0) {
     double arg=(argument-center)/sigma;
     return exp(-0.5*arg*arg);
-  }
-  else {
+  } else {
     return 0.0;
   }
 }
diff --git a/src/ves/TD_VonMises.cpp b/src/ves/TD_VonMises.cpp
index d14f2d890c..dbf1ed1b18 100644
--- a/src/ves/TD_VonMises.cpp
+++ b/src/ves/TD_VonMises.cpp
@@ -131,16 +131,19 @@ TD_VonMises::TD_VonMises(const ActionOptions& ao):
   normalization_(0),
   weights_(0),
   periods_(0),
-  ncenters_(0)
-{
+  ncenters_(0) {
   for(unsigned int i=1;; i++) {
     std::vector<double> tmp_center;
-    if(!parseNumberedVector("CENTER",i,tmp_center) ) {break;}
+    if(!parseNumberedVector("CENTER",i,tmp_center) ) {
+      break;
+    }
     centers_.push_back(tmp_center);
   }
   for(unsigned int i=1;; i++) {
     std::vector<double> tmp_sigma;
-    if(!parseNumberedVector("SIGMA",i,tmp_sigma) ) {break;}
+    if(!parseNumberedVector("SIGMA",i,tmp_sigma) ) {
+      break;
+    }
     sigmas_.push_back(tmp_sigma);
   }
   //
@@ -154,8 +157,12 @@ TD_VonMises::TD_VonMises(const ActionOptions& ao):
   //
   // check centers and sigmas
   for(unsigned int i=0; i<ncenters_; i++) {
-    if(centers_[i].size()!=getDimension()) {plumed_merror(getName()+": one of the CENTER keyword does not match the given dimension");}
-    if(sigmas_[i].size()!=getDimension()) {plumed_merror(getName()+": one of the SIGMA keyword does not match the given dimension");}
+    if(centers_[i].size()!=getDimension()) {
+      plumed_merror(getName()+": one of the CENTER keyword does not match the given dimension");
+    }
+    if(sigmas_[i].size()!=getDimension()) {
+      plumed_merror(getName()+": one of the SIGMA keyword does not match the given dimension");
+    }
   }
   //
   kappas_.resize(sigmas_.size());
@@ -167,16 +174,28 @@ TD_VonMises::TD_VonMises(const ActionOptions& ao):
   }
   //
   parseVector("WEIGHTS",weights_);
-  if(weights_.size()==0) {weights_.assign(centers_.size(),1.0);}
-  if(centers_.size()!=weights_.size()) {plumed_merror(getName() + ": there has to be as many weights given in WEIGHTS as numbered CENTER keywords");}
+  if(weights_.size()==0) {
+    weights_.assign(centers_.size(),1.0);
+  }
+  if(centers_.size()!=weights_.size()) {
+    plumed_merror(getName() + ": there has to be as many weights given in WEIGHTS as numbered CENTER keywords");
+  }
   //
-  if(periods_.size()==0) {periods_.assign(getDimension(),2*pi);}
+  if(periods_.size()==0) {
+    periods_.assign(getDimension(),2*pi);
+  }
   parseVector("PERIODS",periods_);
-  if(periods_.size()!=getDimension()) {plumed_merror(getName() + ": the number of values given in PERIODS does not match the dimension of the distribution");}
+  if(periods_.size()!=getDimension()) {
+    plumed_merror(getName() + ": the number of values given in PERIODS does not match the dimension of the distribution");
+  }
   //
   double sum_weights=0.0;
-  for(unsigned int i=0; i<weights_.size(); i++) {sum_weights+=weights_[i];}
-  for(unsigned int i=0; i<weights_.size(); i++) {weights_[i]/=sum_weights;}
+  for(unsigned int i=0; i<weights_.size(); i++) {
+    sum_weights+=weights_[i];
+  }
+  for(unsigned int i=0; i<weights_.size(); i++) {
+    weights_[i]/=sum_weights;
+  }
   //
   normalization_.resize(ncenters_);
   for(unsigned int i=0; i<ncenters_; i++) {
@@ -228,7 +247,8 @@ double TD_VonMises::getNormalization(const double kappa, const double period) co
   //
   double sum = 0.0;
   for(unsigned int l=0; l<nbins; l++) {
-    std::vector<double> arg(1); arg[0]= points[l];
+    std::vector<double> arg(1);
+    arg[0]= points[l];
     sum += weights[l] * VonMisesDiagonal(arg,centers,kappas,periods,norm);
   }
   return 1.0/sum;
diff --git a/src/ves/TD_WellTempered.cpp b/src/ves/TD_WellTempered.cpp
index 7d921b2830..a7096eaacf 100644
--- a/src/ves/TD_WellTempered.cpp
+++ b/src/ves/TD_WellTempered.cpp
@@ -121,8 +121,7 @@ void TD_WellTempered::registerKeywords(Keywords& keys) {
 
 TD_WellTempered::TD_WellTempered(const ActionOptions& ao):
   PLUMED_VES_TARGETDISTRIBUTION_INIT(ao),
-  bias_factor_(0.0)
-{
+  bias_factor_(0.0) {
   log.printf("  Well-tempered target distribution, see and cite ");
   log << plumed.cite("Valsson and Parrinello, J. Chem. Theory Comput. 11, 1996-2002 (2015)");
   log << plumed.cite("Barducci, Bussi, and Parrinello, Phys. Rev. Lett. 100, 020603 (2008)");
diff --git a/src/ves/TargetDistribution.cpp b/src/ves/TargetDistribution.cpp
index 805ed5e7c1..d3ded1be13 100644
--- a/src/ves/TargetDistribution.cpp
+++ b/src/ves/TargetDistribution.cpp
@@ -65,8 +65,7 @@ TargetDistribution::TargetDistribution(const ActionOptions&ao):
   fes_grid_pntr_(NULL),
   static_grid_calculated(false),
   allow_bias_cutoff_(true),
-  bias_cutoff_active_(false)
-{
+  bias_cutoff_active_(false) {
   //
   if(keywords.exists("WELLTEMPERED_FACTOR")) {
     double welltempered_factor=0.0;
@@ -75,8 +74,7 @@ TargetDistribution::TargetDistribution(const ActionOptions&ao):
     if(welltempered_factor>0.0) {
       auto pntr = Tools::make_unique<WellTemperedModifer>(welltempered_factor);
       targetdist_modifer_pntrs_.emplace_back(std::move(pntr));
-    }
-    else if(welltempered_factor<0.0) {
+    } else if(welltempered_factor<0.0) {
       plumed_merror(getName()+": negative value in WELLTEMPERED_FACTOR does not make sense");
     }
   }
@@ -84,7 +82,9 @@ TargetDistribution::TargetDistribution(const ActionOptions&ao):
   if(keywords.exists("SHIFT_TO_ZERO")) {
     parseFlag("SHIFT_TO_ZERO",shift_targetdist_to_zero_);
     if(shift_targetdist_to_zero_) {
-      if(bias_cutoff_active_) {plumed_merror(getName()+": using SHIFT_TO_ZERO with bias cutoff is not allowed.");}
+      if(bias_cutoff_active_) {
+        plumed_merror(getName()+": using SHIFT_TO_ZERO with bias cutoff is not allowed.");
+      }
       check_nonnegative_=false;
     }
   }
@@ -93,7 +93,9 @@ TargetDistribution::TargetDistribution(const ActionOptions&ao):
     bool force_normalization=false;
     parseFlag("NORMALIZE",force_normalization);
     if(force_normalization) {
-      if(shift_targetdist_to_zero_) {plumed_merror(getName()+" with label "+getLabel()+": using NORMALIZE with SHIFT_TO_ZERO is not needed, the target distribution will be automatically normalized.");}
+      if(shift_targetdist_to_zero_) {
+        plumed_merror(getName()+" with label "+getLabel()+": using NORMALIZE with SHIFT_TO_ZERO is not needed, the target distribution will be automatically normalized.");
+      }
       setForcedNormalization();
     }
   }
@@ -175,12 +177,13 @@ void TargetDistribution::setupGrids(const std::vector<Value*>& arguments, const
 
 
 void TargetDistribution::calculateStaticDistributionGrid() {
-  if(static_grid_calculated && !bias_cutoff_active_) {return;}
+  if(static_grid_calculated && !bias_cutoff_active_) {
+    return;
+  }
   // plumed_massert(isStatic(),"this should only be used for static distributions");
   plumed_massert(targetdist_grid_pntr_,"the grids have not been setup using setupGrids");
   plumed_massert(log_targetdist_grid_pntr_,"the grids have not been setup using setupGrids");
-  for(Grid::index_t l=0; l<targetdist_grid_pntr_->getSize(); l++)
-  {
+  for(Grid::index_t l=0; l<targetdist_grid_pntr_->getSize(); l++) {
     std::vector<double> argument = targetdist_grid_pntr_->getPoint(l);
     double value = getValue(argument);
     targetdist_grid_pntr_->setValue(l,value);
@@ -216,7 +219,9 @@ Grid TargetDistribution::getMarginalDistributionGrid(Grid* grid_pntr, const std:
   std::vector<unsigned int> args_index(0);
   for(unsigned int i=0; i<argnames.size(); i++) {
     for(unsigned int l=0; l<args.size(); l++) {
-      if(argnames[i]==args[l]) {args_index.push_back(i);}
+      if(argnames[i]==args[l]) {
+        args_index.push_back(i);
+      }
     }
   }
   plumed_massert(args.size()==args_index.size(),"getMarginalDistributionGrid: problem with the arguments of the marginal");
@@ -250,17 +255,24 @@ void TargetDistribution::updateTargetDist() {
     applyTargetDistModiferToGrid(targetdist_modifer_pntrs_[i].get());
   }
   //
-  if(bias_cutoff_active_) {updateBiasCutoffForTargetDistGrid();}
+  if(bias_cutoff_active_) {
+    updateBiasCutoffForTargetDistGrid();
+  }
   //
-  if(shift_targetdist_to_zero_ && !(bias_cutoff_active_)) {setMinimumOfTargetDistGridToZero();}
-  if(force_normalization_ && !(bias_cutoff_active_) ) {normalizeTargetDistGrid();}
+  if(shift_targetdist_to_zero_ && !(bias_cutoff_active_)) {
+    setMinimumOfTargetDistGridToZero();
+  }
+  if(force_normalization_ && !(bias_cutoff_active_) ) {
+    normalizeTargetDistGrid();
+  }
   //
   // if(check_normalization_ && !force_normalization_ && !shift_targetdist_to_zero_){
   if(check_normalization_ && !(bias_cutoff_active_)) {
     double normalization = integrateGrid(targetdist_grid_pntr_.get());
     const double normalization_thrshold = 0.1;
     if(normalization < 1.0-normalization_thrshold || normalization > 1.0+normalization_thrshold) {
-      std::string norm_str; Tools::convert(normalization,norm_str);
+      std::string norm_str;
+      Tools::convert(normalization,norm_str);
       std::string msg = "the target distribution grid is not proberly normalized, integrating over the grid gives: " + norm_str + " - You can avoid this problem by using the NORMALIZE keyword";
       warning(msg);
     }
@@ -270,13 +282,16 @@ void TargetDistribution::updateTargetDist() {
     const double nonnegative_thrshold = -0.02;
     double grid_min_value = targetdist_grid_pntr_->getMinValue();
     if(grid_min_value<nonnegative_thrshold) {
-      std::string grid_min_value_str; Tools::convert(grid_min_value,grid_min_value_str);
+      std::string grid_min_value_str;
+      Tools::convert(grid_min_value,grid_min_value_str);
       std::string msg = "the target distribution grid has negative values, the lowest value is: " + grid_min_value_str + " - You can avoid this problem by using the SHIFT_TO_ZERO keyword";
       warning(msg);
     }
   }
   //
-  if(check_nan_inf_) {checkNanAndInf();}
+  if(check_nan_inf_) {
+    checkNanAndInf();
+  }
   //
 }
 
@@ -290,8 +305,7 @@ void TargetDistribution::updateBiasCutoffForTargetDistGrid() {
   //
   std::vector<double> integration_weights = GridIntegrationWeights::getIntegrationWeights(targetdist_grid_pntr_.get());
   double norm = 0.0;
-  for(Grid::index_t l=0; l<targetdist_grid_pntr_->getSize(); l++)
-  {
+  for(Grid::index_t l=0; l<targetdist_grid_pntr_->getSize(); l++) {
     double value = targetdist_grid_pntr_->getValue(l);
     double bias = getBiasWithoutCutoffGridPntr()->getValue(l);
     double deriv_factor_swf = 0.0;
@@ -315,8 +329,7 @@ void TargetDistribution::applyTargetDistModiferToGrid(TargetDistModifer* modifer
   //
   std::vector<double> integration_weights = GridIntegrationWeights::getIntegrationWeights(targetdist_grid_pntr_.get());
   double norm = 0.0;
-  for(Grid::index_t l=0; l<targetdist_grid_pntr_->getSize(); l++)
-  {
+  for(Grid::index_t l=0; l<targetdist_grid_pntr_->getSize(); l++) {
     double value = targetdist_grid_pntr_->getValue(l);
     std::vector<double> cv_values = targetdist_grid_pntr_->getPoint(l);
     value = modifer_pntr->getModifedTargetDistValue(value,cv_values);
@@ -330,8 +343,7 @@ void TargetDistribution::applyTargetDistModiferToGrid(TargetDistModifer* modifer
 
 
 void TargetDistribution::updateLogTargetDistGrid() {
-  for(Grid::index_t l=0; l<targetdist_grid_pntr_->getSize(); l++)
-  {
+  for(Grid::index_t l=0; l<targetdist_grid_pntr_->getSize(); l++) {
     log_targetdist_grid_pntr_->setValue(l,-std::log(targetdist_grid_pntr_->getValue(l)));
   }
   log_targetdist_grid_pntr_->setMinToZero();
@@ -366,16 +378,18 @@ void TargetDistribution::clearLogTargetDistGrid() {
 
 
 void TargetDistribution::checkNanAndInf() {
-  for(Grid::index_t l=0; l<targetdist_grid_pntr_->getSize(); l++)
-  {
+  for(Grid::index_t l=0; l<targetdist_grid_pntr_->getSize(); l++) {
     double value = targetdist_grid_pntr_->getValue(l);
     if(std::isnan(value) || std::isinf(value)) {
-      std::string vs; Tools::convert(value,vs);
+      std::string vs;
+      Tools::convert(value,vs);
       std::vector<double> p = targetdist_grid_pntr_->getPoint(l);
-      std::string ps; Tools::convert(p[0],ps);
+      std::string ps;
+      Tools::convert(p[0],ps);
       ps = "(" + ps;
       for(unsigned int k=1; k<p.size(); k++) {
-        std::string t1; Tools::convert(p[k],t1);
+        std::string t1;
+        Tools::convert(p[k],t1);
         ps = ps + "," + t1;
       }
       ps = ps + ")";
diff --git a/src/ves/TargetDistribution.h b/src/ves/TargetDistribution.h
index 820b832d49..964994fc59 100644
--- a/src/ves/TargetDistribution.h
+++ b/src/ves/TargetDistribution.h
@@ -49,8 +49,7 @@ class TargetDistModifer;
 class VesBias;
 
 class TargetDistribution :
-  public Action
-{
+  public Action {
 private:
   enum TargetDistType {
     static_targetdist,
@@ -92,15 +91,31 @@ class TargetDistribution :
   void updateBiasCutoffForTargetDistGrid();
   void checkNanAndInf();
 protected:
-  void setStatic() {type_=static_targetdist;}
-  void setDynamic() {type_=dynamic_targetdist;}
+  void setStatic() {
+    type_=static_targetdist;
+  }
+  void setDynamic() {
+    type_=dynamic_targetdist;
+  }
   // set the that target distribution is normalized
-  void setForcedNormalization() {force_normalization_=true; check_normalization_=false;}
-  void unsetForcedNormalization() {force_normalization_=false; check_normalization_=true;};
-  //
-  void setBiasGridNeeded() {needs_bias_grid_=true;}
-  void setBiasWithoutCutoffGridNeeded() {needs_bias_withoutcutoff_grid_=true;}
-  void setFesGridNeeded() {needs_fes_grid_=true;}
+  void setForcedNormalization() {
+    force_normalization_=true;
+    check_normalization_=false;
+  }
+  void unsetForcedNormalization() {
+    force_normalization_=false;
+    check_normalization_=true;
+  };
+  //
+  void setBiasGridNeeded() {
+    needs_bias_grid_=true;
+  }
+  void setBiasWithoutCutoffGridNeeded() {
+    needs_bias_withoutcutoff_grid_=true;
+  }
+  void setFesGridNeeded() {
+    needs_fes_grid_=true;
+  }
   //
   VesBias* getPntrToVesBias() const;
   Action* getPntrToAction() const;
@@ -109,12 +124,22 @@ class TargetDistribution :
   //
   void normalizeTargetDistGrid();
   //
-  Grid& targetDistGrid() const {return *targetdist_grid_pntr_;}
-  Grid& logTargetDistGrid() const {return *log_targetdist_grid_pntr_;}
-  //
-  Grid* getBiasGridPntr() const {return bias_grid_pntr_;}
-  Grid* getBiasWithoutCutoffGridPntr() const {return bias_withoutcutoff_grid_pntr_;}
-  Grid* getFesGridPntr() const {return fes_grid_pntr_;}
+  Grid& targetDistGrid() const {
+    return *targetdist_grid_pntr_;
+  }
+  Grid& logTargetDistGrid() const {
+    return *log_targetdist_grid_pntr_;
+  }
+  //
+  Grid* getBiasGridPntr() const {
+    return bias_grid_pntr_;
+  }
+  Grid* getBiasWithoutCutoffGridPntr() const {
+    return bias_withoutcutoff_grid_pntr_;
+  }
+  Grid* getFesGridPntr() const {
+    return fes_grid_pntr_;
+  }
   //
   double getBeta() const;
   //
@@ -123,29 +148,55 @@ class TargetDistribution :
   void setMinimumOfTargetDistGridToZero();
   void updateLogTargetDistGrid();
   //
-  virtual void updateGrid() {calculateStaticDistributionGrid();}
+  virtual void updateGrid() {
+    calculateStaticDistributionGrid();
+  }
 public:
   static void registerKeywords(Keywords&);
   explicit TargetDistribution(const ActionOptions&);
   ~TargetDistribution();
   //
-  bool isStatic() const {return type_==static_targetdist;}
-  bool isDynamic() const {return type_==dynamic_targetdist;}
+  bool isStatic() const {
+    return type_==static_targetdist;
+  }
+  bool isDynamic() const {
+    return type_==dynamic_targetdist;
+  }
   // is the target distribution normalize or not
-  bool forcedNormalization() const {return force_normalization_;};
-  bool isTargetDistGridShiftedToZero() const {return shift_targetdist_to_zero_;}
-  //
-  bool biasGridNeeded() const {return needs_bias_grid_;}
-  bool biasWithoutCutoffGridNeeded() const {return needs_bias_withoutcutoff_grid_;}
-  bool fesGridNeeded()  const {return needs_fes_grid_;}
-  //
-  void allowBiasCutoff() {allow_bias_cutoff_=true;}
-  void doNotAllowBiasCutoff() {allow_bias_cutoff_=false;}
-  bool isBiasCutoffAllowed() const {return allow_bias_cutoff_;}
-  bool biasCutoffActive() const {return bias_cutoff_active_;}
+  bool forcedNormalization() const {
+    return force_normalization_;
+  };
+  bool isTargetDistGridShiftedToZero() const {
+    return shift_targetdist_to_zero_;
+  }
+  //
+  bool biasGridNeeded() const {
+    return needs_bias_grid_;
+  }
+  bool biasWithoutCutoffGridNeeded() const {
+    return needs_bias_withoutcutoff_grid_;
+  }
+  bool fesGridNeeded()  const {
+    return needs_fes_grid_;
+  }
+  //
+  void allowBiasCutoff() {
+    allow_bias_cutoff_=true;
+  }
+  void doNotAllowBiasCutoff() {
+    allow_bias_cutoff_=false;
+  }
+  bool isBiasCutoffAllowed() const {
+    return allow_bias_cutoff_;
+  }
+  bool biasCutoffActive() const {
+    return bias_cutoff_active_;
+  }
   //
   void setDimension(const unsigned int dimension);
-  unsigned getDimension() const {return dimension_;}
+  unsigned getDimension() const {
+    return dimension_;
+  }
   //
   virtual void linkVesBias(VesBias*);
   virtual void linkAction(Action*);
@@ -156,8 +207,12 @@ class TargetDistribution :
   //
   void setupBiasCutoff();
   //
-  Grid* getTargetDistGridPntr() const {return targetdist_grid_pntr_.get();}
-  Grid* getLogTargetDistGridPntr() const {return log_targetdist_grid_pntr_.get();}
+  Grid* getTargetDistGridPntr() const {
+    return targetdist_grid_pntr_.get();
+  }
+  Grid* getLogTargetDistGridPntr() const {
+    return log_targetdist_grid_pntr_.get();
+  }
   //
   void clearLogTargetDistGrid();
   // calculate the target distribution itself
@@ -198,7 +253,9 @@ Action* TargetDistribution::getPntrToAction() const {
 inline
 void TargetDistribution::normalizeTargetDistGrid() {
   double normalization = normalizeGrid(targetdist_grid_pntr_.get());
-  if(normalization<0.0) {plumed_merror(getName()+": something went wrong trying to normalize the target distribution, integrating over it gives a negative value.");}
+  if(normalization<0.0) {
+    plumed_merror(getName()+": something went wrong trying to normalize the target distribution, integrating over it gives a negative value.");
+  }
 }
 
 
diff --git a/src/ves/VesBias.cpp b/src/ves/VesBias.cpp
index dfa8b7eb0b..2581103dbb 100644
--- a/src/ves/VesBias.cpp
+++ b/src/ves/VesBias.cpp
@@ -76,8 +76,7 @@ VesBias::VesBias(const ActionOptions&ao):
   bias_cutoff_value_(0.0),
   bias_current_max_value(0.0),
   calc_reweightfactor_(false),
-  optimization_threshold_(0.0)
-{
+  optimization_threshold_(0.0) {
   log.printf("  VES bias, please read and cite ");
   log << plumed.cite("Valsson and Parrinello, Phys. Rev. Lett. 113, 090601 (2014)");
   log.printf("\n");
@@ -107,14 +106,15 @@ VesBias::VesBias(const ActionOptions&ao):
     if(targetdist_labels.size()>1) {
       plumed_merror(getName()+" with label "+getLabel()+": multiple target distribution labels not allowed");
     }
-  }
-  else if(keywords.exists("TARGET_DISTRIBUTIONS")) {
+  } else if(keywords.exists("TARGET_DISTRIBUTIONS")) {
     parseVector("TARGET_DISTRIBUTIONS",targetdist_labels);
   }
 
   std::string error_msg = "";
   targetdist_pntrs_ = VesTools::getPointersFromLabels<TargetDistribution*>(targetdist_labels,plumed.getActionSet(),error_msg);
-  if(error_msg.size()>0) {plumed_merror("Problem with target distribution in "+getName()+": "+error_msg);}
+  if(error_msg.size()>0) {
+    plumed_merror("Problem with target distribution in "+getName()+": "+error_msg);
+  }
 
   for(unsigned int i=0; i<targetdist_pntrs_.size(); i++) {
     targetdist_pntrs_[i]->linkVesBias(this);
@@ -180,7 +180,9 @@ VesBias::VesBias(const ActionOptions&ao):
   if(keywords.exists("PROJ_ARG")) {
     std::vector<std::string> proj_arg;
     for(int i=1;; i++) {
-      if(!parseNumberedVector("PROJ_ARG",i,proj_arg)) {break;}
+      if(!parseNumberedVector("PROJ_ARG",i,proj_arg)) {
+        break;
+      }
       // checks
       if(proj_arg.size() > (getNumberOfArguments()-1) ) {
         plumed_merror("PROJ_ARG must be a subset of ARG");
@@ -195,7 +197,8 @@ VesBias::VesBias(const ActionOptions&ao):
           }
         }
         if(!found) {
-          std::string s1; Tools::convert(i,s1);
+          std::string s1;
+          Tools::convert(i,s1);
           std::string error = "PROJ_ARG" + s1 + ": label " + proj_arg[k] + " is not among the arguments given in ARG";
           plumed_merror(error);
         }
@@ -208,7 +211,8 @@ VesBias::VesBias(const ActionOptions&ao):
   if(keywords.exists("CALC_REWEIGHT_FACTOR")) {
     parseFlag("CALC_REWEIGHT_FACTOR",calc_reweightfactor_);
     if(calc_reweightfactor_) {
-      addComponent("rct"); componentIsNotPeriodic("rct");
+      addComponent("rct");
+      componentIsNotPeriodic("rct");
       updateReweightFactor();
     }
   }
@@ -376,8 +380,7 @@ bool VesBias::readCoeffsFromFiles() {
     plumed_massert(coeffs_fnames.size()==ncoeffssets_,"COEFFS keyword is of the wrong size");
     if(ncoeffssets_==1) {
       log.printf("  Read in coefficients from file ");
-    }
-    else {
+    } else {
       log.printf("  Read in coefficients from files:\n");
     }
     for(unsigned int i=0; i<ncoeffssets_; i++) {
@@ -392,8 +395,7 @@ bool VesBias::readCoeffsFromFiles() {
       coeffs_pntrs_[i]->setIterationCounterAndTime(0,getTime());
       if(ncoeffssets_==1) {
         log.printf("%s (read %zu of %zu values)\n", ifile.getPath().c_str(),ncoeffs_read,coeffs_pntrs_[i]->numberOfCoeffs());
-      }
-      else {
+      } else {
         log.printf("   coefficient %u: %s (read %zu of %zu values)\n",i,ifile.getPath().c_str(),ncoeffs_read,coeffs_pntrs_[i]->numberOfCoeffs());
       }
       ifile.close();
@@ -411,7 +413,9 @@ void VesBias::updateGradientAndHessian(const bool use_mwalkers_mpi) {
     comm.Sum(sampled_cross_averages[k]);
     if(use_mwalkers_mpi) {
       double walker_weight=1.0;
-      if(aver_counters[k]==0) {walker_weight=0.0;}
+      if(aver_counters[k]==0) {
+        walker_weight=0.0;
+      }
       multiSimSumAverages(k,walker_weight);
     }
     // NOTE: this assumes that all walkers have the same TargetDist, might change later on!!
@@ -435,7 +439,9 @@ void VesBias::updateGradientAndHessian(const bool use_mwalkers_mpi) {
     // is zero
     unsigned int total_samples = aver_counters[k];
     if(use_mwalkers_mpi) {
-      if(comm.Get_rank()==0) {multi_sim_comm.Sum(total_samples);}
+      if(comm.Get_rank()==0) {
+        multi_sim_comm.Sum(total_samples);
+      }
       comm.Bcast(total_samples,0);
     }
     if(total_samples==0) {
@@ -468,7 +474,9 @@ void VesBias::multiSimSumAverages(const unsigned int c_id, const double walker_w
     multi_sim_comm.Sum(sampled_cross_averages[c_id]);
     double norm_weights = walker_weight;
     multi_sim_comm.Sum(norm_weights);
-    if(norm_weights>0.0) {norm_weights=1.0/norm_weights;}
+    if(norm_weights>0.0) {
+      norm_weights=1.0/norm_weights;
+    }
     for(size_t i=0; i<sampled_averages[c_id].size(); i++) {
       sampled_averages[c_id][i] *= norm_weights;
     }
@@ -544,8 +552,7 @@ unsigned int VesBias::getIterationCounter() const {
   unsigned int iteration = 0;
   if(optimizeCoeffs()) {
     iteration = getOptimizerPntr()->getIterationCounter();
-  }
-  else {
+  } else {
     iteration = getCoeffsPntrs()[0]->getIterationCounter();
   }
   return iteration;
@@ -556,8 +563,7 @@ void VesBias::linkOptimizer(Optimizer* optimizer_pntr_in) {
   //
   if(optimizer_pntr_==NULL) {
     optimizer_pntr_ = optimizer_pntr_in;
-  }
-  else {
+  } else {
     std::string err_msg = "VES bias " + getLabel() + " of type " + getName() + " has already been linked with optimizer " + optimizer_pntr_->getLabel() + " of type " + optimizer_pntr_->getName() + ". You cannot link two optimizer to the same VES bias.";
     plumed_merror(err_msg);
   }
@@ -612,12 +618,18 @@ std::unique_ptr<OFile> VesBias::getOFile(const std::string& filepath, const bool
   auto ofile_pntr = Tools::make_unique<OFile>();
   std::string fp = filepath;
   ofile_pntr->link(*static_cast<Action*>(this));
-  if(enforce_backup) {ofile_pntr->enforceBackup();}
+  if(enforce_backup) {
+    ofile_pntr->enforceBackup();
+  }
   if(multi_sim_single_file) {
     unsigned int r=0;
-    if(comm.Get_rank()==0) {r=multi_sim_comm.Get_rank();}
+    if(comm.Get_rank()==0) {
+      r=multi_sim_comm.Get_rank();
+    }
     comm.Bcast(r,0);
-    if(r>0) {fp="/dev/null";}
+    if(r>0) {
+      fp="/dev/null";
+    }
     ofile_pntr->enforceSuffix("");
   }
   ofile_pntr->open(fp);
@@ -695,9 +707,12 @@ void VesBias::setupBiasCutoff(const double bias_cutoff_value, const double fermi
   //
   double fermi_exp_max = 100.0;
   //
-  std::string str_bias_cutoff_value; VesTools::convertDbl2Str(bias_cutoff_value,str_bias_cutoff_value);
-  std::string str_fermi_lambda; VesTools::convertDbl2Str(fermi_lambda,str_fermi_lambda);
-  std::string str_fermi_exp_max; VesTools::convertDbl2Str(fermi_exp_max,str_fermi_exp_max);
+  std::string str_bias_cutoff_value;
+  VesTools::convertDbl2Str(bias_cutoff_value,str_bias_cutoff_value);
+  std::string str_fermi_lambda;
+  VesTools::convertDbl2Str(fermi_lambda,str_fermi_lambda);
+  std::string str_fermi_exp_max;
+  VesTools::convertDbl2Str(fermi_exp_max,str_fermi_exp_max);
   std::string swfunc_keywords = "FERMI R_0=" + str_bias_cutoff_value + " FERMI_LAMBDA=" + str_fermi_lambda + " FERMI_EXP_MAX=" + str_fermi_exp_max;
   //
   std::string swfunc_errors="";
diff --git a/src/ves/VesBias.h b/src/ves/VesBias.h
index c7c0ec0ff3..5b2f891dc0 100644
--- a/src/ves/VesBias.h
+++ b/src/ves/VesBias.h
@@ -58,8 +58,7 @@ to include functions related to the variational approach.
 */
 
 class VesBias:
-  public bias::Bias
-{
+  public bias::Bias {
 private:
   unsigned int ncoeffssets_;
   std::vector<std::unique_ptr<CoeffsVector>> coeffs_pntrs_;
@@ -134,7 +133,9 @@ class VesBias:
   void addCoeffsSet(std::unique_ptr<CoeffsVector>);
   //
   std::string getCoeffsSetLabelString(const std::string&, const unsigned int coeffs_id = 0) const;
-  void clearCoeffsPntrsVector() {coeffs_pntrs_.clear();}
+  void clearCoeffsPntrsVector() {
+    coeffs_pntrs_.clear();
+  }
   void addToSampledAverages(const std::vector<double>&, const unsigned int c_id = 0);
   void setTargetDistAverages(const std::vector<double>&, const unsigned int coeffs_id = 0);
   void setTargetDistAverages(const CoeffsVector&, const unsigned int coeffs_id= 0);
@@ -161,39 +162,83 @@ class VesBias:
   static void useProjectionArgKeywords(Keywords&);
   static void useReweightFactorKeywords(Keywords&);
   //
-  std::vector<CoeffsVector*> getCoeffsPntrs() const {return Tools::unique2raw(coeffs_pntrs_);}
-  std::vector<CoeffsVector*> getTargetDistAveragesPntrs() const {return Tools::unique2raw(targetdist_averages_pntrs_);}
-  std::vector<CoeffsVector*> getGradientPntrs()const {return Tools::unique2raw(gradient_pntrs_);}
-  std::vector<CoeffsMatrix*> getHessianPntrs() const {return Tools::unique2raw(hessian_pntrs_);}
-  std::vector<TargetDistribution*> getTargetDistributionPntrs() const {return targetdist_pntrs_;}
+  std::vector<CoeffsVector*> getCoeffsPntrs() const {
+    return Tools::unique2raw(coeffs_pntrs_);
+  }
+  std::vector<CoeffsVector*> getTargetDistAveragesPntrs() const {
+    return Tools::unique2raw(targetdist_averages_pntrs_);
+  }
+  std::vector<CoeffsVector*> getGradientPntrs()const {
+    return Tools::unique2raw(gradient_pntrs_);
+  }
+  std::vector<CoeffsMatrix*> getHessianPntrs() const {
+    return Tools::unique2raw(hessian_pntrs_);
+  }
+  std::vector<TargetDistribution*> getTargetDistributionPntrs() const {
+    return targetdist_pntrs_;
+  }
   //
-  CoeffsVector* getCoeffsPntr(const unsigned int coeffs_id = 0) const {return coeffs_pntrs_[coeffs_id].get();}
-  CoeffsVector* getTargetDistAveragesPntr(const unsigned int coeffs_id = 0) const {return targetdist_averages_pntrs_[coeffs_id].get();}
-  CoeffsVector* getGradientPntr(const unsigned int coeffs_id = 0)const {return gradient_pntrs_[coeffs_id].get();}
-  CoeffsMatrix* getHessianPntr(const unsigned int coeffs_id = 0) const {return hessian_pntrs_[coeffs_id].get();}
+  CoeffsVector* getCoeffsPntr(const unsigned int coeffs_id = 0) const {
+    return coeffs_pntrs_[coeffs_id].get();
+  }
+  CoeffsVector* getTargetDistAveragesPntr(const unsigned int coeffs_id = 0) const {
+    return targetdist_averages_pntrs_[coeffs_id].get();
+  }
+  CoeffsVector* getGradientPntr(const unsigned int coeffs_id = 0)const {
+    return gradient_pntrs_[coeffs_id].get();
+  }
+  CoeffsMatrix* getHessianPntr(const unsigned int coeffs_id = 0) const {
+    return hessian_pntrs_[coeffs_id].get();
+  }
   //
-  unsigned int getNumberOfTargetDistributionPntrs() const {return targetdist_pntrs_.size();}
+  unsigned int getNumberOfTargetDistributionPntrs() const {
+    return targetdist_pntrs_.size();
+  }
   //
-  size_t numberOfCoeffs(const unsigned int coeffs_id = 0) const {return coeffs_pntrs_[coeffs_id]->numberOfCoeffs();}
-  size_t totalNumberOfCoeffs() const {return ncoeffs_total_;}
-  unsigned int numberOfCoeffsSets() const {return ncoeffssets_;}
-  double getKbT() const {return kbt_;}
+  size_t numberOfCoeffs(const unsigned int coeffs_id = 0) const {
+    return coeffs_pntrs_[coeffs_id]->numberOfCoeffs();
+  }
+  size_t totalNumberOfCoeffs() const {
+    return ncoeffs_total_;
+  }
+  unsigned int numberOfCoeffsSets() const {
+    return ncoeffssets_;
+  }
+  double getKbT() const {
+    return kbt_;
+  }
   double getBeta() const;
   //
-  CoeffsVector& Coeffs(const unsigned int coeffs_id = 0) const {return *coeffs_pntrs_[coeffs_id];}
-  CoeffsVector& TargetDistAverages(const unsigned int coeffs_id = 0) const {return *targetdist_averages_pntrs_[coeffs_id];}
-  CoeffsVector& Gradient(const unsigned int coeffs_id = 0) const {return *gradient_pntrs_[coeffs_id];}
-  CoeffsMatrix& Hessian(const unsigned int coeffs_id = 0) const {return *hessian_pntrs_[coeffs_id];}
+  CoeffsVector& Coeffs(const unsigned int coeffs_id = 0) const {
+    return *coeffs_pntrs_[coeffs_id];
+  }
+  CoeffsVector& TargetDistAverages(const unsigned int coeffs_id = 0) const {
+    return *targetdist_averages_pntrs_[coeffs_id];
+  }
+  CoeffsVector& Gradient(const unsigned int coeffs_id = 0) const {
+    return *gradient_pntrs_[coeffs_id];
+  }
+  CoeffsMatrix& Hessian(const unsigned int coeffs_id = 0) const {
+    return *hessian_pntrs_[coeffs_id];
+  }
   //
   size_t getCoeffsIndex(const std::vector<unsigned int>& indices, const unsigned int coeffs_id = 0) const;
   std::vector<unsigned int> getCoeffsIndices(const size_t index, const unsigned int coeffs_id = 0) const;
   size_t getHessianIndex(const size_t index1, const size_t index2, const unsigned int coeffs_id = 0) const;
   //
-  bool computeHessian() const {return compute_hessian_;}
-  bool diagonalHessian() const {return diagonal_hessian_;}
+  bool computeHessian() const {
+    return compute_hessian_;
+  }
+  bool diagonalHessian() const {
+    return diagonal_hessian_;
+  }
   //
-  bool optimizeCoeffs() const {return optimize_coeffs_;}
-  Optimizer* getOptimizerPntr() const {return optimizer_pntr_;}
+  bool optimizeCoeffs() const {
+    return optimize_coeffs_;
+  }
+  Optimizer* getOptimizerPntr() const {
+    return optimizer_pntr_;
+  }
   bool useMultipleWalkers() const;
   //
   unsigned int getIterationCounter() const;
@@ -208,66 +253,142 @@ class VesBias:
   void enableHessian(const bool diagonal_hessian=true);
   void disableHessian();
   //
-  void enableMultipleCoeffsSets() {use_multiple_coeffssets_=true;}
+  void enableMultipleCoeffsSets() {
+    use_multiple_coeffssets_=true;
+  }
   //
-  void enableDynamicTargetDistribution() {dynamic_targetdist_=true;}
-  void disableDynamicTargetDistribution() {dynamic_targetdist_=false;}
-  bool dynamicTargetDistribution() const {return dynamic_targetdist_;}
+  void enableDynamicTargetDistribution() {
+    dynamic_targetdist_=true;
+  }
+  void disableDynamicTargetDistribution() {
+    dynamic_targetdist_=false;
+  }
+  bool dynamicTargetDistribution() const {
+    return dynamic_targetdist_;
+  }
   //
-  std::vector<unsigned int> getGridBins() const {return grid_bins_;}
+  std::vector<unsigned int> getGridBins() const {
+    return grid_bins_;
+  }
   void setGridBins(const std::vector<unsigned int>&);
   void setGridBins(const unsigned int);
-  std::vector<double> getGridMax() const {return grid_max_;}
+  std::vector<double> getGridMax() const {
+    return grid_max_;
+  }
   void setGridMax(const std::vector<double>&);
-  std::vector<double> getGridMin() const {return grid_min_;}
+  std::vector<double> getGridMin() const {
+    return grid_min_;
+  }
   void setGridMin(const std::vector<double>&);
   //
-  bool filenamesIncludeIterationNumber() const {return filenames_have_iteration_number_;}
-  void enableIterationNumberInFilenames() {filenames_have_iteration_number_=true;}
+  bool filenamesIncludeIterationNumber() const {
+    return filenames_have_iteration_number_;
+  }
+  void enableIterationNumberInFilenames() {
+    filenames_have_iteration_number_=true;
+  }
   //
   std::string getIterationFilenameSuffix() const;
   std::string getCoeffsSetFilenameSuffix(const unsigned int coeffs_id) const;
   std::string getCurrentOutputFilename(const std::string&, const std::string& suffix="") const;
-  std::string getBiasOutputFilename() const {return bias_filename_;}
+  std::string getBiasOutputFilename() const {
+    return bias_filename_;
+  }
   std::string getCurrentBiasOutputFilename(const std::string& suffix="") const;
-  std::string getFesOutputFilename() const {return fes_filename_;}
+  std::string getFesOutputFilename() const {
+    return fes_filename_;
+  }
   std::string getCurrentFesOutputFilename(const std::string& suffix="") const;
-  std::string getTargetDistOutputFilename() const {return targetdist_filename_;}
+  std::string getTargetDistOutputFilename() const {
+    return targetdist_filename_;
+  }
   std::string getCurrentTargetDistOutputFilename(const std::string& suffix="") const;
   //
-  void enableBiasFileOutput() {bias_fileoutput_active_=true;}
-  void disableBiasFileOutput() {bias_fileoutput_active_=false;}
-  bool isBiasFileOutputActive() const {return bias_fileoutput_active_;}
-  std::string getBiasFileFmt() const {return bias_file_fmt_;}
+  void enableBiasFileOutput() {
+    bias_fileoutput_active_=true;
+  }
+  void disableBiasFileOutput() {
+    bias_fileoutput_active_=false;
+  }
+  bool isBiasFileOutputActive() const {
+    return bias_fileoutput_active_;
+  }
+  std::string getBiasFileFmt() const {
+    return bias_file_fmt_;
+  }
   //
-  void enableFesFileOutput() {fes_fileoutput_active_=true;}
-  void disableFesFileOutput() {fes_fileoutput_active_=false;}
-  bool isFesFileOutputActive() const {return fes_fileoutput_active_;}
-  std::string getFesFileFmt() const {return fes_file_fmt_;}
+  void enableFesFileOutput() {
+    fes_fileoutput_active_=true;
+  }
+  void disableFesFileOutput() {
+    fes_fileoutput_active_=false;
+  }
+  bool isFesFileOutputActive() const {
+    return fes_fileoutput_active_;
+  }
+  std::string getFesFileFmt() const {
+    return fes_file_fmt_;
+  }
   //
-  void enableFesProjFileOutput() {fesproj_fileoutput_active_=true;}
-  void disableFesFileProjOutput() {fesproj_fileoutput_active_=false;}
-  bool isFesProjFileOutputActive() const {return fesproj_fileoutput_active_;}
+  void enableFesProjFileOutput() {
+    fesproj_fileoutput_active_=true;
+  }
+  void disableFesFileProjOutput() {
+    fesproj_fileoutput_active_=false;
+  }
+  bool isFesProjFileOutputActive() const {
+    return fesproj_fileoutput_active_;
+  }
   //
-  void enableDynamicTargetDistFileOutput() {dynamic_targetdist_fileoutput_active_=true;}
-  void disableDynamicTargetDistFileOutput() {dynamic_targetdist_fileoutput_active_=false;}
-  bool isDynamicTargetDistFileOutputActive() const {return dynamic_targetdist_fileoutput_active_;}
-  std::string getTargetDistFileFmt() const {return targetdist_file_fmt_;}
-  std::string getTargetDistRestartFileFmt() const {return targetdist_restart_file_fmt_;}
+  void enableDynamicTargetDistFileOutput() {
+    dynamic_targetdist_fileoutput_active_=true;
+  }
+  void disableDynamicTargetDistFileOutput() {
+    dynamic_targetdist_fileoutput_active_=false;
+  }
+  bool isDynamicTargetDistFileOutputActive() const {
+    return dynamic_targetdist_fileoutput_active_;
+  }
+  std::string getTargetDistFileFmt() const {
+    return targetdist_file_fmt_;
+  }
+  std::string getTargetDistRestartFileFmt() const {
+    return targetdist_restart_file_fmt_;
+  }
   //
-  void enableStaticTargetDistFileOutput() {static_targetdist_fileoutput_active_=true;}
-  void disableStaticTargetDistFileOutput() {static_targetdist_fileoutput_active_=false;}
-  bool isStaticTargetDistFileOutputActive() const {return static_targetdist_fileoutput_active_;}
+  void enableStaticTargetDistFileOutput() {
+    static_targetdist_fileoutput_active_=true;
+  }
+  void disableStaticTargetDistFileOutput() {
+    static_targetdist_fileoutput_active_=false;
+  }
+  bool isStaticTargetDistFileOutputActive() const {
+    return static_targetdist_fileoutput_active_;
+  }
   //
-  std::vector< std::vector<std::string> > getProjectionArguments() const {return projection_args_;}
-  std::vector<std::string> getProjectionArgument(unsigned int i) const {return projection_args_[i];}
-  unsigned int getNumberOfProjectionArguments() const {return projection_args_.size();}
+  std::vector< std::vector<std::string> > getProjectionArguments() const {
+    return projection_args_;
+  }
+  std::vector<std::string> getProjectionArgument(unsigned int i) const {
+    return projection_args_[i];
+  }
+  unsigned int getNumberOfProjectionArguments() const {
+    return projection_args_.size();
+  }
   //
   void setupBiasCutoff(const double, const double);
-  bool biasCutoffActive() const {return bias_cutoff_active_;}
-  double getBiasCutoffValue() const {return bias_cutoff_value_;}
-  void setCurrentBiasMaxValue(const double max_value) {bias_current_max_value=max_value;}
-  double getCurrentBiasMaxValue() const {return bias_current_max_value;}
+  bool biasCutoffActive() const {
+    return bias_cutoff_active_;
+  }
+  double getBiasCutoffValue() const {
+    return bias_cutoff_value_;
+  }
+  void setCurrentBiasMaxValue(const double max_value) {
+    bias_current_max_value=max_value;
+  }
+  double getCurrentBiasMaxValue() const {
+    return bias_current_max_value;
+  }
   double getBiasCutoffSwitchingFunction(const double, double&) const;
   double getBiasCutoffSwitchingFunction(const double) const;
   void applyBiasCutoff(double&, std::vector<double>&) const;
@@ -297,18 +418,26 @@ class VesBias:
   //
   void updateReweightFactor();
   virtual double calculateReweightFactor() const;
-  bool isReweightFactorCalculated() const {return calc_reweightfactor_;}
+  bool isReweightFactorCalculated() const {
+    return calc_reweightfactor_;
+  }
 };
 
 
 inline
-size_t VesBias::getCoeffsIndex(const std::vector<unsigned int>& indices, const unsigned int coeffs_id) const {return coeffs_pntrs_[coeffs_id]->getIndex(indices);}
+size_t VesBias::getCoeffsIndex(const std::vector<unsigned int>& indices, const unsigned int coeffs_id) const {
+  return coeffs_pntrs_[coeffs_id]->getIndex(indices);
+}
 
 inline
-std::vector<unsigned int> VesBias::getCoeffsIndices(const size_t index, const unsigned int coeffs_id) const {return coeffs_pntrs_[coeffs_id]->getIndices(index);}
+std::vector<unsigned int> VesBias::getCoeffsIndices(const size_t index, const unsigned int coeffs_id) const {
+  return coeffs_pntrs_[coeffs_id]->getIndices(index);
+}
 
 inline
-size_t VesBias::getHessianIndex(const size_t index1, const size_t index2, const unsigned int coeffs_id) const {return hessian_pntrs_[coeffs_id]->getMatrixIndex(index1,index2);}
+size_t VesBias::getHessianIndex(const size_t index1, const size_t index2, const unsigned int coeffs_id) const {
+  return hessian_pntrs_[coeffs_id]->getMatrixIndex(index1,index2);
+}
 
 
 inline
@@ -392,7 +521,8 @@ bool VesBias::parseMultipleValues(const std::string& keyword, std::vector<T>& va
     identical_values=true;
   }
   if(values.size()>0 && values.size()!=nvalues) {
-    std::string s1; Tools::convert(nvalues,s1);
+    std::string s1;
+    Tools::convert(nvalues,s1);
     plumed_merror("Error in " + keyword + " keyword: either give 1 common parameter value or " + s1 + " separate parameter values");
   }
   return identical_values;
diff --git a/src/ves/VesDeltaF.cpp b/src/ves/VesDeltaF.cpp
index b5b19be940..854f2732fc 100644
--- a/src/ves/VesDeltaF.cpp
+++ b/src/ves/VesDeltaF.cpp
@@ -220,8 +220,7 @@ VesDeltaF::VesDeltaF(const ActionOptions&ao)
   , afterCalculate_(false)
   , mean_counter_(0)
   , av_counter_(0)
-  , work_(0)
-{
+  , work_(0) {
 //set beta
   const double Kb=getKBoltzmann();
   double KbT=getkBT();
@@ -234,11 +233,11 @@ VesDeltaF::VesDeltaF(const ActionOptions&ao)
   std::string funcl="file.free"; //typical name given by sum_hills
 
   std::vector<std::string> fes_names;
-  for(unsigned n=0;; n++)//NB: here we start from FILE_F0 not from FILE_F1
-  {
+  for(unsigned n=0;; n++) { //NB: here we start from FILE_F0 not from FILE_F1
     std::string filename;
-    if(!parseNumbered("FILE_F",n,filename))
+    if(!parseNumbered("FILE_F",n,filename)) {
       break;
+    }
     fes_names.push_back(filename);
     IFile gridfile;
     gridfile.open(filename);
@@ -257,8 +256,7 @@ VesDeltaF::VesDeltaF(const ActionOptions&ao)
   alpha_size_=grid_p_.size()-1;
   sym_alpha_size_=alpha_size_*(alpha_size_+1)/2; //useful for symmetric matrix [alpha_size_]x[alpha_size_]
   //check for consistency with first local free energy
-  for(unsigned n=1; n<grid_p_.size(); n++)
-  {
+  for(unsigned n=1; n<grid_p_.size(); n++) {
     std::string error_tag="FILE_F"+std::to_string(n)+" '"+fes_names[n]+"' not compatible with reference one, FILE_F0";
     plumed_massert(grid_p_[n]->getSize()==grid_p_[0]->getSize(),error_tag);
     plumed_massert(grid_p_[n]->getMin()==grid_p_[0]->getMin(),error_tag);
@@ -268,10 +266,10 @@ VesDeltaF::VesDeltaF(const ActionOptions&ao)
 
   bool no_mintozero=false;
   parseFlag("NO_MINTOZERO",no_mintozero);
-  if(!no_mintozero)
-  {
-    for(unsigned n=0; n<grid_p_.size(); n++)
+  if(!no_mintozero) {
+    for(unsigned n=0; n<grid_p_.size(); n++) {
       grid_p_[n]->setMinToZero();
+    }
   }
   bool normalize=false;
   parseFlag("NORMALIZE",normalize);
@@ -280,20 +278,18 @@ VesDeltaF::VesDeltaF(const ActionOptions&ao)
   //convert the FESs to probability distributions
   //NB: the spline interpolation will be done on the probability distributions, not on the given FESs
   const unsigned ncv=getNumberOfArguments(); //just for ease
-  for(unsigned n=0; n<grid_p_.size(); n++)
-  {
-    for(Grid::index_t t=0; t<grid_p_[n]->getSize(); t++)
-    {
+  for(unsigned n=0; n<grid_p_.size(); n++) {
+    for(Grid::index_t t=0; t<grid_p_[n]->getSize(); t++) {
       std::vector<double> der(ncv);
       const double val=std::exp(-beta_*grid_p_[n]->getValueAndDerivatives(t,der));
-      for(unsigned s=0; s<ncv; s++)
+      for(unsigned s=0; s<ncv; s++) {
         der[s]*=-beta_*val;
+      }
       grid_p_[n]->setValueAndDerivatives(t,val,der);
       norm_[n]+=val;
     }
     c_norm[n]=1./beta_*std::log(norm_[n]);
-    if(normalize)
-    {
+    if(normalize) {
       grid_p_[n]->scaleAllValuesAndDerivatives(1./norm_[n]);
       norm_[n]=1;
     }
@@ -303,10 +299,11 @@ VesDeltaF::VesDeltaF(const ActionOptions&ao)
   double biasfactor=0;
   parse("BIASFACTOR",biasfactor);
   plumed_massert(biasfactor==0 || biasfactor>1,"BIASFACTOR must be zero (for uniform target) or greater than one");
-  if(biasfactor==0)
+  if(biasfactor==0) {
     inv_gamma_=0;
-  else
+  } else {
     inv_gamma_=1./biasfactor;
+  }
   tg_counter_=0;
   tg_stride_=1;
   parse("TG_STRIDE",tg_stride_);
@@ -325,31 +322,31 @@ VesDeltaF::VesDeltaF(const ActionOptions&ao)
 
   mean_weight_tau_=0;
   parse("TAU_MEAN",mean_weight_tau_);
-  if(mean_weight_tau_!=1) //set it to 1 for basic SGD
-  {
+  if(mean_weight_tau_!=1) { //set it to 1 for basic SGD
     plumed_massert((mean_weight_tau_==0 || mean_weight_tau_>av_stride_),"TAU_MEAN is rescaled with AV_STRIDE, so it has to be greater");
     mean_weight_tau_/=av_stride_; //this way you can look at the number of simulation steps to choose TAU_MEAN
   }
 
   parseVector("INITIAL_ALPHA",mean_alpha_);
-  if(mean_alpha_.size()>0)
-  {
+  if(mean_alpha_.size()>0) {
     plumed_massert(mean_alpha_.size()==alpha_size_,"provide one INITIAL_ALPHA for each basin beyond the first one");
-  }
-  else
+  } else {
     mean_alpha_.resize(alpha_size_,0);
+  }
   inst_alpha_=mean_alpha_;
   exp_alpha_.resize(alpha_size_);
-  for(unsigned i=0; i<alpha_size_; i++)
+  for(unsigned i=0; i<alpha_size_; i++) {
     exp_alpha_[i]=std::exp(-beta_*mean_alpha_[i]);
+  }
   prev_exp_alpha_=exp_alpha_;
 
   damping_off_=false;
   parseFlag("DAMPING_OFF",damping_off_);
-  if(damping_off_)
+  if(damping_off_) {
     past_increment2_.resize(alpha_size_,1);
-  else
+  } else {
     past_increment2_.resize(alpha_size_,0);
+  }
 
 //file printing options
   std::string alphaFileName("ALPHA");
@@ -364,8 +361,7 @@ VesDeltaF::VesDeltaF(const ActionOptions&ao)
   rank_=comm.Get_rank();
   bool serial=false;
   parseFlag("SERIAL",serial);
-  if(serial)
-  {
+  if(serial) {
     log.printf(" -- SERIAL: running without loop parallelization\n");
     NumParallel_=1;
     rank_=0;
@@ -373,37 +369,35 @@ VesDeltaF::VesDeltaF(const ActionOptions&ao)
 
   bool multiple_walkers=false;
   parseFlag("MULTIPLE_WALKERS",multiple_walkers);
-  if(!multiple_walkers)
+  if(!multiple_walkers) {
     NumWalkers_=1;
-  else
-  {
-    if(comm.Get_rank()==0)//multi_sim_comm works well on first rank only
+  } else {
+    if(comm.Get_rank()==0) { //multi_sim_comm works well on first rank only
       NumWalkers_=multi_sim_comm.Get_size();
-    if(comm.Get_size()>1) //if each walker has more than one processor update them all
+    }
+    if(comm.Get_size()>1) { //if each walker has more than one processor update them all
       comm.Bcast(NumWalkers_,0);
+    }
   }
 
   checkRead();
 
 //restart if needed
-  if(getRestart())
-  {
+  if(getRestart()) {
     IFile ifile;
     ifile.link(*this);
-    if(NumWalkers_>1)
+    if(NumWalkers_>1) {
       ifile.enforceSuffix("");
-    if(ifile.FileExist(alphaFileName))
-    {
+    }
+    if(ifile.FileExist(alphaFileName)) {
       log.printf("  Restarting from: %s\n",alphaFileName.c_str());
       log.printf("    all options (also PRINT_STRIDE) must be consistent!\n");
       log.printf("    any INITIAL_ALPHA will be overwritten\n");
       ifile.open(alphaFileName);
       double time;
       std::vector<double> damping(alpha_size_);
-      while(ifile.scanField("time",time)) //room for improvements: only last line is important
-      {
-        for(unsigned i=0; i<alpha_size_; i++)
-        {
+      while(ifile.scanField("time",time)) { //room for improvements: only last line is important
+        for(unsigned i=0; i<alpha_size_; i++) {
           const std::string index(std::to_string(i+1));
           prev_exp_alpha_[i]=std::exp(-beta_*mean_alpha_[i]);
           ifile.scanField("alpha_"+index,mean_alpha_[i]);
@@ -413,80 +407,91 @@ VesDeltaF::VesDeltaF(const ActionOptions&ao)
         ifile.scanField();
         mean_counter_+=print_stride_;
       }
-      for(unsigned i=0; i<alpha_size_; i++)
-      {
+      for(unsigned i=0; i<alpha_size_; i++) {
         exp_alpha_[i]=std::exp(-beta_*mean_alpha_[i]);
         past_increment2_[i]=damping[i]*damping[i];
       }
       //sync all walkers and treads. Not sure is mandatory but is no harm
       comm.Barrier();
-      if(comm.Get_rank()==0)
+      if(comm.Get_rank()==0) {
         multi_sim_comm.Barrier();
-    }
-    else
+      }
+    } else {
       log.printf("  -- WARNING: restart requested, but no '%s' file found!\n",alphaFileName.c_str());
+    }
   }
 
 //setup output file with Alpha values
   alphaOfile_.link(*this);
-  if(NumWalkers_>1)
-  {
-    if(comm.Get_rank()==0 && multi_sim_comm.Get_rank()>0)
-      alphaFileName="/dev/null"; //only first walker writes on file
+  if(NumWalkers_>1) {
+    if(comm.Get_rank()==0 && multi_sim_comm.Get_rank()>0) {
+      alphaFileName="/dev/null";  //only first walker writes on file
+    }
     alphaOfile_.enforceSuffix("");
   }
   alphaOfile_.open(alphaFileName);
-  if(fmt.length()>0)
+  if(fmt.length()>0) {
     alphaOfile_.fmtField(" "+fmt);
+  }
 
 //add other output components
-  addComponent("rct"); componentIsNotPeriodic("rct");
-  addComponent("work"); componentIsNotPeriodic("work");
+  addComponent("rct");
+  componentIsNotPeriodic("rct");
+  addComponent("work");
+  componentIsNotPeriodic("work");
 
 //print some info
   log.printf("  Temperature T: %g\n",1./(Kb*beta_));
   log.printf("  Beta (1/Kb*T): %g\n",beta_);
   log.printf("  Local free energy basins files and normalization constants:\n");
-  for(unsigned n=0; n<grid_p_.size(); n++)
+  for(unsigned n=0; n<grid_p_.size(); n++) {
     log.printf("    F_%d filename: %s  c_%d=%g\n",n,fes_names[n].c_str(),n,c_norm[n]);
-  if(no_mintozero)
+  }
+  if(no_mintozero) {
     log.printf(" -- NO_MINTOZERO: local free energies are not shifted to be zero at minimum\n");
-  if(normalize)
+  }
+  if(normalize) {
     log.printf(" -- NORMALIZE: F_n+=c_n, alpha=DeltaF\n");
+  }
   log.printf("  Using target distribution with 1/gamma = %g\n",inv_gamma_);
   log.printf("    and updated with stride %d\n",tg_stride_);
   log.printf("  Step for the minimization algorithm: %g\n",minimization_step_);
   log.printf("  Stride for the ensemble average: %d\n",av_stride_);
-  if(mean_weight_tau_>1)
+  if(mean_weight_tau_>1) {
     log.printf("  Exponentially decaying average with weight=tau/av_stride=%d\n",mean_weight_tau_);
-  if(mean_weight_tau_==1)
+  }
+  if(mean_weight_tau_==1) {
     log.printf(" +++ WARNING +++ setting TAU_MEAN=1 is equivalent to use simple SGD, without mean alpha nor hessian contribution\n");
+  }
   log.printf("  Initial guess for alpha:\n");
-  for(unsigned i=0; i<alpha_size_; i++)
+  for(unsigned i=0; i<alpha_size_; i++) {
     log.printf("    alpha_%d = %g\n",i+1,mean_alpha_[i]);
-  if(damping_off_)
+  }
+  if(damping_off_) {
     log.printf(" -- DAMPING_OFF: the minimization step will NOT become smaller as the simulation goes on\n");
+  }
   log.printf("  Printing on file %s with stride %d\n",alphaFileName.c_str(),print_stride_);
-  if(serial)
+  if(serial) {
     log.printf(" -- SERIAL: running without loop parallelization\n");
-  if(NumParallel_>1)
+  }
+  if(NumParallel_>1) {
     log.printf("  Using multiple threads per simulation: %d\n",NumParallel_);
-  if(multiple_walkers)
-  {
+  }
+  if(multiple_walkers) {
     log.printf(" -- MULTIPLE_WALKERS: multiple simulations will combine statistics for the optimization\n");
-    if(NumWalkers_>1)
-    {
+    if(NumWalkers_>1) {
       log.printf("    number of walkers: %d\n",NumWalkers_);
       log.printf("    walker rank: %d\n",multi_sim_comm.Get_rank()); //only comm.Get_rank()=0 prints, so this is fine
-    }
-    else
+    } else {
       log.printf(" +++ WARNING +++ only one replica found: are you sure you are running MPI-connected simulations?\n");
+    }
   }
   log.printf(" Bibliography ");
   log<<plumed.cite("Invernizzi and Parrinello, J. Chem. Theory Comput. 15, 2187-2194 (2019)");
   log<<plumed.cite("Valsson and Parrinello, Phys. Rev. Lett. 113, 090601 (2014)");
-  if(inv_gamma_>0)
+  if(inv_gamma_>0) {
     log<<plumed.cite("Valsson and Parrinello, J. Chem. Theory Comput. 11, 1996-2002 (2015)");
+  }
 
 //last initializations
   prob_.resize(grid_p_.size());
@@ -494,37 +499,37 @@ VesDeltaF::VesDeltaF(const ActionOptions&ao)
   update_tg_and_rct();
 }
 
-void VesDeltaF::calculate()
-{
+void VesDeltaF::calculate() {
 //get CVs
   const unsigned ncv=getNumberOfArguments(); //just for ease
   std::vector<double> cv(ncv);
-  for(unsigned s=0; s<ncv; s++)
+  for(unsigned s=0; s<ncv; s++) {
     cv[s]=getArgument(s);
+  }
 //get probabilities for each basin, and total one
-  for(unsigned n=0; n<grid_p_.size(); n++)
+  for(unsigned n=0; n<grid_p_.size(); n++) {
     prob_[n]=grid_p_[n]->getValueAndDerivatives(cv,der_prob_[n]);
+  }
   tot_prob_=prob_[0];
-  for(unsigned i=0; i<alpha_size_; i++)
+  for(unsigned i=0; i<alpha_size_; i++) {
     tot_prob_+=prob_[i+1]*exp_alpha_[i];
+  }
 
 //update bias and forces: V=-(1-inv_gamma_)*fes
   setBias((1-inv_gamma_)/beta_*std::log(tot_prob_));
-  for(unsigned s=0; s<ncv; s++)
-  {
+  for(unsigned s=0; s<ncv; s++) {
     double dProb_dCV_s=der_prob_[0][s];
-    for(unsigned i=0; i<alpha_size_; i++)
+    for(unsigned i=0; i<alpha_size_; i++) {
       dProb_dCV_s+=der_prob_[i+1][s]*exp_alpha_[i];
+    }
     setOutputForce(s,-(1-inv_gamma_)/beta_/tot_prob_*dProb_dCV_s);
   }
   afterCalculate_=true;
 }
 
-void VesDeltaF::update()
-{
+void VesDeltaF::update() {
 //skip first step to sync getTime() and av_counter_, as in METAD
-  if(isFirstStep_)
-  {
+  if(isFirstStep_) {
     isFirstStep_=false;
     return;
   }
@@ -534,21 +539,20 @@ void VesDeltaF::update()
 //calculate derivatives for ensemble averages
   std::vector<double> dV_dAlpha(alpha_size_);
   std::vector<double> d2V_dAlpha2(sym_alpha_size_);
-  for(unsigned i=0; i<alpha_size_; i++)
+  for(unsigned i=0; i<alpha_size_; i++) {
     dV_dAlpha[i]=-(1-inv_gamma_)/tot_prob_*prob_[i+1]*exp_alpha_[i];
-  for(unsigned i=0; i<alpha_size_; i++)
-  {
+  }
+  for(unsigned i=0; i<alpha_size_; i++) {
     d2V_dAlpha2[get_index(i,i)]=-beta_*dV_dAlpha[i];
-    for(unsigned j=i; j<alpha_size_; j++)
+    for(unsigned j=i; j<alpha_size_; j++) {
       d2V_dAlpha2[get_index(i,j)]-=beta_/(1-inv_gamma_)*dV_dAlpha[i]*dV_dAlpha[j];
+    }
   }
 //update ensemble averages
   av_counter_++;
-  for(unsigned i=0; i<alpha_size_; i++)
-  {
+  for(unsigned i=0; i<alpha_size_; i++) {
     av_dV_dAlpha_[i]+=(dV_dAlpha[i]-av_dV_dAlpha_[i])/av_counter_;
-    for(unsigned j=i; j<alpha_size_; j++)
-    {
+    for(unsigned j=i; j<alpha_size_; j++) {
       const unsigned ij=get_index(i,j);
       av_dV_dAlpha_prod_[ij]+=(dV_dAlpha[i]*dV_dAlpha[j]-av_dV_dAlpha_prod_[ij])/av_counter_;
       av_d2V_dAlpha2_[ij]+=(d2V_dAlpha2[ij]-av_d2V_dAlpha2_[ij])/av_counter_;
@@ -556,17 +560,16 @@ void VesDeltaF::update()
   }
 //update work
   double prev_tot_prob=prob_[0];
-  for(unsigned i=0; i<alpha_size_; i++)
+  for(unsigned i=0; i<alpha_size_; i++) {
     prev_tot_prob+=prob_[i+1]*prev_exp_alpha_[i];
+  }
   work_+=(1-inv_gamma_)/beta_*std::log(tot_prob_/prev_tot_prob);
 
 //update coefficients
-  if(av_counter_==av_stride_)
-  {
+  if(av_counter_==av_stride_) {
     update_alpha();
     tg_counter_++;
-    if(tg_counter_==tg_stride_)
-    {
+    if(tg_counter_==tg_stride_) {
       update_tg_and_rct();
       tg_counter_=0;
     }
@@ -578,73 +581,75 @@ void VesDeltaF::update()
   }
 }
 
-void VesDeltaF::update_tg_and_rct()
-{
+void VesDeltaF::update_tg_and_rct() {
 //calculate target averages
   double Z_0=norm_[0];
-  for(unsigned i=0; i<alpha_size_; i++)
+  for(unsigned i=0; i<alpha_size_; i++) {
     Z_0+=norm_[i+1]*exp_alpha_[i];
+  }
   double Z_tg=0;
   std::fill(tg_dV_dAlpha_.begin(),tg_dV_dAlpha_.end(),0);
   std::fill(tg_d2V_dAlpha2_.begin(),tg_d2V_dAlpha2_.end(),0);
-  for(Grid::index_t t=rank_; t<grid_p_[0]->getSize(); t+=NumParallel_)
-  { //TODO can we recycle some code?
+  for(Grid::index_t t=rank_; t<grid_p_[0]->getSize(); t+=NumParallel_) {
+    //TODO can we recycle some code?
     std::vector<double> prob(grid_p_.size());
-    for(unsigned n=0; n<grid_p_.size(); n++)
+    for(unsigned n=0; n<grid_p_.size(); n++) {
       prob[n]=grid_p_[n]->getValue(t);
+    }
     double tot_prob=prob[0];
-    for(unsigned i=0; i<alpha_size_; i++)
+    for(unsigned i=0; i<alpha_size_; i++) {
       tot_prob+=prob[i+1]*exp_alpha_[i];
+    }
     std::vector<double> dV_dAlpha(alpha_size_);
     std::vector<double> d2V_dAlpha2(sym_alpha_size_);
-    for(unsigned i=0; i<alpha_size_; i++)
+    for(unsigned i=0; i<alpha_size_; i++) {
       dV_dAlpha[i]=-(1-inv_gamma_)/tot_prob*prob[i+1]*exp_alpha_[i];
-    for(unsigned i=0; i<alpha_size_; i++)
-    {
+    }
+    for(unsigned i=0; i<alpha_size_; i++) {
       d2V_dAlpha2[get_index(i,i)]=-beta_*dV_dAlpha[i];
-      for(unsigned j=i; j<alpha_size_; j++)
+      for(unsigned j=i; j<alpha_size_; j++) {
         d2V_dAlpha2[get_index(i,j)]-=beta_/(1-inv_gamma_)*dV_dAlpha[i]*dV_dAlpha[j];
+      }
     }
     const double unnorm_tg_p=std::pow(tot_prob,inv_gamma_);
     Z_tg+=unnorm_tg_p;
-    for(unsigned i=0; i<alpha_size_; i++)
+    for(unsigned i=0; i<alpha_size_; i++) {
       tg_dV_dAlpha_[i]+=unnorm_tg_p*dV_dAlpha[i];
-    for(unsigned ij=0; ij<sym_alpha_size_; ij++)
+    }
+    for(unsigned ij=0; ij<sym_alpha_size_; ij++) {
       tg_d2V_dAlpha2_[ij]+=unnorm_tg_p*d2V_dAlpha2[ij];
+    }
   }
-  if(NumParallel_>1)
-  {
+  if(NumParallel_>1) {
     comm.Sum(Z_tg);
     comm.Sum(tg_dV_dAlpha_);
     comm.Sum(tg_d2V_dAlpha2_);
   }
-  for(unsigned i=0; i<alpha_size_; i++)
+  for(unsigned i=0; i<alpha_size_; i++) {
     tg_dV_dAlpha_[i]/=Z_tg;
-  for(unsigned ij=0; ij<sym_alpha_size_; ij++)
+  }
+  for(unsigned ij=0; ij<sym_alpha_size_; ij++) {
     tg_d2V_dAlpha2_[ij]/=Z_tg;
+  }
   getPntrToComponent("rct")->set(-1./beta_*std::log(Z_tg/Z_0)); //Z_tg is the best available estimate of Z_V
 }
 
-void VesDeltaF::update_alpha()
-{
+void VesDeltaF::update_alpha() {
 //combining the averages of multiple walkers
-  if(NumWalkers_>1)
-  {
-    if(comm.Get_rank()==0) //sum only once: in the first rank of each walker
-    {
+  if(NumWalkers_>1) {
+    if(comm.Get_rank()==0) { //sum only once: in the first rank of each walker
       multi_sim_comm.Sum(av_dV_dAlpha_);
       multi_sim_comm.Sum(av_dV_dAlpha_prod_);
       multi_sim_comm.Sum(av_d2V_dAlpha2_);
-      for(unsigned i=0; i<alpha_size_; i++)
+      for(unsigned i=0; i<alpha_size_; i++) {
         av_dV_dAlpha_[i]/=NumWalkers_;
-      for(unsigned ij=0; ij<sym_alpha_size_; ij++)
-      {
+      }
+      for(unsigned ij=0; ij<sym_alpha_size_; ij++) {
         av_dV_dAlpha_prod_[ij]/=NumWalkers_;
         av_d2V_dAlpha2_[ij]/=NumWalkers_;
       }
     }
-    if(comm.Get_size()>1)//if there are more ranks for each walker, everybody has to know
-    {
+    if(comm.Get_size()>1) { //if there are more ranks for each walker, everybody has to know
       comm.Bcast(av_dV_dAlpha_,0);
       comm.Bcast(av_dV_dAlpha_prod_,0);
       comm.Bcast(av_d2V_dAlpha2_,0);
@@ -657,11 +662,9 @@ void VesDeltaF::update_alpha()
 //build the gradient and the Hessian of the functional
   std::vector<double> grad_omega(alpha_size_);
   std::vector<double> hess_omega(sym_alpha_size_);
-  for(unsigned i=0; i<alpha_size_; i++)
-  {
+  for(unsigned i=0; i<alpha_size_; i++) {
     grad_omega[i]=tg_dV_dAlpha_[i]-av_dV_dAlpha_[i];
-    for(unsigned j=i; j<alpha_size_; j++)
-    {
+    for(unsigned j=i; j<alpha_size_; j++) {
       const unsigned ij=get_index(i,j);
       hess_omega[ij]=beta_*(av_dV_dAlpha_prod_[ij]-av_dV_dAlpha_[i]*av_dV_dAlpha_[j])+tg_d2V_dAlpha2_[ij]-av_d2V_dAlpha2_[ij];
     }
@@ -669,16 +672,18 @@ void VesDeltaF::update_alpha()
 //calculate the increment and update alpha
   mean_counter_++;
   long long unsigned mean_weight=mean_counter_;
-  if(mean_weight_tau_>0 && mean_weight_tau_<mean_counter_)
+  if(mean_weight_tau_>0 && mean_weight_tau_<mean_counter_) {
     mean_weight=mean_weight_tau_;
+  }
   std::vector<double> damping(alpha_size_);
-  for(unsigned i=0; i<alpha_size_; i++)
-  {
+  for(unsigned i=0; i<alpha_size_; i++) {
     double increment_i=grad_omega[i];
-    for(unsigned j=0; j<alpha_size_; j++)
+    for(unsigned j=0; j<alpha_size_; j++) {
       increment_i+=hess_omega[get_index(i,j)]*(inst_alpha_[j]-mean_alpha_[j]);
-    if(!damping_off_)
+    }
+    if(!damping_off_) {
       past_increment2_[i]+=increment_i*increment_i;
+    }
     damping[i]=std::sqrt(past_increment2_[i]);
     prev_exp_alpha_[i]=std::exp(-beta_*mean_alpha_[i]);
     inst_alpha_[i]-=minimization_step_/damping[i]*increment_i;
@@ -687,11 +692,9 @@ void VesDeltaF::update_alpha()
   }
 
 //update the Alpha file
-  if(mean_counter_%print_stride_==0)
-  {
+  if(mean_counter_%print_stride_==0) {
     alphaOfile_.printField("time",getTime());
-    for(unsigned i=0; i<alpha_size_; i++)
-    {
+    for(unsigned i=0; i<alpha_size_; i++) {
       const std::string index(std::to_string(i+1));
       alphaOfile_.printField("alpha_"+index,mean_alpha_[i]);
       alphaOfile_.printField("auxiliary_"+index,inst_alpha_[i]);
@@ -702,12 +705,12 @@ void VesDeltaF::update_alpha()
 }
 
 //mapping of a [alpha_size_]x[alpha_size_] symmetric matrix into a vector of size sym_alpha_size_, useful for the communicator
-inline unsigned VesDeltaF::get_index(const unsigned i, const unsigned j) const
-{
-  if(i<=j)
+inline unsigned VesDeltaF::get_index(const unsigned i, const unsigned j) const {
+  if(i<=j) {
     return j+i*(alpha_size_-1)-i*(i-1)/2;
-  else
+  } else {
     return get_index(j,i);
+  }
 }
 
 }
diff --git a/src/ves/VesLinearExpansion.cpp b/src/ves/VesLinearExpansion.cpp
index 2d237ad6f0..db0f832e2e 100644
--- a/src/ves/VesLinearExpansion.cpp
+++ b/src/ves/VesLinearExpansion.cpp
@@ -340,15 +340,16 @@ VesLinearExpansion::VesLinearExpansion(const ActionOptions&ao):
   valueForce2_(NULL),
   all_values_inside(true),
   bf_values(0),
-  bf_values_set(false)
-{
+  bf_values_set(false) {
   std::vector<std::string> basisf_labels;
   parseMultipleValues("BASIS_FUNCTIONS",basisf_labels,nargs_);
   checkRead();
 
   std::string error_msg = "";
   basisf_pntrs_ = VesTools::getPointersFromLabels<BasisFunctions*>(basisf_labels,plumed.getActionSet(),error_msg);
-  if(error_msg.size()>0) {plumed_merror("Error in keyword BASIS_FUNCTIONS of "+getName()+": "+error_msg);}
+  if(error_msg.size()>0) {
+    plumed_merror("Error in keyword BASIS_FUNCTIONS of "+getName()+": "+error_msg);
+  }
   //
 
   std::vector<Value*> args_pntrs = getArguments();
@@ -358,8 +359,7 @@ VesLinearExpansion::VesLinearExpansion(const ActionOptions&ao):
   for(unsigned int i=0; i<args_pntrs.size(); i++) {
     if(args_pntrs[i]->isPeriodic() && !(basisf_pntrs_[i]->arePeriodic()) ) {
       plumed_merror("argument "+args_pntrs[i]->getName()+" is periodic while the basis functions " + basisf_pntrs_[i]->getLabel()+ " are not. You need to use the COMBINE action to remove the periodicity of the argument if you want to use these basis functions");
-    }
-    else if(!(args_pntrs[i]->isPeriodic()) && basisf_pntrs_[i]->arePeriodic() ) {
+    } else if(!(args_pntrs[i]->isPeriodic()) && basisf_pntrs_[i]->arePeriodic() ) {
       log.printf("  warning: argument %s is not periodic while the basis functions %s used for it are periodic\n",args_pntrs[i]->getName().c_str(),basisf_pntrs_[i]->getLabel().c_str());
     }
   }
@@ -381,13 +381,13 @@ VesLinearExpansion::VesLinearExpansion(const ActionOptions&ao):
     log.printf("  using an uniform target distribution: \n");
     bias_expansion_pntr_->setupUniformTargetDistribution();
     disableStaticTargetDistFileOutput();
-  }
-  else if(getNumberOfTargetDistributionPntrs()==1) {
-    if(biasCutoffActive()) {getTargetDistributionPntrs()[0]->setupBiasCutoff();}
+  } else if(getNumberOfTargetDistributionPntrs()==1) {
+    if(biasCutoffActive()) {
+      getTargetDistributionPntrs()[0]->setupBiasCutoff();
+    }
     bias_expansion_pntr_->setupTargetDistribution(getTargetDistributionPntrs()[0]);
     log.printf("  using target distribution of type %s with label %s \n",getTargetDistributionPntrs()[0]->getName().c_str(),getTargetDistributionPntrs()[0]->getLabel().c_str());
-  }
-  else {
+  } else {
     plumed_merror("problem with the TARGET_DISTRIBUTION keyword, either give no label or just one label.");
   }
   setTargetDistAverages(bias_expansion_pntr_->TargetDistAverages());
@@ -401,7 +401,8 @@ VesLinearExpansion::VesLinearExpansion(const ActionOptions&ao):
     VesLinearExpansion::writeBiasToFile();
   }
 
-  addComponent("force2"); componentIsNotPeriodic("force2");
+  addComponent("force2");
+  componentIsNotPeriodic("force2");
   valueForce2_=getPntrToComponent("force2");
 }
 
diff --git a/src/ves/VesTools.cpp b/src/ves/VesTools.cpp
index 8969454dc4..a126df55a5 100644
--- a/src/ves/VesTools.cpp
+++ b/src/ves/VesTools.cpp
@@ -46,7 +46,8 @@ void VesTools::copyGridValues(GridBase* grid_pntr_orig, GridBase* grid_pntr_copy
 
 unsigned int VesTools::getGridFileInfo(const std::string& filepath, std::string& grid_label, std::vector<std::string>& arg_labels, std::vector<std::string>& arg_min, std::vector<std::string>& arg_max, std::vector<bool>& arg_periodic, std::vector<unsigned int>& arg_nbins, bool& derivatives) {
 
-  IFile ifile; ifile.open(filepath);
+  IFile ifile;
+  ifile.open(filepath);
   std::vector<std::string> fields;
   ifile.scanFieldList(fields);
   ifile.allowIgnoredFields();
@@ -58,8 +59,7 @@ unsigned int VesTools::getGridFileInfo(const std::string& filepath, std::string&
       derivatives = false;
       nargs = i-1;
       break;
-    }
-    else if(fields[i]=="der_"+fields[0]) {
+    } else if(fields[i]=="der_"+fields[0]) {
       derivatives = true;
       nargs = i-1;
       break;
@@ -79,7 +79,9 @@ unsigned int VesTools::getGridFileInfo(const std::string& filepath, std::string&
     ifile.scanField("max_"+arg_labels[i],arg_max[i]);
     std::string str_periodic;
     ifile.scanField("periodic_"+arg_labels[i],str_periodic);
-    if(str_periodic=="true") {arg_periodic[i]=true;}
+    if(str_periodic=="true") {
+      arg_periodic[i]=true;
+    }
     int nbins;
     ifile.scanField("nbins_"+arg_labels[i],nbins);
     arg_nbins[i] = static_cast<unsigned int>(nbins);
diff --git a/src/ves/VesTools.h b/src/ves/VesTools.h
index 926c641e1e..8ee52cea79 100644
--- a/src/ves/VesTools.h
+++ b/src/ves/VesTools.h
@@ -72,7 +72,9 @@ void VesTools::convertDbl2Str(const double value,std::string& str) {
 inline
 unsigned int log2(unsigned value) {
   unsigned int result = 0;
-  while(value >>= 1) result++;
+  while(value >>= 1) {
+    result++;
+  }
   return result;
 }
 
@@ -112,10 +114,11 @@ std::vector<T> VesTools::getPointersFromLabels(const std::vector<std::string>& a
   if(missing.size()>0) {
     if(missing.size()==1) {
       error_msg = "label "+missing[0]+" does not exist\n";
-    }
-    else if(missing.size()>1) {
+    } else if(missing.size()>1) {
       std::string tmp="";
-      for(unsigned int j=0; j<missing.size(); j++) {tmp +=missing[j]+" ";}
+      for(unsigned int j=0; j<missing.size(); j++) {
+        tmp +=missing[j]+" ";
+      }
       error_msg = "labels "+tmp+"do not exist\n";
     }
     std::vector<T> avail_action_pntrs = actionset.select<T>();
@@ -124,8 +127,7 @@ std::vector<T> VesTools::getPointersFromLabels(const std::vector<std::string>& a
       for(unsigned int i=0; i<avail_action_pntrs.size(); i++) {
         error_msg += "             " + avail_action_pntrs[i]->getName() + " with label " + avail_action_pntrs[i]->getLabel() + "\n";
       }
-    }
-    else {
+    } else {
       error_msg += "             Hint! no actions defined in the input file that can be used here, they should be defined before this actions\n";
     }
   }
diff --git a/src/ves/WaveletGrid.cpp b/src/ves/WaveletGrid.cpp
index 6f6b42eabf..efde4de3ae 100644
--- a/src/ves/WaveletGrid.cpp
+++ b/src/ves/WaveletGrid.cpp
@@ -42,7 +42,9 @@ std::unique_ptr<Grid> WaveletGrid::setupGrid(const unsigned order, unsigned grid
   unsigned maxsupport = order*2 -1;
   // determine needed recursion depth for specified size
   unsigned recursion_number = 0;
-  while (maxsupport*(1U<<recursion_number) < gridsize) { recursion_number++; }
+  while (maxsupport*(1U<<recursion_number) < gridsize) {
+    recursion_number++;
+  }
   // set "true" gridsize
   unsigned bins_per_int = 1U<<recursion_number;
   gridsize = maxsupport*bins_per_int;
@@ -62,8 +64,7 @@ std::unique_ptr<Grid> WaveletGrid::setupGrid(const unsigned order, unsigned grid
     std::vector<double> g_coeffs = getFilterCoefficients(order, false, type);
     g_Matvec = setupMatrices(g_coeffs);
     gridvarname = typeToString(type,true)+std::to_string(order)+"_psi";
-  }
-  else {
+  } else {
     gridvarname = typeToString(type,true)+std::to_string(order)+"_phi";
   }
 
@@ -84,7 +85,8 @@ std::unique_ptr<Grid> WaveletGrid::setupGrid(const unsigned order, unsigned grid
 std::vector<Matrix<double>> WaveletGrid::setupMatrices(const std::vector<double>& coeffs) {
   Matrix<double> M0, M1;
   const int N = coeffs.size() -1;
-  M0.resize(N,N); M1.resize(N,N);
+  M0.resize(N,N);
+  M1.resize(N,N);
   for (int i = 0; i < N; ++i) {
     for (int j = 0; j < N; ++j) {
       int shift = 2*i -j;
@@ -133,9 +135,12 @@ std::vector<double> WaveletGrid::getEigenvector(const Matrix<double> &A, const d
   std::vector<int> iwork(8*N);
 
   // Transfer the matrix to the local array and substract eigenvalue
-  for (int i=0; i<N; ++i) for (int j=0; j<N; ++j) {
+  for (int i=0; i<N; ++i)
+    for (int j=0; j<N; ++j) {
       da[i*N+j]=static_cast<double>( A(j,i) );
-      if (i==j) da[i*N+j] -= eigenvalue;
+      if (i==j) {
+        da[i*N+j] -= eigenvalue;
+      }
     }
 
   // This optimizes the size of the work array used in lapack singular value decomposition
@@ -144,14 +149,17 @@ std::vector<double> WaveletGrid::getEigenvector(const Matrix<double> &A, const d
   plumed_lapack_dgesdd( "A", &N, &N, da.data(), &N, S.data(), U.data(), &N, VT.data(), &N, work.data(), &lwork, iwork.data(), &info );
 
   // Retrieve correct sizes for work and reallocate
-  lwork=static_cast<int>(work[0]); work.resize(lwork);
+  lwork=static_cast<int>(work[0]);
+  work.resize(lwork);
 
   // This does the singular value decomposition
   plumed_lapack_dgesdd( "A", &N, &N, da.data(), &N, S.data(), U.data(), &N, VT.data(), &N, work.data(), &lwork, iwork.data(), &info );
 
   // fill eigenvector with last column of VT
   std::vector<double> eigenvector(N);
-  for (int i=0; i<N; ++i) eigenvector[i] = VT[N-1 + i*N];
+  for (int i=0; i<N; ++i) {
+    eigenvector[i] = VT[N-1 + i*N];
+  }
 
   return eigenvector;
 }
@@ -166,11 +174,17 @@ WaveletGrid::BinaryMap WaveletGrid::cascade(std::vector<Matrix<double>>& h_Matve
   std::vector<double> temp_values;
 
   // multiply matrices by 2 if derivatives are calculated (assumes ascending order)
-  if (derivnum != 0) for (auto& M : h_Matvec) M *= 2;
+  if (derivnum != 0)
+    for (auto& M : h_Matvec) {
+      M *= 2;
+    }
 
   if (use_mother_wavelet) {
     wavelet_map.reserve(bins_per_int);
-    if (derivnum != 0) for (auto& M : g_Matvec) M *= 2;
+    if (derivnum != 0)
+      for (auto& M : g_Matvec) {
+        M *= 2;
+      }
   }
 
   // fill the first two datasets by hand
@@ -231,8 +245,11 @@ void WaveletGrid::fillGridFromMaps(std::unique_ptr<Grid>& grid, const BinaryMap&
 
 WaveletGrid::Type WaveletGrid::stringToType(std::string& type_str) {
   std::unordered_map<std::string, Type> typemap = { {"DAUBECHIES", Type::db}, {"SYMLETS", Type::sym} };
-  try { return typemap.at(type_str); }
-  catch(const std::out_of_range& e) {plumed_merror("The specified wavelet type "+type_str+" is not implemented."); }
+  try {
+    return typemap.at(type_str);
+  } catch(const std::out_of_range& e) {
+    plumed_merror("The specified wavelet type "+type_str+" is not implemented.");
+  }
 }
 
 
diff --git a/src/volumes/ActionVolume.cpp b/src/volumes/ActionVolume.cpp
index 9d2e955edf..296f8e6dfa 100644
--- a/src/volumes/ActionVolume.cpp
+++ b/src/volumes/ActionVolume.cpp
@@ -37,34 +37,55 @@ void ActionVolume::registerKeywords( Keywords& keys ) {
 
 ActionVolume::ActionVolume(const ActionOptions&ao):
   Action(ao),
-  ActionWithVector(ao)
-{
-  std::vector<AtomNumber> atoms; parseAtomList("ATOMS",atoms);
-  if( atoms.size()==0 ) error("no atoms were specified");
+  ActionWithVector(ao) {
+  std::vector<AtomNumber> atoms;
+  parseAtomList("ATOMS",atoms);
+  if( atoms.size()==0 ) {
+    error("no atoms were specified");
+  }
   log.printf("  examining positions of atoms ");
-  for(unsigned i=0; i<atoms.size(); ++i) log.printf(" %d", atoms[i].serial() );
-  log.printf("\n"); ActionAtomistic::requestAtoms( atoms );
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf(" %d", atoms[i].serial() );
+  }
+  log.printf("\n");
+  ActionAtomistic::requestAtoms( atoms );
 
-  parseFlag("OUTSIDE",not_in); sigma=0.0;
-  if( keywords.exists("SIGMA") ) parse("SIGMA",sigma);
-  if( keywords.exists("KERNEL") ) parse("KERNEL",kerneltype);
+  parseFlag("OUTSIDE",not_in);
+  sigma=0.0;
+  if( keywords.exists("SIGMA") ) {
+    parse("SIGMA",sigma);
+  }
+  if( keywords.exists("KERNEL") ) {
+    parse("KERNEL",kerneltype);
+  }
 
-  if( atoms.size()==1 ) ActionWithValue::addValueWithDerivatives();
-  else { std::vector<unsigned> shape(1); shape[0]=atoms.size(); ActionWithValue::addValue( shape ); }
-  setNotPeriodic(); getPntrToComponent(0)->setDerivativeIsZeroWhenValueIsZero();
+  if( atoms.size()==1 ) {
+    ActionWithValue::addValueWithDerivatives();
+  } else {
+    std::vector<unsigned> shape(1);
+    shape[0]=atoms.size();
+    ActionWithValue::addValue( shape );
+  }
+  setNotPeriodic();
+  getPntrToComponent(0)->setDerivativeIsZeroWhenValueIsZero();
 }
 
 bool ActionVolume::isInSubChain( unsigned& nder ) {
-  nder = 0; getFirstActionInChain()->getNumberOfStreamedDerivatives( nder, getPntrToComponent(0) );
+  nder = 0;
+  getFirstActionInChain()->getNumberOfStreamedDerivatives( nder, getPntrToComponent(0) );
   nder = nder - getNumberOfDerivatives();
   return true;
 }
 
 void ActionVolume::requestAtoms( const std::vector<AtomNumber> & a ) {
   std::vector<AtomNumber> all_atoms( getAbsoluteIndexes() );
-  for(unsigned i=0; i<a.size(); ++i) all_atoms.push_back( a[i] );
+  for(unsigned i=0; i<a.size(); ++i) {
+    all_atoms.push_back( a[i] );
+  }
   ActionAtomistic::requestAtoms( all_atoms );
-  if( getPntrToComponent(0)->getRank()==0 ) getPntrToComponent(0)->resizeDerivatives( 3*getNumberOfAtoms()+9 );
+  if( getPntrToComponent(0)->getRank()==0 ) {
+    getPntrToComponent(0)->resizeDerivatives( 3*getNumberOfAtoms()+9 );
+  }
 }
 
 void ActionVolume::areAllTasksRequired( std::vector<ActionWithVector*>& task_reducing_actions ) {
@@ -72,65 +93,110 @@ void ActionVolume::areAllTasksRequired( std::vector<ActionWithVector*>& task_red
 }
 
 void ActionVolume::getNumberOfTasks( unsigned& ntasks ) {
-  setupRegions(); ActionWithVector::getNumberOfTasks( ntasks );
+  setupRegions();
+  ActionWithVector::getNumberOfTasks( ntasks );
 }
 
 int ActionVolume::checkTaskStatus( const unsigned& taskno, int& flag ) const {
   unsigned nref=getNumberOfAtoms()-getConstPntrToComponent(0)->getShape()[0];
-  Vector wdf; Tensor vir; std::vector<Vector> refders( nref );
+  Vector wdf;
+  Tensor vir;
+  std::vector<Vector> refders( nref );
   double weight=calculateNumberInside( ActionAtomistic::getPosition(taskno), wdf, vir, refders );
-  if( not_in ) weight = 1.0 - weight;
-  if( weight>epsilon ) return 1;
+  if( not_in ) {
+    weight = 1.0 - weight;
+  }
+  if( weight>epsilon ) {
+    return 1;
+  }
   return 0;
 }
 
 void ActionVolume::calculate() {
-  if( actionInChain() ) return;
+  if( actionInChain() ) {
+    return;
+  }
   if( getPntrToComponent(0)->getRank()==0 ) {
-    setupRegions(); unsigned nref = getNumberOfAtoms() - 1;
-    Vector wdf; Tensor vir; std::vector<Vector> refders( nref );
+    setupRegions();
+    unsigned nref = getNumberOfAtoms() - 1;
+    Vector wdf;
+    Tensor vir;
+    std::vector<Vector> refders( nref );
     double weight=calculateNumberInside( ActionAtomistic::getPosition(0), wdf, vir, refders );
     if( not_in ) {
-      weight = 1.0 - weight; wdf *= -1.; vir *=-1;
-      for(unsigned i=0; i<refders.size(); ++i) refders[i]*=-1;
+      weight = 1.0 - weight;
+      wdf *= -1.;
+      vir *=-1;
+      for(unsigned i=0; i<refders.size(); ++i) {
+        refders[i]*=-1;
+      }
     }
     // Atom position
-    Value* v = getPntrToComponent(0); v->set( weight );
-    for(unsigned i=0; i<3; ++i ) v->addDerivative( i, wdf[i] );
+    Value* v = getPntrToComponent(0);
+    v->set( weight );
+    for(unsigned i=0; i<3; ++i ) {
+      v->addDerivative( i, wdf[i] );
+    }
     // Add derivatives with respect to reference positions
     for(unsigned i=0; i<refders.size(); ++i) {
-      for(unsigned j=0; j<3; ++j ) v->addDerivative( 3 + 3*i + j, refders[i][j] );
+      for(unsigned j=0; j<3; ++j ) {
+        v->addDerivative( 3 + 3*i + j, refders[i][j] );
+      }
     }
     // Add virial
     unsigned vbase = 3*getNumberOfAtoms();
-    for(unsigned i=0; i<3; ++i) for(unsigned j=0; j<3; ++j) v->addDerivative( vbase + 3*i + j, vir(i,j) );
-  } else runAllTasks();
+    for(unsigned i=0; i<3; ++i)
+      for(unsigned j=0; j<3; ++j) {
+        v->addDerivative( vbase + 3*i + j, vir(i,j) );
+      }
+  } else {
+    runAllTasks();
+  }
 }
 
 void ActionVolume::performTask( const unsigned& curr, MultiValue& outvals ) const {
   unsigned nref=getNumberOfAtoms()-getConstPntrToComponent(0)->getShape()[0];
-  Vector wdf; Tensor vir; std::vector<Vector> refders( nref );
+  Vector wdf;
+  Tensor vir;
+  std::vector<Vector> refders( nref );
   double weight=calculateNumberInside( ActionAtomistic::getPosition(curr), wdf, vir, refders );
 
   if( not_in ) {
-    weight = 1.0 - weight; wdf *= -1.; vir *=-1;
-    for(unsigned i=0; i<refders.size(); ++i) refders[i]*=-1;
+    weight = 1.0 - weight;
+    wdf *= -1.;
+    vir *=-1;
+    for(unsigned i=0; i<refders.size(); ++i) {
+      refders[i]*=-1;
+    }
   }
   unsigned ostrn = getConstPntrToComponent(0)->getPositionInStream();
   outvals.setValue( ostrn, weight );
 
-  if( doNotCalculateDerivatives() ) return;
+  if( doNotCalculateDerivatives() ) {
+    return;
+  }
 
   // Atom position
-  for(unsigned i=0; i<3; ++i ) { outvals.addDerivative( ostrn, 3*curr+i, wdf[i] ); outvals.updateIndex( ostrn, 3*curr+i ); }
+  for(unsigned i=0; i<3; ++i ) {
+    outvals.addDerivative( ostrn, 3*curr+i, wdf[i] );
+    outvals.updateIndex( ostrn, 3*curr+i );
+  }
   // Add derivatives with respect to reference positions
   unsigned vbase = 3*(getNumberOfAtoms()-nref);
   for(unsigned i=0; i<refders.size(); ++i) {
-    for(unsigned j=0; j<3; ++j ) { outvals.addDerivative( ostrn, vbase, refders[i][j] ); outvals.updateIndex( ostrn, vbase ); vbase++; }
+    for(unsigned j=0; j<3; ++j ) {
+      outvals.addDerivative( ostrn, vbase, refders[i][j] );
+      outvals.updateIndex( ostrn, vbase );
+      vbase++;
+    }
   }
   // Add virial
   for(unsigned i=0; i<3; ++i) {
-    for(unsigned j=0; j<3; ++j) { outvals.addDerivative( ostrn, vbase, vir(i,j) ); outvals.updateIndex( ostrn, vbase ); vbase++; }
+    for(unsigned j=0; j<3; ++j) {
+      outvals.addDerivative( ostrn, vbase, vir(i,j) );
+      outvals.updateIndex( ostrn, vbase );
+      vbase++;
+    }
   }
 }
 
diff --git a/src/volumes/ActionVolume.h b/src/volumes/ActionVolume.h
index cafd04ff83..fe83dcee4e 100644
--- a/src/volumes/ActionVolume.h
+++ b/src/volumes/ActionVolume.h
@@ -79,7 +79,9 @@ std::string ActionVolume::getKernelType() const {
 
 inline
 Vector ActionVolume::getPosition( const unsigned& index ) const {
-  if( getConstPntrToComponent(0)->getRank()==0 ) return ActionAtomistic::getPosition( 1 + index );
+  if( getConstPntrToComponent(0)->getRank()==0 ) {
+    return ActionAtomistic::getPosition( 1 + index );
+  }
   return ActionAtomistic::getPosition( getConstPntrToComponent(0)->getShape()[0] + index );
 }
 
diff --git a/src/volumes/Density.cpp b/src/volumes/Density.cpp
index bb6da9248b..097a1894de 100644
--- a/src/volumes/Density.cpp
+++ b/src/volumes/Density.cpp
@@ -49,14 +49,15 @@ void Density::registerKeywords(Keywords& keys) {
   ActionShortcut::registerKeywords( keys );
   keys.add("compulsory","SPECIES","the atoms in the group");
   keys.setValueDescription("indices for the specified group of atoms");
-  keys.needsAction("ONES"); keys.needsAction("GROUP");
+  keys.needsAction("ONES");
+  keys.needsAction("GROUP");
 }
 
 Density::Density(const ActionOptions& ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string atoms; parse("SPECIES",atoms);
+  ActionShortcut(ao) {
+  std::string atoms;
+  parse("SPECIES",atoms);
   readInputLine( getShortcutLabel() + ": GROUP ATOMS=" + atoms);
 }
 
diff --git a/src/volumes/VolumeAround.cpp b/src/volumes/VolumeAround.cpp
index 84758adadc..979e9d9ebc 100644
--- a/src/volumes/VolumeAround.cpp
+++ b/src/volumes/VolumeAround.cpp
@@ -96,7 +96,8 @@ typedef VolumeShortcut<glob_around> VolumeAroundShortcut;
 PLUMED_REGISTER_ACTION(VolumeAroundShortcut,"AROUND")
 
 void VolumeAround::registerKeywords( Keywords& keys ) {
-  ActionVolume::registerKeywords( keys ); keys.setDisplayName("AROUND");
+  ActionVolume::registerKeywords( keys );
+  keys.setDisplayName("AROUND");
   keys.add("atoms","ORIGIN","the atom whose vicinity we are interested in examining");
   keys.add("atoms-2","ATOM","an alternative to ORIGIN");
   keys.add("compulsory","XLOWER","0.0","the lower boundary in x relative to the x coordinate of the atom (0 indicates use full extent of box).");
@@ -109,29 +110,50 @@ void VolumeAround::registerKeywords( Keywords& keys ) {
 
 VolumeAround::VolumeAround(const ActionOptions& ao):
   Action(ao),
-  ActionVolume(ao)
-{
-  std::vector<AtomNumber> atom; parseAtomList("ORIGIN",atom);
-  if( atom.size()==0 ) parseAtomList("ATOM",atom);
-  if( atom.size()!=1 ) error("should only be one atom specified");
+  ActionVolume(ao) {
+  std::vector<AtomNumber> atom;
+  parseAtomList("ORIGIN",atom);
+  if( atom.size()==0 ) {
+    parseAtomList("ATOM",atom);
+  }
+  if( atom.size()!=1 ) {
+    error("should only be one atom specified");
+  }
   log.printf("  boundaries for region are calculated based on positions of atom : %d\n",atom[0].serial() );
 
-  dox=true; parse("XLOWER",xlow); parse("XUPPER",xhigh);
-  doy=true; parse("YLOWER",ylow); parse("YUPPER",yhigh);
-  doz=true; parse("ZLOWER",zlow); parse("ZUPPER",zhigh);
-  if( xlow==0.0 && xhigh==0.0 ) dox=false;
-  if( ylow==0.0 && yhigh==0.0 ) doy=false;
-  if( zlow==0.0 && zhigh==0.0 ) doz=false;
-  if( !dox && !doy && !doz ) error("no subregion defined use XLOWER, XUPPER, YLOWER, YUPPER, ZLOWER, ZUPPER");
+  dox=true;
+  parse("XLOWER",xlow);
+  parse("XUPPER",xhigh);
+  doy=true;
+  parse("YLOWER",ylow);
+  parse("YUPPER",yhigh);
+  doz=true;
+  parse("ZLOWER",zlow);
+  parse("ZUPPER",zhigh);
+  if( xlow==0.0 && xhigh==0.0 ) {
+    dox=false;
+  }
+  if( ylow==0.0 && yhigh==0.0 ) {
+    doy=false;
+  }
+  if( zlow==0.0 && zhigh==0.0 ) {
+    doz=false;
+  }
+  if( !dox && !doy && !doz ) {
+    error("no subregion defined use XLOWER, XUPPER, YLOWER, YUPPER, ZLOWER, ZUPPER");
+  }
   log.printf("  boundaries for region (region of interest about atom) : x %f %f, y %f %f, z %f %f \n",xlow,xhigh,ylow,yhigh,zlow,zhigh);
-  checkRead(); requestAtoms(atom);
+  checkRead();
+  requestAtoms(atom);
 }
 
 void VolumeAround::setupRegions() { }
 
 double VolumeAround::calculateNumberInside( const Vector& cpos, Vector& derivatives, Tensor& vir, std::vector<Vector>& refders ) const {
   // Setup the histogram bead
-  HistogramBead bead; bead.isNotPeriodic(); bead.setKernelType( getKernelType() );
+  HistogramBead bead;
+  bead.isNotPeriodic();
+  bead.setKernelType( getKernelType() );
 
   // Calculate position of atom wrt to origin
   Vector fpos=pbcDistance( getPosition(0), cpos );
@@ -140,19 +162,22 @@ double VolumeAround::calculateNumberInside( const Vector& cpos, Vector& derivati
     bead.set( xlow, xhigh, getSigma() );
     xcontr=bead.calculate( fpos[0], xder );
   } else {
-    xcontr=1.; xder=0.;
+    xcontr=1.;
+    xder=0.;
   }
   if( doy ) {
     bead.set( ylow, yhigh, getSigma() );
     ycontr=bead.calculate( fpos[1], yder );
   } else {
-    ycontr=1.; yder=0.;
+    ycontr=1.;
+    yder=0.;
   }
   if( doz ) {
     bead.set( zlow, zhigh, getSigma() );
     zcontr=bead.calculate( fpos[2], zder );
   } else {
-    zcontr=1.; zder=0.;
+    zcontr=1.;
+    zder=0.;
   }
   derivatives[0]=xder*ycontr*zcontr;
   derivatives[1]=xcontr*yder*zcontr;
diff --git a/src/volumes/VolumeBetweenContours.cpp b/src/volumes/VolumeBetweenContours.cpp
index ac3f249a78..4ff5982adc 100644
--- a/src/volumes/VolumeBetweenContours.cpp
+++ b/src/volumes/VolumeBetweenContours.cpp
@@ -92,7 +92,9 @@ typedef VolumeShortcut<glob_contours> VolumeInEnvelopeShortcut;
 PLUMED_REGISTER_ACTION(VolumeInEnvelopeShortcut,"INENVELOPE")
 
 void VolumeInEnvelope::registerKeywords( Keywords& keys ) {
-  ActionVolume::registerKeywords( keys ); keys.remove("SIGMA"); keys.setDisplayName("INENVELOPE");
+  ActionVolume::registerKeywords( keys );
+  keys.remove("SIGMA");
+  keys.setDisplayName("INENVELOPE");
   keys.add("atoms","FIELD_ATOMS","the atom whose positions we are constructing a field from");
   keys.add("compulsory","BANDWIDTH","the bandwidths for kernel density esimtation");
   keys.add("compulsory","CONTOUR","a switching funciton that tells PLUMED how large the density should be");
@@ -102,59 +104,106 @@ void VolumeInEnvelope::registerKeywords( Keywords& keys ) {
 VolumeInEnvelope::VolumeInEnvelope(const ActionOptions& ao):
   Action(ao),
   ActionVolume(ao),
-  mylinks(comm)
-{
-  std::vector<AtomNumber> atoms; parseAtomList("FIELD_ATOMS",atoms);
+  mylinks(comm) {
+  std::vector<AtomNumber> atoms;
+  parseAtomList("FIELD_ATOMS",atoms);
   log.printf("  creating density field from atoms : ");
-  for(unsigned i=0; i<atoms.size(); ++i) log.printf("%d ",atoms[i].serial() );
-  log.printf("\n"); ltmp_ind.resize( atoms.size() ); ltmp_pos.resize( atoms.size() );
-  for(unsigned i=0; i<atoms.size(); ++i) ltmp_ind[i]=i;
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf("%d ",atoms[i].serial() );
+  }
+  log.printf("\n");
+  ltmp_ind.resize( atoms.size() );
+  ltmp_pos.resize( atoms.size() );
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    ltmp_ind[i]=i;
+  }
 
-  std::string sw, errors; parse("CONTOUR",sw);
-  if(sw.length()==0) error("missing CONTOUR keyword");
+  std::string sw, errors;
+  parse("CONTOUR",sw);
+  if(sw.length()==0) {
+    error("missing CONTOUR keyword");
+  }
   sfunc.set(sw,errors);
-  if( errors.length()!=0 ) error("problem reading RADIUS keyword : " + errors );
+  if( errors.length()!=0 ) {
+    error("problem reading RADIUS keyword : " + errors );
+  }
   log.printf("  density at atom must be larger than %s \n", ( sfunc.description() ).c_str() );
 
-  std::vector<double> pp(3,0.0); bandwidth.resize(3); parseVector("BANDWIDTH",bandwidth);
+  std::vector<double> pp(3,0.0);
+  bandwidth.resize(3);
+  parseVector("BANDWIDTH",bandwidth);
   log.printf("  using %s kernel with bandwidths %f %f %f \n",getKernelType().c_str(),bandwidth[0],bandwidth[1],bandwidth[2] );
-  std::string errors2; switchingFunction.set("GAUSSIAN R_0=1.0 NOSTRETCH", errors2 );
-  if( errors2.length()!=0 ) error("problem reading switching function description " + errors2);
-  double det=1; for(unsigned i=0; i<bandwidth.size(); ++i) det*=bandwidth[i]*bandwidth[i];
-  gvol=1.0; if( getKernelType()=="gaussian" ) gvol=pow( 2*pi, 0.5*bandwidth.size() ) * pow( det, 0.5 );
-  else error("cannot use kernel other than gaussian");
-  double dp2cutoff; parse("CUTOFF",dp2cutoff); double maxs =  sqrt(2*dp2cutoff)*bandwidth[0];
+  std::string errors2;
+  switchingFunction.set("GAUSSIAN R_0=1.0 NOSTRETCH", errors2 );
+  if( errors2.length()!=0 ) {
+    error("problem reading switching function description " + errors2);
+  }
+  double det=1;
+  for(unsigned i=0; i<bandwidth.size(); ++i) {
+    det*=bandwidth[i]*bandwidth[i];
+  }
+  gvol=1.0;
+  if( getKernelType()=="gaussian" ) {
+    gvol=pow( 2*pi, 0.5*bandwidth.size() ) * pow( det, 0.5 );
+  } else {
+    error("cannot use kernel other than gaussian");
+  }
+  double dp2cutoff;
+  parse("CUTOFF",dp2cutoff);
+  double maxs =  sqrt(2*dp2cutoff)*bandwidth[0];
   for(unsigned j=1; j<bandwidth.size(); ++j) {
-    if( sqrt(2*dp2cutoff)*bandwidth[j]>maxs ) maxs=sqrt(2*dp2cutoff)*bandwidth[j];
+    if( sqrt(2*dp2cutoff)*bandwidth[j]>maxs ) {
+      maxs=sqrt(2*dp2cutoff)*bandwidth[j];
+    }
   }
-  checkRead(); requestAtoms(atoms); mylinks.setCutoff( maxs );
+  checkRead();
+  requestAtoms(atoms);
+  mylinks.setCutoff( maxs );
 }
 
 void VolumeInEnvelope::setupRegions() {
-  for(unsigned i=0; i<ltmp_ind.size(); ++i) { ltmp_pos[i]=getPosition(i); }
+  for(unsigned i=0; i<ltmp_ind.size(); ++i) {
+    ltmp_pos[i]=getPosition(i);
+  }
   mylinks.buildCellLists( ltmp_pos, ltmp_ind, getPbc() );
 }
 
 double VolumeInEnvelope::calculateNumberInside( const Vector& cpos, Vector& derivatives, Tensor& vir, std::vector<Vector>& refders ) const {
-  unsigned ncells_required=0, natoms=1; std::vector<unsigned> cells_required( mylinks.getNumberOfCells() ), indices( 1 + getNumberOfAtoms() );
+  unsigned ncells_required=0, natoms=1;
+  std::vector<unsigned> cells_required( mylinks.getNumberOfCells() ), indices( 1 + getNumberOfAtoms() );
   mylinks.addRequiredCells( mylinks.findMyCell( cpos ), ncells_required, cells_required );
-  indices[0]=getNumberOfAtoms(); mylinks.retrieveAtomsInCells( ncells_required, cells_required, natoms, indices );
-  double value=0; std::vector<double> der(3); Vector tder;
+  indices[0]=getNumberOfAtoms();
+  mylinks.retrieveAtomsInCells( ncells_required, cells_required, natoms, indices );
+  double value=0;
+  std::vector<double> der(3);
+  Vector tder;
 
   // convert pointer once
   auto pos_ptr=Tools::unique2raw(pos);
   for(unsigned i=1; i<natoms; ++i) {
     Vector dist = pbcDistance( cpos, getPosition( indices[i] ) );
-    double dval=0; for(unsigned j=0; j<3; ++j) { der[j] = dist[j]/bandwidth[j]; dval += der[j]*der[j]; der[j] = der[j] / bandwidth[j]; }
-    double dfunc; value += switchingFunction.calculateSqr( dval, dfunc ) / gvol; double tmp = dfunc / gvol;
+    double dval=0;
+    for(unsigned j=0; j<3; ++j) {
+      der[j] = dist[j]/bandwidth[j];
+      dval += der[j]*der[j];
+      der[j] = der[j] / bandwidth[j];
+    }
+    double dfunc;
+    value += switchingFunction.calculateSqr( dval, dfunc ) / gvol;
+    double tmp = dfunc / gvol;
     for(unsigned j=0; j<3; ++j) {
-      derivatives[j] -= tmp*der[j]; refders[ indices[i] ][j] += tmp*der[j]; tder[j]=tmp*der[j];
+      derivatives[j] -= tmp*der[j];
+      refders[ indices[i] ][j] += tmp*der[j];
+      tder[j]=tmp*der[j];
     }
     vir -= Tensor( tder, dist );
   }
   double deriv, fval = sfunc.calculate( value, deriv );
-  derivatives *= -deriv*value; vir *= -deriv*value;
-  for(unsigned i=1; i<natoms; ++i) refders[ indices[i] ] *= -deriv*value;
+  derivatives *= -deriv*value;
+  vir *= -deriv*value;
+  for(unsigned i=1; i<natoms; ++i) {
+    refders[ indices[i] ] *= -deriv*value;
+  }
   return 1.0 - fval;
 }
 
diff --git a/src/volumes/VolumeCavity.cpp b/src/volumes/VolumeCavity.cpp
index fb53c8775a..711e1f3778 100644
--- a/src/volumes/VolumeCavity.cpp
+++ b/src/volumes/VolumeCavity.cpp
@@ -139,7 +139,8 @@ typedef VolumeShortcut<glob_cavity> VolumeCavityShortcut;
 PLUMED_REGISTER_ACTION(VolumeCavityShortcut,"CAVITY")
 
 void VolumeCavity::registerKeywords( Keywords& keys ) {
-  ActionVolume::registerKeywords( keys ); keys.setDisplayName("CAVITY");
+  ActionVolume::registerKeywords( keys );
+  keys.setDisplayName("CAVITY");
   keys.add("atoms","BOX","the positions of four atoms that define spatial extent of the cavity");
   keys.addFlag("PRINT_BOX",false,"write out the positions of the corners of the box to an xyz file");
   keys.add("optional","FILE","the file on which to write out the box coordinates");
@@ -156,22 +157,33 @@ VolumeCavity::VolumeCavity(const ActionOptions& ao):
   dlperp(4),
   dbi(3),
   dcross(3),
-  dperp(3)
-{
-  std::vector<AtomNumber> atoms; parseAtomList("BOX",atoms);
-  if( atoms.size()!=4 ) error("number of atoms in box should be equal to four");
+  dperp(3) {
+  std::vector<AtomNumber> atoms;
+  parseAtomList("BOX",atoms);
+  if( atoms.size()!=4 ) {
+    error("number of atoms in box should be equal to four");
+  }
 
   log.printf("  boundaries for region are calculated based on positions of atoms : ");
-  for(unsigned i=0; i<atoms.size(); ++i) log.printf("%d ",atoms[i].serial() );
-  log.printf("\n"); requestAtoms( atoms );
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf("%d ",atoms[i].serial() );
+  }
+  log.printf("\n");
+  requestAtoms( atoms );
 
-  boxout=false; parseFlag("PRINT_BOX",boxout);
+  boxout=false;
+  parseFlag("PRINT_BOX",boxout);
   if(boxout) {
-    std::string boxfname; parse("FILE",boxfname);
-    if(boxfname.length()==0) error("no name for box file specified");
-    std::string unitname; parse("UNITS",unitname);
+    std::string boxfname;
+    parse("FILE",boxfname);
+    if(boxfname.length()==0) {
+      error("no name for box file specified");
+    }
+    std::string unitname;
+    parse("UNITS",unitname);
     if ( unitname.length()>0 ) {
-      Units u; u.setLength(unitname);
+      Units u;
+      u.setLength(unitname);
       lenunit=getUnits().getLength()/u.getLength();
     } else {
       unitname="nm";
@@ -206,10 +218,14 @@ void VolumeCavity::setupRegions() {
   d3 = pbcDistance(origin,getPosition(3));
 
   // Create a set of unit vectors
-  bi = d1 / d1l; len_bi=dotProduct( d3, bi );
-  cross = crossProduct( d1, d2 ); double crossmod=cross.modulo();
-  cross = cross / crossmod; len_cross=dotProduct( d3, cross );
-  perp = crossProduct( cross, bi ); len_perp=dotProduct( d3, perp );
+  bi = d1 / d1l;
+  len_bi=dotProduct( d3, bi );
+  cross = crossProduct( d1, d2 );
+  double crossmod=cross.modulo();
+  cross = cross / crossmod;
+  len_cross=dotProduct( d3, cross );
+  perp = crossProduct( cross, bi );
+  len_perp=dotProduct( d3, perp );
 
   // Calculate derivatives of box shape with respect to atoms
   double d1l3=d1l*d1l*d1l;
@@ -234,7 +250,9 @@ void VolumeCavity::setupRegions() {
   dbi[1](2,2) = ( (d1[1]*d1[1]+d1[0]*d1[0])/d1l3 );
   dbi[2].zero();
 
-  Tensor tcderiv; double cmod3=crossmod*crossmod*crossmod; Vector ucross=crossmod*cross;
+  Tensor tcderiv;
+  double cmod3=crossmod*crossmod*crossmod;
+  Vector ucross=crossmod*cross;
   tcderiv.setCol( 0, crossProduct( d1, Vector(-1.0,0.0,0.0) ) + crossProduct( Vector(-1.0,0.0,0.0), d2 ) );
   tcderiv.setCol( 1, crossProduct( d1, Vector(0.0,-1.0,0.0) ) + crossProduct( Vector(0.0,-1.0,0.0), d2 ) );
   tcderiv.setCol( 2, crossProduct( d1, Vector(0.0,0.0,-1.0) ) + crossProduct( Vector(0.0,0.0,-1.0), d2 ) );
@@ -288,18 +306,29 @@ void VolumeCavity::setupRegions() {
 
   // Ensure that all lengths are positive
   if( len_bi<0 ) {
-    bi=-bi; len_bi=-len_bi;
-    for(unsigned i=0; i<3; ++i) dbi[i]*=-1.0;
+    bi=-bi;
+    len_bi=-len_bi;
+    for(unsigned i=0; i<3; ++i) {
+      dbi[i]*=-1.0;
+    }
   }
   if( len_cross<0 ) {
-    cross=-cross; len_cross=-len_cross;
-    for(unsigned i=0; i<3; ++i) dcross[i]*=-1.0;
+    cross=-cross;
+    len_cross=-len_cross;
+    for(unsigned i=0; i<3; ++i) {
+      dcross[i]*=-1.0;
+    }
   }
   if( len_perp<0 ) {
-    perp=-perp; len_perp=-len_perp;
-    for(unsigned i=0; i<3; ++i) dperp[i]*=-1.0;
+    perp=-perp;
+    len_perp=-len_perp;
+    for(unsigned i=0; i<3; ++i) {
+      dperp[i]*=-1.0;
+    }
+  }
+  if( len_bi<=0 || len_cross<=0 || len_bi<=0 ) {
+    plumed_merror("Invalid box coordinates");
   }
-  if( len_bi<=0 || len_cross<=0 || len_bi<=0 ) plumed_merror("Invalid box coordinates");
 
   // Now derivatives of lengths
   Tensor dd3( Tensor::identity() );
@@ -320,9 +349,15 @@ void VolumeCavity::setupRegions() {
 
   // Need to calculate the jacobian
   Tensor jacob;
-  jacob(0,0)=bi[0]; jacob(1,0)=bi[1]; jacob(2,0)=bi[2];
-  jacob(0,1)=cross[0]; jacob(1,1)=cross[1]; jacob(2,1)=cross[2];
-  jacob(0,2)=perp[0]; jacob(1,2)=perp[1]; jacob(2,2)=perp[2];
+  jacob(0,0)=bi[0];
+  jacob(1,0)=bi[1];
+  jacob(2,0)=bi[2];
+  jacob(0,1)=cross[0];
+  jacob(1,1)=cross[1];
+  jacob(2,1)=cross[2];
+  jacob(0,2)=perp[0];
+  jacob(1,2)=perp[1];
+  jacob(2,2)=perp[2];
   jacob_det = fabs( jacob.determinant() );
 }
 
@@ -364,7 +399,9 @@ void VolumeCavity::update() {
 
 double VolumeCavity::calculateNumberInside( const Vector& cpos, Vector& derivatives, Tensor& vir, std::vector<Vector>& rderiv ) const {
   // Setup the histogram bead
-  HistogramBead bead; bead.isNotPeriodic(); bead.setKernelType( getKernelType() );
+  HistogramBead bead;
+  bead.isNotPeriodic();
+  bead.setKernelType( getKernelType() );
 
   // Calculate distance of atom from origin of new coordinate frame
   Vector datom=pbcDistance( origin, cpos );
@@ -391,15 +428,23 @@ double VolumeCavity::calculateNumberInside( const Vector& cpos, Vector& derivati
   double wdlen=bead.uboundDerivative( wpos );
   double wder2 = bead.lboundDerivative( wpos ) - wdlen;
 
-  Vector dfd; dfd[0]=uder*vcontr*wcontr; dfd[1]=ucontr*vder*wcontr; dfd[2]=ucontr*vcontr*wder;
+  Vector dfd;
+  dfd[0]=uder*vcontr*wcontr;
+  dfd[1]=ucontr*vder*wcontr;
+  dfd[2]=ucontr*vcontr*wder;
   derivatives[0] = (dfd[0]*bi[0]+dfd[1]*cross[0]+dfd[2]*perp[0]);
   derivatives[1] = (dfd[0]*bi[1]+dfd[1]*cross[1]+dfd[2]*perp[1]);
   derivatives[2] = (dfd[0]*bi[2]+dfd[1]*cross[2]+dfd[2]*perp[2]);
   double tot = ucontr*vcontr*wcontr*jacob_det;
 
   // Add reference atom derivatives
-  dfd[0]=uder2*vcontr*wcontr; dfd[1]=ucontr*vder2*wcontr; dfd[2]=ucontr*vcontr*wder2;
-  Vector dfld; dfld[0]=udlen*vcontr*wcontr; dfld[1]=ucontr*vdlen*wcontr; dfld[2]=ucontr*vcontr*wdlen;
+  dfd[0]=uder2*vcontr*wcontr;
+  dfd[1]=ucontr*vder2*wcontr;
+  dfd[2]=ucontr*vcontr*wder2;
+  Vector dfld;
+  dfld[0]=udlen*vcontr*wcontr;
+  dfld[1]=ucontr*vdlen*wcontr;
+  dfld[2]=ucontr*vcontr*wdlen;
   rderiv[0] = dfd[0]*matmul(datom,dbi[0]) + dfd[1]*matmul(datom,dcross[0]) + dfd[2]*matmul(datom,dperp[0]) +
               dfld[0]*dlbi[0] + dfld[1]*dlcross[0] + dfld[2]*dlperp[0] - derivatives;
   rderiv[1] = dfd[0]*matmul(datom,dbi[1]) + dfd[1]*matmul(datom,dcross[1]) + dfd[2]*matmul(datom,dperp[1]) +
@@ -408,7 +453,8 @@ double VolumeCavity::calculateNumberInside( const Vector& cpos, Vector& derivati
               dfld[0]*dlbi[2] + dfld[1]*dlcross[2] + dfld[2]*dlperp[2];
   rderiv[3] = dfld[0]*dlbi[3] + dfld[1]*dlcross[3] + dfld[2]*dlperp[3];
 
-  vir.zero(); vir-=Tensor( cpos,derivatives );
+  vir.zero();
+  vir-=Tensor( cpos,derivatives );
   for(unsigned i=0; i<4; ++i) {
     vir -= Tensor( getPosition(i), rderiv[i] );
   }
diff --git a/src/volumes/VolumeInCylinder.cpp b/src/volumes/VolumeInCylinder.cpp
index 1253007546..df439093f4 100644
--- a/src/volumes/VolumeInCylinder.cpp
+++ b/src/volumes/VolumeInCylinder.cpp
@@ -100,7 +100,8 @@ typedef VolumeShortcut<glob_cylinder> VolumeInCylinderShortcut;
 PLUMED_REGISTER_ACTION(VolumeInCylinderShortcut,"INCYLINDER")
 
 void VolumeInCylinder::registerKeywords( Keywords& keys ) {
-  ActionVolume::registerKeywords( keys ); keys.setDisplayName("INCYLINDER");
+  ActionVolume::registerKeywords( keys );
+  keys.setDisplayName("INCYLINDER");
   keys.add("atoms","CENTER","the atom whose vicinity we are interested in examining");
   keys.add("compulsory","DIRECTION","the direction of the long axis of the cylinder. Must be x, y or z");
   keys.add("compulsory","RADIUS","a switching function that gives the extent of the cylinder in the plane perpendicular to the direction");
@@ -112,35 +113,60 @@ void VolumeInCylinder::registerKeywords( Keywords& keys ) {
 VolumeInCylinder::VolumeInCylinder(const ActionOptions& ao):
   Action(ao),
   ActionVolume(ao),
-  docylinder(false)
-{
+  docylinder(false) {
   std::vector<AtomNumber> atom;
   parseAtomList("CENTER",atom);
-  if( atom.size()!=1 ) error("should only be one atom specified");
+  if( atom.size()!=1 ) {
+    error("should only be one atom specified");
+  }
   log.printf("  center of cylinder is at position of atom : %d\n",atom[0].serial() );
 
-  std::string sdir; parse("DIRECTION",sdir);
-  if( sdir=="X") {dir.push_back(1); dir.push_back(2); dir.push_back(0); }
-  else if( sdir=="Y") {dir.push_back(0); dir.push_back(2); dir.push_back(1); }
-  else if( sdir=="Z") {dir.push_back(0); dir.push_back(1); dir.push_back(2); }
-  else { error(sdir + "is not a valid direction.  Should be X, Y or Z"); }
+  std::string sdir;
+  parse("DIRECTION",sdir);
+  if( sdir=="X") {
+    dir.push_back(1);
+    dir.push_back(2);
+    dir.push_back(0);
+  } else if( sdir=="Y") {
+    dir.push_back(0);
+    dir.push_back(2);
+    dir.push_back(1);
+  } else if( sdir=="Z") {
+    dir.push_back(0);
+    dir.push_back(1);
+    dir.push_back(2);
+  } else {
+    error(sdir + "is not a valid direction.  Should be X, Y or Z");
+  }
   log.printf("  cylinder's long axis is along %s axis\n",sdir.c_str() );
 
-  std::string sw, errors; parse("RADIUS",sw);
-  if(sw.length()==0) error("missing RADIUS keyword");
+  std::string sw, errors;
+  parse("RADIUS",sw);
+  if(sw.length()==0) {
+    error("missing RADIUS keyword");
+  }
   switchingFunction.set(sw,errors);
-  if( errors.length()!=0 ) error("problem reading RADIUS keyword : " + errors );
+  if( errors.length()!=0 ) {
+    error("problem reading RADIUS keyword : " + errors );
+  }
   log.printf("  radius of cylinder is given by %s \n", ( switchingFunction.description() ).c_str() );
 
-  double min, max; parse("LOWER",min); parse("UPPER",max);
+  double min, max;
+  parse("LOWER",min);
+  parse("UPPER",max);
   if( min!=0.0 ||  max!=0.0 ) {
-    if( min>max ) error("minimum of cylinder should be less than maximum");
+    if( min>max ) {
+      error("minimum of cylinder should be less than maximum");
+    }
     docylinder=true;
     log.printf("  cylinder extends from %f to %f along the %s axis\n",min,max,sdir.c_str() );
-    bead.isNotPeriodic(); bead.setKernelType( getKernelType() ); bead.set( min, max, getSigma() );
+    bead.isNotPeriodic();
+    bead.setKernelType( getKernelType() );
+    bead.set( min, max, getSigma() );
   }
 
-  checkRead(); requestAtoms(atom);
+  checkRead();
+  requestAtoms(atom);
 }
 
 void VolumeInCylinder::setupRegions() { }
@@ -153,12 +179,14 @@ double VolumeInCylinder::calculateNumberInside( const Vector& cpos, Vector& deri
   if( docylinder ) {
     vcylinder=bead.calculate( fpos[dir[2]], dcylinder );
   } else {
-    vcylinder=1.0; dcylinder=0.0;
+    vcylinder=1.0;
+    dcylinder=0.0;
   }
 
   const double dd = fpos[dir[0]]*fpos[dir[0]] + fpos[dir[1]]*fpos[dir[1]];
   double dfunc, vswitch = switchingFunction.calculateSqr( dd, dfunc );
-  derivatives.zero(); double value=vswitch*vcylinder;
+  derivatives.zero();
+  double value=vswitch*vcylinder;
   derivatives[dir[0]]=vcylinder*dfunc*fpos[dir[0]];
   derivatives[dir[1]]=vcylinder*dfunc*fpos[dir[1]];
   derivatives[dir[2]]=vswitch*dcylinder;
diff --git a/src/volumes/VolumeInSphere.cpp b/src/volumes/VolumeInSphere.cpp
index 141ad4fbe7..91de7e5719 100644
--- a/src/volumes/VolumeInSphere.cpp
+++ b/src/volumes/VolumeInSphere.cpp
@@ -96,7 +96,8 @@ typedef VolumeShortcut<glob_sphere> VolumeInSphereShortcut;
 PLUMED_REGISTER_ACTION(VolumeInSphereShortcut,"INSPHERE")
 
 void VolumeInSphere::registerKeywords( Keywords& keys ) {
-  ActionVolume::registerKeywords( keys ); keys.setDisplayName("INSPHERE");
+  ActionVolume::registerKeywords( keys );
+  keys.setDisplayName("INSPHERE");
   keys.add("atoms","CENTER","the atom whose vicinity we are interested in examining");
   keys.add("atoms-2","ATOM","the atom whose vicinity we are interested in examining");
   keys.add("compulsory","RADIUS","the switching function that tells us the extent of the sphereical region of interest");
@@ -105,20 +106,30 @@ void VolumeInSphere::registerKeywords( Keywords& keys ) {
 
 VolumeInSphere::VolumeInSphere(const ActionOptions& ao):
   Action(ao),
-  ActionVolume(ao)
-{
-  std::vector<AtomNumber> atom; parseAtomList("CENTER",atom);
-  if( atom.size()==0 ) parseAtomList("ATOM",atom);
-  if( atom.size()!=1 ) error("should only be one atom specified");
+  ActionVolume(ao) {
+  std::vector<AtomNumber> atom;
+  parseAtomList("CENTER",atom);
+  if( atom.size()==0 ) {
+    parseAtomList("ATOM",atom);
+  }
+  if( atom.size()!=1 ) {
+    error("should only be one atom specified");
+  }
   log.printf("  center of sphere is at position of atom : %d\n",atom[0].serial() );
 
-  std::string sw, errors; parse("RADIUS",sw);
-  if(sw.length()==0) error("missing RADIUS keyword");
+  std::string sw, errors;
+  parse("RADIUS",sw);
+  if(sw.length()==0) {
+    error("missing RADIUS keyword");
+  }
   switchingFunction.set(sw,errors);
-  if( errors.length()!=0 ) error("problem reading RADIUS keyword : " + errors );
+  if( errors.length()!=0 ) {
+    error("problem reading RADIUS keyword : " + errors );
+  }
   log.printf("  radius of sphere is given by %s \n", ( switchingFunction.description() ).c_str() );
 
-  checkRead(); requestAtoms(atom);
+  checkRead();
+  requestAtoms(atom);
 }
 
 void VolumeInSphere::setupRegions() { }
@@ -127,7 +138,9 @@ double VolumeInSphere::calculateNumberInside( const Vector& cpos, Vector& deriva
   // Calculate position of atom wrt to origin
   Vector fpos=pbcDistance( getPosition(0), cpos );
   double dfunc, value = switchingFunction.calculateSqr( fpos.modulo2(), dfunc );
-  derivatives.zero(); derivatives = dfunc*fpos; refders[0] = -derivatives;
+  derivatives.zero();
+  derivatives = dfunc*fpos;
+  refders[0] = -derivatives;
   // Add a virial contribution
   vir -= Tensor(fpos,derivatives);
   return value;
diff --git a/src/volumes/VolumeShortcut.h b/src/volumes/VolumeShortcut.h
index 2bf207d7e8..a6ed9395d3 100644
--- a/src/volumes/VolumeShortcut.h
+++ b/src/volumes/VolumeShortcut.h
@@ -53,36 +53,60 @@ void VolumeShortcut<v>::registerKeywords( Keywords& keys ) {
   keys.addOutputComponent("sum","SUM","the sum of all the colvars weighted by the function that determines if we are in the region");
   keys.addFlag("MEAN",false,"calculate the average value of the colvar inside the region of interest");
   keys.addOutputComponent("mean","MEAN","the average values of the colvar in the region of interest");
-  keys.addActionNameSuffix("_CALC"); keys.needsAction("LESS_THAN"); keys.needsAction("MORE_THAN"); keys.needsAction("GROUP");
-  keys.needsAction("BETWEEN"); keys.needsAction("SUM"); keys.needsAction("MEAN"); keys.needsAction("CUSTOM");
+  keys.addActionNameSuffix("_CALC");
+  keys.needsAction("LESS_THAN");
+  keys.needsAction("MORE_THAN");
+  keys.needsAction("GROUP");
+  keys.needsAction("BETWEEN");
+  keys.needsAction("SUM");
+  keys.needsAction("MEAN");
+  keys.needsAction("CUSTOM");
 }
 
 template <const char* v>
 VolumeShortcut<v>::VolumeShortcut(const ActionOptions&ao):
   Action(ao),
-  ActionShortcut(ao)
-{
-  std::string voltype(v), mc_lab; parse("DATA",mc_lab); bool dosum; parseFlag("SUM",dosum);
+  ActionShortcut(ao) {
+  std::string voltype(v), mc_lab;
+  parse("DATA",mc_lab);
+  bool dosum;
+  parseFlag("SUM",dosum);
   if( mc_lab.length()>0 ) {
     Group* mygrp = plumed.getActionSet().template selectWithLabel<Group*>(mc_lab);
     Group* mygrp2 = plumed.getActionSet().template selectWithLabel<Group*>(mc_lab + "_grp");
-    if( mygrp || mygrp2 ) readInputLine( getShortcutLabel() + "_grp: GROUP ATOMS=" + mc_lab );
-    bool domean; parseFlag("MEAN",domean); std::string lt_input, mt_input, bt_input;
-    parse("LESS_THAN",lt_input); parse("MORE_THAN",mt_input); parse("BETWEEN",bt_input);
-    std::string atomsd; parse("ATOMS",atomsd); if( atomsd.length()==0 ) atomsd=mc_lab;
+    if( mygrp || mygrp2 ) {
+      readInputLine( getShortcutLabel() + "_grp: GROUP ATOMS=" + mc_lab );
+    }
+    bool domean;
+    parseFlag("MEAN",domean);
+    std::string lt_input, mt_input, bt_input;
+    parse("LESS_THAN",lt_input);
+    parse("MORE_THAN",mt_input);
+    parse("BETWEEN",bt_input);
+    std::string atomsd;
+    parse("ATOMS",atomsd);
+    if( atomsd.length()==0 ) {
+      atomsd=mc_lab;
+    }
     // Create the apprpriate volume object
     readInputLine( getShortcutLabel() + ": " + voltype + "_CALC " + convertInputLineToString() + " ATOMS=" + atomsd );
     // Now create input for sums
     if( dosum || domean ) {
       readInputLine( getShortcutLabel() + "_prod: CUSTOM ARG=" + mc_lab + "," + getShortcutLabel() + " FUNC=x*y PERIODIC=NO");
-      std::string tlab = getShortcutLabel() + "_numer"; if( dosum ) tlab = getShortcutLabel() + "_sum:";
+      std::string tlab = getShortcutLabel() + "_numer";
+      if( dosum ) {
+        tlab = getShortcutLabel() + "_sum:";
+      }
       readInputLine( tlab + ": SUM ARG=" + getShortcutLabel() + "_prod PERIODIC=NO");
     }
     if( domean ) {
       // Calculate denominator
       readInputLine( getShortcutLabel() + "_norm: SUM ARG=" + getShortcutLabel() + " PERIODIC=NO");
       // And calculate final quantity which is mean of these two actions
-      std::string arg1_lab = getShortcutLabel() + "_numer"; if( dosum ) arg1_lab = getShortcutLabel()  + "_sum";
+      std::string arg1_lab = getShortcutLabel() + "_numer";
+      if( dosum ) {
+        arg1_lab = getShortcutLabel()  + "_sum";
+      }
       readInputLine( getShortcutLabel() + "_mean: CUSTOM ARG=" + arg1_lab + "," + getShortcutLabel() + "_norm FUNC=x/y PERIODIC=NO");
     }
     if( lt_input.length()>0 ) {
diff --git a/src/volumes/VolumeTetrapore.cpp b/src/volumes/VolumeTetrapore.cpp
index 9037331722..a71989b37f 100644
--- a/src/volumes/VolumeTetrapore.cpp
+++ b/src/volumes/VolumeTetrapore.cpp
@@ -147,7 +147,8 @@ typedef VolumeShortcut<glob_tetrapore> VolumeTetraporeShortcut;
 PLUMED_REGISTER_ACTION(VolumeTetraporeShortcut,"TETRAHEDRALPORE")
 
 void VolumeTetrapore::registerKeywords( Keywords& keys ) {
-  ActionVolume::registerKeywords( keys ); keys.setDisplayName("TETRAHEDRALPORE");
+  ActionVolume::registerKeywords( keys );
+  keys.setDisplayName("TETRAHEDRALPORE");
   keys.add("atoms","BOX","the positions of four atoms that define spatial extent of the cavity");
   keys.addFlag("PRINT_BOX",false,"write out the positions of the corners of the box to an xyz file");
   keys.add("optional","FILE","the file on which to write out the box coordinates");
@@ -164,23 +165,32 @@ VolumeTetrapore::VolumeTetrapore(const ActionOptions& ao):
   dlperp(4),
   dbi(3),
   dcross(3),
-  dperp(3)
-{
+  dperp(3) {
   std::vector<AtomNumber> atoms;
   parseAtomList("BOX",atoms);
-  if( atoms.size()!=4 ) error("number of atoms should be equal to four");
+  if( atoms.size()!=4 ) {
+    error("number of atoms should be equal to four");
+  }
 
   log.printf("  boundaries for region are calculated based on positions of atoms : ");
-  for(unsigned i=0; i<atoms.size(); ++i) log.printf("%d ",atoms[i].serial() );
+  for(unsigned i=0; i<atoms.size(); ++i) {
+    log.printf("%d ",atoms[i].serial() );
+  }
   log.printf("\n");
 
-  boxout=false; parseFlag("PRINT_BOX",boxout);
+  boxout=false;
+  parseFlag("PRINT_BOX",boxout);
   if(boxout) {
-    std::string boxfname; parse("FILE",boxfname);
-    if(boxfname.length()==0) error("no name for box file specified");
-    std::string unitname; parse("UNITS",unitname);
+    std::string boxfname;
+    parse("FILE",boxfname);
+    if(boxfname.length()==0) {
+      error("no name for box file specified");
+    }
+    std::string unitname;
+    parse("UNITS",unitname);
     if ( unitname.length()>0 ) {
-      Units u; u.setLength(unitname);
+      Units u;
+      u.setLength(unitname);
       lenunit=getUnits().getLength()/u.getLength();
     } else {
       unitname="nm";
@@ -215,11 +225,15 @@ void VolumeTetrapore::setupRegions() {
   d3 = pbcDistance(origin,getPosition(3));
 
   // Create a set of unit vectors
-  Vector bisector = d1 + d2; double bmod=bisector.modulo(); bisector=bisector/bmod;
+  Vector bisector = d1 + d2;
+  double bmod=bisector.modulo();
+  bisector=bisector/bmod;
 
   // bi = d1 / d1l; len_bi=dotProduct( d3, bi );
-  cross = crossProduct( d1, d2 ); double crossmod=cross.modulo();
-  cross = cross / crossmod; len_cross=dotProduct( d3, cross );
+  cross = crossProduct( d1, d2 );
+  double crossmod=cross.modulo();
+  cross = cross / crossmod;
+  len_cross=dotProduct( d3, cross );
   Vector truep = crossProduct( cross, bisector );
 
   // These are our true vectors 45 degrees from bisector
@@ -227,13 +241,25 @@ void VolumeTetrapore::setupRegions() {
   perp = cos(pi/4.0)*bisector - sin(pi/4.0)*truep;
 
   // And the lengths of the various parts average distance to opposite corners of tetetrahedron
-  len_bi = dotProduct( d1, bi ); double len_bi2 = dotProduct( d2, bi ); unsigned lbi=1;
-  if( len_bi2>len_bi ) { len_bi=len_bi2; lbi=2; }
-  len_perp = dotProduct( d1, perp ); double len_perp2 = dotProduct( d2, perp ); unsigned lpi=1;
-  if( len_perp2>len_perp ) { len_perp=len_perp2; lpi=2; }
+  len_bi = dotProduct( d1, bi );
+  double len_bi2 = dotProduct( d2, bi );
+  unsigned lbi=1;
+  if( len_bi2>len_bi ) {
+    len_bi=len_bi2;
+    lbi=2;
+  }
+  len_perp = dotProduct( d1, perp );
+  double len_perp2 = dotProduct( d2, perp );
+  unsigned lpi=1;
+  if( len_perp2>len_perp ) {
+    len_perp=len_perp2;
+    lpi=2;
+  }
   plumed_assert( lbi!=lpi );
 
-  Tensor tcderiv; double cmod3=crossmod*crossmod*crossmod; Vector ucross=crossmod*cross;
+  Tensor tcderiv;
+  double cmod3=crossmod*crossmod*crossmod;
+  Vector ucross=crossmod*cross;
   tcderiv.setCol( 0, crossProduct( d1, Vector(-1.0,0.0,0.0) ) + crossProduct( Vector(-1.0,0.0,0.0), d2 ) );
   tcderiv.setCol( 1, crossProduct( d1, Vector(0.0,-1.0,0.0) ) + crossProduct( Vector(0.0,-1.0,0.0), d2 ) );
   tcderiv.setCol( 2, crossProduct( d1, Vector(0.0,0.0,-1.0) ) + crossProduct( Vector(0.0,0.0,-1.0), d2 ) );
@@ -274,7 +300,8 @@ void VolumeTetrapore::setupRegions() {
   dcross[2](2,2)=( tcderiv(2,2)/crossmod - ucross[2]*(ucross[0]*tcderiv(0,2) + ucross[1]*tcderiv(1,2) + ucross[2]*tcderiv(2,2))/cmod3 );    // dz/dz
 
   std::vector<Tensor> dbisector(3);
-  double bmod3=bmod*bmod*bmod; Vector ubisector=bmod*bisector;
+  double bmod3=bmod*bmod*bmod;
+  Vector ubisector=bmod*bisector;
   dbisector[0](0,0)= -2.0/bmod + 2*ubisector[0]*ubisector[0]/bmod3;
   dbisector[0](0,1)= 2*ubisector[0]*ubisector[1]/bmod3;
   dbisector[0](0,2)= 2*ubisector[0]*ubisector[2]/bmod3;
@@ -326,22 +353,39 @@ void VolumeTetrapore::setupRegions() {
 
   // Ensure that all lengths are positive
   if( len_bi<0 ) {
-    bi=-bi; len_bi=-len_bi;
-    for(unsigned i=0; i<3; ++i) dbi[i]*=-1.0;
+    bi=-bi;
+    len_bi=-len_bi;
+    for(unsigned i=0; i<3; ++i) {
+      dbi[i]*=-1.0;
+    }
   }
   if( len_cross<0 ) {
-    cross=-cross; len_cross=-len_cross;
-    for(unsigned i=0; i<3; ++i) dcross[i]*=-1.0;
+    cross=-cross;
+    len_cross=-len_cross;
+    for(unsigned i=0; i<3; ++i) {
+      dcross[i]*=-1.0;
+    }
   }
   if( len_perp<0 ) {
-    perp=-perp; len_perp=-len_perp;
-    for(unsigned i=0; i<3; ++i) dperp[i]*=-1.0;
+    perp=-perp;
+    len_perp=-len_perp;
+    for(unsigned i=0; i<3; ++i) {
+      dperp[i]*=-1.0;
+    }
+  }
+  if( len_bi<=0 || len_cross<=0 || len_bi<=0 ) {
+    plumed_merror("Invalid box coordinates");
   }
-  if( len_bi<=0 || len_cross<=0 || len_bi<=0 ) plumed_merror("Invalid box coordinates");
 
   // Now derivatives of lengths
-  Tensor dd3( Tensor::identity() ); Vector ddb2=d1; if( lbi==2 ) ddb2=d2;
-  dlbi[1].zero(); dlbi[2].zero(); dlbi[3].zero();
+  Tensor dd3( Tensor::identity() );
+  Vector ddb2=d1;
+  if( lbi==2 ) {
+    ddb2=d2;
+  }
+  dlbi[1].zero();
+  dlbi[2].zero();
+  dlbi[3].zero();
   dlbi[0] = matmul(ddb2,dbi[0]) - matmul(bi,dd3);
   dlbi[lbi] = matmul(ddb2,dbi[lbi]) + matmul(bi,dd3);  // Derivative wrt d1
 
@@ -350,16 +394,27 @@ void VolumeTetrapore::setupRegions() {
   dlcross[2] = matmul(d3,dcross[2]);
   dlcross[3] = matmul(cross,dd3);
 
-  ddb2=d1; if( lpi==2 ) ddb2=d2;
-  dlperp[1].zero(); dlperp[2].zero(); dlperp[3].zero();
+  ddb2=d1;
+  if( lpi==2 ) {
+    ddb2=d2;
+  }
+  dlperp[1].zero();
+  dlperp[2].zero();
+  dlperp[3].zero();
   dlperp[0] = matmul(ddb2,dperp[0]) - matmul( perp, dd3 );
   dlperp[lpi] = matmul(ddb2,dperp[lpi]) + matmul(perp, dd3);
 
   // Need to calculate the jacobian
   Tensor jacob;
-  jacob(0,0)=bi[0]; jacob(1,0)=bi[1]; jacob(2,0)=bi[2];
-  jacob(0,1)=cross[0]; jacob(1,1)=cross[1]; jacob(2,1)=cross[2];
-  jacob(0,2)=perp[0]; jacob(1,2)=perp[1]; jacob(2,2)=perp[2];
+  jacob(0,0)=bi[0];
+  jacob(1,0)=bi[1];
+  jacob(2,0)=bi[2];
+  jacob(0,1)=cross[0];
+  jacob(1,1)=cross[1];
+  jacob(2,1)=cross[2];
+  jacob(0,2)=perp[0];
+  jacob(1,2)=perp[1];
+  jacob(2,2)=perp[2];
   jacob_det = fabs( jacob.determinant() );
 }
 
@@ -401,7 +456,9 @@ void VolumeTetrapore::update() {
 
 double VolumeTetrapore::calculateNumberInside( const Vector& cpos, Vector& derivatives, Tensor& vir, std::vector<Vector>& rderiv ) const {
   // Setup the histogram bead
-  HistogramBead bead; bead.isNotPeriodic(); bead.setKernelType( getKernelType() );
+  HistogramBead bead;
+  bead.isNotPeriodic();
+  bead.setKernelType( getKernelType() );
 
   // Calculate distance of atom from origin of new coordinate frame
   Vector datom=pbcDistance( origin, cpos );
@@ -428,15 +485,23 @@ double VolumeTetrapore::calculateNumberInside( const Vector& cpos, Vector& deriv
   double wdlen=bead.uboundDerivative( wpos );
   double wder2 = bead.lboundDerivative( wpos ) - wdlen;
 
-  Vector dfd; dfd[0]=uder*vcontr*wcontr; dfd[1]=ucontr*vder*wcontr; dfd[2]=ucontr*vcontr*wder;
+  Vector dfd;
+  dfd[0]=uder*vcontr*wcontr;
+  dfd[1]=ucontr*vder*wcontr;
+  dfd[2]=ucontr*vcontr*wder;
   derivatives[0] = (dfd[0]*bi[0]+dfd[1]*cross[0]+dfd[2]*perp[0]);
   derivatives[1] = (dfd[0]*bi[1]+dfd[1]*cross[1]+dfd[2]*perp[1]);
   derivatives[2] = (dfd[0]*bi[2]+dfd[1]*cross[2]+dfd[2]*perp[2]);
   double tot = ucontr*vcontr*wcontr*jacob_det;
 
   // Add reference atom derivatives
-  dfd[0]=uder2*vcontr*wcontr; dfd[1]=ucontr*vder2*wcontr; dfd[2]=ucontr*vcontr*wder2;
-  Vector dfld; dfld[0]=udlen*vcontr*wcontr; dfld[1]=ucontr*vdlen*wcontr; dfld[2]=ucontr*vcontr*wdlen;
+  dfd[0]=uder2*vcontr*wcontr;
+  dfd[1]=ucontr*vder2*wcontr;
+  dfd[2]=ucontr*vcontr*wder2;
+  Vector dfld;
+  dfld[0]=udlen*vcontr*wcontr;
+  dfld[1]=ucontr*vdlen*wcontr;
+  dfld[2]=ucontr*vcontr*wdlen;
   rderiv[0] = dfd[0]*matmul(datom,dbi[0]) + dfd[1]*matmul(datom,dcross[0]) + dfd[2]*matmul(datom,dperp[0]) +
               dfld[0]*dlbi[0] + dfld[1]*dlcross[0] + dfld[2]*dlperp[0] - derivatives;
   rderiv[1] = dfd[0]*matmul(datom,dbi[1]) + dfd[1]*matmul(datom,dcross[1]) + dfd[2]*matmul(datom,dperp[1]) +
@@ -445,7 +510,8 @@ double VolumeTetrapore::calculateNumberInside( const Vector& cpos, Vector& deriv
               dfld[0]*dlbi[2] + dfld[1]*dlcross[2] + dfld[2]*dlperp[2];
   rderiv[3] = dfld[0]*dlbi[3] + dfld[1]*dlcross[3] + dfld[2]*dlperp[3];
 
-  vir.zero(); vir-=Tensor( cpos,derivatives );
+  vir.zero();
+  vir-=Tensor( cpos,derivatives );
   for(unsigned i=0; i<4; ++i) {
     vir -= Tensor( getPosition(i), rderiv[i] );
   }
diff --git a/src/wham/Wham.cpp b/src/wham/Wham.cpp
index 9ec43b7e50..7a03ac62bf 100644
--- a/src/wham/Wham.cpp
+++ b/src/wham/Wham.cpp
@@ -87,7 +87,9 @@ class Wham :
 public:
   static void registerKeywords(Keywords&);
   explicit Wham(const ActionOptions&ao);
-  unsigned getNumberOfDerivatives() { return 0; }
+  unsigned getNumberOfDerivatives() {
+    return 0;
+  }
   void calculate() override ;
   void apply() override {}
 };
@@ -95,8 +97,10 @@ class Wham :
 PLUMED_REGISTER_ACTION(Wham,"WHAM")
 
 void Wham::registerKeywords(Keywords& keys ) {
-  Action::registerKeywords( keys ); ActionWithValue::registerKeywords( keys );
-  ActionWithArguments::registerKeywords( keys ); keys.remove("ARG");
+  Action::registerKeywords( keys );
+  ActionWithValue::registerKeywords( keys );
+  ActionWithArguments::registerKeywords( keys );
+  keys.remove("ARG");
   keys.add("compulsory","ARG","the stored values for the bias");
   keys.add("compulsory","MAXITER","1000","maximum number of iterations for WHAM algorithm");
   keys.add("compulsory","WHAMTOL","1e-10","threshold for convergence of WHAM algorithm");
@@ -108,59 +112,90 @@ void Wham::registerKeywords(Keywords& keys ) {
 Wham::Wham(const ActionOptions&ao):
   Action(ao),
   ActionWithValue(ao),
-  ActionWithArguments(ao)
-{
+  ActionWithArguments(ao) {
   // Read in the temperature
   simtemp=getkBT();
-  if(simtemp==0) error("The MD engine does not pass the temperature to plumed so you have to specify it using TEMP");
+  if(simtemp==0) {
+    error("The MD engine does not pass the temperature to plumed so you have to specify it using TEMP");
+  }
   // Now read in parameters of WHAM
-  parse("MAXITER",maxiter); parse("WHAMTOL",thresh);
-  if(comm.Get_rank()==0) nreplicas=multi_sim_comm.Get_size();
-  comm.Bcast(nreplicas,0); addValue( getPntrToArgument(0)->getShape() ); setNotPeriodic();
+  parse("MAXITER",maxiter);
+  parse("WHAMTOL",thresh);
+  if(comm.Get_rank()==0) {
+    nreplicas=multi_sim_comm.Get_size();
+  }
+  comm.Bcast(nreplicas,0);
+  addValue( getPntrToArgument(0)->getShape() );
+  setNotPeriodic();
 }
 
 void Wham::calculate() {
   // Retrieve the values that were stored for the biase
   std::vector<double> stored_biases( getPntrToArgument(0)->getNumberOfValues() );
-  for(unsigned i=0; i<stored_biases.size(); ++i) stored_biases[i] = getPntrToArgument(0)->get(i);
+  for(unsigned i=0; i<stored_biases.size(); ++i) {
+    stored_biases[i] = getPntrToArgument(0)->get(i);
+  }
   // Get the minimum value of the bias
   double minv = *min_element(std::begin(stored_biases), std::end(stored_biases));
   // Resize final weights array
   plumed_assert( stored_biases.size()%nreplicas==0 );
   std::vector<double> final_weights( stored_biases.size() / nreplicas, 1.0 );
   if( getPntrToComponent(0)->getNumberOfValues()!=final_weights.size() ) {
-    std::vector<unsigned> shape(1); shape[0]=final_weights.size(); getPntrToComponent(0)->setShape( shape );
+    std::vector<unsigned> shape(1);
+    shape[0]=final_weights.size();
+    getPntrToComponent(0)->setShape( shape );
   }
   // Offset and exponential of the bias
   std::vector<double> expv( stored_biases.size() );
-  for(unsigned i=0; i<expv.size(); ++i) expv[i] = exp( (-stored_biases[i]+minv) / simtemp );
+  for(unsigned i=0; i<expv.size(); ++i) {
+    expv[i] = exp( (-stored_biases[i]+minv) / simtemp );
+  }
   // Initialize Z
   std::vector<double> Z( nreplicas, 1.0 ), oldZ( nreplicas );
   // Now the iterative loop to calculate the WHAM weights
   for(unsigned iter=0; iter<maxiter; ++iter) {
     // Store Z
-    for(unsigned j=0; j<Z.size(); ++j) oldZ[j]=Z[j];
+    for(unsigned j=0; j<Z.size(); ++j) {
+      oldZ[j]=Z[j];
+    }
     // Recompute weights
     double norm=0;
     for(unsigned j=0; j<final_weights.size(); ++j) {
       double ew=0;
-      for(unsigned k=0; k<Z.size(); ++k) ew += expv[j*Z.size()+k]  / Z[k];
-      final_weights[j] = 1.0 / ew; norm += final_weights[j];
+      for(unsigned k=0; k<Z.size(); ++k) {
+        ew += expv[j*Z.size()+k]  / Z[k];
+      }
+      final_weights[j] = 1.0 / ew;
+      norm += final_weights[j];
     }
     // Normalize weights
-    for(unsigned j=0; j<final_weights.size(); ++j) final_weights[j] /= norm;
+    for(unsigned j=0; j<final_weights.size(); ++j) {
+      final_weights[j] /= norm;
+    }
     // Recompute Z
-    for(unsigned j=0; j<Z.size(); ++j) Z[j] = 0.0;
+    for(unsigned j=0; j<Z.size(); ++j) {
+      Z[j] = 0.0;
+    }
     for(unsigned j=0; j<final_weights.size(); ++j) {
-      for(unsigned k=0; k<Z.size(); ++k) Z[k] += final_weights[j]*expv[j*Z.size()+k];
+      for(unsigned k=0; k<Z.size(); ++k) {
+        Z[k] += final_weights[j]*expv[j*Z.size()+k];
+      }
     }
     // Normalize Z and compute change in Z
-    double change=0; norm=0; for(unsigned k=0; k<Z.size(); ++k) norm+=Z[k];
+    double change=0;
+    norm=0;
+    for(unsigned k=0; k<Z.size(); ++k) {
+      norm+=Z[k];
+    }
     for(unsigned k=0; k<Z.size(); ++k) {
-      Z[k] /= norm; double d = std::log( Z[k] / oldZ[k] ); change += d*d;
+      Z[k] /= norm;
+      double d = std::log( Z[k] / oldZ[k] );
+      change += d*d;
     }
     if( change<thresh ) {
-      for(unsigned j=0; j<final_weights.size(); ++j) getPntrToComponent(0)->set( j, final_weights[j] );
+      for(unsigned j=0; j<final_weights.size(); ++j) {
+        getPntrToComponent(0)->set( j, final_weights[j] );
+      }
       return;
     }
   }
diff --git a/src/wham/WhamHistogram.cpp b/src/wham/WhamHistogram.cpp
index 4cbc8c0266..46e092f92a 100644
--- a/src/wham/WhamHistogram.cpp
+++ b/src/wham/WhamHistogram.cpp
@@ -93,18 +93,22 @@ void WhamHistogram::registerKeywords( Keywords& keys ) {
   keys.add("compulsory","GRID_BIN","the number of bins to use for the grid");
   keys.add("optional","BANDWIDTH","the bandwidth for kernel density estimation");
   keys.setValueDescription("the histogram that was generated using the WHAM weights");
-  keys.needsAction("GATHER_REPLICAS"); keys.needsAction("CONCATENATE");
-  keys.needsAction("COLLECT"); keys.needsAction("WHAM"); keys.needsAction("KDE");
+  keys.needsAction("GATHER_REPLICAS");
+  keys.needsAction("CONCATENATE");
+  keys.needsAction("COLLECT");
+  keys.needsAction("WHAM");
+  keys.needsAction("KDE");
 }
 
 
 WhamHistogram::WhamHistogram( const ActionOptions& ao ) :
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Input for collection of weights for WHAM
-  std::string bias; parse("BIAS",bias);
-  std::string stride; parse("STRIDE",stride);
+  std::string bias;
+  parse("BIAS",bias);
+  std::string stride;
+  parse("STRIDE",stride);
   // Input for GATHER_REPLICAS
   readInputLine( getShortcutLabel() + "_gather: GATHER_REPLICAS ARG=" + bias );
   // Put all the replicas in a single vector
@@ -112,22 +116,42 @@ WhamHistogram::WhamHistogram( const ActionOptions& ao ) :
   // Input for COLLECT_FRAMES
   readInputLine( getShortcutLabel() + "_collect: COLLECT TYPE=vector ARG=" + getShortcutLabel() + "_gatherv STRIDE=" + stride);
   // Input for WHAM
-  std::string temp, tempstr=""; parse("TEMP",temp); if( temp.length()>0 ) tempstr="TEMP=" + temp;
+  std::string temp, tempstr="";
+  parse("TEMP",temp);
+  if( temp.length()>0 ) {
+    tempstr="TEMP=" + temp;
+  }
   readInputLine( getShortcutLabel() + "_wham: WHAM ARG=" + getShortcutLabel() + "_collect " + tempstr );
   // Input for COLLECT_FRAMES
-  std::vector<std::string> args; parseVector("ARG",args); std::string argstr;
+  std::vector<std::string> args;
+  parseVector("ARG",args);
+  std::string argstr;
   for(unsigned i=0; i<args.size(); ++i) {
     readInputLine( getShortcutLabel() + "_data_" + args[i] + ": COLLECT ARG=" + args[i] );
-    if( i==0 ) argstr = " ARG="; else argstr += ",";
+    if( i==0 ) {
+      argstr = " ARG=";
+    } else {
+      argstr += ",";
+    }
     argstr += getShortcutLabel() + "_data_" + args[i];
   }
   // Input for HISTOGRAM
-  std::string histo_line, bw=""; parse("BANDWIDTH",bw);
-  if( bw!="" ) histo_line += " BANDWIDTH=" + bw;
-  else histo_line += " KERNEL=DISCRETE";
-  std::string min; parse("GRID_MIN",min); histo_line += " GRID_MIN=" + min;
-  std::string max; parse("GRID_MAX",max); histo_line += " GRID_MAX=" + max;
-  std::string bin; parse("GRID_BIN",bin); histo_line += " GRID_BIN=" + bin;
+  std::string histo_line, bw="";
+  parse("BANDWIDTH",bw);
+  if( bw!="" ) {
+    histo_line += " BANDWIDTH=" + bw;
+  } else {
+    histo_line += " KERNEL=DISCRETE";
+  }
+  std::string min;
+  parse("GRID_MIN",min);
+  histo_line += " GRID_MIN=" + min;
+  std::string max;
+  parse("GRID_MAX",max);
+  histo_line += " GRID_MAX=" + max;
+  std::string bin;
+  parse("GRID_BIN",bin);
+  histo_line += " GRID_BIN=" + bin;
   readInputLine( getShortcutLabel() + ": KDE " + argstr + " HEIGHTS=" + getShortcutLabel() + "_wham" + histo_line );
 }
 
diff --git a/src/wham/WhamWeights.cpp b/src/wham/WhamWeights.cpp
index 2a179246a7..c20d43774c 100644
--- a/src/wham/WhamWeights.cpp
+++ b/src/wham/WhamWeights.cpp
@@ -75,24 +75,29 @@ class WhamWeights : public ActionShortcut {
 PLUMED_REGISTER_ACTION(WhamWeights,"WHAM_WEIGHTS")
 
 void WhamWeights::registerKeywords( Keywords& keys ) {
-  ActionShortcut::registerKeywords( keys ); keys.remove("LABEL");
+  ActionShortcut::registerKeywords( keys );
+  keys.remove("LABEL");
   keys.add("compulsory","BIAS","*.bias","the value of the biases to use when performing WHAM");
   keys.add("optional","TEMP","the temperature at which the simulation was run");
   keys.add("compulsory","STRIDE","1","the frequency with which the bias should be stored to perform WHAM");
   keys.add("compulsory","FILE","the file on which to output the WHAM weights");
   keys.add("optional","FMT","the format to use for the real numbers in the output file");
   keys.setValueDescription("the weights that were calculated using WHAM");
-  keys.needsAction("GATHER_REPLICAS"); keys.needsAction("CONCATENATE");
-  keys.needsAction("COLLECT"); keys.needsAction("WHAM"); keys.needsAction("DUMPVECTOR");
+  keys.needsAction("GATHER_REPLICAS");
+  keys.needsAction("CONCATENATE");
+  keys.needsAction("COLLECT");
+  keys.needsAction("WHAM");
+  keys.needsAction("DUMPVECTOR");
 }
 
 WhamWeights::WhamWeights( const ActionOptions& ao ) :
   Action(ao),
-  ActionShortcut(ao)
-{
+  ActionShortcut(ao) {
   // Input for collection of weights for WHAM
-  std::string bias; parse("BIAS",bias);
-  std::string stride; parse("STRIDE",stride);
+  std::string bias;
+  parse("BIAS",bias);
+  std::string stride;
+  parse("STRIDE",stride);
   // Input for GATHER_REPLICAS
   readInputLine( getShortcutLabel() + "_gather: GATHER_REPLICAS ARG=" + bias );
   // Put all the replicas in a single vector
@@ -100,10 +105,16 @@ WhamWeights::WhamWeights( const ActionOptions& ao ) :
   // Input for COLLECT_FRAMES
   readInputLine( getShortcutLabel() + "_collect: COLLECT TYPE=vector ARG=" + getShortcutLabel() + "_gatherv STRIDE=" + stride);
   // Input for WHAM
-  std::string temp, tempstr=""; parse("TEMP",temp); if( temp.length()>0 ) tempstr="TEMP=" + temp;
+  std::string temp, tempstr="";
+  parse("TEMP",temp);
+  if( temp.length()>0 ) {
+    tempstr="TEMP=" + temp;
+  }
   readInputLine( getShortcutLabel() + ": WHAM ARG=" + getShortcutLabel() + "_collect " + tempstr );
   // Input for PRINT (will just output at end of calc
-  std::string filename, fmt; parse("FILE",filename); parse("FMT",fmt);
+  std::string filename, fmt;
+  parse("FILE",filename);
+  parse("FMT",fmt);
   readInputLine( "DUMPVECTOR STRIDE=0 ARG=" + getShortcutLabel() + " FILE=" + filename + " FMT=" + fmt );
 }
 
diff --git a/src/wrapper/Plumed.h b/src/wrapper/Plumed.h
index 3ea2bc9c75..dd0aad96c2 100644
--- a/src/wrapper/Plumed.h
+++ b/src/wrapper/Plumed.h
@@ -930,7 +930,9 @@ __PLUMED_WRAPPER_STATIC_INLINE void plumed_error_init(plumed_error* error) __PLU
 /** Finalize error - should be called when an error is raised to avoid leaks */
 /* cppcheck-suppress passedByValue */
 __PLUMED_WRAPPER_STATIC_INLINE void plumed_error_finalize(plumed_error error) __PLUMED_WRAPPER_CXX_NOEXCEPT {
-  if(!error.code) return;
+  if(!error.code) {
+    return;
+  }
   if(error.nested) {
     plumed_error_finalize(*error.nested);
     plumed_free(error.nested);
@@ -966,7 +968,9 @@ __PLUMED_WRAPPER_STATIC_INLINE void plumed_error_set_bad_alloc(plumed_error*erro
 
 /** Recursive merge (for internal usage) */
 __PLUMED_WRAPPER_STATIC_INLINE void plumed_error_recursive_merge(plumed_error* error,char*buffer,const char*join,__PLUMED_WRAPPER_STD size_t*len) __PLUMED_WRAPPER_CXX_NOEXCEPT {
-  if(error->nested) plumed_error_recursive_merge(error->nested,buffer,join,len);
+  if(error->nested) {
+    plumed_error_recursive_merge(error->nested,buffer,join,len);
+  }
   __PLUMED_WRAPPER_STD strncat(buffer,plumed_error_what(*error),*len);
   *len -= __PLUMED_WRAPPER_STD strlen(plumed_error_what(*error));
   __PLUMED_WRAPPER_STD strncat(buffer,join,*len);
@@ -985,7 +989,9 @@ __PLUMED_WRAPPER_STATIC_INLINE void plumed_error_merge_with_nested(plumed_error*
   plumed_error*e;
 
   /* If exception is not nested, nothing to do */
-  if(!error->nested) return;
+  if(!error->nested) {
+    return;
+  }
 
   /* Accumulate the total length of the concatenated message */
   len_join=__PLUMED_WRAPPER_STD strlen(join);
@@ -1015,7 +1021,9 @@ __PLUMED_WRAPPER_STATIC_INLINE void plumed_error_merge_with_nested(plumed_error*
   error->what=new_buffer;
 
   /* Deallocate the previous message */
-  if(error->what_buffer) plumed_free(error->what_buffer);
+  if(error->what_buffer) {
+    plumed_free(error->what_buffer);
+  }
   error->what_buffer=new_buffer;
 
   /* Finalize the chain of nested exceptions */
@@ -1031,7 +1039,9 @@ __PLUMED_WRAPPER_STATIC_INLINE void plumed_error_merge_with_nested(plumed_error*
 
 /** Rethrow error (calling abort) */
 __PLUMED_WRAPPER_CXX_NORETURN __PLUMED_WRAPPER_STATIC_INLINE void plumed_error_rethrow(plumed_error h) {
-  if(h.nested) plumed_error_merge_with_nested(&h);
+  if(h.nested) {
+    plumed_error_merge_with_nested(&h);
+  }
   __PLUMED_WRAPPER_STD fprintf(stderr,"Terminate due to exception. Code: %d\n%s\n",h.code,plumed_error_what(h));
   __PLUMED_WRAPPER_STD abort();
 }
@@ -1823,7 +1833,9 @@ namespace wrapper {
 
 /// This is to replace c++17 std::void_t
 template<typename... Ts>
-struct make_void { using type = void; };
+struct make_void {
+  using type = void;
+};
 template<typename... Ts>
 using void_t = typename make_void<Ts...>::type;
 
@@ -1930,39 +1942,79 @@ class Plumed {
     finalize_plumed_error finalize(h);
     /* grab the message */
     const char* msg=plumed_error_what(h);
-    if(h.code==1) f(Plumed::Invalid(msg));
+    if(h.code==1) {
+      f(Plumed::Invalid(msg));
+    }
     /* logic errors */
     if(h.code>=10100 && h.code<10200) {
-      if(h.code>=10105 && h.code<10110) f(::std::invalid_argument(msg));
-      if(h.code>=10110 && h.code<10115) f(::std::domain_error(msg));
-      if(h.code>=10115 && h.code<10120) f(::std::length_error(msg));
-      if(h.code>=10120 && h.code<10125) f(::std::out_of_range(msg));
+      if(h.code>=10105 && h.code<10110) {
+        f(::std::invalid_argument(msg));
+      }
+      if(h.code>=10110 && h.code<10115) {
+        f(::std::domain_error(msg));
+      }
+      if(h.code>=10115 && h.code<10120) {
+        f(::std::length_error(msg));
+      }
+      if(h.code>=10120 && h.code<10125) {
+        f(::std::out_of_range(msg));
+      }
 #if __cplusplus >= 201703L && __PLUMED_WRAPPER_LIBCXX17
-      if(h.code==10125) f(add_buffer_to< ::std::future_error>(::std::future_error(::std::future_errc::broken_promise),msg));
-      if(h.code==10126) f(add_buffer_to< ::std::future_error>(::std::future_error(::std::future_errc::future_already_retrieved),msg));
-      if(h.code==10127) f(add_buffer_to< ::std::future_error>(::std::future_error(::std::future_errc::promise_already_satisfied),msg));
-      if(h.code==10128) f(add_buffer_to< ::std::future_error>(::std::future_error(::std::future_errc::no_state),msg));
+      if(h.code==10125) {
+        f(add_buffer_to< ::std::future_error>(::std::future_error(::std::future_errc::broken_promise),msg));
+      }
+      if(h.code==10126) {
+        f(add_buffer_to< ::std::future_error>(::std::future_error(::std::future_errc::future_already_retrieved),msg));
+      }
+      if(h.code==10127) {
+        f(add_buffer_to< ::std::future_error>(::std::future_error(::std::future_errc::promise_already_satisfied),msg));
+      }
+      if(h.code==10128) {
+        f(add_buffer_to< ::std::future_error>(::std::future_error(::std::future_errc::no_state),msg));
+      }
 #endif
       f(::std::logic_error(msg));
     }
     /* runtime errors */
     if(h.code>=10200 && h.code<10300) {
-      if(h.code>=10205 && h.code<10210) f(::std::range_error(msg));
-      if(h.code>=10210 && h.code<10215) f(::std::overflow_error(msg));
-      if(h.code>=10215 && h.code<10220) f(::std::underflow_error(msg));
+      if(h.code>=10205 && h.code<10210) {
+        f(::std::range_error(msg));
+      }
+      if(h.code>=10210 && h.code<10215) {
+        f(::std::overflow_error(msg));
+      }
+      if(h.code>=10215 && h.code<10220) {
+        f(::std::underflow_error(msg));
+      }
 #if __cplusplus > 199711L && __PLUMED_WRAPPER_LIBCXX11
-      if(h.code==10220) f(::std::system_error(h.error_code,::std::generic_category(),msg));
-      if(h.code==10221) f(::std::system_error(h.error_code,::std::system_category(),msg));
-      if(h.code==10222) f(::std::system_error(h.error_code,::std::iostream_category(),msg));
-      if(h.code==10223) f(::std::system_error(h.error_code,::std::future_category(),msg));
+      if(h.code==10220) {
+        f(::std::system_error(h.error_code,::std::generic_category(),msg));
+      }
+      if(h.code==10221) {
+        f(::std::system_error(h.error_code,::std::system_category(),msg));
+      }
+      if(h.code==10222) {
+        f(::std::system_error(h.error_code,::std::iostream_category(),msg));
+      }
+      if(h.code==10223) {
+        f(::std::system_error(h.error_code,::std::future_category(),msg));
+      }
 #endif
 #if __cplusplus >= 201703L && __PLUMED_WRAPPER_LIBCXX17
       if(h.code==10229) {
         ::std::error_code error_code;
-        if(h.error_category==1) error_code=::std::error_code(h.error_code,::std::generic_category());
-        if(h.error_category==2) error_code=::std::error_code(h.error_code,::std::system_category());
-        if(h.error_category==3) error_code=::std::error_code(h.error_code,::std::iostream_category());
-        if(h.error_category==4) error_code=::std::error_code(h.error_code,::std::future_category());
+        if(h.error_category==1) {
+          error_code=::std::error_code(h.error_code,::std::generic_category());
+        }
+        if(h.error_category==2) {
+          error_code=::std::error_code(h.error_code,::std::system_category());
+        }
+        if(h.error_category==3) {
+          error_code=::std::error_code(h.error_code,::std::iostream_category());
+        }
+        if(h.error_category==4) {
+          error_code=::std::error_code(h.error_code,::std::future_category());
+        }
 
         if(!h.path1.ptr) {
           f(::std::filesystem::filesystem_error(msg,error_code));
@@ -1999,64 +2051,122 @@ class Plumed {
       if(h.code>=10230 && h.code<10240) {
 #if __cplusplus > 199711L && __PLUMED_WRAPPER_LIBCXX11
 // These cases are probably useless as it looks like this should always be std::iostream_category
-        if(h.code==10230) f(::std::ios_base::failure(msg,::std::error_code(h.error_code,::std::generic_category())));
-        if(h.code==10231) f(::std::ios_base::failure(msg,::std::error_code(h.error_code,::std::system_category())));
-        if(h.code==10232) f(::std::ios_base::failure(msg,::std::error_code(h.error_code,::std::iostream_category())));
-        if(h.code==10233) f(::std::ios_base::failure(msg,::std::error_code(h.error_code,::std::future_category())));
+        if(h.code==10230) {
+          f(::std::ios_base::failure(msg,::std::error_code(h.error_code,::std::generic_category())));
+        }
+        if(h.code==10231) {
+          f(::std::ios_base::failure(msg,::std::error_code(h.error_code,::std::system_category())));
+        }
+        if(h.code==10232) {
+          f(::std::ios_base::failure(msg,::std::error_code(h.error_code,::std::iostream_category())));
+        }
+        if(h.code==10233) {
+          f(::std::ios_base::failure(msg,::std::error_code(h.error_code,::std::future_category())));
+        }
 #endif
         f(::std::ios_base::failure(msg));
       }
 #if __cplusplus > 199711L && __PLUMED_WRAPPER_LIBCXX11
-      if(h.code==10240) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_collate),msg));
-      if(h.code==10241) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_ctype),msg));
-      if(h.code==10242) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_escape),msg));
-      if(h.code==10243) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_backref),msg));
-      if(h.code==10244) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_brack),msg));
-      if(h.code==10245) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_paren),msg));
-      if(h.code==10246) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_brace),msg));
-      if(h.code==10247) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_badbrace),msg));
-      if(h.code==10248) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_range),msg));
-      if(h.code==10249) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_space),msg));
-      if(h.code==10250) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_badrepeat),msg));
-      if(h.code==10251) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_complexity),msg));
-      if(h.code==10252) f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_stack),msg));
+      if(h.code==10240) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_collate),msg));
+      }
+      if(h.code==10241) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_ctype),msg));
+      }
+      if(h.code==10242) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_escape),msg));
+      }
+      if(h.code==10243) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_backref),msg));
+      }
+      if(h.code==10244) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_brack),msg));
+      }
+      if(h.code==10245) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_paren),msg));
+      }
+      if(h.code==10246) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_brace),msg));
+      }
+      if(h.code==10247) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_badbrace),msg));
+      }
+      if(h.code==10248) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_range),msg));
+      }
+      if(h.code==10249) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_space),msg));
+      }
+      if(h.code==10250) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_badrepeat),msg));
+      }
+      if(h.code==10251) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_complexity),msg));
+      }
+      if(h.code==10252) {
+        f(add_buffer_to< ::std::regex_error>(::std::regex_error(::std::regex_constants::error_stack),msg));
+      }
 #endif
       f(::std::runtime_error(msg));
     }
     /* "bad" errors */
     /* "< ::" space required in C++ < 11 */
-    if(h.code>=11000 && h.code<11100) f(add_buffer_to< ::std::bad_typeid>(msg));
+    if(h.code>=11000 && h.code<11100) {
+      f(add_buffer_to< ::std::bad_typeid>(msg));
+    }
     if(h.code>=11100 && h.code<11200) {
 #if __cplusplus >= 201703L && __PLUMED_WRAPPER_LIBCXX17
-      if(h.code>=11150) f(add_buffer_to< ::std::bad_any_cast>(msg));
+      if(h.code>=11150) {
+        f(add_buffer_to< ::std::bad_any_cast>(msg));
+      }
 #endif
       f(add_buffer_to< ::std::bad_cast>(msg));
     }
 #if __cplusplus > 199711L && __PLUMED_WRAPPER_LIBCXX11
-    if(h.code>=11200 && h.code<11300) f(add_buffer_to< ::std::bad_weak_ptr>(msg));
-    if(h.code>=11300 && h.code<11400) f(add_buffer_to< ::std::bad_function_call>(msg));
+    if(h.code>=11200 && h.code<11300) {
+      f(add_buffer_to< ::std::bad_weak_ptr>(msg));
+    }
+    if(h.code>=11300 && h.code<11400) {
+      f(add_buffer_to< ::std::bad_function_call>(msg));
+    }
 #endif
     if(h.code>=11400 && h.code<11500) {
 #if __cplusplus > 199711L && __PLUMED_WRAPPER_LIBCXX11
-      if(h.code>=11410 && h.code<11420) f(add_buffer_to< ::std::bad_array_new_length>(msg));
+      if(h.code>=11410 && h.code<11420) {
+        f(add_buffer_to< ::std::bad_array_new_length>(msg));
+      }
 #endif
       f(add_buffer_to< ::std::bad_alloc>(msg));
     }
-    if(h.code>=11500 && h.code<11600) f(add_buffer_to< ::std::bad_exception>(msg));
+    if(h.code>=11500 && h.code<11600) {
+      f(add_buffer_to< ::std::bad_exception>(msg));
+    }
 #if __cplusplus >= 201703L && __PLUMED_WRAPPER_LIBCXX17
-    if(h.code>=11600 && h.code<11700) f(add_buffer_to< ::std::bad_optional_access>(msg));
-    if(h.code>=11700 && h.code<11800) f(add_buffer_to< ::std::bad_variant_access>(msg));
+    if(h.code>=11600 && h.code<11700) {
+      f(add_buffer_to< ::std::bad_optional_access>(msg));
+    }
+    if(h.code>=11700 && h.code<11800) {
+      f(add_buffer_to< ::std::bad_variant_access>(msg));
+    }
 #endif
     /* lepton error */
-    if(h.code>=19900 && h.code<20000) f(Plumed::LeptonException(msg));
+    if(h.code>=19900 && h.code<20000) {
+      f(Plumed::LeptonException(msg));
+    }
     /* plumed exceptions */
     if(h.code>=20000 && h.code<30000) {
       /* debug - only raised with debug options */
-      if(h.code>=20100 && h.code<20200) f(Plumed::ExceptionDebug(msg));
+      if(h.code>=20100 && h.code<20200) {
+        f(Plumed::ExceptionDebug(msg));
+      }
       /* error - runtime check */
-      if(h.code>=20200 && h.code<20300) f(Plumed::ExceptionError(msg));
+      if(h.code>=20200 && h.code<20300) {
+        f(Plumed::ExceptionError(msg));
+      }
       /* error - type error */
-      if(h.code>=20300 && h.code<20400) f(Plumed::ExceptionTypeError(msg));
+      if(h.code>=20300 && h.code<20400) {
+        f(Plumed::ExceptionTypeError(msg));
+      }
       f(Plumed::Exception(msg));
     }
     /* fallback for any other exception */
@@ -2111,7 +2221,9 @@ class Plumed {
       When using C++11 nested exceptions, we need to rethrow recursively
     */
     try {
-      if(h.nested) rethrow(*h.nested); /* recursive throw */
+      if(h.nested) {
+        rethrow(*h.nested);  /* recursive throw */
+      }
     } catch(...) {
       exception_dispatch(h,rethrow_nested());
     }
@@ -2120,7 +2232,9 @@ class Plumed {
     /*
       When using C++<11 exceptions, we merge the message and then throw the resulting exception
     */
-    if(h.nested) plumed_error_merge_with_nested(&h);
+    if(h.nested) {
+      plumed_error_merge_with_nested(&h);
+    }
     exception_dispatch(h,rethrow_not_nested());
 #endif
   }
@@ -2225,12 +2339,13 @@ class Plumed {
     Base class used to rethrow PLUMED exceptions.
   */
   class Exception :
-    public ::std::exception
-  {
+    public ::std::exception {
     ::std::string msg;
   public:
     __PLUMED_WRAPPER_CXX_EXPLICIT Exception(const char* msg): msg(msg) {}
-    const char* what() const __PLUMED_WRAPPER_CXX_NOEXCEPT __PLUMED_WRAPPER_CXX_OVERRIDE {return msg.c_str();}
+    const char* what() const __PLUMED_WRAPPER_CXX_NOEXCEPT __PLUMED_WRAPPER_CXX_OVERRIDE {
+      return msg.c_str();
+    }
 #if ! (__cplusplus > 199711L)
     /* Destructor should be declared in order to have the correct throw() before C++11 */
     /* see https://stackoverflow.com/questions/50025862/why-is-the-stdexception-destructor-not-noexcept */
@@ -2316,12 +2431,13 @@ class Plumed {
   */
 
   class LeptonException :
-    public ::std::exception
-  {
+    public ::std::exception {
     ::std::string msg;
   public:
     __PLUMED_WRAPPER_CXX_EXPLICIT LeptonException(const char* msg): msg(msg) {}
-    const char* what() const __PLUMED_WRAPPER_CXX_NOEXCEPT __PLUMED_WRAPPER_CXX_OVERRIDE {return msg.c_str();}
+    const char* what() const __PLUMED_WRAPPER_CXX_NOEXCEPT __PLUMED_WRAPPER_CXX_OVERRIDE {
+      return msg.c_str();
+    }
 #if ! (__cplusplus > 199711L)
     /* Destructor should be declared in order to have the correct throw() before C++11 */
     /* see https://stackoverflow.com/questions/50025862/why-is-the-stdexception-destructor-not-noexcept */
@@ -2341,31 +2457,32 @@ class Plumed {
 
   template<typename T>
   class add_buffer_to:
-    public T
-  {
+    public T {
     char msg[__PLUMED_WRAPPER_CXX_EXCEPTION_BUFFER];
     void init(const char* msg) __PLUMED_WRAPPER_CXX_NOEXCEPT {
       this->msg[0]='\0';
       __PLUMED_WRAPPER_STD strncat(this->msg,msg,__PLUMED_WRAPPER_CXX_EXCEPTION_BUFFER-1);
       this->msg[__PLUMED_WRAPPER_CXX_EXCEPTION_BUFFER-1]='\0';
-      if(PlumedGetenvExceptionsDebug() && __PLUMED_WRAPPER_STD strlen(msg) > __PLUMED_WRAPPER_CXX_EXCEPTION_BUFFER-1) __PLUMED_WRAPPER_STD fprintf(stderr,"+++ WARNING: message will be truncated\n");
+      if(PlumedGetenvExceptionsDebug() && __PLUMED_WRAPPER_STD strlen(msg) > __PLUMED_WRAPPER_CXX_EXCEPTION_BUFFER-1) {
+        __PLUMED_WRAPPER_STD fprintf(stderr,"+++ WARNING: message will be truncated\n");
+      }
     }
   public:
     __PLUMED_WRAPPER_CXX_EXPLICIT add_buffer_to(const char * msg) __PLUMED_WRAPPER_CXX_NOEXCEPT {
       init(msg);
     }
   add_buffer_to(const T& base,const char * msg) __PLUMED_WRAPPER_CXX_NOEXCEPT:
-    T(base)
-    {
+    T(base) {
       init(msg);
     }
   add_buffer_to(const add_buffer_to & other) __PLUMED_WRAPPER_CXX_NOEXCEPT:
-    T(other)
-    {
+    T(other) {
       init(other.msg);
     }
     add_buffer_to & operator=(const add_buffer_to & other) __PLUMED_WRAPPER_CXX_NOEXCEPT {
-      if(this==&other) return *this;
+      if(this==&other) {
+        return *this;
+      }
       init(other.msg);
       return *this;
     }
@@ -2410,8 +2527,12 @@ class Plumed {
     __PLUMED_WRAPPER_CXX_EXPLICIT SafePtr(const plumed_safeptr & safe,__PLUMED_WRAPPER_STD size_t nelem=0, const __PLUMED_WRAPPER_STD size_t* shape=__PLUMED_WRAPPER_CXX_NULLPTR) __PLUMED_WRAPPER_CXX_NOEXCEPT {
       this->safe=safe;
       buffer[0]='\0';
-      if(nelem>0) this->safe.nelem=nelem;
-      if(shape) this->safe.shape=const_cast<__PLUMED_WRAPPER_STD size_t*>(shape);
+      if(nelem>0) {
+        this->safe.nelem=nelem;
+      }
+      if(shape) {
+        this->safe.shape=const_cast<__PLUMED_WRAPPER_STD size_t*>(shape);
+      }
     }
 
 #if __cplusplus > 199711L
@@ -2712,16 +2833,14 @@ Plumed()__PLUMED_WRAPPER_CXX_NOEXCEPT :
      if the created object is still in scope.
   */
 __PLUMED_WRAPPER_CXX_EXPLICIT Plumed(const char*c)__PLUMED_WRAPPER_CXX_NOEXCEPT :
-  main(plumed_create_reference_f(c))
-  {
+  main(plumed_create_reference_f(c)) {
   }
 
   /**
     Create a reference from a void* pointer. Available as of PLUMED 2.5.
   */
 __PLUMED_WRAPPER_CXX_EXPLICIT Plumed(void*v)__PLUMED_WRAPPER_CXX_NOEXCEPT :
-  main(plumed_create_reference_v(v))
-  {
+  main(plumed_create_reference_v(v)) {
   }
 
   /**
@@ -2734,8 +2853,7 @@ __PLUMED_WRAPPER_CXX_EXPLICIT Plumed(void*v)__PLUMED_WRAPPER_CXX_NOEXCEPT :
      if the created object is still in scope.
   */
 __PLUMED_WRAPPER_CXX_EXPLICIT Plumed(plumed p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
-  main(plumed_create_reference(p))
-  {
+  main(plumed_create_reference(p)) {
   }
 
   /** Copy constructor.
@@ -2743,8 +2861,7 @@ __PLUMED_WRAPPER_CXX_EXPLICIT Plumed(plumed p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
     Takes a reference, incrementing the reference counter of the corresponding object.
   */
 Plumed(const Plumed& p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
-  main(plumed_create_reference(p.main))
-  {
+  main(plumed_create_reference(p.main)) {
   }
 
   /** Assignment operator. Available as of PLUMED 2.5.
@@ -2754,7 +2871,9 @@ Plumed(const Plumed& p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
   Plumed&operator=(const Plumed&p) __PLUMED_WRAPPER_CXX_NOEXCEPT {
     if(this != &p) {
 // the check is needed to avoid calling plumed_finalize on moved objects
-      if(main.p) plumed_finalize(main);
+      if(main.p) {
+        plumed_finalize(main);
+      }
       main=plumed_create_reference(p.main);
     }
     return *this;
@@ -2771,8 +2890,7 @@ Plumed(const Plumed& p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
     Only if move semantics is enabled.
   */
 Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
-  main(p.main)
-  {
+  main(p.main) {
     p.main.p=nullptr;
   }
   /** Move assignment. Available as of PLUMED 2.5.
@@ -2781,7 +2899,9 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
   Plumed& operator=(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT  {
     if(this != &p) {
 // the check is needed to avoid calling plumed_finalize on moved objects
-      if(main.p) plumed_finalize(main);
+      if(main.p) {
+        plumed_finalize(main);
+      }
       main=p.main;
       p.main.p=nullptr;
     }
@@ -2991,7 +3111,9 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
       rethrow();
     }
     /* plumed_error_rethrow is finalizing */
-    if(!error && error_cxx.code!=0) plumed_error_rethrow_cxx(error_cxx);
+    if(!error && error_cxx.code!=0) {
+      plumed_error_rethrow_cxx(error_cxx);
+    }
   }
 
 public:
@@ -3016,14 +3138,12 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
     CString& operator=(CString&&) = delete;
   public:
     /// Initialize from a const char*, copying the address
-    CString(const char* str) noexcept
-    {
+    CString(const char* str) noexcept {
       this->str=str;
       this->static_buffer[0]='\0';
     }
     /// Initialize from a std:string, taking the address of the corresponding c_str
-    CString(const std::string & str) noexcept
-    {
+    CString(const std::string & str) noexcept {
       this->str=str.c_str();
       this->static_buffer[0]='\0';
     }
@@ -3057,7 +3177,9 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
   /// Internal tool to convert initializer_list to shape
   /// This is just taking an initializer list and making a std::array
   std::array<std::size_t,5>  make_shape(std::initializer_list<SizeLike> shape) {
-    if(shape.size()>4) throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    if(shape.size()>4) {
+      throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    }
     std::array<std::size_t,5> shape_;
     unsigned j=0;
     for(auto i : shape) {
@@ -3075,9 +3197,13 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
     unsigned i;
     for(i=0; i<4; i++) {
       shape_[i]=shape[i];
-      if(shape[i]==0) break;
+      if(shape[i]==0) {
+        break;
+      }
     } // one less because we need to append another number!
-    if(i==4) throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    if(i==4) {
+      throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    }
     shape_[i]=newindex;
     shape_[i+1]=0;
     return shape_;
@@ -3118,14 +3244,18 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
     // this would be strict checking
     // "a pointer without a specified size is meant to be pointing to a size 1 object"
     std::size_t shape[] {  0, 0 };
-    if(val) shape[0]=1;
+    if(val) {
+      shape[0]=1;
+    }
     cmd_helper_with_shape(std::forward<Key>(key),val,shape);
 #else
     if(wrapper::is_custom_array<typename std::remove_pointer<typename std::remove_reference<T>::type>::type>::value) {
       // if we are passing a pointer to a fixed sized array, we make sure to retain the information related to
       // the rank of the array and the following (fixed) dimensions
       std::size_t shape[] {  0, 0 };
-      if(val) shape[0]=std::numeric_limits<std::size_t>::max();
+      if(val) {
+        shape[0]=std::numeric_limits<std::size_t>::max();
+      }
       cmd_helper_with_shape(std::forward<Key>(key),val,shape);
     } else {
       // otherwise, for backward compatibility, the pointer is assumed with no shape information
@@ -3157,7 +3287,9 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
   template<typename Key,typename T, typename std::enable_if<!wrapper::is_custom_array<T>::value, int>::type = 0>
   void cmd_helper_with_shape(Key && key,T* val, __PLUMED_WRAPPER_STD size_t* shape,bool nocopy=false) {
     SafePtr s(val,0,shape);
-    if(nocopy) s.safe.flags |= 0x10000000;
+    if(nocopy) {
+      s.safe.flags |= 0x10000000;
+    }
     cmd_priv(main,CString(key),s);
   }
 
@@ -3168,7 +3300,9 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
   template<typename Key,typename T, typename std::enable_if<wrapper::is_custom_array<T>::value, int>::type = 0>
   void cmd_with_nelem(Key && key,T* val, __PLUMED_WRAPPER_STD size_t nelem) {
     std::size_t shape[] {  0, 0 };
-    if(val) shape[0]=nelem;
+    if(val) {
+      shape[0]=nelem;
+    }
     cmd_helper_with_shape(std::forward<Key>(key),val,shape);
   }
 
@@ -3237,8 +3371,13 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
   template<typename Key,typename T>
   void cmd(Key && key,T* val, __PLUMED_WRAPPER_STD size_t* shape) {
     unsigned i;
-    for(i=0; i<5; i++) if(shape[i]==0) break;
-    if(i==5) throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    for(i=0; i<5; i++)
+      if(shape[i]==0) {
+        break;
+      }
+    if(i==5) {
+      throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    }
     cmd_helper_with_shape(std::forward<Key>(key),val,shape);
   }
 
@@ -3300,8 +3439,13 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
   template<typename T>
   void cmd(const char*key,T* val, const __PLUMED_WRAPPER_STD size_t* shape) {
     unsigned i;
-    for(i=0; i<5; i++) if(shape[i]==0) break;
-    if(i==5) throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    for(i=0; i<5; i++)
+      if(shape[i]==0) {
+        break;
+      }
+    if(i==5) {
+      throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    }
     plumed_cmd_cxx(main,key,val,shape);
   }
 
@@ -3339,7 +3483,9 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
 #endif
   ~Plumed() __PLUMED_WRAPPER_CXX_NOEXCEPT {
 // the check is needed to avoid calling plumed_finalize on moved objects
-    if(main.p) plumed_finalize(main);
+    if(main.p) {
+      plumed_finalize(main);
+    }
   }
 
   /**
@@ -3403,8 +3549,13 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
   template<typename T>
   static void plumed_cmd_cxx(plumed p,const char*key,T* val, const __PLUMED_WRAPPER_STD size_t* shape,plumed_error* error=__PLUMED_WRAPPER_CXX_NULLPTR) {
     unsigned i;
-    for(i=0; i<5; i++) if(shape[i]==0) break;
-    if(i==5) throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    for(i=0; i<5; i++)
+      if(shape[i]==0) {
+        break;
+      }
+    if(i==5) {
+      throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    }
     SafePtr s(val,0,shape);
     cmd_priv(p,key,s,error);
   }
@@ -3464,8 +3615,13 @@ Plumed(Plumed&&p)__PLUMED_WRAPPER_CXX_NOEXCEPT :
   template<typename T>
   static void plumed_gcmd_cxx(const char*key,T val, const __PLUMED_WRAPPER_STD size_t* shape,plumed_error* error=__PLUMED_WRAPPER_CXX_NULLPTR) {
     unsigned i;
-    for(i=0; i<5; i++) if(shape[i]==0) break;
-    if(i==5) throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    for(i=0; i<5; i++)
+      if(shape[i]==0) {
+        break;
+      }
+    if(i==5) {
+      throw Plumed::ExceptionTypeError("Maximum shape size is 4");
+    }
     plumed_cmd_cxx(plumed_global(),key,val,shape,error);
   }
 
@@ -3833,14 +3989,18 @@ void* plumed_attempt_dlopen(const char*path,int mode) {
     }
     __PLUMED_WRAPPER_STD strncpy(pathcopy,path,strlenpath+1);
     pc=pathcopy+strlenpath-6;
-    while(pc>=pathcopy && __PLUMED_WRAPPER_STD memcmp(pc,"Kernel",6)) pc--;
+    while(pc>=pathcopy && __PLUMED_WRAPPER_STD memcmp(pc,"Kernel",6)) {
+      pc--;
+    }
     if(pc>=pathcopy) {
       __PLUMED_WRAPPER_STD memmove(pc, pc+6, __PLUMED_WRAPPER_STD strlen(pc)-5);
       __PLUMED_FPRINTF(stderr,"+++ This error is expected if you are trying to load a kernel <=2.4\n");
       __PLUMED_FPRINTF(stderr,"+++ Trying %s +++\n",pathcopy);
       dlerror();
       p=dlopen(pathcopy,mode);
-      if(!p) __PLUMED_FPRINTF(stderr,"+++ An error occurred. Message from dlopen(): %s +++\n",dlerror());
+      if(!p) {
+        __PLUMED_FPRINTF(stderr,"+++ An error occurred. Message from dlopen(): %s +++\n",dlerror());
+      }
     }
     plumed_free(pathcopy);
   }
@@ -3893,7 +4053,9 @@ void plumed_search_symbols(void* handle, plumed_plumedmain_function_holder* f,pl
   */
   debug=__PLUMED_GETENV("PLUMED_LOAD_DEBUG");
   table_ptr=__PLUMED_WRAPPER_STATIC_CAST(plumed_symbol_table_type*, dlsym(handle,"plumed_symbol_table"));
-  if(table_ptr) functions=table_ptr->functions;
+  if(table_ptr) {
+    functions=table_ptr->functions;
+  }
   if(debug) {
     if(table_ptr) {
       __PLUMED_FPRINTF(stderr,"+++ plumed_symbol_table version %i found at %p +++\n",table_ptr->version,__PLUMED_WRAPPER_STATIC_CAST(void*,table_ptr));
@@ -3916,17 +4078,29 @@ void plumed_search_symbols(void* handle, plumed_plumedmain_function_holder* f,pl
   __PLUMED_SEARCH_FUNCTION(plumed_finalize_pointer,tmpptr,handle,functions.finalize,"plumedmain_finalize",debug);
   __PLUMED_SEARCH_FUNCTION(plumed_finalize_pointer,tmpptr,handle,functions.finalize,"plumed_plumedmain_finalize",debug);
   if(functions.create && functions.cmd && functions.finalize) {
-    if(debug) __PLUMED_FPRINTF(stderr,"+++ PLUMED was loaded correctly +++\n");
+    if(debug) {
+      __PLUMED_FPRINTF(stderr,"+++ PLUMED was loaded correctly +++\n");
+    }
     *f=functions;
-    if(table) *table=table_ptr;
+    if(table) {
+      *table=table_ptr;
+    }
   } else {
-    if(!functions.create) __PLUMED_FPRINTF(stderr,"+++ Pointer to (plumed_)plumedmain_create not found +++\n");
-    if(!functions.cmd) __PLUMED_FPRINTF(stderr,"+++ Pointer to (plumed_)plumedmain_cmd not found +++\n");
-    if(!functions.finalize) __PLUMED_FPRINTF(stderr,"+++ Pointer to (plumed_)plumedmain_finalize not found +++\n");
+    if(!functions.create) {
+      __PLUMED_FPRINTF(stderr,"+++ Pointer to (plumed_)plumedmain_create not found +++\n");
+    }
+    if(!functions.cmd) {
+      __PLUMED_FPRINTF(stderr,"+++ Pointer to (plumed_)plumedmain_cmd not found +++\n");
+    }
+    if(!functions.finalize) {
+      __PLUMED_FPRINTF(stderr,"+++ Pointer to (plumed_)plumedmain_finalize not found +++\n");
+    }
     f->create=__PLUMED_WRAPPER_CXX_NULLPTR;
     f->cmd=__PLUMED_WRAPPER_CXX_NULLPTR;
     f->finalize=__PLUMED_WRAPPER_CXX_NULLPTR;
-    if(table) *table=__PLUMED_WRAPPER_CXX_NULLPTR;
+    if(table) {
+      *table=__PLUMED_WRAPPER_CXX_NULLPTR;
+    }
   }
 }
 __PLUMED_WRAPPER_INTERNALS_END
@@ -3993,18 +4167,30 @@ void plumed_retrieve_functions(plumed_plumedmain_function_holder* functions, plu
     This makes the symbols hardcoded and independent of a mis-set PLUMED_KERNEL variable.
   */
   plumed_symbol_table_type* ptr=plumed_symbol_table_reexport();
-  if(plumed_symbol_table_ptr) *plumed_symbol_table_ptr=ptr;
-  if(handle) *handle=__PLUMED_WRAPPER_CXX_NULLPTR;
-  if(functions) *functions=ptr->functions;
+  if(plumed_symbol_table_ptr) {
+    *plumed_symbol_table_ptr=ptr;
+  }
+  if(handle) {
+    *handle=__PLUMED_WRAPPER_CXX_NULLPTR;
+  }
+  if(functions) {
+    *functions=ptr->functions;
+  }
 #elif ! defined(__PLUMED_HAS_DLOPEN)
   /*
     When dlopen is not available, we hard code them to NULL
   */
   __PLUMED_FPRINTF(stderr,"+++ PLUMED has been compiled without dlopen and without a static kernel +++\n");
   plumed_plumedmain_function_holder g= {__PLUMED_WRAPPER_CXX_NULLPTR,__PLUMED_WRAPPER_CXX_NULLPTR,__PLUMED_WRAPPER_CXX_NULLPTR};
-  if(plumed_symbol_table_ptr) *plumed_symbol_table_ptr=__PLUMED_WRAPPER_CXX_NULLPTR;
-  if(handle) *handle=__PLUMED_WRAPPER_CXX_NULLPTR;
-  if(functions) *functions=g;
+  if(plumed_symbol_table_ptr) {
+    *plumed_symbol_table_ptr=__PLUMED_WRAPPER_CXX_NULLPTR;
+  }
+  if(handle) {
+    *handle=__PLUMED_WRAPPER_CXX_NULLPTR;
+  }
+  if(functions) {
+    *functions=g;
+  }
 #else
   /*
     On the other hand, for runtime binding, we use dlsym to find the relevant functions.
@@ -4022,8 +4208,12 @@ void plumed_retrieve_functions(plumed_plumedmain_function_holder* functions, plu
   p=__PLUMED_WRAPPER_CXX_NULLPTR;
   debug=__PLUMED_GETENV("PLUMED_LOAD_DEBUG");
   dlopenmode=0;
-  if(plumed_symbol_table_ptr) *plumed_symbol_table_ptr=__PLUMED_WRAPPER_CXX_NULLPTR;
-  if(handle) *handle=__PLUMED_WRAPPER_CXX_NULLPTR;
+  if(plumed_symbol_table_ptr) {
+    *plumed_symbol_table_ptr=__PLUMED_WRAPPER_CXX_NULLPTR;
+  }
+  if(handle) {
+    *handle=__PLUMED_WRAPPER_CXX_NULLPTR;
+  }
 #ifdef __PLUMED_DEFAULT_KERNEL
   /*
     This variable allows a default path for the kernel to be hardcoded.
@@ -4035,37 +4225,57 @@ void plumed_retrieve_functions(plumed_plumedmain_function_holder* functions, plu
   /* This is required to add quotes */
 #define PLUMED_QUOTE_DIRECT(name) #name
 #define PLUMED_QUOTE(macro) PLUMED_QUOTE_DIRECT(macro)
-  if(! (path && (*path) )) path=PLUMED_QUOTE(__PLUMED_DEFAULT_KERNEL);
+  if(! (path && (*path) )) {
+    path=PLUMED_QUOTE(__PLUMED_DEFAULT_KERNEL);
+  }
 #endif
 #if defined(__PLUMED_PROGRAM_NAME) && defined(__PLUMED_SOEXT)
-  if(! (path && (*path) )) path="lib" __PLUMED_PROGRAM_NAME "Kernel." __PLUMED_SOEXT;
+  if(! (path && (*path) )) {
+    path="lib" __PLUMED_PROGRAM_NAME "Kernel." __PLUMED_SOEXT;
+  }
 #endif
   if(path && (*path)) {
     __PLUMED_FPRINTF(stderr,"+++ Loading the PLUMED kernel runtime +++\n");
     __PLUMED_FPRINTF(stderr,"+++ PLUMED_KERNEL=\"%s\" +++\n",path);
-    if(debug) __PLUMED_FPRINTF(stderr,"+++ Loading with mode RTLD_NOW");
+    if(debug) {
+      __PLUMED_FPRINTF(stderr,"+++ Loading with mode RTLD_NOW");
+    }
     dlopenmode=RTLD_NOW;
     if(__PLUMED_GETENV("PLUMED_LOAD_NAMESPACE") && !__PLUMED_WRAPPER_STD strcmp(__PLUMED_GETENV("PLUMED_LOAD_NAMESPACE"),"GLOBAL")) {
       dlopenmode=dlopenmode|RTLD_GLOBAL;
-      if(debug) __PLUMED_FPRINTF(stderr,"|RTLD_GLOBAL");
+      if(debug) {
+        __PLUMED_FPRINTF(stderr,"|RTLD_GLOBAL");
+      }
     } else {
       dlopenmode=dlopenmode|RTLD_LOCAL;
-      if(debug) __PLUMED_FPRINTF(stderr,"|RTLD_LOCAL");
+      if(debug) {
+        __PLUMED_FPRINTF(stderr,"|RTLD_LOCAL");
+      }
     }
 #ifdef RTLD_DEEPBIND
 #if __PLUMED_WRAPPER_ENABLE_RTLD_DEEPBIND
     if(!__PLUMED_GETENV("PLUMED_LOAD_NODEEPBIND")) {
       dlopenmode=dlopenmode|RTLD_DEEPBIND;
-      if(debug) __PLUMED_FPRINTF(stderr,"|RTLD_DEEPBIND");
+      if(debug) {
+        __PLUMED_FPRINTF(stderr,"|RTLD_DEEPBIND");
+      }
     }
 #endif
 #endif
-    if(debug) __PLUMED_FPRINTF(stderr," +++\n");
+    if(debug) {
+      __PLUMED_FPRINTF(stderr," +++\n");
+    }
     p=plumed_attempt_dlopen(path,dlopenmode);
-    if(p) plumed_search_symbols(p,&g,plumed_symbol_table_ptr);
+    if(p) {
+      plumed_search_symbols(p,&g,plumed_symbol_table_ptr);
+    }
+  }
+  if(handle) {
+    *handle=p;
+  }
+  if(functions) {
+    *functions=g;
   }
-  if(handle) *handle=p;
-  if(functions) *functions=g;
 #endif
 }
 __PLUMED_WRAPPER_INTERNALS_END
@@ -4136,8 +4346,12 @@ __PLUMED_WRAPPER_INTERNALS_END
 
 __PLUMED_WRAPPER_INTERNALS_BEGIN
 int plumed_check_pimpl(plumed_implementation*pimpl) {
-  if(!pimpl) return 0;
-  if(__PLUMED_WRAPPER_STD memcmp(pimpl->magic,"pLuMEd",6)) return 0;
+  if(!pimpl) {
+    return 0;
+  }
+  if(__PLUMED_WRAPPER_STD memcmp(pimpl->magic,"pLuMEd",6)) {
+    return 0;
+  }
   return 1;
 }
 __PLUMED_WRAPPER_INTERNALS_END
@@ -4161,7 +4375,9 @@ plumed plumed_create(void) {
 #endif
   /* note if handle should not be dlclosed */
   pimpl->dlclose=1;
-  if(__PLUMED_GETENV("PLUMED_LOAD_DLCLOSE") && !__PLUMED_WRAPPER_STD strcmp(__PLUMED_GETENV("PLUMED_LOAD_DLCLOSE"),"no")) pimpl->dlclose=0;
+  if(__PLUMED_GETENV("PLUMED_LOAD_DLCLOSE") && !__PLUMED_WRAPPER_STD strcmp(__PLUMED_GETENV("PLUMED_LOAD_DLCLOSE"),"no")) {
+    pimpl->dlclose=0;
+  }
   /* in case of failure, return */
   /* the resulting object should be plumed_finalized, though you cannot use plumed_cmd */
   if(!pimpl->functions.create) {
@@ -4189,7 +4405,9 @@ plumed plumed_create_dlopen(const char*path) {
   dlopenmode=RTLD_NOW|RTLD_LOCAL;
 #ifdef RTLD_DEEPBIND
 #if __PLUMED_WRAPPER_ENABLE_RTLD_DEEPBIND
-  if(!__PLUMED_GETENV("PLUMED_LOAD_NODEEPBIND")) dlopenmode=dlopenmode|RTLD_DEEPBIND;
+  if(!__PLUMED_GETENV("PLUMED_LOAD_NODEEPBIND")) {
+    dlopenmode=dlopenmode|RTLD_DEEPBIND;
+  }
 #endif
 #endif
 #else
@@ -4237,7 +4455,9 @@ plumed plumed_create_dlopen2(const char*path,int mode) {
   /* handler */
   void* dlhandle;
   dlhandle=__PLUMED_WRAPPER_CXX_NULLPTR;
-  if(path) dlhandle=plumed_attempt_dlopen(path,mode);
+  if(path) {
+    dlhandle=plumed_attempt_dlopen(path,mode);
+  }
   /* a NULL handle implies the file could not be loaded */
   if(dlhandle) {
     p=plumed_create_dlsym(dlhandle);
@@ -4305,7 +4525,9 @@ void plumed_cmd(plumed p,const char*key,const void*val) {
   assert(plumed_check_pimpl(pimpl));
   if(!pimpl->p) {
     __PLUMED_FPRINTF(stderr,"+++ ERROR: You are trying to use an invalid plumed object. +++\n");
-    if(pimpl->used_plumed_kernel) __PLUMED_FPRINTF(stderr,"+++ Check your PLUMED_KERNEL environment variable. +++\n");
+    if(pimpl->used_plumed_kernel) {
+      __PLUMED_FPRINTF(stderr,"+++ Check your PLUMED_KERNEL environment variable. +++\n");
+    }
     __PLUMED_WRAPPER_STD abort();
   }
   assert(pimpl->functions.create);
@@ -4339,9 +4561,13 @@ void plumed_cmd_safe_nothrow(plumed p,const char*key,plumed_safeptr safe,plumed_
   assert(pimpl->functions.cmd);
   assert(pimpl->functions.finalize);
   /* execute */
-  if(pimpl->table && pimpl->table->version>2) (*(pimpl->table->cmd_safe_nothrow))(pimpl->p,key,safe,nothrow);
-  else if(pimpl->table && pimpl->table->version>1) (*(pimpl->table->cmd_nothrow))(pimpl->p,key,safe.ptr,nothrow);
-  else (*(pimpl->functions.cmd))(pimpl->p,key,safe.ptr);
+  if(pimpl->table && pimpl->table->version>2) {
+    (*(pimpl->table->cmd_safe_nothrow))(pimpl->p,key,safe,nothrow);
+  } else if(pimpl->table && pimpl->table->version>1) {
+    (*(pimpl->table->cmd_nothrow))(pimpl->p,key,safe.ptr,nothrow);
+  } else {
+    (*(pimpl->functions.cmd))(pimpl->p,key,safe.ptr);
+  }
 }
 __PLUMED_WRAPPER_C_END
 
@@ -4365,15 +4591,20 @@ void plumed_cmd_safe(plumed p,const char*key,plumed_safeptr safe) {
   assert(plumed_check_pimpl(pimpl));
   if(!pimpl->p) {
     __PLUMED_FPRINTF(stderr,"+++ ERROR: You are trying to use an invalid plumed object. +++\n");
-    if(pimpl->used_plumed_kernel) __PLUMED_FPRINTF(stderr,"+++ Check your PLUMED_KERNEL environment variable. +++\n");
+    if(pimpl->used_plumed_kernel) {
+      __PLUMED_FPRINTF(stderr,"+++ Check your PLUMED_KERNEL environment variable. +++\n");
+    }
     __PLUMED_WRAPPER_STD abort();
   }
   assert(pimpl->functions.create);
   assert(pimpl->functions.cmd);
   assert(pimpl->functions.finalize);
   /* execute */
-  if(pimpl->table && pimpl->table->version>2) (*(pimpl->table->cmd_safe))(pimpl->p,key,safe);
-  else (*(pimpl->functions.cmd))(pimpl->p,key,safe.ptr);
+  if(pimpl->table && pimpl->table->version>2) {
+    (*(pimpl->table->cmd_safe))(pimpl->p,key,safe);
+  } else {
+    (*(pimpl->functions.cmd))(pimpl->p,key,safe.ptr);
+  }
 }
 __PLUMED_WRAPPER_C_END
 
@@ -4389,9 +4620,13 @@ void plumed_finalize(plumed p) {
 #endif
   /* with PLUMED > 2.8, we can use an internal reference counter which is thread safe */
   if(pimpl->p && pimpl->table && pimpl->table->version>3) {
-    if(pimpl->table->delete_reference(pimpl->p)>0) return;
+    if(pimpl->table->delete_reference(pimpl->p)>0) {
+      return;
+    }
   } else {
-    if(--pimpl->refcount>0) return;
+    if(--pimpl->refcount>0) {
+      return;
+    }
   }
   /* to allow finalizing an invalid plumed object, we only call
      finalize if the object is valid */
@@ -4405,7 +4640,9 @@ void plumed_finalize(plumed p) {
 #ifdef __PLUMED_HAS_DLOPEN
   /* dlclose library */
   if(pimpl->dlhandle && pimpl->dlclose) {
-    if(__PLUMED_GETENV("PLUMED_LOAD_DEBUG")) __PLUMED_FPRINTF(stderr,"+++ Unloading library\n");
+    if(__PLUMED_GETENV("PLUMED_LOAD_DEBUG")) {
+      __PLUMED_FPRINTF(stderr,"+++ Unloading library\n");
+    }
     dlclose(pimpl->dlhandle);
   }
 #endif
@@ -4423,8 +4660,11 @@ int plumed_valid(plumed p) {
   /* obtain pimpl */
   pimpl=__PLUMED_WRAPPER_STATIC_CAST(plumed_implementation*, p.p);
   assert(plumed_check_pimpl(pimpl));
-  if(pimpl->p) return 1;
-  else return 0;
+  if(pimpl->p) {
+    return 1;
+  } else {
+    return 0;
+  }
 }
 __PLUMED_WRAPPER_C_END
 
@@ -4459,7 +4699,9 @@ void* plumed_malloc(__PLUMED_WRAPPER_STD size_t size) {
   void* ptr;
   ptr=__PLUMED_WRAPPER_STD malloc(size);
 #if __PLUMED_WRAPPER_DEBUG_REFCOUNT
-  if(ptr) fprintf(stderr,"plumed_malloc: %p\n",ptr);
+  if(ptr) {
+    fprintf(stderr,"plumed_malloc: %p\n",ptr);
+  }
 #endif
   return ptr;
 }
@@ -4507,8 +4749,11 @@ void plumed_gfinalize(void) {
 }
 
 int plumed_ginitialized(void) {
-  if(plumed_gmain.p) return 1;
-  else        return 0;
+  if(plumed_gmain.p) {
+    return 1;
+  } else {
+    return 0;
+  }
 }
 
 int plumed_gvalid() {