Abstract:
The adaptive superconductive magnetic energy storage (SMES) control method and system control a SMES device connected to a power generation system. A radial basis function neural network (RBFNN) connected to the controller adaptively adjusts gain constants of the controller. A processor executes an improved particle swarm optimization (IPSO) procedure to train the RBFNN from input-output training data created by the IPSO, and thereafter generate starting weights for the neural network. Tests carried out show that the proposed adaptive SMES controller maintains the DC capacitor voltage constant, thus improving the efficiency of wind energy transfer. The power output (reactive and real) of the SMES device improves the voltage profile following large voltage dips and provides added damping to the system.

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention relates to energy storage devices, and particularly to an adaptive superconductive magnetic energy storage (SMES) control method and system. 
     2. Description of the Related Art 
     Because of diminishing oil reserves and environmental concerns, renewable energy research is gaining momentum. Wind energy in itself encompasses various engineering fields and is rapidly developing into a multi-disciplinary area of research and experimentation. In wind generation systems, the variable speed, doubly fed induction generator (DFIG) is preferred over the permanent magnet synchronous generator (PMSG) for its versatility. Background details on the various wind turbine systems may be found in U.S. patent Publication Ser. No. 13/862,327, filed on Apr. 12, 2013, which is incorporated by reference in its entirety herein. The &#39;327 patent application and the present patent application have a common inventor, Abu Hamed Abdur-Rahim. 
     The control of energy storage devices fed by the aforementioned wind turbines is necessary, since by controlling the energy storage device, power that flows to the grid can be adjusted. The system dynamics relied upon in some installations use a PI (proportional-integral) controller. Many installations use Fuzzy logic to find the energy storage device controller parameters. A self-tuning fuzzy PID (proportional-integral-derivative) controller has been described in the related art. Robust controllers for output power leveling of energy storage systems are also available in the literature. The use of generalized predictive control has also been reported. Moreover, the literature reports a neural network capable of self-tuning for different operating conditions. 
     An energy storage device gaining increasing popularity is the superconductive magnetic energy storage (SMES) device. The SMES is a device that can deliver both real and reactive power, and hence provides good damping to a PMSG system. 
     SMES has found widespread application in power systems. However, studies on application of this powerful energy storage device in PMSG wind generator systems are virtually missing. Because of the erratic nature of wind speed variations, this storage device, which can compensate for both real and reactive power, is expected to be a useful control tool. 
     Wind turbulence and grid faults are the main concerns in a PMSG wind turbine system. Because of them, systems are not able to meet the active and reactive power demand during these faults. Energy storage devices may improve wind system performance by providing active power to the system at the time of contingencies. Variable speed wind generators integrated with an energy storage system are getting attention in recent times. 
     Thus, an adaptive superconductive magnetic energy storage (SMES) control method and system solving the aforementioned problems is desired. 
     SUMMARY OF THE INVENTION 
     The adaptive superconductive magnetic energy storage (SMES) control method and system involves generating starting weights for a neural network by training the network from input-output data created by an improved particle swarm optimization (IPSO) procedure. Tests carried out show that the proposed adaptive SMES controller maintains the DC capacitor voltage constant, thus improving the efficiency of wind energy transfer. The power output (reactive and real) of the SMES improves the voltage profile following large voltage dips, and at the same time, provides added damping to the system. 
     These and other features of the present invention will become readily apparent upon further review of the following specification and drawings. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  is a schematic diagram showing an adaptive SMES control system according to the present invention. 
         FIG. 2  is a perspective view of a superconductive magnetic energy storage (SMES) device. 
         FIG. 3  is a schematic diagram of a SMES and its controller. 
         FIG. 4  is a schematic diagram of an adaptive SMES control system according to the present invention. 
         FIG. 5  is a schematic diagram of a SMES on the grid side section of the system. 
         FIG. 6  is a schematic diagram of active power of an adaptive SMES control system according to the present invention. 
         FIG. 7  is a schematic diagram of reactive power of an adaptive SMES control system according to the present invention. 
         FIG. 8  is a flowchart of an ISO algorithm used in an adaptive SMES control system according to the present invention. 
         FIG. 9  is a flowchart of an RBFNN learning algorithm used in an adaptive SMES control system according to the present invention. 
         FIG. 10  is a plot showing a Gaussian function used for neuron activation used in an adaptive SMES control system according to the present invention. 
         FIG. 11  is a diagram showing the processing of signals by the adaptive RBFNN in an adaptive SMES control system according to the present invention. 
         FIG. 12  is a block diagram of a PMSG having an adaptive SMES control system according to the present invention. 
         FIG. 13  is a plot showing the cost as a function of iterations in an adaptive SMES control system according to the present invention. 
         FIG. 14  is a plot showing MSE convergence of RBFNN according to the present invention. 
         FIG. 15  is a plot showing difference between an adaptive-tuned SMES controller and no SMES. 
     
    
    
     Similar reference characters denote corresponding features consistently throughout the attached drawings. 
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     At the outset, it should be understood by one of ordinary skill in the art that embodiments of the present method can comprise software or firmware code executing on a computer, a microcontroller, a microprocessor, or a DSP processor; state machines implemented in application specific or programmable logic; or numerous other forms without departing from the spirit and scope of the method described herein. The present method can be provided as a computer program, which includes a non-transitory machine-readable medium having stored thereon instructions that can be used to program a computer (or other electronic devices) to perform a process according to the method. The machine-readable medium can include, but is not limited to, floppy diskettes, optical disks, CD-ROMs, and magneto-optical disks, ROMs, RAMs, EPROMs, EEPROMs, magnetic or optical cards, flash memory, or other type of media or machine-readable medium suitable for storing electronic instructions, but excludes intangible media or transient waveforms or signals. 
     A superconductive magnetic energy storage (SMES) device stores energy in the form of a magnetic field, which is generated by the flow of DC current in a coil. This coil is cryogenically cooled. This technology has been used to improve the power quality of the industries. SMES technology uses a superconducting coil, which is virtually free from electrical resistance. If a SMES were to use conventional wire, such as copper, at non-superconducting temperatures, the magnetic energy would be dissipated as heat due to the wire&#39;s resistance to the flow of current. An exemplary SMES device  102  is shown in  FIG. 2 . Although superconductivity was discovered in 1911, SMES has been under study for electric utility energy storage application since the early 1970s. Because of the fast response, SMES can provide load-following, system stability, and automatic generation control, can be used as a spinning reserve, or for bulk energy management, dynamic voltage stability, tie line control, power quality improvement, a backup power supply, and minimization of power and voltage fluctuations of a wind generator. The other major advantage of SMES is that it can deliver a large amount of energy in a very small duration of time. 
     In the present system, as shown in  FIG. 12 , a controller  2104  is connected to control the SMES  102  of a SMES-equipped permanent magnet synchronous generator (PMSG) power generation system  1200 . A generator power sensor  1204  output combines with a generator reference power signal  1206 , wherein their difference provides a generator power control signal ΔP PG . The output of a generator bus voltage sensor  1202  combines with a generator bus reference voltage  414 , wherein their difference provides a generator voltage control signal ΔV G . 
     As shown in  FIG. 4 , the control methodology  400  includes a radial basis function neural network (RBFNN)  412  connected to the SMES controller  2104  to adaptively adjust gain constants of the SMES controller  2104 . A processor running an adaptive algorithm  410  executes an improved particle swarm optimization (IPSO) procedure to train the RBFNN  412  from input-output training data created by the IPSO, and thereafter generates starting weights for the RBFNN  412 . As most clearly shown in  FIG. 4 , a generator reference power and voltage (P go ,V go ) are fed to a summation unit  406 . 
     The SMES-equipped generic power generation system  404  sends a measurement of the actual power and voltage (P g , V g ) to the summation unit  406  so that the summation unit can provide error power and voltage signals (ΔP g , ΔV g ) to the input of the SMES controller  2104 , which outputs corrective real power and reactive power signals (ΔP SM , ΔQ SM ) to the SMES of system  404 . The system  404  outputs a y performance measurement to a second summation unit  408 . The y performance measurement is summed with an RBFNN reference parameter, r, to generate an error signal e a , which is fed as an input to the adaptive algorithm  410 . This error signal, e a , is used by the RBFNN  412  to update its weights. Once a weight update has been performed by the RBFNN  412 , the RBFNN outputs a new set of gain and time constants (K PG , K VG , T PG , T PVG ) to the SMES controller  2104 . 
     As shown in  FIG. 11 , the structure of the RBFNN  412  includes a plurality of input layer neurons accepting a corresponding plurality of inputs, I 1 , I 2 , . . . , I j  . . . , I h . The input layer then feeds a hidden layer, which, in turn, feeds an output layer. An error e a (i) between the output y a  and a desired output r(i) is fed to a weights updater  1100 , which adaptively updates weights of the RBFN  412  to minimize the error e a (i). The RBFNN  412  is used to tune the parameters of the SMES controller to keep the system stable in case of any disturbance, and it is adjusted according to the error between the input and output in its loop. The aim of the adaptive strategy is to make the SMES controller a more powerful reference to different contingencies or different loading conditions. In case of disturbance, the adaptive SMES controller, based on the RBFNN, will take effect more successfully. This approach not only ensures the power generation system performance and robustness of the system, but also improves online tuning for the SMES controller parameters at different contingencies. 
     Recently, the RBFNN has been widely used to model and approximate non-linear functions. Here a RBFNN is employed to model the relationship between the input variable, I p , and the system control, u. The weightings between hidden layer neurons and output layer neurons are adjusted based on an adaptive rule. In the present method, an RBFNN-based controller  412  is proposed by an adaptive rule. The control input of the RBFNN controller  412  is: 
     
       
         
           
             
               
                 
                   u 
                   = 
                   
                     
                       ∑ 
                       
                         j 
                         = 
                         1 
                       
                       N 
                     
                     ⁢ 
                     
                       
                         w 
                         j 
                       
                       ⁢ 
                       
                         
                           exp 
                           ⁡ 
                           
                             ( 
                             
                               
                                 - 
                                 
                                   
                                      
                                     
                                       I 
                                       - 
                                       
                                         c 
                                         j 
                                       
                                     
                                      
                                   
                                   2 
                                 
                               
                               
                                 β 
                                 j 
                                 2 
                               
                             
                             ) 
                           
                         
                         . 
                       
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
     The adaptive rule is used to adjust the weightings for searching the optimal weighting values and obtaining the stable convergence property. The adaptive rule is derived from the steepest descent rule to minimize the value of e a  with respect to w j . Then, the updated equation of the weighting parameters is:
 
 w   jnew   =w   jold   +w   j ( t+ 1),  (2)
 
