acoular 23.6__py3-none-any.whl → 24.3__py3-none-any.whl

acoular/fbeamform.py

@@ -43,12 +43,19 @@ invert, dot, newaxis, zeros, linalg, \
 searchsorted, pi, sign, diag, arange, sqrt, log10, \
 reshape, hstack, vstack, eye, tril, size, clip, tile, round, delete, \
 absolute, argsort, sum, hsplit, fill_diagonal, zeros_like, \
-einsum, ndarray, isscalar, inf, real, unique
+einsum, ndarray, isscalar, inf, real, unique, atleast_2d, einsum_path,trace
 
 from numpy.linalg import norm
 
 from sklearn.linear_model import LassoLars, LassoLarsCV, LassoLarsIC,\
-OrthogonalMatchingPursuitCV
+OrthogonalMatchingPursuitCV, LinearRegression
+
+#check for sklearn version to account for incompatible behavior
+import sklearn
+from packaging.version import parse
+sklearn_ndict = {}
+if parse(sklearn.__version__)<parse('1.4'):
+    sklearn_ndict['normalize'] = False
 
 from scipy.optimize import nnls, linprog, fmin_l_bfgs_b, shgo
 from scipy.linalg import inv, eigh, eigvals, fractional_matrix_power
@@ -170,7 +177,7 @@ class SteeringVector( HasPrivateTraits ):
 
     @property_depends_on('grid.digest, mics.digest, env.digest')
     def _get_rm ( self ):
-        return self.env._r(self.grid.pos(), self.mics.mpos)
+        return atleast_2d(self.env._r(self.grid.pos(), self.mics.mpos))
  
     @cached_property
     def _get_digest( self ):
@@ -681,8 +688,14 @@ class BeamformerBase( HasPrivateTraits ):
 #        return h.reshape(h.shape[0], prod(h.shape[1:])).sum(axis=1)
         if isinstance(sector, Sector):
             ind = self.steer.grid.subdomain(sector)
-        else:
+        elif hasattr(self.steer.grid, 'indices'):
             ind = self.steer.grid.indices(*sector)
+        else:
+            raise NotImplementedError(
+            f'Grid of type {self.steer.grid.__class__.__name__} does not have an indices method! '
+            f'Please use a sector derived instance of type :class:`~acoular.grids.Sector` '
+            'instead of type numpy.array.'
+            )
         gshape = self.steer.grid.shape
         r = self.result
         h = zeros(r.shape[0])
@@ -1415,51 +1428,56 @@ class BeamformerDamasPlus (BeamformerDamas):
                 p.freq = f[i]
                 psf = p.psf[:]
 
-                if self.method == 'NNLS':
-                    resopt = nnls(psf,y)[0]
-                elif self.method == 'LP': # linear programming (Dougherty)
+                if self.method == "NNLS":
+                    ac[i] = nnls(psf, y)[0] / unit
+                elif self.method == "LP":  # linear programming (Dougherty)
                     if self.r_diag:
-                        warn('Linear programming solver may fail when CSM main '
-                              'diagonal is removed for delay-and-sum beamforming.', 
-                              Warning, stacklevel = 5)
-                    cT = -1*psf.sum(1) # turn the minimization into a maximization
-                    resopt = linprog(c=cT, A_ub=psf, b_ub=y).x # defaults to simplex method and non-negative x
-                elif self.method == 'LassoLars':
-                    model = LassoLars(alpha = self.alpha * unit, 
-                                      max_iter = self.max_iter)
-                else: # self.method == 'OMPCV':
-                    model = OrthogonalMatchingPursuitCV()
-                
-                
-                if self.method in ('NNLS','LP'):
-                    ac[i] = resopt / unit
-                else: # sklearn models
-                    model.fit(psf,y)
-                    ac[i] = model.coef_[:] / unit
+                        warn(
+                            "Linear programming solver may fail when CSM main "
+                            "diagonal is removed for delay-and-sum beamforming.",
+                            Warning,
+                            stacklevel=5,
+                        )
+                    cT = -1 * psf.sum(1)  # turn the minimization into a maximization
+                    ac[i] = (
+                        linprog(c=cT, A_ub=psf, b_ub=y).x / unit
+                    )  # defaults to simplex method and non-negative x
+                else:
+                    if self.method == "LassoLars":
+                        model = LassoLars(
+                            alpha=self.alpha * unit, max_iter=self.max_iter
+                        )
+                    elif self.method == "OMPCV":
+                        model = OrthogonalMatchingPursuitCV()
+                    else:
+                        raise NotImplementedError(f"%model solver not implemented")
+                    model.normalize = False
+                    # from sklearn 1.2, normalize=True does not work the same way anymore and the pipeline approach
+                    # with StandardScaler does scale in a different way, thus we monkeypatch the code and normalize
+                    # ourselves to make results the same over different sklearn versions
+                    norms = norm(psf, axis=0)
+                    # get rid of annoying sklearn warnings that appear
+                    # for sklearn<1.2 despite any settings
+                    with warnings.catch_warnings():
+                        warnings.simplefilter("ignore", category=FutureWarning)
+                        # normalized psf
+                        model.fit(psf / norms, y)
+                    # recover normalization in the coef's
+                    ac[i] = model.coef_[:] / norms / unit
                 
                 fr[i] = 1
 
