first updates to function names

da/sf6/statevector.py

@@ -14,9 +14,10 @@ import sys
 sys.path.append(os.getcwd())
 
 import logging
-from da.baseclasses.statevector import StateVector
 import numpy as np
+from da.baseclasses.statevector import StateVector, EnsembleMember
 import da.tools.io4 as io
+from datetime import timedelta
 
 identifier = 'SF6 Statevector '
 version = '0.0'
@@ -26,13 +27,11 @@ version = '0.0'
 class SF6StateVector(StateVector):
     """ This is a StateVector object for CarbonTracker. It has a private method to make new ensemble members """
 
-    def get_covariance(self, date):
+    def get_covariance(self, date, dacycle):
         """ Make a new ensemble from specified matrices, the attribute lag refers to the position in the state vector. 
             Note that lag=1 means an index of 0 in python, hence the notation lag-1 in the indexing below.
             The argument is thus referring to the lagged state vector as [1,2,3,4,5,..., nlag]
         """    
-
-        import da.tools.io4 as io
         try:
             import matplotlib.pyplot as plt
         except:
@@ -46,7 +45,7 @@ class SF6StateVector(StateVector):
 
         return fullcov
 
-    def Initialize(self):
+    def setup(self):
         """
         Initialize the object by specifying the dimensions. 
         There are two major requirements for each statvector that you want to build:
@@ -57,41 +56,40 @@ class SF6StateVector(StateVector):
         An example is given below.
         """
 
-        self.nlag = int(self.DaCycle['time.nlag'])
-        self.nmembers = int(self.DaCycle['da.optimizer.nmembers'])
-        self.nparams = int(self.DaCycle.DaSystem['nparameters'])
+        self.nlag = int(dacycle['time.nlag'])
+        self.nmembers = int(dacycle['da.optimizer.nmembers'])
+        self.nparams = int(dacycle.dasystem['nparameters'])
         self.nobs = 0
         
-        self.isOptimized = False
-        self.ObsToAssimmilate = ()  # empty containter to hold observations to assimilate later on
+        self.obs_to_assimilate = ()  # empty containter to hold observations to assimilate later on
 
         # These list objects hold the data for each time step of lag in the system. Note that the ensembles for each time step consist 
         # of lists of EnsembleMember objects, we define member 0 as the mean of the distribution and n=1,...,nmembers as the spread.
 
-        self.EnsembleMembers = range(self.nlag)
+        self.ensemble_members = range(self.nlag)
 
         for n in range(self.nlag):
-            self.EnsembleMembers[n] = []
+            self.ensemble_members[n] = []
 
 
         # This specifies the file to read with the gridded mask at 1x1 degrees. Each gridbox holds a number that specifies the parametermember
         #  that maps onto it. From this map, a dictionary is created that allows a reverse look-up so that we can map parameters to a grid.
 
-        mapfile = os.path.join(self.DaCycle.DaSystem['regionsfile'])
-        ncf = io.CT_Read(mapfile, 'read')
-        self.tcmap = ncf.GetVariable('transcom_regions')
+        mapfile = os.path.join(dacycle.daystem['regionsfile'])
+        ncf = io.ct_read(mapfile, 'read')
+        self.tcmap = ncf.get_variable('transcom_regions')
         ncf.close()
 
         self.gridmap = np.ones((180,360),'float')
 
-        logging.debug("A TransCom  map on 1x1 degree was read from file %s" % self.DaCycle.DaSystem['regionsfile'])
+        logging.debug("A TransCom  map on 1x1 degree was read from file %s" % self.dacycle.dasystem['regionsfile'])
         logging.debug("A parameter map on 1x1 degree was created")
 
         # Create a dictionary for state <-> gridded map conversions
 
         nparams = self.gridmap.max()
         self.griddict = {}
-        for r in range(1, nparams + 1):
+        for r in range(1, int(nparams) + 1):
             sel = (self.gridmap.flat == r).nonzero()
             if len(sel[0]) > 0: 
                 self.griddict[r] = sel
@@ -142,11 +140,10 @@ class SF6StateVector(StateVector):
         In the future, this routine can incorporate a formal propagation of the statevector.
 
         """
-        from datetime import timedelta
 
-        ensemble_deviations = np.array([p.ParameterValues for p in self.EnsembleMembers[0] ])
+        ensemble_deviations = np.array([p.param_values for p in self.ensemble_members[0] ])
         if ensemble_deviations.std(axis=0) < 0.05 :
-            for m in self.EnsembleMembers[0]:
+            for m in self.ensemble_members[0]:
                 m  = 3.0 * m  # inflate deviations by a factor of 3.0
 
             logging.info('The state vector covariance was inflated to 1-sigma of %5.2f ' % (ensemble_deviations.std(axis=0)*3.0))
@@ -157,36 +154,3 @@ class SF6StateVector(StateVector):
 
 ################### End Class SF6StateVector ###################
 
-
-if __name__ == "__main__":
-    from da.tools.initexit import StartLogger 
-    from da.tools.pipeline import start_job
-
-    sys.path.append(os.getcwd())
-
-    opts = ['-v']
-    args = {'rc':'da.rc', 'logfile':'da_initexit.log', 'jobrcfilename':'test.rc'}
-
-    StartLogger()
-
-    DaCycle = start_job(opts, args)
-
-    DaCycle.Initialize()
-
-    StateVector = CtStateVector()
-
-    StateVector.Initialize()
-
-    for n in range(dims[0]):
-        cov = StateVector.get_covariance()
-        dummy = StateVector.make_new_ensemble(n + 1, cov)
-
-    StateVector.propagate()
-
-    savedir = DaCycle['dir.output']
-    filename = os.path.join(savedir, 'savestate.nc')
-
-    dummy = StateVector.WriteToFile()
-
-    StateVector.ReadFromFile(filename)
-