where w j  (t+1) is the predicted value of the weight vector, w jold  is the present value of the weight vector, and w jnew  is the new value of the weight vector. Also,
 
                       w   j     ⁡     (     t   +   1     )       =       -   η     ⁢       ∂       (       e   a     ⁡     (   t   )       )     2         ∂       w   j     ⁡     (   t   )                     (   3   )               
and
 
 e   a ( t )= r ( t )− y ( t )  (4)
 
where r(t) is the summation of the output of the RBFNN model, y(t) is the output generated by the system, k=1, 2, 3 . . . m; and η is the regulation factor. The error e a  is a linear difference between r and y used to update the weights vector.
 
     Based on the chain rule, equation (3) can be rewritten as: 
     
       
         
           
             
               
                 
                   
                     
                       w 
                       j 
                     
                     ⁡ 
                     
                       ( 
                       
                         t 
                         + 
                         1 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         - 
                         η 
                       
                       ⁢ 
                       
                         
                           ∂ 
                           
                             
                               ( 
                               
                                 
                                   e 
                                   a 
                                 
                                 ⁡ 
                                 
                                   ( 
                                   t 
                                   ) 
                                 
                               
                               ) 
                             
                             2 
                           
                         
                         
                           ∂ 
                           
                             u 
                             ⁡ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                       
                       ⁢ 
                       
                         
                           ∂ 
                           
                             u 
                             ⁡ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                         
                           ∂ 
                           
                             
                               w 
                               j 
                             
                             ⁡ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                       
                     
                     = 
                     
                       ρ 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       
                         
                           e 
                           a 
                         
                         ⁡ 
                         
                           ( 
                           t 
                           ) 
                         
                       
                       ⁢ 
                       
                         
                           ∂ 
                           
                             u 
                             ⁡ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                         
                           ∂ 
                           
                             
                               w 
                               j 
                             
                             ⁡ 
                             
                               ( 
                               t 
                               ) 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
                       w   j     ⁡     (     t   +   1     )       =       ρ   ⁢           ⁢       e   a     ⁡     (   t   )       ⁢     exp   ⁡     (       -            x   -     c   j            2         β   j   2       )         =     ρ   ⁢           ⁢       e   a     ⁡     (   t   )       ⁢     ϕ   j                 (   6   )               
where ρ is the learning rate parameter. The overall weights of the network which will be updated by using an adaptive RBFNN algorithm are:
 
 w   1new   =w   1old   +w   1 ( t+ 1)  (7)
 
 w   mnew   =w   mold   +w   m ( t+ 1).  (8)
 
     The adaptive control scheme, as presented in  FIG. 4 , utilizes an adaptive strategy, which is used to extract adaptive SMES controller parameters in different contingencies. The input vector contains generator current, generator angle, generator speed, DC-link capacitor voltage, the inverter current, generator power, and terminal voltage. This data set is used as input to the RBFNN for training. The output data set contains SMES controller parameters (K pg , K vg , T pg  and T vg ), which are obtained by applying the IPSO algorithm. When the network is trained, the weight vector of the RBFNN is fixed. The present algorithm uses the RBFNN trained network as a reference model. 
     As shown in  FIG. 4 , the SMES controller provides the appropriate signal of ΔP SM  and ΔQ SM  to the system to compensate the power. In order to calculate the adaptive parameters of the SMES controller, the adaptive RBFNN output, y a , should be driven to as close as possible to the desired output r specified by the reference model. The error, e a (t), between the reference model and the output is generated by the system to adjust the weights of the RBFNN. The adaptive algorithm will allow the weights update between the hidden layer and the output layer using equation (7). When the system faces a disturbance in terms of wind speed change or other type of disturbance, system parameters, such as generator current, generator angle, generator speed, DC-link capacitor voltage, the inverter current, generator power, and terminal voltage, vary according to the disturbance. The reference model generates the new optimum values of K pg , K vg , T pg  and T vg . By setting the new values of K pg , K vg , T pg  and T vg  as the targets, the predicted value of weights of the adaptive RBFNN is calculated using equations (3)-(6). After updating the weights, new values of SMES controller parameters are applied to the system for calculating the real and the reactive powers of SMES according to the demand. 
     As shown in  FIG. 1 , the permanent magnet synchronous generator (PMSG)  100  is connected to the power grid via a full-scale, back-to-back conversion assembly through a DC link capacitor. It should be understood that the wind turbine shaft is directly coupled to the generator rotor of the PMSG  100 . The generator side and the grid side back-to-back converters are connected to each other through a DC link capacitor  110 . The superconducting magnetic energy storage (SMES) device  102  is connected at the inverter terminal, along with a local load  106 . The inverter terminal is connected to the transmission line through a step-up transformer. The system dynamic model includes PMSG  100 , wind turbine, the converters  104 , SMES  102 , the load, and the transmission line. The SMES controller  2104  takes into account a complex model of the PMSG  100  that includes wind turbine, drive train, and converter power electronics (including DC link capacitor  110 , the inverters  104 , the SMES  102 , and grid side converter currents). The linearized state equation (9) results, as follows: 
                     [             Δι   gd     .                 Δι   gq     .               Δδ   .               Δω   .               Δ   ⁢       θ   .     z                 Δ   ⁢       ω   .     t                 Δ   ⁢       V   .     c                   Δι   id     .                 Δ   ⁢           ⁢     ι   iq       .                 Δ   ⁢           ⁢     I   dc       .               Δ   ⁢       P   .     SM                 Δ   ⁢       Q   .     SM             ]     =       [           a     1   ,   1             a     1   ,   2             a     1   ,   3             a     1   ,   4           0       0         a     1   ,   7           0       0       0       0       0             a     2   ,   1             a     2   ,   2             a     2   ,   3             a     2   ,   4           0       0         a     2   ,   7           0       0       0       0       0           0       0       0         a     3   ,   4           0       0       0       0       0       0       0       0             a     4   ,   1             a     4   ,   2             a     4   ,   3             a     4   ,   4             a     4   ,   5           0         a     4   ,   7           0       0       0       0       0           0       0       0         a     5   ,   4           0         a     5   ,   6           0       0       0       0       0       0           0       0       0       0         a     6   ,   5             a     6   ,   6           0       0       0       0       0       0             a     7   ,   1             a     7   ,   2             a     7   ,   3           0       0       0         a     7   ,   7             a     7   ,   8             a     7   ,   9           0       0       0           0       0       0         a     8   ,   4           0       0         a     8   ,   7             a     8   ,   8             a     8   ,   9             a     8   ,   10             a     8   ,   11             a     8   ,   12               0       0       0         a     9   ,   4           0       0         a     9   ,   7             a     9   ,   8             a     9   ,   9             a     9   ,   10             a     9   ,   11             a     9   ,   12               0       0       0       0       0       0       0         a     10   ,   8             a     10   ,   9             a     10   ,   10             a     10   ,   11             a     10   ,   12                 a     11   ,   1             a     11   ,   2             a     11   ,   3           0       0       0         a     11   ,   7           0       0       0         a     11   ,   11           0           0       0         a     12   ,   3           0       0       0         a     12   ,   7           0       0       0       0         a     12   ,   12             ]     ⁡     [           Δ   ⁢           ⁢     i   gd                 Δ   ⁢           ⁢     i   gq               Δδ             Δ   ⁢           ⁢   ω               Δ   ⁢           ⁢     θ   z                 Δ   ⁢           ⁢     ω   t                 Δ   ⁢           ⁢     V   c                 Δ   ⁢           ⁢     i   id                 Δ   ⁢           ⁢     i   iq                 Δ   ⁢           ⁢     I   dc                 Δ   ⁢           ⁢     P   SM                 Δ   ⁢           ⁢     Q   SM             ]               (   9   )               
where Δi gd  is the generator real current (d-axis current), Δd gq  is the generator quadrature current (q-axis current), Δδ is the generator phase angle, Δω is the generator speed, Δθ z  is the torsional twist angle of the generator shaft, Δω t  is the (wind) turbine speed, ΔV c  is the DC link capacitor voltage, Δi id  is the inverter side d-axis current, Δi iq  is the inverter side q-axis current, ΔI dc  is the total DC current available from the SMES to an external AC bus, ΔP SM  is the real power available from the SMES, and ΔQ SM  is the reactive power available from the SMES.
 
     The SMES is capable of supplying both real and reactive power by adjusting the firing angle and the modulation index of its converter. The assumptions made in modeling are: (1) the superconducting coil resistance is zero because of heat dissipation; (2) it has a large inductance because of the high amount of energy storage; (3) the voltage drop in the converter is small; and (4) the harmonic power generated in the converter is also negligible. As shown in  FIG. 3 , the basic SMES/controller unit circuit includes a superconductive coil (SC) and an AC-to-DC power converter, which is voltage source converter (VSC)  104 . DC link capacitor  110  couples the SC coil circuit, comprising a pair of diodes and an insulated gate bipolar transistor (IGBT), to the VSC  104 . The voltage source converter  104  converts the DC current of the superconductive coil to AC current compatible with an external AC bus. The power supply can be properly controlled by tuning both the modulation index (M SM ) and the phase angle (α sm ) of the VSC  104 . The values of the modulation index and the phase angle are computed from the demanded real power and demanded reactive power. The block diagram  600  of  FIG. 6  shows active power of the SMES, including gain and the time constant of the active power transfer function. Similarly, the block diagram  700  of  FIG. 7  shows the reactive power of the SMES, including the gain and the time constant of the reactive power transfer function. Using the inputs and the real and reactive power outputs and the transfer functions illustrated in  FIGS. 6 and 7 , P SM  and Q SM , the VSC modulation index is: 
                       M   SM     =           P   SM   2     +     Q   SM   2             V   t     ⁢     I     d   ⁢           ⁢   c             ,           (   10   )               
and
 
     
       
         
           
             
               
                 
                   
                     α 
                     
                       S 
                       ⁢ 
                       
                           
                       
                       ⁢ 
                       M 
                     
                   
                   = 
                   
                     
                       
                         tan 
                         
                           - 
                           1 
                         
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             Q 
                             
                               S 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               M 
                             
                           
                           
                             P 
                             
                               S 
                               ⁢ 
                               
                                   
                               
                               ⁢ 
                               M 
                             
                           
                         
                         ) 
                       
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
           
         
       
     
     The complete system model, written as:
 
 {dot over (X)}=f[x,u],   (12)
 