-class BeamformerOrth (BeamformerBase):
+
+class BeamformerOrth( BeamformerBase ):
     """
-    Orthogonal beamforming, see :ref:`Sarradj, 2010<Sarradj2010>`.
-    Needs a-priori beamforming with eigenvalue decomposition (:class:`BeamformerEig`).
+    Orthogonal deconvolution, see :ref:`Sarradj, 2010<Sarradj2010>`.
+    New faster implementation without explicit (:class:`BeamformerEig`).
     """
-
-    #: :class:`BeamformerEig` object that provides data for deconvolution.
+    #: (only for backward compatibility) :class:`BeamformerEig` object
+    #: if set, provides :attr:`freq_data`, :attr:`steer`, :attr:`r_diag`
+    #: if not set, these have to be set explicitly
     beamformer = Trait(BeamformerEig)
 
-    #: :class:`~acoular.spectra.PowerSpectra` object that provides the cross spectral matrix 
-    #: and eigenvalues, is set automatically.    
-    freq_data = Delegate('beamformer')
-
-    #: Flag, if 'True' (default), the main diagonal is removed before beamforming, 
-    #: is set automatically.
-    r_diag =  Delegate('beamformer')
-    
-    #: instance of :class:`~acoular.fbeamform.SteeringVector` or its derived classes,
-    #: that contains information about the steering vector. Is set automatically.
-    steer = Delegate('beamformer')
-
     #: List of components to consider, use this to directly set the eigenvalues
     #: used in the beamformer. Alternatively, set :attr:`n`.
     eva_list = CArray(dtype=int,
@@ -1473,14 +1491,10 @@ class BeamformerOrth (BeamformerBase):
 
     # internal identifier
     digest = Property( 
-        depends_on = ['beamformer.digest', 'eva_list'], 
-        )
-
-    # internal identifier
-    ext_digest = Property( 
-        depends_on = ['digest', 'beamformer.ext_digest'], 
+        depends_on = ['freq_data.digest', '_steer_obj.digest', 'r_diag', 
+            'eva_list'], 
         )
-    
+   
     @cached_property
     def _get_digest( self ):
         return digest( self )
@@ -1488,7 +1502,13 @@ class BeamformerOrth (BeamformerBase):
     @cached_property
     def _get_ext_digest( self ):
         return digest( self, 'ext_digest' )
-    
+
+    @on_trait_change('beamformer.digest')
+    def delegate_beamformer_traits(self):
+        self.freq_data = self.beamformer.freq_data
+        self.r_diag = self.beamformer.r_diag
+        self.steer = self.beamformer.steer
+
     @on_trait_change('n')
     def set_eva_list(self):
         """ sets the list of eigenvalues to consider """
@@ -1521,19 +1541,23 @@ class BeamformerOrth (BeamformerBase):
         This method only returns values through the *ac* and *fr* parameters
         """
         # prepare calculation
-        ii = []
+        f = self.freq_data.fftfreq()
+        numchannels = self.freq_data.numchannels
+        normFactor = self.sig_loss_norm()
+        param_steer_type, steer_vector = self._beamformer_params()
         for i in self.freq_data.indices:        
             if not fr[i]:
-                ii.append(i)
-        numchannels = self.freq_data.numchannels
-        e = self.beamformer
-        for n in self.eva_list:
-            e.n = n
-            for i in ii:
-                ac[i, e.result[i].argmax()]+=e.freq_data.eva[i, n]/numchannels
-        for i in ii:
-            fr[i] = 1
-    
+                eva = array(self.freq_data.eva[i], dtype='float64')
+                eve = array(self.freq_data.eve[i], dtype='complex128')
+                for n in self.eva_list:
+                    beamformerOutput = beamformerFreq(param_steer_type, 
+                                                self.r_diag, 
+                                                normFactor, 
+                                                steer_vector(f[i]), 
+                                                (ones(1), eve[:, n].reshape((-1,1))))[0]
+                    ac[i, beamformerOutput.argmax()]+=eva[n]/numchannels
+                fr[i] = 1
+
 class BeamformerCleansc( BeamformerBase ):
     """
     CLEAN-SC deconvolution, see :ref:`Sijtsma, 2007<Sijtsma2007>`.
@@ -1865,13 +1889,7 @@ class BeamformerCMF ( BeamformerBase ):
                 else:
                     # take all real parts -- also main diagonal
                     ind_reim = hstack([ones(size(ind_im0),)>0,ind_im0])
-                    ind_reim[0]=True # TODO: warum hier extra definiert??
-#                    if sigma2:
-#                        # identity matrix, needed when noise term sigma is used
-#                        I  = eye(nc).reshape(nc*nc,1)                
-#                        A = realify( hstack([Ac, I])[ind,:] )[ind_reim,:]
-#                        # ... ac[i] = model.coef_[:-1]
-#                    else:
+                    ind_reim[0]=True # why this ?
 
                 A = realify( Ac [ind,:] )[ind_reim,:]
                 # use csm.T for column stacking reshape!
@@ -1879,18 +1897,18 @@ class BeamformerCMF ( BeamformerBase ):
                 # choose method
                 if self.method == 'LassoLars':
                     model = LassoLars(alpha = self.alpha * unit,
-                                      max_iter = self.max_iter)
+                                      max_iter = self.max_iter,
+                                      **sklearn_ndict)
                 elif self.method == 'LassoLarsBIC':
                     model = LassoLarsIC(criterion = 'bic',
-                                        max_iter = self.max_iter)
+                                        max_iter = self.max_iter,
+                                        **sklearn_ndict)
                 elif self.method == 'OMPCV':
