An ordered collection of Pot objects - which is itself a Pot object. 
 
An instantiated object will act like a Python Sequence- it is iterable,
indexable (by position number, and by instance name), and the len()
builtin works as expected.
 
Constructor:
  PotList(NAME) 
   NAME is a name given to this instance of the PotList class.
 
Methods:
 
  only the standard potential terms exist:
 
  potName()      - returns 'PotList'
  instanceName() - returns NAME given in the constructor
 
  scale()/ setScale(scaleFac) 
                 - get/set a scale factor for this term
                   NOTE: this is independent of scalings set within
                        the XPLOR interface.
 
  calcEnergy()                   - calc energy without and with gradient
  calcEnergyAndDerivs(DerivList) -   evaluation. Return the value of energy
                                 - these calculate and sum energy of each term
                                 - in the list.
 
  energyReports()      - return a list of energyReport.EnergyReports for 
                         each term. This list is sorted by the instanceNames
                         of each term.
 
  clearEnergyReports() - clear the EnergyReport list.
 
  violations()         - report the sum of all violations
  rms()                - report the average rmsd. If the PotList consists of 
                         term which are all the same type, and which contain
                         restraints, the returned value R is computed as
                         
                             R^2 = sum_i N_i * w_i * R_i^2 / (sum_i N_i * w_i)
 
                         where for term i, R_i is rms(), w_i is scale(), N_i is
                         numRestraints(). If the terms are of the same type, 
                         but don't have a meaningful concept of restraint 
                         (numRestraints()==-1), then N_i is set to 1 in the 
                         above equation. If all terms return rms=-1, then 
                         return rms, else skip those terms which have 
                         negative rms
  numRestraints()      - return the sum of the values of numRestraints() for
                         all included potential terms, for positive values of
                         numRestraints.
 
  append(pot)          - add a new term to the end of the list.
  remove(name)         - remove the term with the given name.
  removeAll()          - remove all terms.
  makeCopy(name="")    - return a copy of this PotList, with the argument
                         giving the instanceName of the new term. If name is
                         omitted, the name will be instanceName()+"_copy".
 
  byName(instanceName) - return the potential term specified.
 
  keys()               - return a list of instanceNames of all potential
                         terms in the list.
 
  ensWeights()    - ensemble weights. Not directly used in any computations.
  setEnsWeights() - set ensemble weights for all contain potential terms. 
 
 
 
 
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.