is extracted from the complex model of the PMSG  100  that includes the wind turbine, drive train, and the converter power electronics (including DC link capacitor  110 , the inverters  104 , the SMES  102 , and grid side converter currents), where X=f[i gd , i gq , δ, ω, θ z , ω t , V c , i id , i iq I dc P SM , Q SM ] and u=f[K pg , K vg , T pg , T vg ], where u shows the SMES controller parameters. For proper function of the SMES controller these parameters need to be adaptively tuned.  FIG. 5  shows grid side section  500  of the SMES  102  connected to local load  106 . The modulation index M SM  and the phase angle α SM  inputs to the SMES  102  are also shown in  FIG. 1  as control input  108 .
 
     With respect to the improved particle swarm optimization (IPSO), each particle shows a candidate solution to the optimization problem. Each particle has its own direction and velocity in the search space. These movements of the particles are controlled by the best position in a search area and position a particle has visited. In this proposed improved particle swarm optimization, each particle updates its velocity and position by updating the inertia weight (w). Each particle modifies its velocity and position using the best solution among the particles achieved and gbest (global best) of neighborhood particles. It is the same instance in the social society where the better decisions could be made by the group of leaders. However, in standard PSO, only a gbest of neighborhood particles is employed. By contrast, this process uses some neighborhood particles that can be called ‘intensifying’ and ‘enhancing’ the social influence. Based on this technique, these particles should be intensified, which could lead individuals to better fitness. 
     For the evaluation of each particle, an eigenvalue-based objective function will be used. Initially, the population is generated stochastically and referred to as a search space. 
     The IPSO uses a population of N particles, which is the dimension of the search space. The position of the particle is represented as:
 
 x   i ( k )=[ x   i1 ( k ), x   i2 ( k ), . . . , x   iN ( k )],  (13)
 