-                    model = OrthogonalMatchingPursuitCV()
+                    model = OrthogonalMatchingPursuitCV(**sklearn_ndict)
+                elif self.method == 'NNLS':
+                    model = LinearRegression(positive=True)
 
-                # nnls is not in sklearn
-                if self.method == 'NNLS':
-                    ac[i] , x = nnls(A,R.flat)
-                    ac[i] /= unit
-                elif self.method == 'Split_Bregman' and PYLOPS_TRUE:   
+                if self.method == 'Split_Bregman' and PYLOPS_TRUE:   
                     Oop = MatrixMult(A) #tranfer operator 
                     Iop = self.alpha*Identity(numpoints) # regularisation 
                     ac[i],iterations = SplitBregman(Oop, [Iop] , R[:,0], 
@@ -1932,11 +1950,17 @@ class BeamformerCMF ( BeamformerBase ):
                     
                     ac[i] /= unit
                 else:
-                    # get rid of annoying sklearn warnings that appear despite any settings
+                    # from sklearn 1.2, normalize=True does not work the same way anymore and the pipeline
+                    # approach with StandardScaler does scale in a different way, thus we monkeypatch the 
+                    # code and normalize ourselves to make results the same over different sklearn versions
+                    norms = norm(A, axis=0)
+                    # get rid of annoying sklearn warnings that appear for sklearn<1.2 despite any settings
                     with warnings.catch_warnings():
                         warnings.simplefilter("ignore", category=FutureWarning)
-                        model.fit(A,R[:,0])
-                    ac[i] = model.coef_[:] / unit
+                        # normalized A
+                        model.fit(A/norms,R[:,0])
+                    # recover normalization in the coef's
+                    ac[i] = model.coef_[:] / norms / unit
                 fr[i] = 1
                 
 
@@ -2024,7 +2048,8 @@ class BeamformerSODIX( BeamformerBase ):
                                           group)
             ac = self.h5f.get_data_by_reference('result','/'+nodename)
             fr = self.h5f.get_data_by_reference('freqs','/'+nodename)
