Abstract:
An apparatus is provided for extracting slowness dispersion characteristics of sonic wave forms in broadband acoustic waves received by multiple sensors including means to digitize the sonic wave forms to form discrete time wave forms and converting the discrete time wave forms into frequency domain wave forms and means to divide a processing band of the wave forms into frequency sub-bands. For each sub-band approximating a family of candidate dispersion curves for multiple modes, parameterizing each of the curves by phase and group slowness, and forming a frequency dependent over-complete dictionary of basis elements, each corresponding to a pair of phase and group slownesses. In addition, forming multiple measurement vectors from the frequency domain data and implementing a sparse Bayesian learning (SBL) algorithm on the vectors with a block sparse signal model and outputting the results. Also, a means for generating a fmal dispersion curve.

Description:
RELATED APPLICATIONS 
       [0001]    This application claims the benefit of a related U.S. Provisional Application Ser. No. 61/862,207 filed Aug. 5, 2013, entitled “SPARSE BAYESIAN EXTRACTION OF BOREHOLE ACOUSTIC DISPERSIONS,” to Pu WANG, et al., the disclosure of which is incorporated by reference herein in its entirety. 
     
    
     BACKGROUND 
       [0002]    The following descriptions and examples are not admitted to be prior art by virtue of their inclusion in this section. 
         [0003]    Acoustic waves in fluid-filled boreholes may be excited and recorded from sonic logging tools. Their propagation in the borehole is affected by the type of surrounding rocks. More specifically, non-dispersive acoustic waves have been observed such as P- and S-headwaves, and dispersive waves such as Stoneley and pseudo-Rayleigh waves in monopole logging and flexural waves in dipole logging. In contrast to the constant slowness at all frequencies for the non-dispersive modes, the dispersive waves exhibit varied phase and group slownesses at different frequencies. Analysis and estimation of the slowness and its change over the frequency (i.e., the dispersion) provide important information to infer the properties of surrounding formation. For example, the compressional and shear slownesses have been used for reservoir characterizations and radial profiling of near-wellbore formation. 
       SUMMARY 
       [0004]    This summary is provided to introduce a selection of concepts that are further described below in the detailed description. This summary is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used as an aid in limiting the scope of the claimed subject matter. 
         [0005]    In accordance with one embodiment, an apparatus is provided for extracting slowness dispersion characteristics of one or more sonic wave forms in broadband acoustic waves received by an array of two or more sensors. The apparatus includes means for digitizing the sonic wave forms to form discrete time wave forms and converting the discrete time wave forms into frequency domain wave forms and means for dividing a processing band of the frequency domain wave forms into frequency sub-bands. For each sub-band, approximating a family of candidate dispersion curves for multiple modes, parameterizing each of the family of approximated candidate dispersion curves by phase and group slowness, and forming a frequency dependent over-complete dictionary of basis elements, each corresponding to a pair of phase and group slownesses, and spanning a range of values thereof In addition, for each sub-band forming multiple measurement vectors from the frequency domain data, and implementing a sparse Bayesian learning (SBL) algorithm on the multiple measurement vectors with a block sparse signal model. 
         [0006]    SLB is implemented by estimating a mode spectrum amplitude with a Bayesian approach, estimating a mode spectrum variance, noise variance and other model parameters with a maximum likelihood estimation, and optionally utilizing spectrum correlation patterns of multiple modes. In addition, pruning mode candidates by comparing the estimated mode parameters with a threshold, iterating between the Bayesian approach and the maximum likelihood estimation until convergence according to a criterion, and outputting the phase and group slowness and the mode spectrum amplitude for the given sub-band. The apparatus further includes means for generating a final dispersion curve over the processing frequency band. 
         [0007]    Other or alternative features will become apparent from the following description, from the drawings, and from the claims. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0008]    Certain embodiments will hereafter be described with reference to the accompanying drawings, wherein like reference numerals denote like elements. It should be understood, however, that the accompanying drawings illustrate only the various implementations described herein and are not meant to limit the scope of various technologies described herein. The drawings are as follows: 
           [0009]      FIG. 1A  is a graphic representation of time-domain borehole acoustic waveforms; 
           [0010]      FIG. 1B  is a graphic representation of frequency-domain borehole acoustic waveforms, only the real parts are illustrated in the FIG.; 
           [0011]      FIG. 1C  is a graphic representation of the narrowband (frequency) method; 
           [0012]      FIG. 1D  is a graphic representation of the broadband (frequency) method; 
           [0013]      FIG. 2  is a graphic representation of wave-number vs. frequency using the broadband (frequency) method; 
           [0014]      FIG. 3A  is a graphic representation of wave-number vs. frequency using local approximation in the f-k (frequency-wavenumber) domain; 
           [0015]      FIG. 3B  is a graphic representation of slowness vs. frequency using local approximation in the f-s (frequency-slowness) domain; 
           [0016]      FIGS. 4A &amp; 4B  are graphic representations of an overcomplete representation of all possible acoustic modes in a chosen frequency band wherein  4 A illustrates three modes and  4 B illustrates an overcomplete representation. 
           [0017]      FIG. 5  is a graphic illustration of dividing the space-frequency data into successive blocks; 
           [0018]      FIG. 6A  is the recovered phase and group slowness pairs from an algorithm of the current disclosure; 
           [0019]      FIG. 6B  is a graphic illustration of the construction of the local fitness function according to an algorithm of an embodiment of the current disclosure; 
           [0020]      FIG. 7  is a flowchart of a global workflow for a method for broadband dispersion extraction, according to an embodiment of the current disclosure; 
           [0021]      FIG. 8  is a flowchart of a local workflow for a method for broadband dispersion extraction, according to an embodiment of the current disclosure; 
           [0022]      FIGS. 9A &amp; 9B  are graphic representations of time domain waveforms and frequency spectra for synthetic data when the Signal to Noise Ratio (SNR) is 20 dB; 
           [0023]      FIG. 10A  is a graphic representation of phase slowness vs. frequency by the MP method (noise free); 
           [0024]      FIG. 10B  is a graphic representation of phase slowness vs. frequency by the LASSO-KS method; 
           [0025]      FIG. 10C  is a graphic representation of phase slowness vs. frequency by global estimates; 
           [0026]      FIG. 10D  is a graphic representation of phase slowness vs. frequency by local estimates; 
           [0027]      FIG. 10E  is a graphic representation of phase slowness vs. frequency by Corr-FP by global estimates, according to an embodiment of the current disclosure; 
           [0028]      FIG. 10F  is a graphic representation of phase slowness vs. Frequency by Corr-FP by local estimates, according to an embodiment of the current disclosure; 
           [0029]      FIGS. 11A &amp; 11B  are graphic representations of time domain waveforms and frequency spectra for synthetic data when the SNR is 0 dB; 
           [0030]      FIG. 12A  is a graphic representation of phase slowness vs. frequency by the MP method (noise free); 
           [0031]      FIG. 12B  is a graphic representation of phase slowness vs. frequency by the LASSO-KS method; 
           [0032]      FIG. 12C  is a graphic representation of phase slowness vs. frequency by global estimates; 
           [0033]      FIG. 12D  is a graphic representation of phase slowness vs. frequency by local estimates; 
           [0034]      FIG. 12E  is a graphic representation of phase slowness vs. frequency by Corr-FP by global estimates, according to an embodiment of the current disclosure; 
           [0035]      FIG. 12F  is a graphic representation of phase slowness vs. frequency by Corr-FP by local estimates, according to an embodiment of the current disclosure; 
           [0036]      FIG. 13A  is a graphic representation of sample dipole waveforms acquired with a Logging While Drilling (LWD) tool; 
           [0037]      FIG. 13B  is a graphic representation of phase slowness vs. frequency by the MP method; 
           [0038]      FIG. 13C  is a graphic representation of phase slowness vs. frequency by global estimates; 
           [0039]      FIG. 13D  is a graphic representation of phase slowness vs. frequency by local estimates; 
           [0040]      FIG. 13E  is a graphic representation of phase slowness vs. frequency by Corr-FP by global estimates, according to an embodiment of the current disclosure; 
           [0041]      FIG. 13F  is a graphic representation of phase slowness vs. frequency by Corr-FP by local estimates, according to an embodiment of the current disclosure; and 
           [0042]      FIG. 14  is a schematic representation of a physical set-up for acquisition of waves in a borehole. 
       
    
    
     DETAILED DESCRIPTION 
       [0043]    Reference throughout the specification to “one embodiment,” “an embodiment,” “some embodiments,” “one aspect,” “an aspect,” or “some aspects” means that a particular feature, structure, method, or characteristic described in connection with the embodiment or aspect is included in at least one embodiment of the present disclosure. Thus, the appearance of the phrases “in one embodiment” or “in an embodiment” or “in some embodiments” in various places throughout the specification are not necessarily all referring to the same embodiment. Furthermore, the particular features, structures, methods, or characteristics may be combined in any suitable manner in one or more embodiments. The words “including” and “having” shall have the same meaning as the word “comprising.” 
         [0044]    As used throughout the specification and claims, the term “downhole” refers to a subterranean environment, particularly in a wellbore. “Downhole tool” is used broadly to mean any tool used in a subterranean environment including, but not limited to, a logging tool, an imaging tool, an acoustic tool, a permanent monitoring tool, and a combination tool. 
         [0045]    The various techniques disclosed herein may be utilized to facilitate and improve data acquisition and analysis in downhole tools and systems. In this, downhole tools and systems are provided that utilize arrays of sensing devices that are configured or designed for easy attachment and detachment in downhole sensor tools or modules that are deployed for purposes of sensing data relating to environmental and tool parameters downhole, within a borehole. The tools and sensing systems disclosed herein may effectively sense and store characteristics relating to components of downhole tools as well as formation parameters at elevated temperatures and pressures. The sensing systems herein may be incorporated in tool systems such as wireline logging tools, measurement-while-drilling and logging-while-drilling tools, permanent monitoring systems, drill bits, drill collars, sondes, among others. For purposes of this disclosure, when any one of the terms wireline, cable line, slickline or coiled tubing or conveyance is used it is understood that any of the referenced deployment means, or any other suitable equivalent means, may be used with the present disclosure without departing from the spirit and scope of the present disclosure. 
         [0046]    Moreover, inventive aspects lie in less than all features of a single disclosed embodiment. Thus, the claims following the Detailed Description are hereby expressly incorporated into this Detailed Description, with each claim standing on its own as a separate embodiment. 
         [0047]    A method is proposed for extraction of multiple strong/weak borehole acoustic modes (possibly overlapping over the time and/or frequency domains) including both the dispersion characteristic (slowness or wavenumber as a function of frequency) and the wavetrains by processing acoustic array waveforms at multiple frequency points simultaneously. This broadband dispersion analysis is achieved by first formulating it as the basis selection with an overcomplete dictionary and then deriving the solution by exploiting the mode sparsity through the framework of sparse Bayesian learning (SBL). Specifically, two SBL methods, the broadband SBL method and the broadband Corr-SBL method, are proposed for the purpose of acoustic dispersion extraction. The broadband Corr-SBL method is proposed to not only utilize the mode sparsity, but also to learn multiple spectrum correlation patterns across frequency in each mode. In the case of no spectrum correlation, the broadband SBL method enables a fast, iterative solution to extract multiple acoustic modes. 
         [0048]    For a given frequency band, the two broadband SBL methods are featured by 1) the ability to utilize the sparsity of acoustic modes, 2) a simple and iterative implementation, and 3) no intervention of user-parameters. To obtain a global dispersion analysis, two workflow procedures, either producing the slowness estimation locally or estimating the slowness from a global fitness function, are proposed to extract the multiple acoustic dispersion curves. 
         [0049]    Acoustic waves in fluid-filled boreholes may be excited and recorded from sonic logging tools. Sonic generally referring to frequencies and tools opereated in, but not limited to, a frequency range of about 1 to 25 kilohertz. Embodiments herein relate to the processing of acoustic waveforms specifically those with dispersion, i.e. a dependence of wave speed with frequency. This has applications to the processing of borehole acoustic data, dominated by dispersive borehole modes, using logging-while-drilling (LWD) and wireline tools but could also be used in other situations where dispersion exists and needs to be estimated. These can then be used to extract information of interest such as rock compressional and shear velocities, radial variation, anisotropy, etc. In some embodiments, a method is described to estimate the dispersion characteristics of multiple propagating modes that overlap in the time and/or frequency domains using an array of two or more sensors. 
         [0050]    Embodiments of the invention may be implemented, at least in part, either manually or automatically. Manual or automatic implementations may be executed, or at least assisted, through the use of machines, hardware, software, firmware, middleware, microcode, hardware description languages, or any combination thereof When implemented in software, firmware, middleware or microcode, the program code or code segments to perform the necessary tasks may be stored in a machine readable medium. A processor(s) may perform the necessary tasks. 
         [0051]    Over the past two decades, both narrowband and broadband approaches have been proposed to estimate the slowness for the non-dispersive and dispersive modes. These frequency-based methods first digitize the recorded acoustic waveforms (see  FIG. 1A  for an illustration of synthetic borehole waveforms), convert the discrete time waveforms to the frequency domain with the fast Fourier transform (see  FIG. 1B ), and then process the frequency-domain waveforms for the estimation of slowness and its dispersion. 
         [0052]    Within the narrowband framework, the slowness is estimated independently from one frequency to another. As illustrated in  FIG. 1C  (with some exaggeration), the narrowband method only processes the frequency-domain waveforms at a particular frequency point (within the small window) at a time, and then proceeds the processing at the next adjacent frequency point. Prony&#39;s method and the modified matrix pencil method (MP, also referred to as the TKO method in the industry) belong to this category. Specifically, these two methods are based on a parametric assumption that the borehole acoustic mode at a given frequency can be modeled as the superposition of multiple exponential functions. Although computationally efficient, these two methods are sensitive to a preset mode number and, hence, suffer from either spurious slowness estimation with an over-estimated mode number or suppression of a weak mode with an under-estimated mode number. Such performance sensitivity to the preset mode number exists even in the noise-free case and can be amplified in the noise case. The narrowband maximum-likelihood (ML) method or, equivalently, the Capon beamforming, was modified for sonic logging. The idea is to keep the mode at a given slowness undistorted, while suppressing the noise and modes at other wavenumbers. However, a spectral averaging operation of the narrowband ML method usually causes poor slowness estimation due to the unstable covariance matrix estimation averaged over non-stationary signals from adjacent frequency points. 
         [0053]    Meanwhile, non-parametric narrowband methods were introduced in the borehole acoustic analysis without the parametric assumption. A coherency maximization method was proposed that can only identify one mode (the strongest one) at a given frequency. More recently, the amplitude and phase estimation (APES) method was promoted for the dispersion analysis of borehole acoustic modes. APES first computes the qualitative fitness function over the slowness domain at a given frequency and then uses a peak finding algorithm with a preset peak/mode number to obtain the quantitative slowness estimates. Similar to the MP method, the narrowband APES method is sensitive to the preset mode number. 
         [0054]    Conversely, the broadband approach collects the array data from a chosen frequency band (as in the large window of  FIG. 1D ), instead of a single frequency point, and simultaneously estimates the phase and group slownesses from the broadband array data. With more data processed at a time, the broadband approach is able to deliver smooth slowness estimates with small fluctuations from one frequency to another, high-resolution slowness estimates, and robust performance at low signal-to-noise ratio (SNR). 
         [0055]    Another broadband technique was recently proposed that uses the l 1  norm, together with the l 2  fitting criterion, to regularize the slowness estimates towards a sparse solution. Specifically, the group LASSO method was used to solve the hybrid l 1 /l 2  optimization problem. However, group LASSOs use for the acoustic mode extraction may be limited due to a) the demanding complexity, and b) the selection of a regularization parameter that controls the trade-off between the l 2  fitting residuals and the solution sparsity. Regarding issue a), even with a properly chosen regularization parameter the group LASSO method solved by the second-order cone program (SOCP) implementation or the interior-point (IP) method tends to be slow in a high dimensional setup even with a state-of-art numerical solver. Issue a) is further escalated when one has to address issue b). For issue b), one may use the L -curve method, the cross-validation method, and the Kolmogorov-Smirnov (KS) procedure. For each of these methods, multiple start-over runs of the entire group LASSO method are required and this significantly increases the computational burden. An improper regularization parameter determined by the KS test may result in either spurious estimates or suppression of weak modes, similar to the effect caused by an improper mode number when used in the narrowband approach. 
         [0056]    Some embodiments of this disclosure reformulate the problem of interest in a block sparse signal model with varying overcomplete dictionaries propagating along the columns, and propose a generalized sparse Bayesian learning (SBL) method for the application-specified block sparse model. For a given frequency band, an embodiment incorporating the resulting SBL method is able to extract the slowness from the broadband array data in a fully automatic, user-parameter free way, without any specification of the mode number and/or the regularization parameter. 
         [0057]    To obtain the overall dispersion analysis, various embodiments of both global and local workflow procedures are described herein. During this part of the procedure, a limited number of algorithm parameters are introduced such as the number of frequency point in a frequency band, the overlapping ratio between two consecutive frequency bands, and the mode number. By exploiting the mode sparsity, the workflow produces smoother slowness estimates with less fluctuation, less spurious estimates, and better capability to extract weak modes. Besides the performance improvement, the described SBL method provides less computational complexity than the broadband ML method or the the group LASSO method. 
         [0058]    In an exemplary embodiment, to begin the signal model a conventional space-frequency model of the recorded array waveform from L receivers in an acoustic logging tool is used: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         y 
                         l 
                       
                        
                       
                         ( 
                         ω 
                         ) 
                       
                     
                     = 
                     
                       
                         
                           ∑ 
                           
                             p 
                             = 
                             1 
                           
                           P 
                         
                          
                         
                             
                         
                          
                         
                           
                             
                               
                                 a 
                                 _ 
                               
                               p 
                             
                              
                             
                               ( 
                               ω 
                               ) 
                             
                           
                            
                           
                              
                             
                               j 
                                
                               
                                 
                                   
                                     k 
                                     _ 
                                   
                                   p 
                                 
                                  
                                 
                                   ( 
                                   ω 
                                   ) 
                                 
                               
                                
                               
                                 z 
                                 l 
                               
                             
                           
                         
                       
                       + 
                       
                         
                           v 
                           n 
                         
                          
                         
                           ( 
                           ω 
                           ) 
                         
                       
                     
                   
                   , 
                   
                     l 
                     = 
                     1 
                   
                   , 
                   2 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   L 
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where y 1 (ω) is the frequency spectrum of the recorded waveform at the l-th receiver at a given angular frequency ω, P is the number of modes at frequency ω, ā p (ω) and  k   p (ω) are the true but unknown spectrum amplitude and wavenumber of the p-th mode, z l  is the distance from the source (or a reference point) to the l-th receiver, and v n (ω) is the complex white Gaussian noise with zero mean and variance σ 2 . 
         [0059]    An example of an acoustic logging tool is shown in  FIG. 14 . An acoustic source ( 100 ) which may be in communication with surface equipment is fired in a fluid filled borehole and the resulting waves that are generated in the borehole are recorded at a linear array of sonic sensors (e.g., hydrophones) ( 102 ) located on the acoustic tool. 
         [0060]    As illustrated in an exemplary embodiment shown in  FIG. 2 , the broadband approach usually divides the whole frequency domain into successive (overlapping and/or non-overlapping) frequency bands (illustrated as separate columns) and estimates the slowness for one frequency band by jointly processing the frequency-domain waveforms within that frequency band. A global estimate of the slowness of various acoustic modes can then be obtained by putting together the slowness estimates from different frequency bands. For the convenience of description, the following will focus on a slowness estimation over a particular frequency band as an exemplary process. An embodiment of the workflow for a global estimate of slowness will be considered later. 
         [0061]    As an example describing a given frequency band, e.g., Ω={ω 0 −ω B ≦ω≦ω 0 +ω B } with the one-side bandwidth ω B  and the center frequency ω 0 , a first-order Taylor series expansion of the wavenumber  k   p (ω) is used for the purpose of joint processing the array waveforms {γ l (ω)} l=1   L  within the chosen band Ω. That is, specifically, 
         [0000]          k     p (ω)≈   k     p (ω 0 )+   k ′   p (ω 0 )(ω−ω 0 ), forall ω ∈ Ω;  p= 1, . . . ,  P    (2)
 
         [0000]    where  k   p (ω 0 ) and  k ′ p (ω 0 ) denote the wavenumber and its first-order derivative of the p-th mode at the center frequency ω 0 . Taking (2) to (1) yields 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         y 
                         l 
                       
                        
                       
                         ( 
                         ω 
                         ) 
                       
                     
                     = 
                     
                       
                         
                           ∑ 
                           
                             p 
                             = 
                             1 
                           
                           P 
                         
                          
                         
                             
                         
                          
                         
                           
                             
                               
                                 a 
                                 _ 
                               
                               p 
                             
                              
                             
                               ( 
                               ω 
                               ) 
                             
                           
                            
                           
                              
                             
                               
                                 
                                   
                                     js 
                                     _ 
                                   
                                   p 
                                 
                                  
                                 
                                   ( 
                                   
                                     ω 
                                     0 
                                   
                                   ) 
                                 
                               
                                
                               
                                 ω 
                                 0 
                               
                                
                               
                                 z 
                                 l 
                               
                             
                           
                            
                           
                              
                             
                               
                                 
                                   
                                     
                                       j 
                                        
                                       g 
                                     
                                     _ 
                                   
                                   p 
                                 
                                  
                                 
                                   ( 
                                   
                                     ω 
                                     0 
                                   
                                   ) 
                                 
                               
                                
                               
                                 ( 
                                 
                                   ω 
                                   - 
                                   
                                     ω 
                                     0 
                                   
                                 
                                 ) 
                               
                                
                               
                                 z 
                                 l 
                               
                             
                           
                         
                       
                       + 
                       
                         
                           v 
                           n 
                         
                          
                         
                           ( 
                           ω 
                           ) 
                         
                       
                     
                   
                   , 
                   
                     
 
                   
                    
                   
                     l 
                     = 
                     1 
                   
                   , 
                   2 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   L 
                   , 
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where, by convention,  k   p (ω 0 ) and  k ′ p (ω 0 ) are one-to-one mapped to the pair of the phase and group slownesses, ( s   p (ω 0 ),  g   p (ω 0 )) , at the center frequency ω 0 : 
         [0000]    
       
         
           
             
               
                 
                   
                     [ 
                     
                       
                         
                           
                             
                               s 
                               _ 
                             
                             p 
                           
                         
                       
                       
                         
                           
                             
                               g 
                               _ 
                             
                             p 
                           
                         
                       
                     
                     ] 
                   
                   = 
                   
                     
                       [ 
                       
                         
                           
                             
                               ω 
                               0 
                               
                                 - 
                                 1 
                               
                             
                           
                           
                             0 
                           
                         
                         
                           
                             0 
                           
                           
                             1 
                           
                         
                       
                       ] 
                     
                      
                     
                       [ 
                       
                         
                           
                             
                               
                                 k 
                                 _ 
                               
                               p 
                             
                           
                         
                         
                           
                             
                               
                                 k 
                                 _ 
                               
                               p 
                               ′ 
                             
                           
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where the dependence of  s   p  and  g   p  on ω 0  is skipped for notational simplicity. Finally, since the slowness is defined as the ratio of wavenumber over the frequency, 
         [0000]    
       
         
           
             
               
                 
                   s 
                   _ 
                 
                 p 
               
                
               
                 ( 
                 ω 
                 ) 
               
             
             = 
             
               
                 
                   
                     k 
                     _ 
                   
                   p 
                 
                  
                 
                   ( 
                   ω 
                   ) 
                 
               
               ω 
             
           
         
       
     
         [0062]    The local wavenumber approximation in (2) states that each dispersion curve in the wavenumber-frequency domain can be uniquely determined by its wavenumber k(ω 0 ) and its slope k′(ω 0 ) at the center frequency co o  of the chosen frequency band; see  FIG. 2  for an exemplary illustration where the solid line denotes the true dispersion curve, while the dash/dotted straightlines are the locally first-order approximated dispersion curves over different frequency bands. Alternatively, the dispersion curve in the slowness-frequency domain is uniquely determined by the phase slowness s p  and the group slowness g p  at the center frequency ω 0  over a particular frequency band due to (5).  FIGS. 3A and 3B  illustrate the equivalent dependence of dispersion curves in two different domains over two different sets of parameters defined at the center frequency. 
         [0063]      FIG. 3A  illustrates that the dispersion curves are locally approximated by straightlines over the wavenumber-frequency domain, while the dispersion curves in the slowness-frequency domain are approximated by smooth curves determined by (s p , g p ) as shown in  FIG. 3B .  FIGS. 3A and 3B  also include a second-order quadratic approximation of the dispersion curve in both domains. 
         [0064]    Stacking the frequency data from all L receivers at a given frequency ω ∈ Ω into a column vector, 
         [0000]        y (ω)=[ y   1 (ω),  y   2 (ω), . . . ,  y   L (ω)] T , ω ∈ Ω,   (6)
 
         [0000]    and defining the dictionary as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         Φ 
                         P 
                       
                        
                       
                         ( 
                         ω 
                         ) 
                       
                     
                     = 
                     
                       [ 
                       
                         
                           
                             φ 
                             1 
                           
                            
                           
                             ( 
                             ω 
                             ) 
                           
                         
                         , 
                         
                           
                             φ 
                             2 
                           
                            
                           
                             ( 
                             ω 
                             ) 
                           
                         
                         , 
                         … 
                          
                         
                             
                         
                         , 
                         
                           
                             φ 
                             P 
                           
                            
                           
                             ( 
                             ω 
                             ) 
                           
                         
                       
                       ] 
                     
                   
                   , 
                   
                     
 
                   
                    
                   with 
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         ϕ 
                         p 
                       
                        
                       
                         ( 
                         ω 
                         ) 
                       
                     
                     = 
                     
                       [ 
                       
                         
                           
                             
                                
                               
                                 
                                   j 
                                    
                                   
                                     [ 
                                     
                                       
                                         
                                           ω 
                                           0 
                                         
                                          
                                         
                                           
                                             s 
                                             _ 
                                           
                                           p 
                                         
                                       
                                       + 
                                       
                                         
                                           ( 
                                           
                                             ω 
                                             - 
                                             
                                               ω 
                                               0 
                                             
                                           
                                           ) 
                                         
                                          
                                         
                                           
                                             g 
                                             _ 
                                           
                                           p 
                                         
                                       
                                     
                                     ] 
                                   
                                 
                                  
                                 
                                   z 
                                   1 
                                 
                               
                             
                           
                         
                         
                           
                             
                                
                               
                                 
                                   j 
                                    
                                   
                                     [ 
                                     
                                       
                                         
                                           ω 
                                           0 
                                         
                                          
                                         
                                           
                                             s 
                                             _ 
                                           
                                           p 
                                         
                                       
                                       + 
                                       
                                         
                                           ( 
                                           
                                             ω 
                                             - 
                                             
                                               ω 
                                               0 
                                             
                                           
                                           ) 
                                         
                                          
                                         
                                           
                                             g 
                                             _ 
                                           
                                           p 
                                         
                                       
                                     
                                     ] 
                                   
                                 
                                  
                                 
                                   z 
                                   2 
                                 
                               
                             
                           
                         
                         
                           
                             ⋮ 
                           
                         
                         
                           
                             
                                
                               
                                 
                                   j 
                                    
                                   
                                     [ 
                                     
                                       
                                         
                                           ω 
                                           0 
                                         
                                          
                                         
                                           
                                             s 
                                             _ 
                                           
                                           p 
                                         
                                       
                                       + 
                                       
                                         
                                           ( 
                                           
                                             ω 
                                             - 
                                             
                                               ω 
                                               0 
                                             
                                           
                                           ) 
                                         
                                          
                                         
                                           
                                             g 
                                             _ 
                                           
                                           p 
                                         
                                       
                                     
                                     ] 
                                   
                                 
                                  
                                 
                                   z 
                                   L 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0000]    we have the following signal model from (3) 
         [0000]        y (ω)=Φ P (ω) a (ω)+ v (ω), ω ∈ Ω  (9)
 
         [0000]    where a(ω) is a P×1 spectrum amplitude vector and v(ω) is an L×1 observed noise vector at each frequency points within Ω 
         [0000]        a (ω)=[ā 1 (ω), ā 2 (ω), . . . , ā P (ω)] T , ω ∈ Ω,   (10)
 
         [0000]        v (ω)=[ v   1 (ω),  v   2 (ω), . . . ,  v   L (ω)] T , ω ∈ Ω  (11)
 
         [0065]    Mathematically, the signal model of (9) represents the P acoustic modes with P bases {φ p (ω)} p=1   P  (i.e., the column vectors of Φ P (ω)), each parametrized by the true but unknown { s   p ,  g   p } in (8). Geometrically, this is illustrated in  FIG. 4A , where P=3 acoustic modes over the chosen Ω are represented by three straightlines (equivalent to the bases {φ p (ω)} p=1   3 ) in the wavenumber-frequency domain, each determined by its center and slope { k   p (ω),  k ′ p (ω)} at the center frequency ω 0 .  FIG. 4B  illustrates an overcomplete representation of all possible modes in the frequency band. 
         [0066]    From (9), it is seen that the broadband data y(ω), ω ∈ Ω, are nonlinear with respect to the unknown parameters { s   p ,  g   p }. Therefore, traditional broadband methods such as the broadband ML method tend to use a multi-dimensional nonlinear optimization to first find the estimates of { s   p ,  g   p }, and then use these estimates to obtain the estimates of the spectrum amplitude ā p . The dimension of the nonlinear optimization depends on the mode number P, which is not a priori. As a result, the implementation of the ML estimation requires a pre-specified mode number or an estimate of mode number from an order-determination method. 
         [0067]    The broadband dispersion extraction can be reformulated in a block sparse signal model with varying dictionaries, which extends the sparse signal model. Specifically, one can express the broadband array waveforms in an overcomplete dictionary consisting of N&gt;&gt;P basis vectors parametrized by a pre-determined set of (s p , g p ). Mathematically, 
         [0000]        y (ω)=Φ(ω) a (ω)+ v (ω), ω ∈ Ω  (12)
 
         [0000]    where a(ω)=[a 1 (ω), a 2 (ω), . . . , a N (ω)] T  is an N×1 spectrum amplitude vector, and the dictionary Φ(ω) is expanded from P basis vectors with unknown ( s   p ,  g   p ) to N basis vectors with N pre-determined (s i , g j ) 
         [0000]      Φ(ω)=[φ 1 (ω), φ 2 (ω), . . . , φ N (ω)],   (13)
 
         [0000]    with the n-th basis defined as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         ϕ 
                         n 
                       
                        
                       
                         ( 
                         ω 
                         ) 
                       
                     
                     = 
                     
                       [ 
                       
                         
                           
                             
                                
                               
                                 
                                   j 
                                    
                                   
                                     [ 
                                     
                                       
                                         
                                           ω 
                                           0 
                                         
                                          
                                         
                                           s 
                                           i 
                                         
                                       
                                       + 
                                       
                                         
                                           ( 
                                           
                                             ω 
                                             - 
                                             
                                               ω 
                                               0 
                                             
                                           
                                           ) 
                                         
                                          
                                         
                                           g 
                                           j 
                                         
                                       
                                     
                                     ] 
                                   
                                 
                                  
                                 
                                   z 
                                   1 
                                 
                               
                             
                           
                         
                         
                           
                             
                                
                               
                                 
                                   j 
                                    
                                   
                                     [ 
                                     
                                       
                                         
                                           ω 
                                           0 
                                         
                                          
                                         
                                           s 
                                           i 
                                         
                                       
                                       + 
                                       
                                         
                                           ( 
                                           
                                             ω 
                                             - 
                                             
                                               ω 
                                               0 
                                             
                                           
                                           ) 
                                         
                                          
                                         
                                           g 
                                           j 
                                         
                                       
                                     
                                     ] 
                                   
                                 
                                  
                                 
                                   z 
                                   2 
                                 
                               
                             
                           
                         
                         
                           
                             ⋮ 
                           
                         
                         
                           
                             
                                
                               
                                 
                                   j 
                                    
                                   
                                     [ 
                                     
                                       
                                         
                                           ω 
                                           0 
                                         
                                          
                                         
                                           s 
                                           i 
                                         
                                       
                                       + 
                                       
                                         
                                           ( 
                                           
                                             ω 
                                             - 
                                             
                                               ω 
                                               0 
                                             
                                           
                                           ) 
                                         
                                          
                                         
                                           g 
                                           j 
                                         
                                       
                                     
                                     ] 
                                   
                                 
                                  
                                 
                                   z 
                                   L 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
         [0000]    corresponding to the (i, j) pre-determined {s i , g j } 
         [0000]        i=┌n/N   g   ┐, j=n −( i− 1) N   g   , n= 1, 2, . . . ,  N,    (15)
 
         [0000]    where ┌·┐ denotes the ceiling function. 
         [0068]    To take into account the spectrum correlation, i.e., the mode spectrum correlation of a(ω) across the frequency points ω, (12) is further rewriten under the block sparse signal model. First defining 
         [0000]        y   i  ∈ □ F×1   =[y   l (ω 1 ),  y   l (ω 2 ), . . . ,  y   l (ω F )] T ,   (16)
 
         [0000]        a   n  ∈ □ F×1   =[a   n (ω 1 ),  a   n (ω 2 ), . . . ,  a   n (ω F )] T    (17)
 
         [0000]    which, at the l-th receiver, collects the recorded data and the n-th mode spectrum amplitudes from F frequency points. Accordingly, F frequency-varying dictionaries Φ(ω) are consolidated into a single dictionary as 
         [0000]    
       
         
           
             
               
                 
                   
                     Φ 
                     ∈ 
                     
                       C 
                       
                         LF 
                         × 
                         NF 
                       
                     
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             Φ 
                             11 
                           
                         
                         
                           
                             Φ 
                             12 
                           
                         
                         
                           … 
                         
                         
                           
                             Φ 
                             
                               1 
                                
                               
                                   
                               
                                
                               N 
                             
                           
                         
                       
                       
                         
                           
                             Φ 
                             21 
                           
                         
                         
                           
                             Φ 
                             22 
                           
                         
                         
                           … 
                         
                         
                           
                             Φ 
                             
                               2 
                                
                               N 
                             
                           
                         
                       
                       
                         
                           ⋮ 
                         
                         
                           ⋮ 
                         
                         
                           ⋱ 
                         
                         
                           ⋮ 
                         
                       
                       
                         
                           
                             Φ 
                             
                               L 
                                
                               
                                   
                               
                                
                               1 
                             
                           
                         
                         
                           
                             Φ 
                             
                               L 
                                
                               
                                   
                               
                                
                               2 
                             
                           
                         
                         
                           … 
                         
                         
                           
                             Φ 
                             LN 
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   18 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where the (l, n)-th block matrix given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       Φ 
                       ln 
                     
                     ∈ 
                     
                       C 
                       
                         F 
                         × 
                         F 
                       
                     
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             
                               Φ 
                               
                                 l 
                                  
                                 n 
                               
                             
                              
                             
                               ( 
                               
                                 ω 
                                 1 
                               
                               ) 
                             
                           
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           … 
                         
                         
                           0 
                         
                       
                       
                         
                           0 
                         
                         
                           
                             
                               Φ 
                               
                                 l 
                                  
                                 n 
                               
                             
                              
                             
                               ( 
                               
                                 ω 
                                 2 
                               
                               ) 
                             
                           
                         
                         
                           0 
                         
                         
                           … 
                         
                         
                           0 
                         
                       
                       
                         
                           0 
                         
                         
                           0 
                         
                         
                           
                             
                               Φ 
                               
                                 l 
                                  
                                 n 
                               
                             
                              
                             
                               ( 
                               
                                 ω 
                                 3 
                               
                               ) 
                             
                           
                         
                         
                           … 
                         
                         
                           0 
                         
                       
                       
                         
                           ⋮ 
                         
                         
                           ⋮ 
                         
                         
                           ⋮ 
                         
                         
                           ⋱ 
                         
                         
                           ⋮ 
                         
                       
                       
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           … 
                         
                         
                           
                             
                               Φ 
                               
                                 l 
                                  
                                 n 
                               
                             
                              
                             
                               ( 
                               
                                 ω 
                                 F 
                               
                               ) 
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   19 
                   ) 
                 
               
             
           
         
       
     
         [0000]    has the (l, n)-th elements of {Φ(ω f )} f-1   F  at its diagonal elements. With the new definitions of 
         [0000]      y ∈ C LF×1 =[y 1   T , y 2   T , . . . , y L   T ] T ,   (20)
 
         [0000]      a ∈ C NF×1 =[a 1   T , a 2   T , . . . , a N   T ] T ,   (21)
 
         [0000]    the signal model in (12) can be rewritten as 
         [0000]        y=Φa+v,    (22)
 
         [0000]    where a is assumed to have the block sparsity; that is only a few blocks a n  ∈ C F×1  have non-zero values. From the Bayesian viewpoint, we assume that each block in a , i.e., a n , are complex Gaussian distributed with zero mean and covariance matrix R n , 
         [0000]      a n ; y n , Σ: CN(0,R n ),   (23)
 
         [0000]    where R n =γ n  Σ n . Explicitly, γ n  controls the presence of the n-th basis/acoustic mode in the array data. If γ n =0, a n =0 in probability one and, hence, the n-th basis vector (or, equivalently, the n-th block column of Φ, i.e., {Φ ln } l=1   L ) is excluded from the dictionary. Meanwhile, Σ n  captures the mode spectrum correlation patterns of the n-th acoustic mode. In the case of no spectrum correlation, there is simply Σ 1 = . . . =Σ N =I. To remove the ambiguity between γ n  and Σ n , assume that 
         [0000]      tr{E n }=F.   (24)
 
         [0069]    (23) is equivalent to having 
         [0000]      a;γ, Σ: CN(0,R),   (25)
 
         [0000]    where 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         R 
                         = 
                           
                          
                         
                           [ 
                           
                             
                               
                                 
                                   R 
                                   1 
                                 
                               
                               
                                 0 
                               
                               
                                 0 
                               
                               
                                 … 
                               
                               
                                 0 
                               
                             
                             
                               
                                 0 
                               
                               
                                 
                                   R 
                                   2 
                                 
                               
                               
                                 0 
                               
                               
                                 … 
                               
                               
                                 0 
                               
                             
                             
                               
                                 0 
                               
                               
                                 0 
                               
                               
                                 
                                   R 
                                   3 
                                 
                               
                               
                                 … 
                               
                               
                                 0 
                               
                             
                             
                               
                                 ⋮ 
                               
                               
                                 ⋮ 
                               
                               
                                 ⋮ 
                               
                               
                                 ⋱ 
                               
                               
                                 ⋮ 
                               
                             
                             
                               
                                 0 
                               
                               
                                 0 
                               
                               
                                 0 
                               
                               
                                 … 
                               
                               
                                 
                                   R 
                                   n 
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           [ 
                           
                             
                               
                                 
                                   
                                     γ 
                                     1 
                                   
                                    
                                   
                                     Σ 
                                     1 
                                   
                                 
                               
                               
                                 0 
                               
                               
                                 0 
                               
                               
                                 … 
                               
                               
                                 0 
                               
                             
                             
                               
                                 0 
                               
                               
                                 
                                   
                                     γ 
                                     2 
                                   
                                    
                                   
                                     Σ 
                                     2 
                                   
                                 
                               
                               
                                 0 
                               
                               
                                 … 
                               
                               
                                 0 
                               
                             
                             
                               
                                 0 
                               
                               
                                 0 
                               
                               
                                 
                                   
                                     γ 
                                     3 
                                   
                                    
                                   
                                     Σ 
                                     3 
                                   
                                 
                               
                               
                                 … 
                               
                               
                                 0 
                               
                             
                             
                               
                                 ⋮ 
                               
                               
                                 ⋮ 
                               
                               
                                 ⋮ 
                               
                               
                                 ⋱ 
                               
                               
                                 ⋮ 
                               
                             
                             
                               
                                 0 
                               
                               
                                 0 
                               
                               
                                 0 
                               
                               
                                 … 
                               
                               
                                 
                                   
                                     γ 
                                     N 
                                   
                                    
                                   
                                     Σ 
                                     N 
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   26 
                   ) 
                 
               
             
           
         
       
     
         [0000]    and Γ=diag[γ]=diag[γ 1 , γ 2 , . . . , γ N ]. The noise vector is assumed to be complex Gaussian distributed with zero mean and variance σ 2 , i.e., 
         [0000]      v;σ 2 :CN(0,σo 2 I LF ),   (27)
 
         [0000]    where I LF  denotes the identity matrix with dimension LF. It can be seen that the application-specified block sparse model introduced herein is different from the block sparse model with a Kronecker structure of Φ, which also considers the spectrum correlation. Specifically, the block sparse model considered assumes a fixed dictionary across multiple measurement vectors, while, for the broadband acoustic dispersion extraction, the design of varying dictionaries for multiple frequency measurements is necessary to utilize the row sparsity. If no spectrum correlation is considered, i.e., Σ n =I, the block sparse signal model (23) reduces to the MMV model with multiple dictionaries {Φ(ω f )} f=1   F  in (12), which includes the SMV model and the MMV model with a fixed dictionary Φ(ω 1 )= . . . =Φ(ω F ) as special cases. Therefore, the proposed SBL methods can be applied to other applications such as time-varying direction-of-arrival (DOA) estimation where the dictionaries along the time domain need to be different to take into account the evolution of the DOA. 
         [0070]    In determining new algorithms for slowness estimation for a given frequency band, the broadband Corr-SBL method is initially derived by taking into account the mode sparsity and the mode spectrum correlation. The method is derived in a two-step procedure: Step I) conditioned on the hyperparameters (γ and Σ) and the noise variance σ 2 , the Bayesian minimum mean square error (MMSE) estimate of the spectrum amplitude vector a is first obtained; Step II) the hyperparameters and noise variance are then estimated based on the Type-II maximum likelihood estimation. Particularly, the FP and EM iteration is used for the Type-II maximum likelihood estimation. Alternating these two steps gives the iterative, fully automatic, user-parameter free broadband Corr-SBL method for acoustic dispersion extraction for a particular frequency band. 
         [0071]    Previously, the special case of Σ n =I was considered and this demonstrated the broadband Corr-SBL method reducing to the broadband SBL method. The resulting broadband SBL method generalizes the current SBL methods for the SMV model and the MMV model with a fixed dictionary by allowing varying dictionaries for each measurement. 
         [0072]    Given the above signal model and conditioned on a and σ 2 , the likelihood function of the observed data can be shown as 
         [0000]      y|a;σ 2 : CN(Φa,σ 2 I LF ).   (28)
 
         [0000]    By applying the Bayes&#39; rule, the posterior distribution of the amplitude vector a(ω) can be obtained as 
         [0000]      a|y;γ, Σ n , σ 2 :CN(u, Σ a )   (29)
 
         [0000]    where the posterior mean u and the posterior covariance matrix Σ a  are given by, respectively, 
         [0000]      u=σ −2  Σ a  Φ H  y   (30)
 
         [0000]      Σ a =(σ −2  Φ H    Φ+R   −1 ) &#39;1    (31)
 
         [0000]    with R given by (26). 
         [0073]    The optimal Bayesian minimum mean-square error (MMSE) estimate of the coefficient vector a can be obtained by minimizing the Bayesian MSE 
         [0000]      E(∥a−∥ 2 |γ, Σ, σ 2 )
 
         [0000]      =∫∫∥a−a∥ 2 p(a, y|γ, Σ, σ 2 )dady.   (32)
 
         [0000]    Given the Gaussian posterior of a in (29) and conditioned on {γ, Σ n , σ 2 }, it is known that the Bayesian MMSE estimate of a coincides with the MAP estimate, and they both are equal to the posterior mean of a. From (30), the Bayesian MMSE estimate of a is given by 
         [0000]        a=u=σ   −2  Σ a  Φ H (ω) y (ω).   (33)
 
         [0074]    The block sparsity is enforced by pushing the hyperparameters {γ n } n=1   N  into zeros. As γ n →0, from (26), the n-th diagonal block of R is equal to zero, i.e., γ n  Σ n =0, and the n-th block of a, i.e., a n , approaches to zeros from (33). Therefore, the block sparsity of the amplitude vector is naturally transferred to the sparsity in the hyperparameters {γ n } n−1   N . Once the hyperparameters {γ n } n=1   N  are estimated, a can then be estimated from (33). 
         [0075]    The above Bayesian MMSE estimate of a is based on the given hyperparameters {γ, Σ n } and the noise variance σ 2 . In the following, the hyperparameters and the noise variance are estimated and updated from the type-II ML estimates [?, ?] by maximizing the marginal likelihood function of y with respect to {γ, Σ n , σ 2 }. 
         [0076]    Give the signal model, the marginal likelihood function of y can be computed as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       p 
                        
                       
                         ( 
                         
                           
                             y 
                              
                             γ 
                           
                           , 
                           Σ 
                           , 
                           
                             σ 
                             2 
                           
                         
                         ) 
                       
                     
                     = 
                     
                       
                         
                           ∫ 
                           
                             
                               p 
                                
                               
                                 ( 
                                 
                                   
                                     y 
                                      
                                     a 
                                   
                                   , 
                                   
                                     σ 
                                     2 
                                   
                                 
                                 ) 
                               
                             
                              
                             
                               p 
                                
                               
                                 ( 
                                 
                                   
                                     a 
                                      
                                     γ 
                                   
                                   , 
                                   Σ 
                                 
                                 ) 
                               
                             
                              
                             
                                
                               a 
                             
                           
                         
                         ⇒ 
                         y 
                       
                        
                       γ 
                     
                   
                   , 
                   
                     
 
                   
                    
                   Σ 
                   , 
                   
                     
                       σ 
                       2 
                     
                      
                     
                       : 
                     
                      
                     
                         
                     
                      
                     
                       CN 
                        
                       
                         ( 
                         
                           0 
                           , 
                           
                             Σ 
                             y 
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   34 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where p(y|a, σ 2 ) and p(a|γ, Σ) are given by (28) and (25), respectively, and 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Σ 
                           y 
                         
                         = 
                           
                          
                         
                           
                             
                               σ 
                               2 
                             
                              
                             
                               I 
                               LF 
                             
                           
                           + 
                           
                             Φ 
                              
                             
                                 
                             
                              
                             R 
                              
                             
                                 
                             
                              
                             
                               Φ 
                               H 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             
                               ( 
                               
                                 
                                   
                                     σ 
                                     
                                       - 
                                       2 
                                     
                                   
                                    
                                   
                                     I 
                                     LF 
                                   
                                 
                                 - 
                                 
                                   
                                     σ 
                                     
                                       - 
                                       4 
                                     
                                   
                                    
                                   
                                     ΦΣ 
                                     a 
                                   
                                    
                                   
                                     Φ 
                                     H 
                                   
                                 
                               
                               ) 
                             
                             
                               - 
                               1 
                             
                           
                           . 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   35 
                   ) 
                 
               
             
           
         
       
     
         [0077]    Equivalently, the following cost function L(γ, Σ n , σ 2 ) can be minimized with respect to {γ, Σ n , σ 2 } which is proportional to the negative logarithm of the marginal likelihood function in (34), 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           L 
                            
                           
                             ( 
                             
                               γ 
                               , 
                               
                                 Σ 
                                 n 
                               
                               , 
                               
                                 σ 
                                 2 
                               
                             
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             ln 
                              
                             
                                
                               
                                 Σ 
                                 y 
                               
                                
                             
                           
                           + 
                           
                             
                               y 
                               H 
                             
                              
                             
                               R 
                               y 
                               
                                 - 
                                 1 
                               
                             
                              
                             y 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             LF 
                              
                             
                                 
                             
                              
                             ln 
                              
                             
                                 
                             
                              
                             
                               σ 
                               2 
                             
                           
                           + 
                           
                             ln 
                              
                             
                                
                               R 
                                
                             
                           
                           + 
                           
                             ln 
                              
                             
                                
                               
                                 Σ 
                                 a 
                                 
                                   - 
                                   1 
                                 
                               
                                
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               σ 
                               
                                 - 
                                 2 
                               
                             
                              
                             
                               y 
                               H 
                             
                              
                             y 
                           
                           - 
                           
                             
                               σ 
                               
                                 - 
                                 4 
                               
                             
                              
                             
                               y 
                               H 
                             
                              
                             
                               ΦΣ 
                               a 
                             
                              
                             
                               Φ 
                               H 
                             
                              
                             y 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   36 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where the second equation holds with the help of (35). 
         [0078]    Unfortunately, a direct maximization of L(γ, Σ n , σ 2 ) with respect to {γ, Σ n , σ 2 } yields no closed-form solution for the type-II ML estimation. Alternatively, iterative implementation may be used to estimate {γ, Σ n , σ 2 }. In the following, two strategies are considered for such updates: 1) the Fixed-Point (FP) algorithm; and 2) the Expectation-Maximization (EM) algorithm. 
         [0079]    The FP algorithm simply takes the derivative of L(γ, Σ n , σ 2 ) with respect to {γ, Σ n , σ 2 } and, then, forms a fixed-point equation by setting the derivatives to zeros. 
         [0080]    The FP Iteration of γ: Starting from (36), initially the derivative of L(γ, Σ, σ 2 ) is taken with respect to γ n , i.e., the n-th element of γ, 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ∂ 
                       
                         L 
                          
                         
                           ( 
                           
                             γ 
                             , 
                             
                               Σ 
                               n 
                             
                             , 
                             
                               σ 
                               2 
                             
                           
                           ) 
                         
                       
                     
                     
                       ∂ 
                       
                         γ 
                         n 
                       
                     
                   
                   = 
                   
                     
                       F 
                       
                         γ 
                         n 
                       
                     
                     - 
                     
                       
                         tr 
                          
                         
                           { 
                           
                             
                               ∑ 
                               a 
                               
                                 { 
                                 n 
                                 } 
                               
                             
                              
                             
                               ∑ 
                               n 
                               
                                 - 
                                 1 
                               
                             
                           
                           } 
                         
                       
                       
                         γ 
                         n 
                         2 
                       
                     
                     - 
                     
                       
                         
                           u 
                           n 
                           H 
                         
                          
                         
                           
                             ∑ 
                             n 
                             
                               - 
                               1 
                             
                           
                            
                           
                             u 
                             n 
                             H 
                           
                         
                       
                       
                         γ 
                         n 
                         2 
                       
                     
                   
                 
               
               
                 
                   ( 
                   37 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where Σ a   {n}  denotes the n-th diagonal block of the posterior covariance matrix Σ a  in (31), and u n  denotes the n-th block of the posterior mean u in (30). 
         [0081]    Setting the above derivative to zero, produces the fixed-point equation for γ 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         γ 
                         ^ 
                       
                       n 
                     
                     = 
                     
                       
                         
                           tr 
                            
                           
                             { 
                             
                               
                                 ∑ 
                                 a 
                                 
                                   { 
                                   n 
                                   } 
                                 
                               
                                
                               
                                 ∑ 
                                 n 
                                 
                                   - 
                                   1 
                                 
                               
                             
                             } 
                           
                         
                         + 
                         
                           
                             u 
                             n 
                             H 
                           
                            
                           
                             
                               ∑ 
                               n 
                               
                                 - 
                                 1 
                               
                             
                              
                             
                               u 
                               n 
                               H 
                             
                           
                         
                       
                       F 
                     
                   
                   , 
                   
                     n 
                     = 
                     1 
                   
                   , 
                   2 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     N 
                     . 
                   
                 
               
               
                 
                   ( 
                   38 
                   ) 
                 
               
             
           
         
       
     
         [0000]    From the above equation, it can be seen that the estimate of the n-th hyperparameter is given by the whitened posterior variance average over the F frequency points 
         [0082]    The FP Iteration of Σ n : taking the derivative of L(γ, Σ n , σ 2 ) with respect to the (i, j)-th element of Σ n , results in 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ∂ 
                       
                         L 
                          
                         
                           ( 
                           
                             γ 
                             , 
                             Σ 
                             , 
                             
                               σ 
                               2 
                             
                           
                           ) 
                         
                       
                     
                     
                       ∂ 
                       
                         
                           [ 
                           
                             Σ 
                             n 
                           
                           ] 
                         
                         ij 
                       
                     
                   
                   = 
                   
                     
                       
                         { 
                         
                           ∑ 
                           n 
                           
                             - 
                             1 
                           
                         
                         } 
                       
                       ij 
                     
                     - 
                     
                       
                         
                           { 
                           
                             
                               ∑ 
                               n 
                               
                                 - 
                                 1 
                               
                             
                              
                             
                               
                                 ∑ 
                                 a 
                                 
                                   { 
                                   n 
                                   } 
                                 
                               
                                
                               
                                 ∑ 
                                 n 
                                 
                                   - 
                                   1 
                                 
                               
                             
                           
                           } 
                         
                         ij 
                       
                       
                         γ 
                         n 
                       
                     
                     - 
                     
                       
                         
                           { 
                           
                             
                               ∑ 
                               n 
                               
                                 - 
                                 1 
                               
                             
                              
                             
                               
                                 u 
                                 n 
                               
                                
                               
                                 u 
                                 n 
                                 H 
                               
                                
                               
                                 ∑ 
                                 n 
                                 
                                   - 
                                   1 
                                 
                               
                             
                           
                           } 
                         
                         ij 
                       
                       
                         γ 
                         n 
                       
                     
                   
                 
               
               
                 
                   ( 
                   39 
                   ) 
                 
               
             
           
         
       
     
         [0000]    which results in 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ∂ 
                       
                         L 
                          
                         
                           ( 
                           
                             γ 
                             , 
                             Σ 
                             , 
                             
                               σ 
                               2 
                             
                           
                           ) 
                         
                       
                     
                     
                       ∂ 
                       Σ 
                     
                   
                   = 
                   
                     
                       
                         ∑ 
                         n 
                         
                           - 
                           1 
                         
                       
                        
                       
                         - 
                         
                           
                             
                               ∑ 
                               n 
                               
                                 - 
                                 1 
                               
                             
                              
                             
                               
                                 ∑ 
                                 a 
                                 
                                   { 
                                   n 
                                   } 
                                 
                               
                                
                               
                                 ∑ 
                                 n 
                                 
                                   - 
                                   1 
                                 
                               
                             
                           
                           
                             γ 
                             n 
                           
                         
                       
                     
                     - 
                     
                       
                         
                           ∑ 
                           n 
                           
                             - 
                             1 
                           
                         
                          
                         
                           
                             u 
                             n 
                           
                            
                           
                             u 
                             n 
                             H 
                           
                            
                           
                             ∑ 
                             n 
                             
                               - 
                               1 
                             
                           
                         
                       
                       
                         γ 
                         n 
                       
                     
                   
                 
               
               
                 
                   ( 
                   40 
                   ) 
                 
               
             
           
         
       
     
         [0083]    Setting the above derivative to zero, produces the fixed-point equation for Σ n    
         [0000]      Σ n =γ n   −1 (Σ a   {n}   +u   n   u   n   H ),   (41)
 
         [0000]    From the above equation, it can be seen that the estimate of the structural covariance matrix is given by the posterior mean-squared error matrix. 
         [0084]    The FP Iteration of σ 2 : Similarly, taking the derivative of L(γ, Σ n , σ 2 ) with respect to σ 2 , results in 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ∂ 
                       
                         L 
                          
                         
                           ( 
                           
                             γ 
                             , 
                             Σ 
                             , 
                             
                               σ 
                               2 
                             
                           
                           ) 
                         
                       
                     
                     
                       ∂ 
                       
                         σ 
                         2 
                       
                     
                   
                   = 
                   
                     
                       LF 
                        
                       
                           
                       
                        
                       
                         σ 
                         
                           - 
                           2 
                         
                       
                     
                     - 
                     
                       
                         σ 
                         
                           - 
                           2 
                         
                       
                        
                       tr 
                        
                       
                         { 
                         
                           
                             I 
                             NF 
                           
                           - 
                           
                             
                               R 
                               
                                 - 
                                 1 
                               
                             
                              
                             
                               Σ 
                               a 
                             
                           
                         
                         } 
                       
                     
                     - 
                     
                       
                         σ 
                         
                           - 
                           4 
                         
                       
                        
                       
                         
                           
                              
                             
                               y 
                               - 
                               
                                 Φ 
                                  
                                 
                                     
                                 
                                  
                                 u 
                               
                             
                              
                           
                           2 
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   42 
                   ) 
                 
               
             
           
         
       
     
         [0085]    Setting the above derivative to zero, produces the fixed-point equation for σ 2    
         [0000]    
       
         
           
             
               
                 
                   
                     
                       σ 
                       ^ 
                     
                     2 
                   
                   = 
                   
                     
                       
                         
                            
                           
                             y 
                             - 
                             
                               Φ 
                                
                               
                                   
                               
                                
                               u 
                             
                           
                            
                         
                         2 
                       
                       
                         FL 
                         - 
                         
                           
                             ∑ 
                             
                               n 
                               = 
                               1 
                             
                             N 
                           
                            
                           
                               
                           
                            
                           
                             ( 
                             
                               F 
                               - 
                               
                                 
                                   γ 
                                   n 
                                   
                                     - 
                                     1 
                                   
                                 
                                  
                                 tr 
                                  
                                 
                                   { 
                                   
                                     
                                       ∑ 
                                       n 
                                       
                                         - 
                                         1 
                                       
                                     
                                      
                                     
                                       ∑ 
                                       a 
                                       
                                         { 
                                         n 
                                         } 
                                       
                                     
                                   
                                   } 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   43 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Therefore, the estimate of the noise variance is given by the residual energy normalized by a factor related to the whitened posterior covariance matrix. 
         [0086]    To gain a fast convergence, defining a new quantity 
         [0000]      ζ n   =F−γ   n   −1    tr{Σ   n   −1  Σ n   {n} }  (44)
 
         [0000]    the FP iteration for {γ, Σ n , σ 2 } can be rewritten as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         γ 
                         ^ 
                       
                       n 
                       new 
                     
                     = 
                     
                       
                         
                           u 
                           n 
                           H 
                         
                          
                         
                           
                             ∑ 
                             n 
                             
                               - 
                               1 
                             
                           
                            
                           
                             u 
                             n 
                             H 
                           
                         
                       
                       
                         ζ 
                         n 
                       
                     
                   
                   , 
                   
                     n 
                     = 
                     1 
                   
                   , 
                   2 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     N 
                     . 
                   
                 
               
               
                 
                   ( 
                   45 
                   ) 
                 
               
             
             
               
                 
                   
                     ∑ 
                     n 
                     new 
                   
                    
                   
                     = 
                     
                       
                         γ 
                         n 
                         
                           - 
                           1 
                         
                       
                        
                       
                         ( 
                         
                           
                             ∑ 
                             a 
                             
                               { 
                               n 
                               } 
                             
                           
                            
                           
                             
                               + 
                               
                                 u 
                                 n 
                               
                             
                              
                             
                               u 
                               n 
                               H 
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   46 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       σ 
                       ^ 
                     
                     2 
                     new 
                   
                   = 
                   
                     
                       
                          
                         
                           y 
                           - 
                           
                             Φ 
                              
                             
                                 
                             
                              
                             u 
                           
                         
                          
                       
                       2 
                     
                     
                       FL 
                       - 
                       
                         
                           ∑ 
                           
                             n 
                             = 
                             1 
                           
                           N 
                         
                          
                         
                             
                         
                          
                         
                           ζ 
                           n 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   47 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where ζ n , u and Σ a  are obtained with (γ) old , (Σ) old , and ({circumflex over (σ)} 2 ) old  in the previous iteration. 
         [0087]    The EM algorithm, on the other hand, is an alternative to maximize the marginal likelihood function in (36) by treating a as the hidden (unobservable) variable. In particular, the EM algorithm is a two-step iterative algorithm by first, in the E-step, computing the expectation of log-likelihood of the complete data (the observation y and the hidden variable a), given the old parameter estimates and then, in the M-step, updating the estimates of unknown parameters by maximizing this expectation with respect to unknown parameters. 
         [0088]    Define θ=[γ, Σ n , σ 2 ]. In the E-step, given the estimate of θ at the k-th iteration, i.e., θ (k) , the expectation of log-likelihood of the complete data, also referred to as the Q-function, is given as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Q 
                            
                           
                             ( 
                             θ 
                             ) 
                           
                         
                         = 
                           
                          
                         
                           
                             E 
                             
                               
                                 a 
                                  
                                 y 
                               
                               ; 
                               
                                 θ 
                                 
                                   ( 
                                   k 
                                   ) 
                                 
                               
                             
                           
                            
                           
                             { 
                             
                               ln 
                                
                               
                                 [ 
                                 
                                   p 
                                    
                                   
                                     ( 
                                     
                                       a 
                                       , 
                                       
                                         y 
                                         ; 
                                         θ 
                                       
                                     
                                     ) 
                                   
                                 
                                 ] 
                               
                             
                             } 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           ∫ 
                           
                             
                               p 
                                
                               
                                 ( 
                                 
                                   
                                     a 
                                      
                                     y 
                                   
                                   ; 
                                   
                                     θ 
                                     
                                       ( 
                                       k 
                                       ) 
                                     
                                   
                                 
                                 ) 
                               
                             
                              
                             
                               ln 
                                
                               
                                 [ 
                                 
                                   
                                     p 
                                      
                                     
                                       ( 
                                       
                                         
                                           y 
                                            
                                           a 
                                         
                                         ; 
                                         
                                           σ 
                                           2 
                                         
                                       
                                       ) 
                                     
                                   
                                    
                                   
                                     p 
                                      
                                     
                                       ( 
                                       
                                         
                                           a 
                                           ; 
                                           γ 
                                         
                                         , 
                                         Σ 
                                       
                                       ) 
                                     
                                   
                                 
                                 ] 
                               
                             
                              
                             
                                
                               a 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   48 
                   ) 
                 
               
             
           
         
       
     
         [0000]    In the second M-step, the updated estimate of θ is obtained by maximizing the Q-function 
         [0000]    
       
         
           
             
               
                 
                   
                     θ 
                     
                       ( 
                       
                         k 
                         + 
                         1 
                       
                       ) 
                     
                   
                   = 
                   
                     arg 
                      
                     
                       
                         max 
                         θ 
                       
                        
                       
                           
                       
                        
                       
                         Q 
                          
                         
                           ( 
                           θ 
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   49 
                   ) 
                 
               
             
           
         
       
     
         [0089]    The EM Iteration of γ: From the above result, the EM update of γ is given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           γ 
                           
                             ( 
                             
                               k 
                               + 
                               1 
                             
                             ) 
                           
                         
                         = 
                           
                          
                         
                           arg 
                            
                           
                             
                               max 
                               γ 
                             
                              
                             
                               ∫ 
                               
                                 
                                   p 
                                    
                                   
                                     ( 
                                     
                                       
                                         a 
                                          
                                         y 
                                       
                                       ; 
                                       
                                         θ 
                                         
                                           ( 
                                           k 
                                           ) 
                                         
                                       
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   ln 
                                    
                                   
                                     [ 
                                     
                                       
                                         p 
                                          
                                         
                                           ( 
                                           
                                             
                                               y 
                                                
                                               a 
                                             
                                             ; 
                                             
                                               σ 
                                               2 
                                             
                                           
                                           ) 
                                         
                                       
                                        
                                       
                                         p 
                                          
                                         
                                           ( 
                                           
                                             
                                               a 
                                               ; 
                                               γ 
                                             
                                             , 
                                             Σ 
                                           
                                           ) 
                                         
                                       
                                     
                                     ] 
                                   
                                 
                                  
                                 
                                    
                                   a 
                                 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           arg 
                            
                           
                             
                               max 
                               γ 
                             
                              
                             
                               ⌊ 
                               
                                 
                                   
                                     - 
                                     ln 
                                   
                                    
                                   
                                      
                                     
                                       π 
                                        
                                       
                                           
                                       
                                        
                                       R 
                                     
                                      
                                   
                                 
                                 - 
                                 
                                   tr 
                                    
                                   
                                     { 
                                     
                                       
                                         R 
                                         
                                           - 
                                           1 
                                         
                                       
                                        
                                       
                                         ∑ 
                                         a 
                                         
                                           ( 
                                           k 
                                           ) 
                                         
                                       
                                     
                                     } 
                                   
                                 
                                 - 
                                 
                                   
                                     
                                       ( 
                                       
                                         u 
                                         
                                           ( 
                                           k 
                                           ) 
                                         
                                       
                                       ) 
                                     
                                     H 
                                   
                                    
                                   
                                     R 
                                     
                                       - 
                                       1 
                                     
                                   
                                    
                                   
                                     u 
                                     
                                       ( 
                                       k 
                                       ) 
                                     
                                   
                                 
                               
                               ⌋ 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   50 
                   ) 
                 
               
             
           
         
       
     
         [0090]    Taking the derivative of the above equation and setting to zero, produces the EM iteration of σ: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       γ 
                       n 
                       
                         ( 
                         
                           k 
                           + 
                           1 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         
                           tr 
                            
                           
                             { 
                             
                               
                                 ∑ 
                                 a 
                                 
                                   { 
                                   n 
                                   } 
                                 
                               
                                
                               
                                 ∑ 
                                 n 
                                 
                                   - 
                                   1 
                                 
                               
                             
                             } 
                           
                         
                         + 
                         
                           
                             u 
                             n 
                             H 
                           
                            
                           
                             
                               ∑ 
                               n 
                               
                                 - 
                                 1 
                               
                             
                              
                             
                               u 
                               n 
                               H 
                             
                           
                         
                       
                       F 
                     
                   
                   , 
                   
                     n 
                     = 
                     1 
                   
                   , 
                   2 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     N 
                     . 
                   
                 
               
               
                 
                   ( 
                   51 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where u, Σ a  and Σ n  are all computed with the estimate of θ (k) ={γ (k) , Σ n   (k) , (σ 2 ) (k) } from the k-th iteration. Compared it with (41), it can be seen that the EM iteration of γ is the same at the FP iteration of γ. 
         [0091]    The EM Iteration of Σ n : Similarly, the EM update of Σ n  is given by 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           ∑ 
                           n 
                           
                             ( 
                             
                               k 
                               + 
                               1 
                             
                             ) 
                           
                         
                          
                         
                           = 
                             
                            
                           
                             arg 
                              
                             
                               
                                 max 
                                 
                                   Σ 
                                   n 
                                 
                               
                                
                               
                                 ∫ 
                                 
                                   
                                     p 
                                      
                                     
                                       ( 
                                       
                                         
                                           a 
                                            
                                           y 
                                         
                                         ; 
                                         
                                           θ 
                                           
                                             ( 
                                             k 
                                             ) 
                                           
                                         
                                       
                                       ) 
                                     
                                   
                                    
                                   
                                     ln 
                                      
                                     
                                       [ 
                                       
                                         
                                           p 
                                            
                                           
                                             ( 
                                             
                                               
                                                 y 
                                                  
                                                 a 
                                               
                                               ; 
                                               
                                                 σ 
                                                 2 
                                               
                                             
                                             ) 
                                           
                                         
                                          
                                         
                                           p 
                                            
                                           
                                             ( 
                                             
                                               
                                                 a 
                                                 ; 
                                                 γ 
                                               
                                               , 
                                               
                                                 Σ 
                                                 n 
                                               
                                             
                                             ) 
                                           
                                         
                                       
                                       ] 
                                     
                                   
                                    
                                   
                                      
                                     a 
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         
                           = 
                             
                            
                           
                             
                               γ 
                               n 
                               
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   ∑ 
                                   a 
                                   
                                     { 
                                     n 
                                     } 
                                   
                                 
                                  
                                 
                                   
                                     + 
                                     
                                       u 
                                       n 
                                     
                                   
                                    
                                   
                                     u 
                                     n 
                                     H 
                                   
                                 
                               
                               ) 
                             
                           
                         
                         , 
                       
                     
                   
                 
               
               
                 
                   ( 
                   52 
                   ) 
                 
               
             
           
         
       
     
         [0000]    which, again, the same as the one used in the FP iteration. 
         [0092]    The EM Iteration of σ 2 : Based on the EM algorithm, we have 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           
                             ( 
                             
                               σ 
                               2 
                             
                             ) 
                           
                           
                             ( 
                             
                               k 
                               + 
                               1 
                             
                             ) 
                           
                         
                         = 
                           
                          
                         
                           arg 
                            
                           
                             
                               max 
                               
                                 σ 
                                 2 
                               
                             
                              
                             
                               ∫ 
                               
                                 
                                   p 
                                    
                                   
                                     ( 
                                     
                                       
                                         a 
                                          
                                         y 
                                       
                                       ; 
                                       
                                         θ 
                                         
                                           ( 
                                           k 
                                           ) 
                                         
                                       
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   ln 
                                    
                                   
                                     [ 
                                     
                                       
                                         p 
                                          
                                         
                                           ( 
                                           
                                             
                                               y 
                                                
                                               a 
                                             
                                             ; 
                                             
                                               σ 
                                               2 
                                             
                                           
                                           ) 
                                         
                                       
                                        
                                       
                                         p 
                                          
                                         
                                           ( 
                                           
                                             
                                               a 
                                               ; 
                                               γ 
                                             
                                             , 
                                             
                                               Σ 
                                               n 
                                             
                                           
                                           ) 
                                         
                                       
                                     
                                     ] 
                                   
                                 
                                  
                                 
                                    
                                   a 
                                 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           arg 
                            
                           
                             
                               max 
                               
                                 σ 
                                 2 
                               
                             
                              
                             
                               [ 
                               
                                 
                                   
                                     - 
                                     LF 
                                   
                                    
                                   
                                       
                                   
                                    
                                   ln 
                                    
                                   
                                       
                                   
                                    
                                   
                                     σ 
                                     2 
                                   
                                 
                                 - 
                                 
                                   
                                     σ 
                                     
                                       - 
                                       2 
                                     
                                   
                                   ( 
                                   
                                     
                                       tr 
                                        
                                       
                                         { 
                                         
                                           
                                             Φ 
                                             H 
                                           
                                            
                                           Φ 
                                            
                                           
                                             ∑ 
                                             a 
                                             
                                               ( 
                                               k 
                                               ) 
                                             
                                           
                                         
                                         } 
                                       
                                     
                                     + 
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         
                             
                            
                           
                             
                                
                               
                                 y 
                                 - 
                                 
                                   Φ 
                                    
                                   
                                       
                                   
                                    
                                   
                                     u 
                                     
                                       ( 
                                       k 
                                       ) 
                                     
                                   
                                 
                               
                                
                             
                             2 
                           
                           ) 
                         
                         ] 
                       
                     
                   
                 
               
               
                 
                   ( 
                   53 
                   ) 
                 
               
             
           
         
       
     
         [0093]    Taking the derivative of the above equation with respect to σ 2  and equating it to zero, we have the EM iteration of σ 2    
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         ( 
                         
                           σ 
                           2 
                         
                         ) 
                       
                       
                         ( 
                         
                           k 
                           + 
                           1 
                         
                         ) 
                       
                     
                     = 
                     
                       
                         
                           tr 
                            
                           
                             { 
                             
                               
                                 Φ 
                                 H 
                               
                                
                               Φ 
                                
                               
                                 ∑ 
                                 a 
                                 
                                   ( 
                                   k 
                                   ) 
                                 
                               
                             
                             } 
                           
                         
                         + 
                         
                           
                              
                             
                               y 
                               - 
                               
                                 Φ 
                                  
                                 
                                     
                                 
                                  
                                 
                                   u 
                                   
                                     ( 
                                     k 
                                     ) 
                                   
                                 
                               
                             
                              
                           
                           2 
                         
                       
                       LF 
                     
                   
                   , 
                 
               
               
                 
                   ( 
                   54 
                   ) 
                 
               
             
           
         
       
     
         [0000]    which appears to be different from the FP iteration of σ 2  in (43). 
         [0094]    The overall SBL algorithm is obtained by alternating these two steps. With both the FP and EM iterations, the two SBL algorithms result, i.e., the Corr-SBL-FP and Corr-SBL-EM algorithm, for the broadband dispersion extraction for a chosen frequency band. Specifically, either SBL algorithm uses all measurements y(ω), ω ∈ Ω, within the chosen frequency band and the pre-determined dictionaries Φ(ω), ω ∈ Ω, as inputs, and deliveries the estimates of the amplitude vectors a and the noise variance {circumflex over (σ)} 2 . Additional information about the prior variance γ i , the posterior covariance matrix Σ a(ω) , and the marginal covariance matrix Σ y(ω)  of the measurement can be obtained as well. 
         [0095]    For practical application, several comments on the estimation of the correlation matrices are in order. It is noted that it may cause over-fitting by using N correlation matrices {Σ n } n=1   N =Σ for the block sparse signal model. Alternatively, one can use only one correlation matrix {Σ n } n=1   N =Σ to avoid the over-fitting. However, simulation results show that this usually leads to the suppression of weak modes. This is due to the fact that, by using only one correlation matrix, the learned correlation matrix appears to converge to the correlation matrix of the strongest mode. Therefore, one embodiment takes a hybrid approach for the iterative Corr-SBL methods. At the early stage of iteration, a single structured/unstructured correlation matrix is learned at each iteration by averaging over the N estimated {Σ n } n=1   N  in the Corr-SBL methods. When the number of active basis (say K) is less than F (the number of frequency measurements), K correlation matrices are simultaneously learned by imposing them to be Toeplitz, i.e., 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         Σ 
                         ^ 
                       
                       k 
                       Toeplitz 
                     
                     = 
                     
                       [ 
                       
                         
                           
                             1 
                           
                           
                             
                               ρ 
                               k 
                             
                           
                           
                             … 
                           
                           
                             
                               ρ 
                               k 
                               
                                 F 
                                 - 
                                 1 
                               
                             
                           
                         
                         
                           
                             
                               ρ 
                               k 
                             
                           
                           
                             1 
                           
                           
                             … 
                           
                           
                             
                               ρ 
                               k 
                               
                                 F 
                                 - 
                                 2 
                               
                             
                           
                         
                         
                           
                             ⋮ 
                           
                           
                             ⋮ 
                           
                           
                             ⋱ 
                           
                           
                             ⋮ 
                           
                         
                         
                           
                             
                               ρ 
                               k 
                               
                                 F 
                                 - 
                                 1 
                               
                             
                           
                           
                             
                               ρ 
                               k 
                               
                                 F 
                                 - 
                                 2 
                               
                             
                           
                           
                             … 
                           
                           
                             1 
                           
                         
                       
                       ] 
                     
                   
                   , 
                   
                     
 
                   
                    
                   
                     k 
                     = 
                     1 
                   
                   , 
                   2 
                   , 
                   … 
                    
                   
                       
                   
                   , 
                   
                     K 
                     ≤ 
                     F 
                      
                     N 
                   
                 
               
               
                 
                   ( 
                   55 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where ρ k =d 1 /d 0  with d 1  and d 0  given by the sum of diagonal entries and the main sub-diagonal entries of Σ k  obtained in the Corr-SBL methods. Other physics-driven correlation matrix can be similarly used. 
         [0096]    The detailed algorithms for the Corr-SBL-FP and Corr-SBL-EM iterations can be found in Tables 1 and 2, respectively. In the performance evaluation, the threshold ε for the pruning step is set to be, e.g., ε=1×10 −6 . The convergence is claimed if the maximum number of iterations is met or the maximum change of prior variances from one iteration to the next is below a threshold. The maximum allowable change of the marginal likelihood function L(γ, σ 2 ) between two consecutive iterations can also be used for the convergence condition. 
         [0000]    
       
         
               
             
               
             
           
               
                 TABLE 1 
               
               
                   
               
               
                 The Broadband Corr-SLB-FP Algorithm 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 Inputs: y, Φ; 
               
               
                 Outputs: a, {circumflex over (σ)} 2 ; 
               
               
                 Initialization: γ (0) = 1 N , Σ (0) = I F ,(σ 2 ) (0)  = 1; 
               
               
                 Repeat: 
               
               
                 R (k)  = diag (γ (k) )            Σ (k) ; 
               
               
                 Σ a  = (Φ H  Φ/(σ 2 ) (k)  + (R (k) ) −1 ) −1 ; 
               
               
                 u = Σ a  Φ H  y/(σ 2 ) (k) ; 
               
               
                 ζ n  = F − tr{(Σ (k) ) −1  Σ a }/γ n   (k) ; 
               
               
                   
               
               
                 
                   
                     
                       
                         
                           
                             γ 
                             n 
                             
                               ( 
                               
                                 k 
                                 + 
                                 1 
                               
                               ) 
                             
                           
                           = 
                           
                             
                               
                                 
                                   
                                     u 
                                     n 
                                     H 
                                   
                                    
                                   
                                     ( 
                                     
                                       Σ 
                                       
                                         ( 
                                         k 
                                         ) 
                                       
                                     
                                     ) 
                                   
                                 
                                 
                                   - 
                                   1 
                                 
                               
                                
                               
                                 u 
                                 n 
                                 H 
                               
                             
                             
                               ζ 
                               n 
                             
                           
                         
                         , 
                         
                           n 
                           = 
                           1 
                         
                         , 
                         2 
                         , 
                         … 
                          
                         
                             
                         
                         , 
                         
                           N 
                           ; 
                         
                       
                     
                   
                 
               
               
                   
               
               
                 
                   
                     
                       
                         
                           
                             Σ 
                             
                               ( 
                               
                                 k 
                                 + 
                                 1 
                               
                               ) 
                             
                           
                           = 
                           
                             
                               
                                 ∑ 
                                 
                                   n 
                                   = 
                                   1 
                                 
                                 N 
                               
                                
                               
                                   
                               
                                
                               
                                 
                                   ( 
                                   
                                     
                                       Σ 
                                       a 
                                       
                                         { 
                                         n 
                                         } 
                                       
                                     
                                     + 
                                     
                                       
                                         u 
                                         n 
                                       
                                        
                                       
                                         u 
                                         n 
                                         H 
                                       
                                     
                                   
                                   ) 
                                 
                                 / 
                                 
                                   γ 
                                   n 
                                   
                                     ( 
                                     k 
                                     ) 
                                   
                                 
                               
                             
                             N 
                           
                         
                         ; 
                       
                     
                   
                 
               
               
                   
               
               
                 
                   
                     
                       
                         
                           
                             
                               ( 
                               
                                 σ 
                                 2 
                               
                               ) 
                             
                             
                               ( 
                               
                                 k 
                                 + 
                                 1 
                               
                               ) 
                             
                           
                           = 
                           
                             
                               
                                  
                                 
                                   y 
                                   - 
                                   
                                     Φ 
                                      
                                     
                                         
                                     
                                      
                                     u 
                                   
                                 
                                  
                               
                               2 
                             
                             
                               FL 
                               - 
                               
                                 
                                   ∑ 
                                   
                                     n 
                                     = 
                                     1 
                                   
                                   N 
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   ζ 
                                   n 
                                 
                               
                             
                           
                         
                         ; 
                       
                     
                   
                 
               
               
                   
               
               
                 Remove F columns of Φ with indices between (n − 1) × F + 1  
               
               
                 and n × F, if corresponding γ n  ≦           ; 
               
               
                 Until (convergence) 
               
               
                 a = u; 
               
               
                 {circumflex over (σ)} 2  = (σ 2 ) (k) ; 
               
               
                   
               
             
          
         
       
     
         [0000]    
       
         
               
             
               
             
           
               
                 TABLE 2 
               
               
                   
               
               
                 The Broadband Corr-SLB-EM Algorithm 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 Inputs: y, Φ 
               
               
                 Outputs: a, {circumflex over (σ)} 2 ; 
               
               
                 Initialization: γ (0) = 1 N , Σ (0) = I F ,(σ 2 ) (0)  = 1; 
               
               
                 Repeat: 
               
               
                 R (k)  = diag (γ (k) )            Σ (k) ; 
               
               
                 Σ a  = (Φ H  Φ/(σ 2 ) (k)  + (R (k) ) −1 ) −1 ; 
               
               
                 u = Σ a  Φ H  y/(σ 2 ) (k) ; 
               
               
                 ζ n  = F − tr{(Σ (k) ) −1  Σ a }/γ n   (k) ; 
               
               
                   
               
               
                 
                   
                     
                       
                         
                           
                             γ 
                             n 
                             
                               ( 
                               
                                 k 
                                 + 
                                 1 
                               
                               ) 
                             
                           
                           = 
                           
                             
                               
                                 
                                   
                                     u 
                                     n 
                                     H 
                                   
                                    
                                   
                                     ( 
                                     
                                       Σ 
                                       
                                         ( 
                                         k 
                                         ) 
                                       
                                     
                                     ) 
                                   
                                 
                                 
                                   - 
                                   1 
                                 
                               
                                
                               
                                 u 
                                 n 
                                 H 
                               
                             
                             
                               ζ 
                               n 
                             
                           
                         
                         , 
                         
                           n 
                           = 
                           1 
                         
                         , 
                         2 
                         , 
                         … 
                          
                         
                             
                         
                         , 
                         
                           N 
                           ; 
                         
                       
                     
                   
                 
               
               
                   
               
               
                 
                   
                     
                       
                         
                           
                             Σ 
                             
                               ( 
                               
                                 k 
                                 + 
                                 1 
                               
                               ) 
                             
                           
                           = 
                           
                             
                               
                                 ∑ 
                                 
                                   n 
                                   = 
                                   1 
                                 
                                 N 
                               
                                
                               
                                   
                               
                                
                               
                                 
                                   ( 
                                   
                                     
                                       Σ 
                                       a 
                                       
                                         { 
                                         n 
                                         } 
                                       
                                     
                                     + 
                                     
                                       
                                         u 
                                         n 
                                       
                                        
                                       
                                         u 
                                         n 
                                         H 
                                       
                                     
                                   
                                   ) 
                                 
                                 / 
                                 
                                   γ 
                                   n 
                                   
                                     ( 
                                     k 
                                     ) 
                                   
                                 
                               
                             
                             N 
                           
                         
                         ; 
                       
                     
                   
                 
               
               
                   
               
               
                 
                   
                     
                       
                         
                           
                             
                               ( 
                               
                                 σ 
                                 2 
                               
                               ) 
                             
                             
                               ( 
                               
                                 k 
                                 + 
                                 1 
                               
                               ) 
                             
                           
                           = 
                           
                             
                               
                                  
                                 
                                   y 
                                   - 
                                   
                                     Φ 
                                      
                                     
                                         
                                     
                                      
                                     u 
                                   
                                 
                                  
                               
                               2 
                             
                             
                               FL 
                               - 
                               
                                 
                                   ∑ 
                                   
                                     n 
                                     = 
                                     1 
                                   
                                   N 
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   ζ 
                                   n 
                                 
                               
                             
                           
                         
                         ; 
                       
                     
                   
                 
               
               
                   
               
               
                 Remove F columns of Φ with indices between (n − 1) × F + 1  
               
               
                 and n × F, if corresponding γ n  ≦           ; 
               
               
                 Until (convergence) 
               
               
                 a = u; 
               
               
                 {circumflex over (σ)} 2  = (σ 2 ) (k) ; 
               
               
                   
               
             
          
         
       
     
         [0097]    If the mode spectrum correlation is not considered, the correlation matrix can simply be imposed to be an identity matrix, i.e., Σ n =I. In this case, the learning step of Σ in the Corr-SBL method can be skipped and, by exploiting the multiple measurement structure, the implementation of the broadband SBL method can be further simplified from the LF×NF dimension to the L×N dimension. As a result, the broadband SBL method can be operated in a much faster way than the Corr-SBL method, which may be favored in applications where the computational efficiency is a high priority. 
         [0098]    Correspondingly, the FP and EM iterations for updating the hyperparameters and the noise variance are employed for the broadband SBL method. Specifically, the SBL-FP method is summarized in the following two steps: 
         [0099]    1. The MMSE Estimate of a(ω): 
         [0000]        a (ω)=(Φ H (ω)Φ(ω)+σ 2  Γ −1 ) −1  Φ H (ω) y (ω), ω ∈ Ω,   (56)
 
         [0100]    2. The FP Iteration of (γ, σ 2 ): 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       γ 
                       ^ 
                     
                     i 
                     new 
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           f 
                           = 
                           1 
                         
                         F 
                       
                        
                       
                           
                       
                        
                       
                         
                            
                           
                             
                               u 
                               i 
                             
                              
                             
                               ( 
                               
                                 ω 
                                 f 
                               
                               ) 
                             
                           
                            
                         
                         2 
                       
                     
                     
                       
                         ∑ 
                         
                           ω 
                           f 
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           ζ 
                           i 
                         
                          
                         
                           ( 
                           
                             ω 
                             f 
                           
                           ) 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   57 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       ( 
                       
                         
                           σ 
                           ^ 
                         
                         2 
                       
                       ) 
                     
                     new 
                   
                   = 
                   
                     
                       
                         
                           ∑ 
                           
                             f 
                             = 
                             1 
                           
                           F 
                         
                          
                         
                             
                         
                          
                         
                           
                              
                             
                               
                                 y 
                                  
                                 
                                   ( 
                                   
                                     ω 
                                     f 
                                   
                                   ) 
                                 
                               
                               - 
                               
                                 
                                   Φ 
                                    
                                   
                                     ( 
                                     
                                       ω 
                                       f 
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   u 
                                    
                                   
                                     ( 
                                     
                                       ω 
                                       f 
                                     
                                     ) 
                                   
                                 
                               
                             
                              
                           
                           2 
                         
                       
                       
                         FL 
                         - 
                         
                           
                             ∑ 
                             
                               f 
                               = 
                               1 
                             
                             F 
                           
                            
                           
                               
                           
                            
                           
                             
                               ∑ 
                               
                                 i 
                                 = 
                                 1 
                               
                               N 
                             
                              
                             
                                 
                             
                              
                             
                               
                                 ζ 
                                 i 
                               
                                
                               
                                 ( 
                                 
                                   ω 
                                   f 
                                 
                                 ) 
                               
                             
                           
                         
                       
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   58 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where 
         [0000]        u (ω)=σ −2  Σ a(ω)  Φ H (ω) y (ω),   (59)
 
         [0000]      Σ a(ω) =(σ −2  Φ H (ω)Φ(ω)+Γ −1 ) −1 ,   (60)
 
         [0000]      ζ i (ω)=1−γ i   −1  Σ a(ω)   ii ,   (61)
 
         [0000]    are computed with γ old  and ({circumflex over (σ)} 2 ) old  from the previous iteration. 
         [0101]    Similarly, the SBL-EM method is implemented as follows: 
         [0102]    1. The MMSE Estimate of a(ω): 
         [0000]        a (ω)=(Φ H (ω)Φ(ω)+σ 2  Γ −1 ) −1  Φ H (ω) y (ω), ω ∈ Ω,   (62)
 
         [0103]    2. The EM Iteration of (γ, σ 2 ): 
         [0000]    
       
         
           
             
               
                 
                   
                       
                   
                    
                   
                     
                       
                         
                           ( 
                           
                             γ 
                             i 
                           
                           ) 
                         
                         new 
                       
                       = 
                       
                         
                           
                             ∑ 
                             f 
                           
                            
                           
                               
                           
                            
                           
                             ( 
                             
                               
                                 ∑ 
                                 
                                   a 
                                    
                                   
                                     ( 
                                     
                                       ω 
                                       f 
                                     
                                     ) 
                                   
                                 
                                 ii 
                               
                                
                               
                                 + 
                                 
                                   
                                      
                                     
                                       
                                         u 
                                         i 
                                       
                                        
                                       
                                         ( 
                                         
                                           ω 
                                           f 
                                         
                                         ) 
                                       
                                     
                                      
                                   
                                   2 
                                 
                               
                             
                             ) 
                           
                         
                         F 
                       
                     
                     , 
                   
                 
               
               
                 
                   ( 
                   63 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       ( 
                       
                         σ 
                         2 
                       
                       ) 
                     
                     new 
                   
                   = 
                   
                     
                       
                         
                           ∑ 
                           f 
                         
                          
                         
                           [ 
                           
                             
                               
                                 
                                   ( 
                                   
                                     σ 
                                     2 
                                   
                                   ) 
                                 
                                 old 
                               
                                
                               
                                 
                                   ∑ 
                                   
                                     i 
                                     = 
                                     1 
                                   
                                   N 
                                 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     ζ 
                                     i 
                                   
                                    
                                   
                                     ( 
                                     
                                       ω 
                                       f 
                                     
                                     ) 
                                   
                                 
                               
                             
                             + 
                             
                               
                                  
                                 
                                   
                                     y 
                                      
                                     
                                       ( 
                                       ω 
                                       ) 
                                     
                                   
                                   - 
                                   
                                     
                                       Φ 
                                        
                                       
                                         ( 
                                         
                                           ω 
                                           f 
                                         
                                         ) 
                                       
                                     
                                      
                                     
                                       u 
                                        
                                       
                                         ( 
                                         
                                           ω 
                                           f 
                                         
                                         ) 
                                       
                                     
                                   
                                 
                                  
                               
                               2 
                             
                           
                           ] 
                         
                       
                       FL 
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   64 
                   ) 
                 
               
             
           
         
       
     
         [0104]    The above procedure is only for dispersion extraction for a given frequency band. For a global dispersion extraction of borehole acoustic modes, the measurements need to be separated into successive blocks and the SBL algorithm applied to each block. Let Y B =└y(ω 1 ), y(ω 2 ), . . . , y(ω N     F   )┘ represent the frequency-domain measurement over a large frequency range of interest, where N F  is the total number of measurements. The matrix Y B  is then divided into consecutive blocks with individual length F d , where d=1, 2, . . . , D with D denoting the number of blocks over the frequency range [ω 1 , ω N     F   ]. 
         [0105]    Assuming η d+1  ∈ [0,1) is the overlapping ratio between the d-th and (d+1)-th blocks, the number of overlapping measurements is N s =└η d+1 F d−1 ┘, where d=1, 2, . . . , D−1. In the case of non-overlapping blocks with equal length, {η d } d=1   D-1 =0, {F d } d=1   D =F, and D=┌N F /F┐. The divided blocks are then denoted as {Y d } d=1   D  ∈ C L×F     d   . An illustration of the block separation is given in  FIG. 5 , where the array data in the frequency domain are divided into several overlapping blocks with equal length. The overlapping data between two consecutive blocks are denoted by dashed brackets. 
         [0106]    In the following, two workflow procedures are elaborated, i.e., the global workflow and the local workflow, in order to extract the dispersion of borehole acoustic modes over the whole frequency range of interest. 
         [0107]    In some embodiments the global workflow may be used if the non-overlapping ratio η is relatively small and the computational complexity is a higher priority. In this scenario, a suggestion is to first construct the local fitness function over each block and overlying the local fitness functions of two consecutive blocks on the overlapping portion for a global fitness function. The global fitness function displays the estimated mode spectrum amplitude over the slowness-frequency domain and provides a qualitative assessment on the dispersion extraction. For a quantitative dispersion extraction, one can simply apply a standard peak finding over the global fitness function and obtain the slowness estimation over various acoustic modes. 
         [0108]    One step is the construction of the local fitness function over each block based on the estimated phase and group slowness pairs. The non-zero rows are located in the estimated amplitude matrix A, the corresponding phase and group slowness pairs are obtained, see  FIG. 7B . For example, if the norm of the n-th row of A is greater than zero, the corresponding phase and group slowness pair (ŝ i , ĝ j ) are given by (15). Then we map the n-th coordinate pair (ŝ i , ĝ j ) back to a dispersion curve ŝ n (ω) in the slowness-frequency domain with the help of 
         [0000]        ŝ   n (ω)= ŝ   i   +ĝ   j (1−ω 0 /ω), ω ∈ Ω.   (65)
 
         [0000]    which is the same as (5) but with the estimated (ŝ i , ĝ j ). As illustrated in  FIG. 6B , the coordinates of active bases are projected back to different dispersion trajectories in the slowness-frequency domain based on the relationship in (65). Finally, the magnitude of the n-th row of A is used as the spectrum intensity along the dispersion trajectories. 
         [0109]    The global workflow of the SBL method for broadband dispersion extraction is summarized in  FIG. 8 . The initialization step refers to the selection of algorithm parameters including the number of measurement vectors in one block {F d } d-1   D , the overlapping ratio {η d } d=1   D-1 , and the number of peaks P. Once they are determined, the measurement matrices Y d , d=1, 2, . . . , D, can be determined Another algorithm parameter is the number of peaks P used in the peak finding algorithm. 
         [0110]    In other embodiments, the local workflow may be used if the data blocks are highly overlapped. Compared to the global workflow which uses both the recovered phase and group slownesses, the local workflow relies more heavily on the recovered phase slowness. This is due to the observation that the estimate of group slowness is less accurate than the phase slowness estimate, by inspecting the experimental results as well as the theoretical Cramér-Rao bound. Therefore, for each frequency band, the local workflow explicitly obtains a quantitative estimate of the phase slowness at the center frequency. By stacking the estimated phase slowness at center frequency of each frequency band together, a global estimate of slowness can be obtained. 
         [0111]    The local estimate of phase slowness at the center frequency can be obtained in many ways. For instance, in some embodiments a two-dimensional peak find (or clustering) algorithm can be employed on the recovered A with a preset number of peaks. However, other embodiments may first form a one-dimensional amplitude spectrum over the phase slowness and then apply a one-dimensional peak finding algorithm. The one-dimensional spectrum over the phase slowness is achieved by the following step 
         [0000]    
       
         
           
             
               
                 
                   
                     A 
                      
                     
                       ( 
                       
                         s 
                         i 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         j 
                         = 
                         1 
                       
                       
                         N 
                         g 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                          
                         
                           A 
                           
                             
                               
                                 ( 
                                 
                                   i 
                                   - 
                                   1 
                                 
                                 ) 
                               
                                
                               
                                 N 
                                 g 
                               
                             
                             + 
                             j 
                           
                         
                          
                       
                       2 
                     
                   
                 
               
               
                 
                   ( 
                   66 
                   ) 
                 
               
             
           
         
       
     
         [0000]    where A n  denotes the n-th row of A and P·P 2  is the Euclidean norm of a vector. The above step essentially obtains the recovered energy for each pair of (s i , g j ) by computing the Euclidean norm of each row and then, for a given s i , sums the energy along the group slowness (g j ) domain. Applying the one-dimensional peak finding algorithm to the one-dimensional spectrum A(s i ) gives the estimates of the phase slowness at the center frequency of this frequency band. 
         [0112]    The local workflow of the SBL method is summarized in  FIG. 7 . The initialization is similar to the global workflow by configuring the algorithm parameters. One difference between the global and local workflow is whether the peak finding algorithm is used within each frequency band or over the whole frequency range. 
         [0113]    In this section, simulation results are presented to verify the effectiveness of embodiments of the proposed SBL and Corr-SBL methods for dispersion extraction of borehole acoustic modes. The performance is numerically evaluated by using one synthetic dataset and one field dataset. For each dataset, we compare the proposed SBL method with the industry benchmark matrix-pencil (MP) method and the broadband LASSO method with the KS test (referred to as the LASSO-KS method). 
         [0114]    In one example, synthetic data are generated according to a semi-analytic method. The dataset contains a simulated array data with L=20 receivers. The synthetic waveforms and spectra with SNR=20 dB are shown in  FIGS. 9A and 9B . The SNR is defined as the ratio of the total signal energy to the total noise energy over the whole frequency band. 
         [0115]    In  FIG. 10A , the MP method is applied to the noisy synthetic RZX data with a preset mode number P=4 and a tolerance level tol=40%. It may be seen from  FIG. 10A  that the MP method can estimate the slowness for stronger modes but is unable to deliver the slowness estimates when the signal energy is small. For example, the slownesses of the flexural mode when the frequency is less than 2.5 kHz and when the frequency is in between than 6 kHz and 11 kHz cannot be extracted. Also, the low-frequency ([3,8] kHz) asymptotic of the higher-order flexural mode is not shown in  FIG. 10A . At the same time, spurious slowness estimates due to the noise contribution can be observed in the frequency band between 6 kHz and 8 kHz. The performance of the LASSO-KS method is shown in  FIG. 10B . It is seen that the slowness estimates of the flexural mode and the higher-order flexural mode at low frequency region are not well preserved.  FIGS. 10C and 10D  give the slowness estimates by the proposed SBL-FP method together with the global and local workflow procedures with a preset mode number P=4, respectively, while  FIGS. 10E and 10F  show the slowness estimates by the broadband Corr-SBL methods with the two workflows (The SBL-EM method gives similar performance with more computation time and, hence, it is skipped here.). The algorithm parameters for the SBL-FP method include {F d } d-1   D =7 (i.e., the data blocks have the same length) and a uniform overlapping ratio {η d } d=1   D-1 =0.8333. These parameters give the bandwidth of each frequency band 2ω B =1.1070 kHz since the frequency resolution for this dataset is Δf=0.1845 kHz. The results from the global and local workflow procedures are similar; i.e., a better capability to estimate the slowness for the flexural mode at a large frequency range, the full recovery of the low-frequency slowness of the higher-order flexural mode, robustness against the spurious estimates, and the smooth dispersion extraction with less variation of the slowness estimates. Moreover, the extracted slownesses of the flexural mode and higher-order flexural mode at the low frequency range agree well with the true shear slowness around 105 us/ft. 
         [0116]    In yet another example, a more noisy scenario is considered in order to test the robustness of embodiments of the evaluated methods.  FIGS. 11A and 11B  show the waveforms and the spectra of the synthetic dataset when SNR=0 dB. As shown in  FIG. 12A , the performance degradation of the MP method can be seen. In this strong noise case, the MP method almost fails to identify the entire flexural mode and only presents scattered slowness estimates at the frequency range from 3 kHz to 5 kHz. Similar effects can be observed for the higher-order flexural mode. With SNR=0 dB, the LASSO-KS method shown in  FIG. 12B  suffers from dense spurious estimates when the preset mode number is still set to P=4, which smears the estimates of the true modes. The performance degradation of the LASSO-KS method is largely contributed to the incorrect determination of the regularization parameter from the KS test which may not be robust in low SNR case. In comparison, embodiments of the proposed SBL and Corr-SBL methods with P=4, shown in  FIGS. 12C-12F , provide relatively cleaner dispersion extraction with the ability to estimate the flexural mode with a larger frequency range and less variation. It may be observed that in the strong noise case, the local workflow may be able to provide some spurious estimates of slowness around the shear slowness at 105 us/ft in  FIG. 12C  that may not be observed with the global workflow. This may be attributed to the reduced accuracy of the group slowness estimate based on the global workflow at low SNR, while the local workflow only uses the phase slowness at the center frequency for the dispersion estimation. 
         [0117]    In yet another example, embodiments of this disclosure are presented with the dispersion extraction results from a frame of field data obtained with a logging while drilling (LWD) sonic tool. As shown in  FIG. 13A , the LWD dipole waveforms were recorded from 12 receivers. 
         [0118]    The MP method with P=4 and tol=40% is first applied to the dipole waveforms and the result is shown in  FIG. 13A . As shown in  FIG. 13A , the extracted slowness estimates are scattered at the low frequency region, and the identification of the high-order flexural model may appear to be difficult. For embodiments of the proposed SBL-FP method, the algorithm parameters are set to {F d } d-1   D =9, {η d } d=1   D 1 =0.8889 and P=2. These parameters result in the bandwidth of each frequency band 2ω B =1.0417 kHz.  FIGS. 13C-13F  show the dispersion extraction by the SBL and Corr-SBL methods with the global and local workflow procedures, respectively. Compared with the MP method, the SBL and Corr-SBL methods provide more robust slowness estimates of the three acoustic modes (tool flexural, formation flexural, and high-order flexural modes) with less fluctuation from one frequency to another. Particularly, embodiments of the SBL and Corr-SBL methods provide relatively improved slowness estimates at low frequency points for both the tool and formation flexural modes. Moreover, embodiments of the SBL and Corr-SBL methods provide additional slowness estimates corresponding to reflector sources. 
         [0119]    Elements of the embodiments have been introduced with either the articles “a” or “an.” The articles are intended to mean that there are one or more of the elements. The terms “including” and “having” are intended to be inclusive such that there may be additional elements other than the elements listed. The term “or” when used with a list of at least two elements is intended to mean any element or combination of elements. 
         [0120]    In view of the above description it will be appreciated that features of the invention may be implemented in computer programs stored on a computer readable medium and run by processors, application specific integrated circuits and other hardware. Moreover, the computer programs and hardware may be distributed across devices including but not limited to tooling which is inserted into the borehole and equipment which is located at the surface, whether onsite or elsewhere. 
         [0121]    Although only a few example embodiments have been described in detail above, those skilled in the art will readily appreciate that many modifications are possible in the example embodiments without materially departing from this disclosure. Accordingly, all such modifications are intended to be included within the scope of this disclosure as defined in the following claims. In the claims, means-plus-function clauses are intended to cover the structures described herein as performing the recited function and not only structural equivalents, but also equivalent structures. Thus, although a nail and a screw may not be structural equivalents in that a nail employs a cylindrical surface to secure wooden parts together, whereas a screw employs a helical surface, in the environment of fastening wooden parts, a nail and a screw may be equivalent structures. It is the express intention of the applicant not to invoke 35 U.S.C. §112, paragraph 6 for any limitations of any of the claims herein, except for those in which the claim expressly uses the words ‘means for’ together with an associated function.