where k is the iteration number. By adding velocity, the position of the particles is updated by the following equation:
 
 x   i ( k+ 1)= x   i ( k )+ v   i ( k ).  (14)
 
Each particle has its own search space area and search experience, depending on objective function calculation. In IPSO, mainly two algorithms work, the global best (gbest) and the local best (pbest). Their calculation is dependent on cognitive and social components. The i th  particle velocity in IPSO is calculated as:
 
 v   i ( k+ 1)= v   i ( k )+ c   1 rand 1 ( p   i ( k )− x   i ( k ))+c 2 rand 2 ( p   g ( k )− x   i ( k )).  (15)
 
     The operations rand 1  and rand 2  produce random values, which are uniformly distributed random numbers in the range [0, 1], c 1  and c 2  are the acceleration constant and p g  (k) is the global best position it has visited. The local best state of the particles is written as:
 
 p   i ( k )=[ p   i1 ( k ), p   i2 ( k ), . . . , p   iN ( k )]  (16)
 
The local best position can be updated as:
 
 p   i ( k+ 1)= p   i ( k ) if  J ( x   i ( k+ 1))≧ J ( p   i ( k ))  (17)
 
 p   i ( k+ 1)= x   i ( k+ 1) if  J ( x   i ( k+ 1))&lt; J ( p   i ( k ))  (18)
 
     The objective function J, which is to be minimized, can be calculated as: 
                   J   =       ∑     i   =   1     N     ⁢       (       ϛ   ⁡     (   k   )       -     ϛ   0       )     2               (   19   )               
and
 
                     ϛ   =       -   σ           σ   2     +     γ   2             ,           (   20   )               
where             is the preselected value of damping ratio, σ and γ are the real and imaginary parts of the eigenvalues of the linearized 12×12 matrix of equation (9). The detailed 12×12 matrix components of equation (9) are listed in Table 1. The movement of the particles is predicted by the global best position. The global position in the entire swarm can be defined as:
 
 p   gbest ( k )ε{ p   i1 ( k ), p   i2 ( k ), . . . , p   iN ( k )}| J ( p   gbest ( k ))=min{ p   i1 ( k ), p   i2 ( k ), . . . , p   iN ( k )}.  (21)
 
The velocity of the particle in the local best is calculated as:
 
 v   i ( k+ 1)= v   i ( k )+ c   1 rand 1 ( p   i ( k )− x   i ( k ))+c 2 rand 2 ( p   ilocal best ( k )− x   i ( k )),  (22)
 