-            return (ac,fr)    
+            gpos = None
+            return (ac,fr,gpos) 
     
     @property_depends_on('ext_digest')
     def _get_sodix_result ( self ):
@@ -2042,7 +2067,7 @@ class BeamformerSODIX( BeamformerBase ):
                     config.global_caching == 'none' or 
                     (config.global_caching == 'individual' and self.cached == False)
                 ):
-                (ac,fr) = self._get_filecache() 
+                (ac,fr,gpos) = self._get_filecache() 
                 if ac and fr: 
                     if not fr[f.ind_low:f.ind_high].all():                       
                         if config.global_caching == 'readonly': 
@@ -2199,21 +2224,28 @@ class BeamformerSODIX( BeamformerBase ):
 
                         '''           
                         #### the sodix function ####
-                        Djm = D.reshape([numpoints,num_mics])                           
-                        csmmod = einsum('jm,jm,jn,jn->mn',h.T,Djm,Djm,h.T.conj() )        
-                        func = sum(absolute((csm - csmmod)))**2 + self.alpha*norm(Djm,self.pnorm)
-                        ####the sodix  derivitaive ####
-                        inner = csm - einsum('jl,jl,jm,jm->lm',h.T,Djm,Djm,h.T.conj() )      
-                        derdrl = -4 *  Djm * real(einsum('rm,rl,lm->rl',h.T,h.T.conj(),inner)) + \
-                            self.alpha * (abs(Djm)/norm(Djm,self.pnorm))**(1-self.pnorm)*sign(Djm)
-
-                        return  func, derdrl[:].flatten()  #func[0]
-                    
+                        Djm = D.reshape([numpoints,num_mics])
+                        p = h.T * Djm
+                        csm_mod = dot(p.T, p.conj())
+                        Q = csm - csm_mod
+                        func = sum((absolute(Q))**2)
+
+                        # subscripts and operands for numpy einsum and einsum_path
+                        subscripts = 'rl,rm,ml->rl'
+                        operands = (h.T,h.T.conj()*Djm,Q)
+                        es_path = einsum_path(subscripts, *operands, optimize='greedy')[0]
+
+                        #### the sodix derivative ####
+                        derdrl = einsum(subscripts, *operands, optimize=es_path)
+                        derdrl = -4 * real(derdrl)
+                        return func, derdrl.ravel()
+
                     ##### initial guess #### 
                     if all(ac[(i-1)]==0):
                          D0 = ones([numpoints,num_mics])
                     else:
-                         D0 = ac[(i-1)]
+                         D0 = sqrt(ac[(i-1)]*
+                             real((trace(csm)/trace(array(self.freq_data.csm[i-1], dtype='complex128',copy=1)))))
                     
                     #boundarys - set to non negative [2*(numpoints*num_mics)]
                     boundarys = tile((0, +inf), (numpoints*num_mics,1))
@@ -2222,11 +2254,11 @@ class BeamformerSODIX( BeamformerBase ):
                     # see https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.fmin_l_bfgs_b.html                    
 
                     qi = ones([numpoints,num_mics])
-                    qi, yval, dicts =  fmin_l_bfgs_b(function, D0, fprime=None, args=(),  #None  
-                                                         approx_grad=0, bounds=boundarys, #approx_grad 0 or True
-                                                         factr=100.0, pgtol=1e-09, epsilon=1e-08,
-                                                          iprint=0, maxfun=1500000, maxiter=self.max_iter,
-                                                          disp=None, callback=None, maxls=20)
+                    qi, yval, dicts =  fmin_l_bfgs_b(function, D0, fprime=None, args=(),
+                                                         approx_grad=0, bounds=boundarys, 
+                                                         factr=100.0, pgtol=1e-12, epsilon=1e-08,
+                                                          iprint=-1, maxfun=1500000, maxiter=self.max_iter,
+                                                          disp=-1, callback=None, maxls=20)
                     #squared pressure
                     ac[i]=qi**2
                 else:
@@ -2411,21 +2443,34 @@ class BeamformerGIB(BeamformerEig):  #BeamformerEig #BeamformerBase
                             AB = vstack([hstack([A.real,-A.imag]),hstack([A.imag,A.real])])
                             R  = hstack([emode.real.T,emode.imag.T]) * unit
                             if self.method == 'LassoLars':
-                                model = LassoLars(alpha=self.alpha * unit,max_iter=self.max_iter)
+                                model = LassoLars(alpha=self.alpha * unit,
+                                                  max_iter=self.max_iter)
                             elif self.method == 'LassoLarsBIC':
-                                model = LassoLarsIC(criterion='bic',max_iter=self.max_iter)
+                                model = LassoLarsIC(criterion='bic',
+                                                    max_iter=self.max_iter)
                             elif self.method == 'OMPCV':
                                 model = OrthogonalMatchingPursuitCV()
                             elif self.method == 'LassoLarsCV':
-                                model = LassoLarsCV()                        
-                            if self.method == 'NNLS':
-                                x , zz = nnls(AB,R)
-                                qi_real,qi_imag = hsplit(x/unit, 2) 
-                            else:
-                                with warnings.catch_warnings():
-                                    warnings.simplefilter("ignore", category=FutureWarning)
-                                    model.fit(AB,R)
-                                qi_real,qi_imag = hsplit(model.coef_[:]/unit, 2)
+                                model = LassoLarsCV()
+                            elif self.method == 'NNLS':
+                                model = LinearRegression(positive=True)
+                            model.normalize = False
+                            # from sklearn 1.2, normalize=True does not work 
+                            # the same way anymore and the pipeline approach 
+                            # with StandardScaler does scale in a different 
+                            # way, thus we monkeypatch the code and normalize
+                            # ourselves to make results the same over different
+                            # sklearn versions
+                            norms = norm(AB, axis=0)
+                            # get rid of annoying sklearn warnings that appear
+                            # for sklearn<1.2 despite any settings
+                            with warnings.catch_warnings():
+                                warnings.simplefilter("ignore",
+                                                      category=FutureWarning)
+                                # normalized A
+                                model.fit(AB/norms,R)
+                            # recover normalization in the coef's
+                            qi_real,qi_imag = hsplit(model.coef_[:]/norms/unit, 2)
                             #print(s,qi.size)    
                             qi[s,locpoints] = qi_real+qi_imag*1j
                     else:
@@ -2464,6 +2509,12 @@ class BeamformerAdaptiveGrid(BeamformerBase,Grid):
         array of floats
             The spectrum (all calculated frequency bands) for the integrated sector.
         """
+        if not isinstance(sector, Sector):
+            raise NotImplementedError(
+            f'Please use a sector derived instance of type :class:`~acoular.grids.Sector` '
+            f'instead of type {type(sector)}.'
+            )
+
         ind = self.subdomain(sector)
         r = self.result
         h = zeros(r.shape[0])
@@ -2648,13 +2699,15 @@ def integrate(data, grid, sector):
     grid: Grid object 
         Object of a :class:`~acoular.grids.Grid`-derived class 
         that provides the grid locations.        
-    sector: array of floats
+    sector: array of floats or :class:`~acoular.grids.Sector`-derived object
         Tuple with arguments for the `indices` method 
         of a :class:`~acoular.grids.Grid`-derived class 
         (e.g. :meth:`RectGrid.indices<acoular.grids.RectGrid.indices>` 
         or :meth:`RectGrid3D.indices<acoular.grids.RectGrid3D.indices>`).
         Possible sectors would be `array([xmin, ymin, xmax, ymax])`
         or `array([x, y, radius])`.
+        Alternatively, a :class:`~acoular.grids.Sector`-derived object
+        can be used.
           
     Returns
     -------
@@ -2664,8 +2717,14 @@ def integrate(data, grid, sector):
     
     if isinstance(sector, Sector):
         ind = grid.subdomain(sector)
-    else:
+    elif hasattr(grid, 'indices'):
         ind = grid.indices(*sector)
+    else:
+        raise NotImplementedError(
+        f'Grid of type {grid.__class__.__name__} does not have an indices method! '
+        f'Please use a sector derived instance of type :class:`~acoular.grids.Sector` '
+        'instead of type numpy.array.'
+        )
     
     gshape = grid.shape
     gsize = grid.size

acoular/grids.py

@@ -15,6 +15,7 @@
     LineGrid
     MergeGrid
     Sector
+    SingleSector
     RectSector
     RectSector3D
     CircSector
@@ -27,7 +28,7 @@
 # imports from other packages
 from numpy import mgrid, s_, array, arange, isscalar, absolute, ones, argmin,\
 zeros, where,  asfarray,concatenate,sum,ma,ones_like,inf,copysign,fabs ,append,\
-tile,newaxis
+tile,newaxis, unique
 from numpy.linalg import norm
 from traits.api import HasPrivateTraits, Float, Property, Any, \
 property_depends_on, cached_property, Bool, List, Instance, File ,on_trait_change,\
@@ -733,7 +734,7 @@ class ImportGrid( Grid ):
     @on_trait_change('basename')
     def import_gpos( self ):
         """
-        Import the microphone positions from .xml file.
+        Import the the grid point locations from .xml file.
         Called when :attr:`basename` changes.
         """
         if not path.isfile(self.from_file):
@@ -749,98 +750,6 @@ class ImportGrid( Grid ):
             xyz.append(list(map(lambda a : float(el.getAttribute(a)), 'xyz')))
         self.gpos_file = array(xyz, 'd').swapaxes(0, 1)
         self.subgrids = array(names)
-        
-    def index ( self, x, y ):
-        """
-        Queries the indices for a grid point near a certain co-ordinate.
-
-        This can be used to query results or co-ordinates at/near a certain
-        co-ordinate.
-        
-        Parameters
-        ----------
-        x, y : float
-            The co-ordinates for which the indices are queried.
-
-        Returns
-        -------
-        2-tuple of integers
-            The indices that give the grid point nearest to the given x, y
-            co-ordinates from an array with the same shape as the grid.            
-        """
-        if x < self.x_min or x > self.x_max:
-            raise ValueError("x-value out of range")
-        if y  <  self.y_min or y > self.y_max:
-            raise ValueError("y-value out of range")
-        xi = int((x-self.x_min)/self.increment+0.5)
-        yi = int((y-self.y_min)/self.increment+0.5)
-        return xi, yi
-
-    def indices ( self, *r):
-        """
-        Queries the indices for a subdomain in the grid.
-        
-        Allows either rectangular, circular or polygonial subdomains.
-        This can be used to mask or to query results from a certain 
-        sector or subdomain.
-        
-        Parameters
-        ----------
-        x1, y1, x2, y2, ... : float
-            If three parameters are given, then a circular sector is assumed
-            that is given by its center (x1, y1) and the radius x2.
-            If four paramters are given, then a rectangular sector is
-            assumed that is given by two corners (x1, y1) and (x2, y2). 
-            If more parameters are given, the subdomain is assumed to have
-            polygonial shape with corners at (x_n, y_n).
-
-        Returns
-        -------
-        2-tuple of arrays of integers or of numpy slice objects
-            The indices that can be used to mask/select the grid subdomain from 
-            an array with the same shape as the grid.            
-        """
-        
-        if len(r) == 3: # only 3 values given -> use x,y,radius method
-            xpos = self.gpos
-            xis = []
-            yis = []
-            dr2 = (xpos[0, :]-r[0])**2 + (xpos[1, :]-r[1])**2
-            # array with true/false entries
-            inds = dr2 <= r[2]**2 
-            for np in arange(self.size)[inds]: # np -- points in x2-circle
-                xi, yi = self.index(xpos[0, np], xpos[1, np])
-                xis += [xi]
-                yis += [yi]
-            if not (xis and yis): # if no points in circle, take nearest one
-                return self.index(r[0], r[1])
-            else:
-                return array(xis), array(yis)
-        elif len(r) == 4: # rectangular subdomain - old functionality
-            xi1, yi1 = self.index(min(r[0], r[2]), min(r[1], r[3]))
-            xi2, yi2 = self.index(max(r[0], r[2]), max(r[1], r[3]))
-            return s_[xi1:xi2+1], s_[yi1:yi2+1]
-        else: # use enveloping polygon
-            xpos = self.gpos
-            xis = []
-            yis = []
-            #replaced matplotlib Path by numpy
-            #p = Path(array(r).reshape(-1,2))
-            #inds = p.contains_points()
-            #inds = in_poly(xpos[:2,:].T,array(r).reshape(-1,2))
-            poly = Polygon(array(r).reshape(-1,2)[:,0],array(r).reshape(-1,2)[:,1])
-            dists = poly.is_inside(xpos[0,:],xpos[1,:])   
-            inds = dists >= 0
-            for np in arange(self.size)[inds]: # np -- points in x2-circle
-                xi, yi = self.index(xpos[0, np], xpos[1, np])
-                xis += [xi]
-                yis += [yi]
-            if not (xis and yis): # if no points inside, take nearest to center
-                center = array(r).reshape(-1,2).mean(0)
-                return self.index(center[0], center[1])
-            else:
-                return array(xis), array(yis)
-                #return arange(self.size)[inds]
 
 class LineGrid( Grid ):
     """
@@ -948,7 +857,6 @@ class MergeGrid( Grid ):
             subgrids = append(subgrids,tile(grid.__class__.__name__+grid.digest,grid.size))
         return subgrids[:,newaxis].T
     
-
     @property_depends_on('digest')
     def _get_gpos( self ):
         bpos = zeros((3,0))
@@ -956,29 +864,18 @@ class MergeGrid( Grid ):
         for grid in self.grids:
             bpos = append(bpos,grid.gpos, axis = 1)
             #subgrids = append(subgrids,str(grid))
+        bpos = unique(bpos,axis=1)
         return bpos
 
 class Sector( HasPrivateTraits ):
     """
-    Base class for sector types.
+    Base class for all sector types.
     
-    Defines the common interface for all sector classes. This class
+    Defines the common interface for all tbdsector classes. This class
     may be used as a base for diverse sector implementaions. If used
     directly, it implements a sector encompassing the whole grid.
     """
     
-    #: Boolean flag, if 'True' (default), grid points lying on the sector border are included.
-    include_border = Bool(True, 
-                          desc="include points on the border")    
-    
-    #: Absolute tolerance for sector border
-    abs_tol = Float(1e-12,
-                    desc="absolute tolerance for sector border")
-
-    #: Boolean flag, if 'True' (default), the nearest grid point is returned if none is inside the sector.
-    default_nearest = Bool(True, 
-                          desc="return nearest grid point to center of none inside sector")
-
     def contains ( self, pos ):
         """
         Queries whether the coordinates in a given array lie within the 
@@ -1000,7 +897,30 @@ class Sector( HasPrivateTraits ):
         return ones(pos.shape[1], dtype=bool)
 
 
-class RectSector( Sector ):
+class SingleSector( Sector ):
+    """
+    Base class for single sector types.
+    
+    Defines the common interface for all single sector classes. This class
+    may be used as a base for diverse single sector implementaions. If used
+    directly, it implements a sector encompassing the whole grid.
+    """
+    
+    #: Boolean flag, if 'True' (default), grid points lying on the sector border are included.
+    include_border = Bool(True, 
+                          desc="include points on the border")    
+    
+    #: Absolute tolerance for sector border
+    abs_tol = Float(1e-12,
+                    desc="absolute tolerance for sector border")
+
+    #: Boolean flag, if 'True' (default), the nearest grid point is returned if none is inside the sector.
+    default_nearest = Bool(True, 
+                          desc="return nearest grid point to center of none inside sector")
+
+
+
+class RectSector( SingleSector ):
     """
     Class for defining a rectangular sector.
     
@@ -1142,7 +1062,7 @@ class RectSector3D( RectSector ):
         return inds.astype(bool)
 
 
-class CircSector( Sector ):
+class CircSector( SingleSector ):
     """
     Class for defining a circular sector.
     
@@ -1197,7 +1117,7 @@ class CircSector( Sector ):
         return inds
 
 
-class PolySector( Sector ):
+class PolySector( SingleSector ):
     """
      Class for defining a polygon sector.
      
@@ -1242,7 +1162,7 @@ class PolySector( Sector ):
           
         return inds
 
-class ConvexSector( Sector ):
+class ConvexSector( SingleSector ):
     """
      Class for defining a convex hull sector.
     
@@ -1297,7 +1217,6 @@ class MultiSector(Sector):
     #: to be mixed.
     sectors = List(Instance(Sector)) 
     
-    
     def contains ( self, pos ):
         """
         Queries whether the coordinates in a given array lie within any