A 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 <m energyReport>.EnergyReports for 
                         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.

  append(pot)          - add a new term to the list.

  byName(instanceName) - return the potential term specified.