where p ilocal best  is the local best position, and p ilocal best  can be defined as:
 
 p   ilocal best ( k+ 1)ε{ N   i   |J ( p   ilocal best ( k ))=min{ J ( x )}}∀ xεN   i   (23)

     
       
         
               
             
               
               
               
             
           
               
                 TABLE 1 
               
               
                   
               
               
                 Linearized 12 × 12 matrix Eqn. (9) state matrix detail 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 a(1,1) = −((ω o X d )/X q ) 
                 a(1,2) = −((ω o R a )/X q ) 
                 a(1,3) = −((ω o /X d )m gco V co  cos δ o ) 
               
               
                 a(1,4) = ((ω o X q )/X d )i gqo   
                 a(1,7) = −((ω o /X d )m gco  sin δ o ) 
                 a(2,1) = −((ω o X d )/X q ) 
               
               
                 a(2,2) = −((ω o R a )/X q ) 
                 a(2,3) = ((ω o m gco V co  sin δ o )/X q ) 
                 a(2,4) = (ω o (E rso  − X d i gdo ))/X q   
               
               
                 a(2,7) = −((ω o m gco  cos δ o )/X q ) 
                 a(3,4) = ω o   
                 a(4,1) = −(m gco V co  sin δ o  + 2i gdo R a )/2H g   
               
               
                 a(4,2) = −(m gco V co  cos δ o  + 2i gqo R a )/X q   
                 a(4,3) = −(v gdo i gdo  − v gqo i gqo )/2H g   
                 a(4,4) = −D g /2H g   
               
               
                 a(4,5) = −K s /2H g   
                 a(4,7) = 
                 a(5,4) = −ω o   
               
               
                   
                 −(m gco i gdo  sin δ o  + m gco i gqo  cos δ o )/2H g   
                   
               
               
                 a(5,6) = ω o   
                 a(6,5) = −K S /2H t   
                 a(6,6) = −(D t /2H t ) 
               
               
                 a(7,1) = (m gco  sin δ o )/C 
                 a(7,2) = (m gco  cos δ o )/C 
                 a(7,3) = 
               
               
                   
                   
                 (m gco i gdo  cos δ o  − m gco i gpo  sin δ o )/C 
               
               
                   
               
               
                 
                   
                     
                       
                         
                           
                             
                               
                                 a 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     7 
                                     ⁢ 
                                     
                                       , 
                                     
                                     ⁢ 
                                     7 
                                   
                                   ) 
                                 
                               
                               = 
                             
                           
                         
                         
                           
                             
                               
                                 ( 
                                 
                                   
                                     
                                       
                                         
                                           
                                             m 
                                             gco 
                                           
                                           ⁢ 
                                           
                                             i 
                                             gdo 
                                           
                                           ⁢ 
                                           sin 
                                           ⁢ 
                                           
                                               
                                           
                                           ⁢ 
                                           
                                             δ 
                                             o 
                                           
                                         
                                         + 
                                         
                                           
                                             m 
                                             gco 
                                           
                                           ⁢ 
                                           
                                             i 
                                             gqo 
                                           
                                           ⁢ 
                                           cos 
                                           ⁢ 
                                           
                                               
                                           
                                           ⁢ 
                                           
                                             δ 
                                             o 
                                           
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         
                                           
                                             m 
                                             ico 
                                           
                                           ⁢ 
                                           
                                             i 
                                             ido 
                                           
                                           ⁢ 
                                           cos 
                                           ⁢ 
                                           
                                               
                                           
                                           ⁢ 
                                           
                                             α 
                                             ico 
                                           
                                         
                                         - 
                                         
                                           
                                             m 
                                             ico 
                                           
                                           ⁢ 
                                           
                                             i 
                                             iqo 
                                           
                                           ⁢ 
                                           sin 
                                           ⁢ 
                                           
                                               
                                           
                                           ⁢ 
                                           
                                             α 
                                             ico 
                                           
                                         
                                       
                                     
                                   
                                 
                                 ) 
                               
                               / 
                               C 
                             
                           
                         
                       
                     
                   
                 
                 a(7,8) = (m ico  cos α ico )/C 
                 a(7,9) = (m ico  sin α ico )/C 
               
               
                   
               
               
                 a(8,4) = T 38   
                 a(8,7) = T 39   
                 a(8,8) = T 53   
               
               
                 a(8,9) = T 54   
                 a(8,10) = T 55   
                 a(8,11) = T 56   
               
               
                 a(8,12) = T 57   
                 a(9,4) = T 40   
                 a(9,7) = T 41   
               
               
                 a(9,8) = T 58   
                 a(9,9) = T 59   
                 a(9,10) = T 60   
               
               
                 a(9,11) = T 61   
                 a(9,12) = T 62   
                 a(10,8) = T 63   
               
               
                 a(10,9) = T 64   
                 a(10,10) = T 65   
                 a(10,11) = T 66   
               
               
                 a(10,12) = T 67   
                 a(11,1) = 
                 a(11,2) = 
               
               
                   
                 −(K PG (m gco V co  sin δ o  + 2i gdo R a ))/T PG   
                 −(K PG (m gco V co  cos δ o  + 2i gqo R a ))/T PG   
               
               
                   
               
               
                 
                   
                     
                       
                         
                           
                             
                               
                                 a 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     11 
                                     ⁢ 
                                     
                                       , 
                                     
                                     ⁢ 
                                     3 
                                   
                                   ) 
                                 
                               
                               = 
                             
                           
                         
                         
                           
                             
                               
                                 - 
                                 
                                   ( 
                                   
                                     
                                       K 
                                       PG 
                                     
                                     ⁡ 
                                     
                                       ( 
                                       
                                         
                                           
                                             
                                               
                                                 
                                                   m 
                                                   gco 
                                                 
                                                 ⁢ 
                                                 
                                                   V 
                                                   co 
                                                 
                                                 ⁢ 
                                                 
                                                   i 
                                                   gdo 
                                                 
                                                 ⁢ 
                                                 cos 
                                                 ⁢ 
                                                 
                                                     
                                                 
                                                 ⁢ 
                                                 
                                                   δ 
                                                   o 
                                                 
                                               
                                               - 
                                             
                                           
                                         
                                         
                                           
                                             
                                               
                                                 m 
                                                 gco 
                                               
                                               ⁢ 
                                               
                                                 V 
                                                 co 
                                               
                                               ⁢ 
                                               
                                                 i 
                                                 gqo 
                                               
                                               ⁢ 
                                               sin 
                                               ⁢ 
                                               
                                                   
                                               
                                               ⁢ 
                                               
                                                 δ 
                                                 o 
                                               
                                             
                                           
                                         
                                       
                                       ) 
                                     
                                   
                                   ) 
                                 
                               
                               / 
                               
                                 T 
                                 PG 
                               
                             
                           
                         
                       
                     
                   
                 
                 
                   
                     
                       
                         
                           
                             
                               
                                 a 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     11 
                                     ⁢ 
                                     
                                       , 
                                     
                                     ⁢ 
                                     7 
                                   
                                   ) 
                                 
                               
                               = 
                             
                           
                         
                         
                           
                             
                               
                                 ( 
                                 
                                   
                                     K 
                                     PG 
                                   
                                   ⁡ 
                                   
                                     ( 
                                     
                                       
                                         
                                           
                                             
                                               
                                                 m 
                                                 gco 
                                               
                                               ⁢ 
                                               
                                                 i 
                                                 gdo 
                                               
                                               ⁢ 
                                               sin 
                                               ⁢ 
                                               
                                                   
                                               
                                               ⁢ 
                                               
                                                 δ 
                                                 o 
                                               
                                             
                                             + 
                                           
                                         
                                       
                                       
                                         
                                           
                                             
                                               m 
                                               gco 
                                             
                                             ⁢ 
                                             
                                               i 
                                               gqo 
                                             
                                             ⁢ 
                                             cos 
                                             ⁢ 
                                             
                                                 
                                             
                                             ⁢ 
                                             
                                               δ 
                                               o 
                                             
                                           
                                         
                                       
                                     
                                     ) 
                                   
                                 
                                 ) 
                               
                               / 
                               
                                 T 
                                 PG 
                               
                             
                           
                         
                       
                     
                   
                 
                 a(11,11) = −(1/T PG ) 
               
               
                   
               
               
                 
                   
                     
                       
                         
                           
                             
                               
                                 a 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     12 
                                     ⁢ 
                                     
                                       , 
                                     
                                     ⁢ 
                                     3 
                                   
                                   ) 
                                 
                               
                               = 
                             
                           
                         
                         
                           
                             
                               
                                 
                                   - 
                                   
                                     ( 
                                     
                                       
                                         K 
                                         VG 
                                       
                                       ⁡ 
                                       
                                         ( 
                                         
                                           
                                             
                                               
                                                 
                                                   
                                                     m 
                                                     gco 
                                                   
                                                   ⁢ 
                                                   
                                                     V 
                                                     gdo 
                                                   
                                                   ⁢ 
                                                   
                                                     V 
                                                     co 
                                                   
                                                   ⁢ 
                                                   cos 
                                                   ⁢ 
                                                   
                                                       
                                                   
                                                   ⁢ 
                                                   
                                                     δ 
                                                     o 
                                                   
                                                 
                                                 + 
                                               
                                             
                                           
                                           
                                             
                                               
                                                 
                                                   m 
                                                   gco 
                                                 
                                                 ⁢ 
                                                 
                                                   V 
                                                   gqo 
                                                 
                                                 ⁢ 
                                                 
                                                   V 
                                                   co 
                                                 
                                                 ⁢ 
                                                 sin 
                                                 ⁢ 
                                                 
                                                     
                                                 
                                                 ⁢ 
                                                 
                                                   δ 
                                                   o 
                                                 
                                               
                                             
                                           
                                         
                                         ) 
                                       
                                     
                                     ) 
                                   
                                 
                                 / 
                                 
                                   T 
                                   VG 
                                 
                               
                               ⁢ 
                               
                                 V 
                                 go 
                               
                             
                           
                         
                       
                     
                   
                 
                 
                   
                     
                       
                         
                           
                             
                               
                                 a 
                                 ⁡ 
                                 
                                   ( 
                                   
                                     12 
                                     ⁢ 
                                     
                                       , 
                                     
                                     ⁢ 
                                     7 
                                   
                                   ) 
                                 
                               
                               = 
                             
                           
                         
                         
                           
                             
                               
                                 
                                   ( 
                                   
                                     
                                       K 
                                       VG 
                                     
                                     ⁡ 
                                     
                                       ( 
                                       
                                         
                                           
                                             
                                               
                                                 
                                                   m 
                                                   gco 
                                                 
                                                 ⁢ 
                                                 
                                                   V 
                                                   gdo 
                                                 
                                                 ⁢ 
                                                 sin 
                                                 ⁢ 
                                                 
                                                     
                                                 
                                                 ⁢ 
                                                 
                                                   δ 
                                                   o 
                                                 
                                               
                                               + 
                                             
                                           
                                         
                                         
                                           
                                             
                                               
                                                 m 
                                                 gco 
                                               
                                               ⁢ 
                                               
                                                 V 
                                                 gqo 
                                               
                                               ⁢ 
                                               cos 
                                               ⁢ 
                                               
                                                   
                                               
                                               ⁢ 
                                               
                                                 δ 
                                                 o 
                                               
                                             
                                           
                                         
                                       
                                       ) 
                                     
                                   
                                   ) 
                                 
                                 / 
                                 
                                   T 
                                   VG 
                                 
                               
                               ⁢ 
                               
                                 V 
                                 go 
                               
                             
                           
                         
                       
                     
                   
                 
                 a(12,12) = −(1/T VG ) 
               
               
                   
               
             
          
         
       
     
     Exploration and exploitation of an algorithm need to be under consideration. Exploration is the ability of the algorithm to explore the entire search space. Exploitation is the ability of the algorithm to focus only on an optimum area to refine the solution. Inertia Weight plays a key role in the process of providing balance between exploration and exploitation process. The Inertia Weight determines the contribution rate of a particle&#39;s previous velocity to its velocity at the current time step. Selection of the suitable inertia weight enhances the performance and provides excellent results. The inertia weight W is shown in eqn. (24) as: 
                     w   =       w   max     -       (         w   max     -     w   min         iter   max       )     ⁢   iter         ,           (   24   )               
where iter max  is the maximum number of iterations and iter is the current iteration number.
 
     Improvement in the inertia weight helps to converge the objective function fast. The velocity equation for the gbest and local best with inertia weight can be written as:
 
 v   i ( k+ 1)= wv   i ( k )+ c   1 rand 1 ( p   i ( k )− x   i ( k ))+c 2 rand 2 ( p   g ( k )− x   i ( k )),  (25)
 
and
 
 v   i ( k+ 1)= wv   i ( k )+ c   1 rand 1 ( p   i ( k )− x   i ( k ))+c 2 rand 2 ( p   ilocal best ( k )− x   i ( k )).  (26)
 
     The major advantages of IPSO are its simplicity, lower computational complexity, and lower computational effort due to its fast convergence. Because of the fast convergence, IPSO can be used for generating training data for a neural network, optimization of a cost function, pattern recognition, scheduling assignment, and combination optimization. Steps of the IPSO algorithm flowchart  800  of  FIG. 8  are outlined in Table 2. 
     
       
         
               
             
               
               
             
               
               
             
           
               
                 TABLE 2 
               
             
             
               
                   
               
               
                 IPSO Algorithm Steps 
               
             
          
           
               
                 Step # 
                 Process 
               
               
                   
               
             
          
           
               
                 1 
                 Generate particle array with random position and corresponding 
               
               
                   
                 velocities 
               
               
                 2 
                 Check boundaries satisfaction 
               
               
                 3 
                 If boundaries not satisfied, 
               
               
                   
                  redefine search area 
               
               
                 4 
                 If boundaries satisfied, 
               
               
                   
                  use rand function to generate population of K PG ,  
               
               
                   
                  K VG , T PG , T VG   
               
               
                 5 
                 Load system information and generate eigenvalues 
               
               
                 6 
                 Calculate the objective function of each set of controller  
               
               
                   
                 parameters 
               
               
                 7 
                 Determine whether J &lt; p best   
               
               
                 8 
                  Yes: Set p best  = J, then continue in-line processing 
               
               
                 9 
                  No: Search g best  from all particles&#39; objective function (J&#39;) 
               
               
                 10 
                 Set g best  = J&#39; if J&#39; &lt; g best   
               
               
                 11 
                 If the termination criteria are satisfied, 
               
               
                   
                  terminate the algorithm 
               
               
                 12 
                 If the termination criteria are not satisfied, 
               
               
                   
                  update the inertia weight, velocity and position and repeat 
               
               
                   
                  steps 2 through 12. 
               
               
                   
               
             
          
         
       
     
     In the following example, the parameters in equations (14) and (15) were initialized. The cognitive and social acceleration constants c 1  and c 2  were set to 2. The random numbers rand1 and rand2 were initialized by using the “rand” function in MATLAB. A sample of 100 sets of SMES controller parameters have been generated and designated as the population of the parameters. The system information is loaded, and the eigenvalues are calculated for each set of the SMES controller parameters (K pg , K vg , T pg  and T vg ) from the population. From these eigenvalues, the objective function is calculated by using eqn. (19). A loop runs for 50 iterations, during which the optimized controller parameters are generated using new inertia weight, position and velocity values, based on equations (24) through (26). The updates are made to the g best  and p best  parameters based on the minimized value of the objective function of the particles. The example was implemented to find the global best within the iterations. The stop condition was user-defined upon consideration of the applied problem. 
     Generally, the stop condition could be in terms of optimized value or fixed iterations. In this scenario, the stop condition was considered to be a specific number of iterations. A set of 50 iterations provided considerably more stable predicted data than others. So, in this work, 50 iterations have been fixed. The value that satisfies the objective function from the values extracted during each iteration was selected as an optimized value. A similar procedure followed to calculate the predicted position parameter of all the particles. One such process of optimization for each of the particles is considered as one iteration. This process prepares the RBFNN training data, which is used by the RBFNN to train the network. 
     The three-layer RBFNN, shown in  FIG. 11 , is configured so that the input units are directly connected to the hidden layer with hidden nodes. The hidden layer is fully connected, by linear combination, to the output layer via output weights. The performance of the RBFNN is controlled by three parameters, i.e., the center of the hidden units, the number of hidden units, and the RBF functions. For various types of contingencies, a trained network is needed, which identifies the SMES parameters under various contingencies. Here, an RBFNN is used for training the network. The response of the RBFNN is linear with respect to its output-connection weights. This property guarantees fast convergence. Moreover, the local tunability of the RBFNN reduces the training time and computational overhead, and makes the RBFNN a good candidate for tuning. The radial basis function neural network (RBFNN) is a feed-forward, 3-Layer network that is based on radial basis functions (such as the exemplary Gaussian function  1000 , shown in  FIG. 10 ) as their activation function. As shown in  FIG. 11 , this neural network includes a single hidden layer  413 , which has several hidden linear units  415  connected to the output layer. Each hidden linear unit  415  calculates a nonlinear function by measuring the distance between the network input and the unit weight vector. This unit vector is usually called the center of the unit, and the distance is called the Euclidean distance. The Gaussian function is used as a basis function. This function mainly depends on two parameters, β and c, so that: 
                       ϕ   ⁡     (            I   -     c   j            ,   β     )       =     exp   ⁡     (       -          I   -     c   j                β   j   2       )         ,           (   27   )               
where I is the input vector, β is the spread factor, and c j  is the j th  center. In the Gaussian function, output given by the neuron is maximum at the center and decreases when the neuron moves away from the center. A Gaussian function, such as Gaussian function  1000 , is normally used for hidden neurons. If an input vector coincides with the centroid of the cluster, then the neuron representing that cluster will give the maximum output. As the distance of the input vector from the centroid of the cluster increases, the response of that cluster decreases. If the receptive fields of the neurons are overlapping, then all the neurons with overlapping fields will give output according to the distance of the vector from the cluster&#39;s centroid.
 
     The hidden linear units  415  of the hidden layer  413  take a p-dimensional input vector I p  with unit connection weights and calculate the Euclidean distance between the input vector and the center. This result passes to a Gaussian function. The hidden layer  413  maps the input space onto a new space by performing the fixed nonlinear transformation. Then the output layer performs the linear combination onto this new space by adjusting the weight matrix. In this way, the RBFNN maps the p-dimensional input space to the m-dimensional output space. Equation (28) gives the output of the RBFNN and is calculated as the weighted sum of the hidden layer outputs, as follows: 
                       y   i     =       w     o   ⁢           ⁢   i       +       ∑     j   =   1     h     ⁢       w     j   ⁢           ⁢   i       ⁢     ϕ   ⁡     (            I   -     c   j            ,   β     )               ,           (   28   )               
where i=1, 2, 3, . . . , m; j=1, 2, 3, . . . , h; h shows the hidden units;
 
                  I   -     c   j                
shows the Euclidean distance between input and the j th  center; φ(•) is the nonlinear transfer function of the radial basis function; w ji  is the weight value between the i th  center and j th  output node.
 
     With respect to training the network, using the RBFNN, the input vector (I) is directly connected to the single hidden layer  413  with h nodes. It can be observed that h is the key factor, not only for performance, but also the computational complexity of the network. For the h th  hidden unit, c h  (h=1, 2, 3, . . . , h) denotes the mean vector of the h th  cluster. The vector c h  is also known as the center vector or kernel vector. The h th  hidden unit Euclidean net function for the p th  training pattern can be calculated as: 
                         ED   p     ⁡     (   n   )       =       ∑     n   =   1     N     ⁢       (         I   p     ⁡     (   n   )       -       c   h     ⁡     (   n   )         )     2         ,           (   29   )               
where c h (n) is the n th  element of c h  corresponding to the n th  input unit. The mean vector parameter c h  and spread factor parameter β are conventional parameters of a RBFNN. The hidden layer  413  is fully connected to the output layer via output weights. So, the output will be calculated through eqn. (28). The training mean square error (E p ) for each pattern can be calculated as:
 
                       E   p     =       ∑     i   =   1     m     ⁢       [         o   p     ⁡     (   i   )       -     y   ⁡     (   i   )         ]     2         ,           (   30   )               
where O p  is the output calculated by the IPSO method and y is the output calculated by the RBFNN, and both are column vectors.
 
     The training data set consists of training patterns {I p , o p }. The input data (I p ) is achieved by taking the values of the generator current, generator angle, generator speed, DC-link capacitor voltage, the inverter current, generator power, and terminal voltage at different operating conditions, while the controller parameters (K pg , K vg , T pg  and T vg ) for a particular operating condition are saved into an output vector. The weights of the hidden layer are trained through the RBFNN algorithm. The training data of 800 sets are used in the training process. 
     In the RBFNN algorithm, the spread factor β is an important parameter with respect to the input space. The spread factor β determines the width of an area in the input space to which each neuron responds. If β is 0.1, then each RBFNN hidden layer neuron will respond with 0.5 or more to any input vectors within a vector distance of 0.1 from their weight vector, the maximum response output being equal to 1. In the present method, the spread factor β is set to be 0.1. The error goal is set to be 0.02. The RBFNN is trained till an error goal of 0.02 is reached. The algorithm takes the input vector and calculates the Euclidean distance by using eqn. (29). The RBFNN algorithm adds neurons into the hidden layer and maps the input space onto a new space by performing the nonlinear Gaussian function. After calculating the nonlinear function, the output layer performs the linear combination by adjusting the weight matrix. Based on the weight matrix, a mean square error (E p ) of each pattern is calculated through eqn. (30). If E p  is greater than the error goal, which is defined at the start of the algorithm, then add a neuron into the hidden layer and repeat the procedure from the Euclidean distance calculation. But on the other hand, if the E p  is meeting the error goal, then the algorithm will be terminated by saving the network, to be recalled during simulations. This network is called the RBFNN trained network.  FIG. 9  shows the flowchart  900  of the RBFNN algorithm. Steps of the IPSO algorithm flowchart  900  of  FIG. 9  are outlined in Table 3. 
     
       
         
               
             
               
               
             
           
               
                 TABLE 3 
               
             
             
               
                   
               
               
                 RBFNN Algorithm Steps 
               
             
          
           
               
                 Step # 
                 Process 
               
               
                   
               
               
                 1 
                 Read training data from IPSO 
               
               
                 2 
                 Set spread constant and error 
               
               
                 3 
                 Calculate the Euclidean distance using equation (29) 
               
               
                 4 
                 Add Neuron 
               
               
                 5 
                 Map input space onto a new space by performing the fixed  
               
               
                   
                 nonlinear function 
               
               
                 6 
                 Use output layer to perform the linear combination by  
               
               
                   
                 adjusting the weight matrix 
               
               
                 7 
                 Calculate the MSE using equation (30) 
               
               
                 8 
                 If target error is not met and if the # neurons are not  
               
               
                   
                 maxed out, then repeat steps 3 through 8 
               
               
                 9 
                  Else, save the neuron structure 
               
               
                   
               
             
          
         
       
     
     The PMSG system given in  FIG. 12  was simulated to test the adaptive SMES control strategy. In the simulation, optimum output training data for the neural network was generated using the IPSO method. The radial basis function neural network (RBFNN) was trained to generate a nominal weighting function for the RBFNN controller. The controller was tested considering different contingencies. 
     The training data for the radial basis function neural network (RBFNN) is generated using the improved particle swarm optimization (IPSO). The IPSO finds the optimum set of SMES controller parameters for a given initial condition. The algorithm begins with the generator current, generator angle, generator speed, DC-link capacitor voltage, the inverter current, generator power, and terminal voltage as input, and generates a population of size 100 by taking the random values of SMES controller parameters (K pg , K vg , T pg  and T vg ). The IPSO algorithm sets the minimum and maximum values of the SMES controller parameters as:
 
−30 ≦K   PG ≦30
 
−30 ≦K   VG ≦30
 
0.001 ≦T   PG ≦1
 
0.001 ≦T   VG ≦1.  (31)
 
The IPSO tries to find the optimum values of the SMES controller parameters within the above ranges.
 
     The SMES controller parameters were optimized using IPSO, which made use of an eigenvalue-based objective function to obtain the optimized parameters. The objective function to be minimized is equation (19). For a torque pulse of 20% for 0.3 sec, plot  1300  of  FIG. 13  shows the convergence characteristic of the IPSO objective function (J) for one step size of simulation time. The IPSO converges the objective function to the optimum value in 22 iterations. The optimized SMES controller parameters for one step size of simulation time for 20% torque pulse are given in Table 4. 
     
       
         
               
             
               
               
               
               
               
             
           
               
                 TABLE 4 
               
             
             
               
                   
               
               
                 Optimum SMES controller parameters 
               
             
          
           
               
                 Disturbance 
                 K pg   
                 K vg   
                 T pg   
                 T vg   
               
               
                   
               
               
                 Torque pulse of 20% for 0.3 sec 
                 3.75 
                 9.25 
                 0.2001 
                 0.23 
               
               
                   
               
             
          
         
       
     
     The eigenvalues of the system shown in  FIG. 12 , without any control and with the present SMES control under a rated wind speed of V=9 m/s for one step size of simulation time are listed in Table 5. The eigenvalues E 1 -E 5  listed in Table 5 are related to the PMSG system without a SMES, whereas the eigenvalues E 6 -E 8  refer to the PMSG with the present SMES control unit. An examination of the eigenvalues listed in Table 5 reveals that the eigenvalues E 1  and E 2  are almost fixed on the complex plane. The system without the SMES unit has eigenvalue E 4 , which is close to the imaginary axis of the complex plane. The damping of E 3 -E 5  is improved when the present SMES control system is included in the wind system. 
     
       
         
               
             
               
               
               
             
           
               
                 TABLE 5 
               
             
             
               
                   
               
               
                 Eigenvalues for the system of FIG. 12 
               
             
          
           
               
                 Eigenvalues 
                 PMSG Without Control 
                 PMSG With SMES 
               
               
                   
               
               
                 E 1   
                 −530.8766 ± j1063.1562 
                 −530.8766 ± 
               
               
                 E 2   
                  −4.6210 ± j377.3165 
                  −4.6210 ± j377.2155 
               
               
                 E 3   
                  −0.5778 ± j27.6791 
                  −4.8112 ± j25.6013 
               
               
                 E 4   
                  −0.0998 ± j4.0035 
                  −0.7948 ± j13.8378 
               
               
                 E 5   
                 −1.0095 
                  −1.0206 
               
               
                 E 6   
                 — 
                 −10.1237 
               
               
                 E 7   
                 — 
                  −9.9999 
               
               
                 E 8   
                 — 
                  −0.5131 
               
               
                   
               
             
          
         
       
     
     The results of the IPSO algorithm were used to train the radial basis function neural network (RBFNN). The input vector contains generator current, generator angle, generator speed, DC-link capacitor voltage, the inverter current, generator power, and terminal voltage, while the SMES controller parameters (K pg , K vg , T pg  and T vg ) are the outputs. In this learning process, a collection of desired input-output pairs are used for the RBFNN to learn. For the learning phase, 800 input-output data sets were obtained. For online tuning using the RBFNN, the centers and network weights are updated at each iteration. Initial centers, which have been generated randomly in the input domain, are updated based upon how far the current input vector is away from the last updated centers (Euclidean distance). After calculating the Euclidean distance, the nonlinear function (Gaussian function) is updated. The outputs of the hidden layer can be calculated by updating the weight matrix. The mean squared error (MSE) of the RBFNN is calculated using equation (30). The MSE is set to 0.02 in this work. The training process continues until the targeted error is met, as shown in plot  1400  of  FIG. 14 . The training error converges in about 1625 epochs. 
     The present adaptive SMES control method and system was tested through simulations of different disturbances on the PMSG system. The disturbances considered were torque pulses of various magnitudes and duration (input torque pulse of 20% for 0.3 sec; input torque pulse of 10% for 2 sec.), a low voltage condition on the grid simulated through symmetrical 3-phase fault, and wind gust. All performed satisfactorily. The Torque pulse results are shown in plot  1500  of  FIG. 15 . It can be seen that the SMES adaptive controller provides good damping to the generator so that transient oscillations have been effectively suppressed within 5 seconds. 
     It is to be understood that the present invention is not limited to the embodiments described above, but encompasses any and all embodiments within the scope of the following claims.