






//
//
//
//
//    												   
//                i13 -+						  iBus_p -+					
//                -----------------------------------+----- VBus_p                
//               |      i1ct   						 |
//               |-------- +                         |
//             |-   |D11  |-                         |
//           - |- + ^   <C11>                        |
//          S11|-|- |i1st |                          |
//               |--------                           |
//    -----------| v1   i1cb                         |
//   |    i12 -+ |-------- +                         |
//   |         |-   |D12  |-                         |
//   |       - |- + ^   <C12>                        |
//   |      S12|-|- |i1sb |                          |
//   |           |--------                           |
//   |     i11 + | v11                   +- iBus_m   |
//   |         -  ------------<R12>----+----- VBus_m |
//   |                	  			   |             |
//    --------------<L1>------<R11>----------        |
//                   .    v12          |     |       |
//      ..............                 |     |       |
//      .                              |     |       |
//      .                              |     |       |
//      .         i23 -+               |     |       |
//      .         -----------------------------------+       
//      .        |      i2ct           |     |       |
//      .        |-------- +           |     |       |
//      .      |-   |D21  |-           |     |       |
//      .    - |- + ^   <C21>          |     |       |
//      .   S21|-|- |i2st |            |     |       |       
//      .        |--------             |     |       |
//    -----------| v2   i2cb           |     |       |
//   |  . i22 -+ |-------- +           |     |       |
//   |  .      |-   |D22  |-           |     |       |
//   |  .    - |- + ^   <C22>          |     |       |
//   |  .   S22|-|- |i2sb |            |     |       |
//   |  .        |--------             |     |       |
//   |  .  i21 + | v21                 |     |       |
//   |  .      -  ------------<R22>----+     |       |
//   |  .                              |     |       |
//    --------------<L2>------<R21>----------+ v_n   |
//      .            .    v22          |     |       |
//      ..............                 |     |       |
//      .                              |     |       |
//      .                              |     |       |
//      .         i33 -+               |     |       |
//      .         -----------------------------------
//      .        |      i3ct           |     |
//      .        |-------- +           |     |
//      .      |-   |D31  |-           |     |
//      .    - |- + ^   <C31>          |     |
//      .   S31|-|- |i3st |            |     |
//      .        |--------             |     |
//    -----------| v3   i3cb           |     |
//   |  . i32 -+ |-------- +           |     |
//   |  .      |-   |D32  |-           |     |
//   |  .    - |- + ^   <C32>          |     |
//   |  .   S32|-|- |i3sb |            |     |
//   |  .        |--------             |     |
//   |  .  i31 + | v31                 |     |
//   |  .      -  ------------<R32>----      |
//   |  .                                    |
//    --------------<L3>------<R31>----------      
//		.    		 . 	  v32
//      ..............
//
//
//
//			   NOTE: Removed "Trapezoidal" equations from CoefObject's.  
//					 (see https://en.wikipedia.org/wiki/Trapezoidal_rule_(differential_equations) )
//
//			   NOTE: i1st, i1sb, i2st, i2sb, i3st, and i3sb is the total current through the respective transistor AND diode.
//
//             NOTE: For all equations below, VBus_p and VBus_m are constant. As such VBus_p = VBus_p_ and VBus_m = VBus_m.
//
//	 v1/rS11 - VBus_p/rS11 + v1/rD11 - VBus_p/rD11 = i1st    		=> v1*(1/rS11 + 1/rD11) - i1st = VBus_p*(1/rS11 + 1/rD11)        	(1)
//
//	 v11/rS12 - v1/rS12 + v11/rD12 - v1/rD12 = i1sb          		=> v11*(1/rS12 + 1/rD12) - v1*(1/rS12 + 1/rD12) - ilsb = 0       	(2)
//
// 	 i12 + i11 = i13										 		=> i12 + i11 - i13 = 0											  	(3)
//
//   i1st + i1ct = i13										 		=> i1st + i1ct - i13 = 0										  	(4)
//
//   i1sb + i1cb = i11												=> i1sb + i1cb - i11 = 0										  	(5)
//
//   v1*C11/h - VBus_p*C11/h - v1_*C11/h + VBus_p_*C11/h = i1ct 	=> v1*C11/h - i1ct = v1_*C11/h 										(6)	
//
//	 v11*C12/h - v1*C12/h - v11_*C12/h + v1_*C12/h = i1cb    		=> v11*C12/h - v1*C12/h - i1cb = v11_*C12/h - v1_*C12/h  			(7)
//
//	 VBus_m/R12 - v11/R12 = i11   									=> v11/R12 + i11 = VBus_m/R12							    		(8)
//
//	 (L1*i12/h - L1*i12_/h) -  										=> L1*i12/h -  
//	 (M12*i22/h - M12*i22_/h) -  									   M12*i22/h -
//	 (M31*i32/h - M31*i32_/h) = v12 - v1							   M31*i32/h - v12 + v1 = L1*i12_/h - M12*i22_/h - M31*i32_/h       (9)
//
//	 v_n/R11 - v12/R11 = i12										=> v_n/R11 - v12/R11 - i12 = 0										(10)
//
//
//
//
//	 v2/rS21 - VBus_p/rS21 + v2/rD21 - VBus_p/rD21 = i2st    		=> v2*(1/rS21 + 1/rD21) - i2st = VBus_p*(1/rS21 + 1/rD21)        	(11)
//
//	 v21/rS22 - v2/rS22 + v21/rD22 - v2/rD22 = i2sb          		=> v21*(1/rS22 + 1/rD22) - v2*(1/rS22 + 1/rD22) - i2sb = 0       	(12)
//
// 	 i22 + i21 = i23										 		=> i22 + i21 - i23 = 0											  	(13)
//
//   i2st + i2ct = i23										 		=> i2st + i2ct - i23 = 0										  	(14)
//
//   i2sb + i2cb = i21												=> i2sb + i2cb - i21 = 0										  	(15)
//
//   v2*C21/h - VBus_p*C21/h - v2_*C21/h + VBus_p_*C21/h = i2ct 	=> v2*C21/h - i2ct = v2_*C21/h 										(16)
//
//	 v21*C22/h - v2*C22/h - v21_*C22/h + v2_*C22/h = i2cb    		=> v21*C22/h - v2*C22/h - i2cb = v21_*C22/h - v2_*C22/h  			(17)
//
//	 VBus_m/R22 - v21/R22 = i21   									=> v21/R22 + i21 = VBus_m/R22							    		(18)
//
//	 (L2*i22/h - L2*i22_/h) -  										=> L2*i22/h -  
//	 (M12*i12/h - M12*i12_/h) -  									   M12*i12/h -
//	 (M23*i32/h - M23*i32_/h) = v22 - v2							   M23*i32/h - v22 + v2 = L2*i22_/h - M12*i12_/h - M23*i32_/h       (19)
//
//	 v_n/R21 - v22/R21 = i22										=> v_n/R21 - v22/R21 - i22 = 0										(20)
//
//
//
//
//	 v3/rS31 - VBus_p/rS31 + v3/rD31 - VBus_p/rD31 = i3st    		=> v3*(1/rS31 + 1/rD31) - i3st = VBus_p*(1/rS31 + 1/rD31)        	(21)
//
//	 v31/rS32 - v3/rS32 + v31/rD32 - v3/rD32 = i3sb          		=> v31*(1/rS32 + 1/rD32) - v3*(1/rS32 + 1/rD32) - i3sb = 0       	(22)
//
// 	 i32 + i31 = i33										 		=> i32 + i31 - i33 = 0											  	(23)
//
//   i3st + i3ct = i33										 		=> i3st + i3ct - i33 = 0										  	(24)
//
//   i3sb + i3cb = i31												=> i3sb + i3cb - i31 = 0										  	(25)
//
//   v3*C31/h - VBus_p*C31/h - v3_*C31/h + VBus_p_*C31/h = i3ct 	=> v3*C31/h - i3ct = v3_*C31/h 										(26)
//
//	 v31*C32/h - v3*C32/h - v31_*C32/h + v3_*C32/h = i3cb    		=> v31*C32/h - v3*C32/h - i3cb = v31_*C32/h - v3_*C32/h  			(27)
//
//	 VBus_m/R32 - v31/R32 = i31   									=> v31/R32 + i31 = VBus_m/R32							    		(28)
//
//	 (L3*i32/h - L3*i32_/h) -  										=> L3*i32/h -  
//	 (M31*i12/h - M31*i12_/h) -  									   M31*i12/h -
//	 (M23*i22/h - M23*i22_/h) = v32 - v3							   M23*i22/h - v32 + v3 = L3*i32_/h - M31*i12_/h - M23*i22_/h       (29)
//
//	 v_n/R31 - v32/R31 = i32										=> v_n/R31 - v32/R31 - i32 = 0										(30)
//
//
//
//	 i12 + i22 + i32 = 0											=> i12 + i22 + i32 = 0												(31)
//
//
//
//
//
//      Constants: 
//
//				VBus_p and VBus_m
//
//		Variables computed from the previous pass, used as constants in the current pass:
//
//
//				v11_, v1_ 
//				v21_, v2_ 
//				v31_, v3_
//				i12_, i22_, i32_
//
//
//      The state vector for the DC solution:
//
//
//				| v1 v11 i1st i1sb i12 i11 i13 i1ct i1cb v12
//				  v2 v21 i2st i2sb i22 i21 i23 i2ct i2cb v22
//				  v3 v31 i3st i3sb i32 i31 i33 i3ct i3cb v32
//				  v_n |'
//
//

typedef enum {
  SRC_FUNC_NULL = -1,
  SRC_FUNC_TriangleWave,
  SRC_FUNC_PwmA,
  SRC_FUNC_PwmB,
  SRC_FUNC_PwmC,

} SRC_FUNCTION;


typedef enum {
  ODE_FUNC_NULL = -1,
} ODE_FUNCTION;




typedef enum {
  CTRL_FUNC_NULL = -1,
  CTRL_FUNC_VDqCmd,


} CTRL_FUNCTION;


typedef enum {
  COEF_FUNC_NULL = -1,
  
  
 

} COEF_FUNCTION; 


typedef enum {
  SWITCH_FUNC_NULL = -1,
  SWITCH_FUNC_rS11,
  SWITCH_FUNC_rS12,
  SWITCH_FUNC_rS21,
  SWITCH_FUNC_rS22,
  SWITCH_FUNC_rS31,
  SWITCH_FUNC_rS32,
  
 
} SWITCH_FUNCTION; 

typedef enum {
  SPICE_FUNC_NULL = -1,
  SPICE_FUNC_ThreePhaseBridge,
  
} SPICE_FUNCTION;


//define this only for debugging the matrix of any declared SpiceObjects. The size must appropriately.
//#define DEBUG_SPICE_MATRIX
//#define SPICE_DEBUG_MATRIX_SIZE ?? 


//if "DEBUG_SPICE_MATRIX" defined above, as an option we can also elect to dump the "a_matrix" and "a_equate_vector" for
//analysis using Octave.
//#define DUMP_MATRIX_EQUATE_VECTOR_TO_FILE_FOR_EXTERNAL_ANALYSIS 


#include "../Simulation/Simulation.hpp"


//Parameters....

#define M12  .495e-3          
#define M23  M12
#define M31  M12

#define L1  1.0e-3               
#define L2  L1  
#define L3  L1  

#define R11 1.0
#define R21 R11
#define R31 R11

#define RECEP_R11  ((double) 1.0/R11)
#define RECEP_R21  ((double) 1.0/R21)
#define RECEP_R31  ((double) 1.0/R31)

#define R12 .1
#define R22 R12
#define R32 R12

#define RECEP_R12  ((double) 1.0/R12)
#define RECEP_R22  ((double) 1.0/R22)
#define RECEP_R32  ((double) 1.0/R32)


#define C11	 .0000005
#define C12	 .0000005
#define C21	 .0000005
#define C22	 .0000005
#define C31	 .0000005
#define C32	 .0000005


#define MIN_PWM_FREQ_SCALE    1.0
#define MAX_PWM_FREQ_SCALE    10.0

      //Value is such such that "PwmFreqScale" equals MIN_PWM_FREQ_SCALE  when "vcmd_mag" obtains a value >= "PWM_FREQ_GAIN * v_bus"
#define PWM_FREQ_GAIN  .2            // (.000010 / (PWM_CYCLE_QUANTUM_CNT * QUANTUM_PERIOD)) //*** Original test ***


#define VDQ_CMD_QUANTUM_CNT       4
#define PWM_CYCLE_QUANTUM_CNT     4


#define QUANTUM_PERIOD .0000125

     //Un-comment to allow PWM time period to be scaled dynamically.
//#define CTRL_PWM_SCALE

#ifdef CTRL_PWM_SCALE

           //NOTE: "PwmFreqScale" is a local variable defined in CtrlObject "VDqCmd" and SrcObject "TrangleWave"
           //      In this context, it is combined into definitions QUARTER_PWM_CYCLE, T_Z, PWM_GAIN and PWM_OFFSET.
           //      There is sourced by "VDqCmd" and use as an R-Value in "TriangleWave"
#define QUARTER_PWM_CYCLE (QUANTUM_PERIOD*PwmFreqScale) 
 
#else

#define QUARTER_PWM_CYCLE QUANTUM_PERIOD

#endif

#define DEADTIME_VALUE .000003


#define SECTOR_ANGLE   (PI / 3.0)
#define T_Z            (QUARTER_PWM_CYCLE * (double) PWM_CYCLE_QUANTUM_CNT)
#define SQRT_3          1.7320508075688772935274463415059


#define PWM_GAIN    T_Z
#define PWM_OFFSET  (.5*T_Z)


#define VBus_p 200.0
#define VBus_m 0

#define PI   3.1415926535897932384626433832795

        // Indices for the vector to solve.
#define Ind_v1      0
#define Ind_v11     1
#define Ind_i1st    2
#define Ind_i1sb    3
#define Ind_i12     4
#define Ind_i11     5
#define Ind_i13     6
#define Ind_i1ct    7
#define Ind_i1cb    8
#define Ind_v12     9
#define Ind_v2      10
#define Ind_v21     11
#define Ind_i2st    12
#define Ind_i2sb    13
#define Ind_i22     14
#define Ind_i21     15
#define Ind_i23     16
#define Ind_i2ct    17
#define Ind_i2cb    18
#define Ind_v22     19
#define Ind_v3      20
#define Ind_v31     21
#define Ind_i3st    22
#define Ind_i3sb    23
#define Ind_i32     24
#define Ind_i31     25
#define Ind_i33     26
#define Ind_i3ct    27
#define Ind_i3cb    28
#define Ind_v32     29
#define Ind_v_n     30



typedef enum {TIME_NONE,
	      TIME_T1,
	      TIME_T2,
	      TIME_T1_T2
} REFERENCE_CONSTRUCT;



// **** SrcObject Classes ********************************

// ---- TriangleWave ---------------------------------------

class TriangleWave : public SrcObject
{
public:
  virtual void SrcFunction(double t);
  virtual void SrcRValueUpdate(void);
  TriangleWave(void);
  ~TriangleWave(void);
  double t_mod;
  double t_prev;
  double PwmRampDir;
  double PwmFreqScale;



};


TriangleWave Inst_TriangleWave;


// --------------------------------------------------------

// ---- PwmA  ---------------------------------------------

class PwmA : public SrcObject
{
public:
  virtual void SrcFunction(double t);
  virtual void SwitchRValueUpdate(void);
  PwmA(void);
  ~PwmA(void);
  bool DeadtimeGenerator(double t, double current_state);
  //source for this ODE
  double TriAngWave;
  double V_xo;   
  bool   GateCtrl_11;
  bool   GateCtrl_12;              
                 
 
};



PwmA Inst_PwmA;

// -------------------------------------------------------------

// ---- PwmB  ---------------------------------------------

class PwmB : public SrcObject
{
public:
  virtual void SrcFunction(double t);
  virtual void SwitchRValueUpdate(void);
  PwmB(void);
  ~PwmB(void);
   bool DeadtimeGenerator(double t, double current_state);
  //source for this ODE
  double TriAngWave;
  double V_xo;   
  bool   GateCtrl_21;
  bool   GateCtrl_22;                    
                 

};



PwmB Inst_PwmB;

// -------------------------------------------------------------

// ---- PwmC  ---------------------------------------------

class PwmC : public SrcObject
{
public:
  virtual void SrcFunction(double t);
  virtual void SwitchRValueUpdate(void);
  PwmC(void);
  ~PwmC(void);
  bool DeadtimeGenerator(double t, double current_state);
  //source for this ODE
  double TriAngWave;
  double V_xo;   
  bool   GateCtrl_31;
  bool   GateCtrl_32;                     
                  
 

};



PwmC Inst_PwmC;

// -------------------------------------------------------------


SrcObject * SrcObjectList[] = {(SrcObject *) &Inst_TriangleWave,
			       (SrcObject *) &Inst_PwmA,
			       (SrcObject *) &Inst_PwmB,
			       (SrcObject *) &Inst_PwmC,
			       0};


// ***********************************************************



// **** OdeObject Classes ********************************

// ***********************************************************


// **** CtrlObject Classes **********************************




// ---- VDqCmd  ---------------------------------------------

class VDqCmd : public CtrlObject
{
public:
  virtual void CtrlFunction(double t);
  virtual void CtrlRValueUpdate(void);
  virtual void RecordProbes(void);
  virtual void PlotProbes(Gnuplot & SimuPlot, vector<double> & Plot_t, string TagNamesToPlot[]);
  VDqCmd(void);
  ~VDqCmd(void);
  void SpaceVectorControl(void);
  //source for this CTRL
  double V_xo[3];

    
  double vcmd_mag;
  double vcmd_ang;
    
  double v_bus;
     
  REFERENCE_CONSTRUCT SVTable[6][3];  
     
  
  //storage for probes..
  vector<double> VCmd_a;  //value of V_xo[0].
  vector<double> VCmd_b;  //value of V_xo[1].
  vector<double> VCmd_c;  //value of V_xo[2].
  vector<double> VCmd_mag; 
  vector<double> VCmd_ang; 

};



VDqCmd Inst_VDqCmd;

// -------------------------------------------------------------


CtrlObject * CtrlObjectList[] = {(CtrlObject *) &Inst_VDqCmd,
									0};

int CtrlObjectQuantum[] = { VDQ_CMD_QUANTUM_CNT,
                          };
						  
						  
// **************************************************************



// **** CoefObject Classes ****************************************

// ---- Coef_recp_rSrD11 ---------------------------------------------

class Coef_recp_rSrD11 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_recp_rSrD11(void);
  ~Coef_recp_rSrD11(void);
  double rS11;
  double rD11;

};

Coef_recp_rSrD11 Coef_recp_rSrD11_i;

// -------------------------------------------------------------

// ---- Coef_recp_rSrD12 ---------------------------------------------

class Coef_recp_rSrD12 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_recp_rSrD12(void);
  ~Coef_recp_rSrD12(void);
  double rS12;
  double rD12;


};

Coef_recp_rSrD12 Coef_recp_rSrD12_i;

// -------------------------------------------------------------


// ---- Coef_C11_h ---------------------------------------------

class Coef_C11_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_C11_h(void);
  ~Coef_C11_h(void);




};

Coef_C11_h Coef_C11_h_i;

// -------------------------------------------------------------


// ---- Coef_C12_h ---------------------------------------------

class Coef_C12_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_C12_h(void);
  ~Coef_C12_h(void);




};

Coef_C12_h Coef_C12_h_i;

// -------------------------------------------------------------


// ---- Coef_v1_h_prev_C11 -------------------------------------

class Coef_v1_h_prev_C11 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_v1_h_prev_C11(void);
  ~Coef_v1_h_prev_C11(void);
  double v1_;
  
  
  
};

Coef_v1_h_prev_C11 Coef_v1_h_prev_C11_i;

// -------------------------------------------------------------


// ---- Coef_v11_v1_h_prev_C12 ---------------------------------

class Coef_v11_v1_h_prev_C12 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_v11_v1_h_prev_C12(void);
  ~Coef_v11_v1_h_prev_C12(void);
  double v11_;
  double v1_;
  	 




};

Coef_v11_v1_h_prev_C12 Coef_v11_v1_h_prev_C12_i;

// -------------------------------------------------------------


// ---- Coef_L1_h ---------------------------------------------

class Coef_L1_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_L1_h(void);
  ~Coef_L1_h(void);

  


};

Coef_L1_h Coef_L1_h_i;

// -------------------------------------------------------------


// ---- Coef_M12_h ---------------------------------------------

class Coef_M12_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_M12_h(void);
  ~Coef_M12_h(void);

  


};

Coef_M12_h Coef_M12_h_i;

// -------------------------------------------------------------


// ---- Coef_M31_h ---------------------------------------------

class Coef_M31_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_M31_h(void);
  ~Coef_M31_h(void);

  


};

Coef_M31_h Coef_M31_h_i;

// -------------------------------------------------------------



// ---- Coef_L1_M12_M31_h_prev_i12_i22_i32 -------------------------------------

class Coef_L1_M12_M31_h_prev_i12_i22_i32  : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_L1_M12_M31_h_prev_i12_i22_i32(void);
  ~Coef_L1_M12_M31_h_prev_i12_i22_i32(void);
  double i12_;
  double i22_;
  double i32_;
  	   


};

Coef_Coef_L1_M12_M31_h_prev_i12_i22_i32 Coef_L1_M12_M31_h_prev_i12_i22_i32_i;

// -------------------------------------------------------------




// ---- Coef_recp_rSrD21 ---------------------------------------------

class Coef_recp_rSrD21 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_recp_rSrD21(void);
  ~Coef_recp_rSrD21(void);
  double rS21;
  double rD21;

};

Coef_recp_rSrD21 Coef_recp_rSrD21_i;

// -------------------------------------------------------------

// ---- Coef_recp_rSrD22 ---------------------------------------------

class Coef_recp_rSrD22 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_recp_rSrD22(void);
  ~Coef_recp_rSrD22(void);
  double rS22;
  double rD22;


};

Coef_recp_rSrD22 Coef_recp_rSrD22_i;

// -------------------------------------------------------------


// ---- Coef_C21_h ---------------------------------------------

class Coef_C21_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_C21_h(void);
  ~Coef_C21_h(void);




};

Coef_C21_h Coef_C21_h_i;

// -------------------------------------------------------------


// ---- Coef_C22_h ---------------------------------------------

class Coef_C22_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_C22_h(void);
  ~Coef_C22_h(void);




};

Coef_C22_h Coef_C22_h_i;

// -------------------------------------------------------------


// ---- Coef_v2_h_prev_C21 -------------------------------------

class Coef_v2_h_prev_C21 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_v2_h_prev_C21(void);
  ~Coef_v2_h_prev_C21(void);
  double v2_;
  
  
  
  
};

Coef_v2_h_prev_C21 Coef_v2_h_prev_C21_i;

// -------------------------------------------------------------


// ---- Coef_v21_v2_h_prev_C22 ---------------------------------

class Coef_v21_v2_h_prev_C22 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_v21_v2_h_prev_C22(void);
  ~Coef_v21_v2_h_prev_C22(void);
  double v21_;
  double v2_;
  	 




};

Coef_v21_v2_h_prev_C22 Coef_v21_v2_h_prev_C22_i;

// -------------------------------------------------------------


// ---- Coef_L2_h ---------------------------------------------

class Coef_L2_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_L2_h(void);
  ~Coef_L2_h(void);

  


};

Coef_L2_h Coef_L2_h_i;

// -------------------------------------------------------------


// ---- Coef_M12_h ---------------------------------------------

	// (Previous defined above.)

// -------------------------------------------------------------


// ---- Coef_M23_h ---------------------------------------------

class Coef_M23_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_M23_h(void);
  ~Coef_M23_h(void);

  


};

Coef_M23_h Coef_M23_h_i;

// -------------------------------------------------------------



// ---- Coef_L2_M12_M23_h_prev_i12_i22_i32 -------------------------------------

class Coef_L2_M12_M23_h_prev_i12_i22_i32  : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_L2_M12_M23_h_prev_i12_i22_i32(void);
  ~Coef_L2_M12_M23_h_prev_i12_i22_i32(void);
  double i12_;
  double i22_;
  double i32_;
  	   


};

Coef_Coef_L2_M12_M23_h_prev_i12_i22_i32 Coef_L2_M12_M23_h_prev_i12_i22_i32_i;

// -------------------------------------------------------------


 
 
 // ---- Coef_recp_rSrD31 ---------------------------------------------

class Coef_recp_rSrD31 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_recp_rSrD31(void);
  ~Coef_recp_rSrD31(void);
  double rS31;
  double rD31;

};

Coef_recp_rSrD31 Coef_recp_rSrD31_i;

// -------------------------------------------------------------

// ---- Coef_recp_rSrD32 ---------------------------------------------

class Coef_recp_rSrD32 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_recp_rSrD32(void);
  ~Coef_recp_rSrD32(void);
  double rS32;
  double rD32;


};

Coef_recp_rSrD32 Coef_recp_rSrD32_i;

// -------------------------------------------------------------


// ---- Coef_C31_h ---------------------------------------------

class Coef_C31_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_C31_h(void);
  ~Coef_C31_h(void);




};

Coef_C31_h Coef_C31_h_i;

// -------------------------------------------------------------


// ---- Coef_C32_h ---------------------------------------------

class Coef_C32_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_C32_h(void);
  ~Coef_C32_h(void);




};

Coef_C32_h Coef_C32_h_i;

// -------------------------------------------------------------


// ---- Coef_v3_h_prev_C31 -------------------------------------

class Coef_v3_h_prev_C31 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_v3_h_prev_C31(void);
  ~Coef_v3_h_prev_C31(void);
  double v3_;
  
  
  
  
};

Coef_v3_h_prev_C31 Coef_v3_h_prev_C31_i;

// -------------------------------------------------------------


// ---- Coef_v31_v3_h_prev_C32 ---------------------------------

class Coef_v31_v3_h_prev_C32 : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_v31_v3_h_prev_C32(void);
  ~Coef_v31_v3_h_prev_C32(void);
  double v31_;
  double v3_;
  	  




};

Coef_v31_v3_h_prev_C32 Coef_v31_v3_h_prev_C32_i;

// -------------------------------------------------------------


// ---- Coef_L3_h ---------------------------------------------

class Coef_L3_h : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_L3_h(void);
  ~Coef_L3_h(void);

  


};

Coef_L3_h Coef_L3_h_i;

// -------------------------------------------------------------


// ---- Coef_M31_h ---------------------------------------------

	// (Previous defined above.)

// -------------------------------------------------------------


// ---- Coef_M23_h ---------------------------------------------

	// (Previous defined above.)

 // -------------------------------------------------------------



// ---- Coef_L3_M31_M23_h_prev_i12_i22_i32 -------------------------------------

class Coef_L3_M31_M23_h_prev_i12_i22_i32  : public CoefObject
{
public:
  virtual void CoefFunction(double recp_h, bool DoTrapezoidal);
  Coef_L3_M31_M23_h_prev_i12_i22_i32(void);
  ~Coef_L3_M31_M23_h_prev_i12_i22_i32(void);
  double i12_;
  double i22_;
  double i32_;
  	   


};

Coef_Coef_L3_M31_M23_h_prev_i12_i22_i32 Coef_L3_M31_M23_h_prev_i12_i22_i32_i;

// -------------------------------------------------------------
 
 
 CoefObject * CoefObjectList[] = {(CoefObject *)  &Coef_recp_rSrD11_i,
								  (CoefObject *)  &Coef_recp_rSrD12_i,
								  (CoefObject *)  &Coef_C11_h_i,
								  (CoefObject *)  &Coef_C12_h_i,
								  (CoefObject *)  &Coef_v1_h_prev_C11_i,
								  (CoefObject *)  &Coef_v11_v1_h_prev_C12_i,
								  (CoefObject *)  &Coef_L1_h_i,
								  (CoefObject *)  &Coef_M12_h_i,
								  (CoefObject *)  &Coef_M31_h_i,
								  (CoefObject *)  &Coef_L1_M12_M31_h_prev_i12_i22_i32_i,

								  (CoefObject *)  &Coef_recp_rSrD21_i,
								  (CoefObject *)  &Coef_recp_rSrD22_i,
								  (CoefObject *)  &Coef_C21_h_i,
								  (CoefObject *)  &Coef_C22_h_i,
								  (CoefObject *)  &Coef_v2_h_prev_C21_i,
								  (CoefObject *)  &Coef_v21_v2_h_prev_C22_i,
								  (CoefObject *)  &Coef_L2_h_i,
								  (CoefObject *)  &Coef_M23_h_i,
								  (CoefObject *)  &Coef_L2_M12_M23_h_prev_i12_i22_i32_i,

								  (CoefObject *)  &Coef_recp_rSrD31_i,
								  (CoefObject *)  &Coef_recp_rSrD32_i,
								  (CoefObject *)  &Coef_C31_h_i,
								  (CoefObject *)  &Coef_C32_h_i,
								  (CoefObject *)  &Coef_v3_h_prev_C31_i,
								  (CoefObject *)  &Coef_v31_v3_h_prev_C32_i,
								  (CoefObject *)  &Coef_L3_h_i,
								  (CoefObject *)  &Coef_L3_M31_M23_h_prev_i12_i22_i32_i,
								  
								  0};								  
	
	
// ****************************************************************


// **** SwitchObject Classes **************************************

// ---- Switch_rS11 -----------------------------------------------

class Switch_rS11 : public SwitchObject
{
public:
  virtual void CoefRValueUpdate(void);
  Switch_rS11(void);
  ~Switch_rS11(void);

};

Switch_rS11 Switch_rS11_i;

// ----------------------------------------------------------------


// ---- Switch_rS12 -----------------------------------------------

class Switch_rS12 : public SwitchObject
{
public:
  virtual void CoefRValueUpdate(void);
  Switch_rS12(void);
  ~Switch_rS12(void);
};

Switch_rS12 Switch_rS12_i;

// ----------------------------------------------------------------


// ---- Switch_rS21 -----------------------------------------------

class Switch_rS21 : public SwitchObject
{
public:
  virtual void CoefRValueUpdate(void);
  Switch_rS21(void);
  ~Switch_rS21(void);

};

Switch_rS21 Switch_rS21_i;

// ----------------------------------------------------------------


// ---- Switch_rS22 -----------------------------------------------

class Switch_rS22 : public SwitchObject
{
public:
  virtual void CoefRValueUpdate(void);
  Switch_rS22(void);
  ~Switch_rS22(void);
};

Switch_rS22 Switch_rS22_i;

// ----------------------------------------------------------------


// ---- Switch_rS31 -----------------------------------------------

class Switch_rS31 : public SwitchObject
{
public:
  virtual void CoefRValueUpdate(void);
  Switch_rS31(void);
  ~Switch_rS31(void);
};

Switch_rS31 Switch_rS31_i;

// ----------------------------------------------------------------


// ---- Switch_rS32 -----------------------------------------------

class Switch_rS32 : public SwitchObject
{
public:
  virtual void CoefRValueUpdate(void);
  Switch_rS32(void);
  ~Switch_rS32(void);
};

Switch_rS32 Switch_rS32_i;

// ----------------------------------------------------------------


SwitchObject * SwitchObjectList[] = {(SwitchObject *) &Switch_rS11_i,
									 (SwitchObject *) &Switch_rS12_i,
									 (SwitchObject *) &Switch_rS21_i,
									 (SwitchObject *) &Switch_rS22_i,
									 (SwitchObject *) &Switch_rS31_i,
									 (SwitchObject *) &Switch_rS32_i,
									0};

									
									
									
// ****************************************************************




// **** SpiceObject Classes ***************************************

// ---- Spice_ThreePhaseBridge ------------------------------------------

class Spice_ThreePhaseBridge : public SpiceObject
{
public:

  Spice_ThreePhaseBridge(void);
  ~Spice_ThreePhaseBridge(void);
  virtual void SwitchRValueUpdate(void);
  virtual void CoefRValueUpdate(void);
  virtual void SrcRValueUpdate(void);

};


Spice_ThreePhaseBridge Spice_ThreePhaseBridge_i;


// ---------------------------------------------------------------

SpiceObject * SpiceObjectList[] = {(SpiceObject *) &Spice_ThreePhaseBridge_i,
				   0};
				    



// **************************************************************




// **** SrcObject Functions **************************************

// ---- TriangleWave  ----------------------------------------------------

TriangleWave::TriangleWave(void)
{
 
  SrcObjItem * pCurSrcItem;

  SrcFuncName = SRC_FUNC_TriangleWave;
  LiteralName = "TriangleWave";


  //build the SRC Rvalue list.

  pSrcObjRValList = new SrcObjItem;
  pCurSrcItem = pSrcObjRValList;

  pCurSrcItem->pSrcObject = SrcObjectList[SRC_FUNC_PwmA];
  pCurSrcItem->pNextSrcItem = new SrcObjItem;
  pCurSrcItem = pCurSrcItem->pNextSrcItem;
  pCurSrcItem->pSrcObject = SrcObjectList[SRC_FUNC_PwmB];
  pCurSrcItem->pNextSrcItem = new SrcObjItem;
  pCurSrcItem = pCurSrcItem->pNextSrcItem;
  pCurSrcItem->pSrcObject = SrcObjectList[SRC_FUNC_PwmC];

   



  PwmRampDir = 1.0;
#ifdef RECORD_ALL_PROBES
  PlotThisOutput = TRUE;
#endif 
  Plot_Tag = "TriangleWave";
}

TriangleWave::~TriangleWave(void)
{



}

void TriangleWave::SrcFunction(double t)
{
  t_mod += (t - t_prev);
  t_prev = t;

  if(t_mod > QUARTER_PWM_CYCLE){
    t_mod -=  QUARTER_PWM_CYCLE;
    PwmRampDir *= -1.0;
  }
 
  y = PWM_GAIN*(t_mod/QUARTER_PWM_CYCLE - .5)*PwmRampDir + PWM_OFFSET;

}

void TriangleWave::SrcRValueUpdate(void)          
{
  SrcObjItem * pCurSrcItem;

  //Update Rvalues
  pCurSrcItem = pSrcObjRValList;

  ((PwmA *) pCurSrcItem->pSrcObject)->TriAngWave = y;
  pCurSrcItem = pCurSrcItem->pNextSrcItem;    
  ((PwmB *) pCurSrcItem->pSrcObject)->TriAngWave = y;
  pCurSrcItem = pCurSrcItem->pNextSrcItem;    
  ((PwmC *) pCurSrcItem->pSrcObject)->TriAngWave = y;

 

}




// -----------------------------------------------------------------

// ---- PwmA ---------------------------------------------------

PwmA::PwmA(void)
{
  SwitchObjItem * pCurSwitchItem;
  
  SrcFuncName = SRC_FUNC_PwmA;
  LiteralName = "PwmA";
  
 //build the Switch Rvalue list.

  pSwitchObjRValList = new SwitchObjItem;
  pCurSwitchItem = pSwitchObjRValList;

  pCurSwitchItem->pSwitchObject = SwitchObjectList[SWITCH_FUNC_rS11];
  pCurSwitchItem->pNextSwitchItem = new SwitchObjItem;
  pCurSwitchItem = pCurSwitchItem->pNextSwitchItem;
  pCurSwitchItem->pSwitchObject = SwitchObjectList[SWITCH_FUNC_rS12];  

}

PwmA::~PwmA(void)
{



}

void PwmA::SrcFunction(double t)
{

 

//  //For simulation, "V_xo" is space vector reference to a triangle wave
//  //running between 0 and PWM_GAIN.
//  y = V_xo > TriAngWave ? 1.0 : 0;

  


}

void PwmA::SwitchRValueUpdate(void)
{
  SwitchObjItem * pCurSwitchItem;

  //Update RValues
  pCurSwitchItem = pSwitchObjRValList;

  ((Switch_rS11 *) pCurSwitchItem->pSwitchObject)->DevGate = GateCtrl_11;
  pCurSwitchItem = pCurSwitchItem->pNextSwitchItem;
  ((Switch_rS12 *) pCurSwitchItem->pSwitchObject)->DevGate = GateCtrl_12;



}


bool PwmA::DeadtimeGenerator(double t, double state)
{
  static double t_previous = DEADTIME_VALUE;
  static double state_previous = 0;
	
	//"state" is either the value of the phase current (smart deadtime control mode) or
	//the difference between V_xo and TriAngWave (standard deadtime control mode).
	
	if(!((state >= 0) && (state_previous >= 0)) || ((state < 0) && (state_previous < 0))))
	{
		t_previous = t + DEADTIME_VALUE;
		state_previous = state;
	}
 	
	if(t >= t_previous)
	{
		t_previous = t;
		return TRUE;
	}
	else
	{
		return FALSE;
	}
	
	
}


// -----------------------------------------------------------------


// ---- PwmB ---------------------------------------------------


PwmB::PwmB(void)
{
  SwitchObjItem * pCurSwitchItem;

  SrcFuncName = SRC_FUNC_PwmB;
  LiteralName = "PwmB";
  
   //build the Switch Rvalue list.

  pSwitchObjRValList = new SwitchObjItem;
  pCurSwitchItem = pSwitchObjRValList;

  pCurSwitchItem->pSwitchObject = SwitchObjectList[SWITCH_FUNC_rS21];
  pCurSwitchItem->pNextSwitchItem = new SwitchObjItem;
  pCurSwitchItem = pCurSwitchItem->pNextSwitchItem;
  pCurSwitchItem->pSwitchObject = SwitchObjectList[SWITCH_FUNC_rS22];  
  

}


PwmB::~PwmB(void)
{


}


void PwmB::SrcFunction(double t)
{



//   //For simulation, "V_xo" is space vector reference to a triangle wave
//  //running between 0 and PWM_GAIN.
//  y = V_xo > TriAngWave ? 1.0 : 0;





}

void PwmB::SwitchRValueUpdate(void)
{
  SwitchObjItem * pCurSwitchItem;

  //Update RValues
  pCurSwitchItem = pSwitchObjRValList;

  ((Switch_rS21 *) pCurSwitchItem->pSwitchObject)->DevGate = GateCtrl_21;
  pCurSwitchItem = pCurSwitchItem->pNextSwitchItem;
  ((Switch_rS22 *) pCurSwitchItem->pSwitchObject)->DevGate = GateCtrl_22;



}


bool PwmB::DeadtimeGenerator(double t, double state)
{
  static double t_previous = DEADTIME_VALUE;
  static double state_previous = 0;
	
	//"state" is either the value of the phase current (smart deadtime control mode) or
	//the difference between V_xo and TriAngWave (standard deadtime control mode).
	
	if(!((state >= 0) && (state_previous >= 0)) || ((state < 0) && (state_previous < 0))))
	{
		t_previous = t + DEADTIME_VALUE;
		state_previous = state;
	}
 	
	if(t >= t_previous)
	{
		t_previous = t;
		return TRUE;
	}
	else
	{
		return FALSE;
	}
	
	
}

// ----------------------------------------------------------------- 


// ---- PwmC ---------------------------------------------------

PwmC::PwmC(void)
{
  SwitchObjItem * pCurSwitchItem;

  SrcFuncName = SRC_FUNC_PwmC;
  LiteralName = "PwmC";
  
 
    //build the Switch Rvalue list.

  pSwitchObjRValList = new SwitchObjItem;
  pCurSwitchItem = pSwitchObjRValList;

  pCurSwitchItem->pSwitchObject = SwitchObjectList[SWITCH_FUNC_rS31];
  pCurSwitchItem->pNextSwitchItem = new SwitchObjItem;
  pCurSwitchItem = pCurSwitchItem->pNextSwitchItem;
  pCurSwitchItem->pSwitchObject = SwitchObjectList[SWITCH_FUNC_rS32];  
 

}

PwmC::~PwmC(void)
{


}


void PwmC::SrcFunction(double t)
{



//  //For simulation, "V_xo" is space vector reference to a triangle wave
//  //running between 0 and PWM_GAIN.
//  y = V_xo > TriAngWave ? 1.0 : 0;



}

void PwmC::SwitchRValueUpdate(void)
{
  SwitchObjItem * pCurSwitchItem;

  //Update RValues
  pCurSwitchItem = pSwitchObjRValList;

  ((Switch_rS31 *) pCurSwitchItem->pSwitchObject)->DevGate = GateCtrl_31;
  pCurSwitchItem = pCurSwitchItem->pNextSwitchItem;
  ((Switch_rS32 *) pCurSwitchItem->pSwitchObject)->DevGate = GateCtrl_32;



}


bool PwmC::DeadtimeGenerator(double t, double state)
{
  static double t_previous = DEADTIME_VALUE;
  static double state_previous = 0;
	
	//"state" is either the value of the phase current (smart deadtime control mode) or
	//the difference between V_xo and TriAngWave (standard deadtime control mode).
	
	if(!((state >= 0) && (state_previous >= 0)) || ((state < 0) && (state_previous < 0))))
	{
		t_previous = t + DEADTIME_VALUE;
		state_previous = state;
	}
 	
	if(t >= t_previous)
	{
		t_previous = t;
		return TRUE;
	}
	else
	{
		return FALSE;
	}
	
	
}

// ----------------------------------------------------------------- 



// *****************************************************************


// **** OdeObject Functions ****************************************


// *****************************************************************

// **** CtrlObject Functions ****************************************

// ---- VDqCmd  ---------------------------------------------------

VDqCmd::VDqCmd(void)
{
  SrcObjItem * pCurSrcItem;

  CtrlFuncName = CTRL_FUNC_VDqCmd;
  LiteralName = "VDqCmd";  

    // Definitions here are for minus side "clamped" SVPWM. For regular SVPWM, add ".5*T_Z" to all reference values.
  SVTable[0][0] = TIME_T1_T2;
  SVTable[0][1] = TIME_T2;
  SVTable[0][2] = TIME_NONE;
  SVTable[1][0] = TIME_T1; 
  SVTable[1][1] = TIME_T1_T2;
  SVTable[1][2] = TIME_NONE;
  SVTable[2][0] = TIME_NONE;
  SVTable[2][1] = TIME_T1_T2;
  SVTable[2][2] = TIME_T2;
  SVTable[3][0] = TIME_NONE;
  SVTable[3][1] = TIME_T1;
  SVTable[3][2] = TIME_T1_T2;
  SVTable[4][0] = TIME_T2;
  SVTable[4][1] = TIME_NONE;
  SVTable[4][2] = TIME_T1_T2;
  SVTable[5][0] = TIME_T1_T2;
  SVTable[5][1] = TIME_NONE;
  SVTable[5][2] = TIME_T1;
  
  v_bus = VBus_p - VBus_m;
  
  
   //build the SRC Rvalue list.

  pSrcObjRValList = new SrcObjItem;
  pCurSrcItem = pSrcObjRValList;

  pCurSrcItem->pSrcObject = SrcObjectList[SRC_FUNC_PwmA];  
  pCurSrcItem->pNextSrcItem = new SrcObjItem;
  pCurSrcItem = pCurSrcItem->pNextSrcItem;
  pCurSrcItem->pSrcObject = SrcObjectList[SRC_FUNC_PwmB];
  pCurSrcItem->pNextSrcItem = new SrcObjItem;
  pCurSrcItem = pCurSrcItem->pNextSrcItem;
  pCurSrcItem->pSrcObject = SrcObjectList[SRC_FUNC_PwmC];
  pCurSrcItem->pNextSrcItem = new SrcObjItem;
  pCurSrcItem = pCurSrcItem->pNextSrcItem;
  pCurSrcItem->pSrcObject = SrcObjectList[SRC_FUNC_TriangleWave]; 
  
  
    DoProbes = TRUE;
  

}

VDqCmd::~VDqCmd(void)
{



}

void VDqCmd::CtrlFunction(double t)
{
  int i;

     
#ifdef CTRL_PWM_SCALE

  //For now, we provide constant commands for magnitude and angle.
  //These will come form seperate CTRL later.
  vcmd_mag = 10.0;
  vcmd_ang = PI/2;   //valid values are  +/-PI/2 <= vcmd_ang < +/-PI (pure "q" to pure "d") 
#else
 // vcmd_mag =	//control vcmd_mag with some simple  function.
  vcmd_ang = PI/2;
#endif

  //generate the references.
  SpaceVectorControl();

  
}

void VDqCmd::RecordProbes(void)
{



  VCmd_a.push_back(V_xo[0]);
  VCmd_b.push_back(V_xo[1]);
#ifdef RECORD_ALL_PROBES
  VCmd_c.push_back(V_xo[2]);
#endif

  VCmd_mag.push_back(vcmd_mag);
  VCmd_ang.push_back(vcmd_ang);
  FreqScale.push_back(PwmFreqScale);

}

void VDqCmd::PlotProbes(Gnuplot & SimuPlot, vector<double> & Plot_t, string TagNamesToPlot[])
{

  int i;
  if(TagNamesToPlot[0] == ""){
    SimuPlot.plot_xy(Plot_t, VCmd_a, "VCmd_a");
    SimuPlot.plot_xy(Plot_t, VCmd_b, "VCmd_b");
    SimuPlot.plot_xy(Plot_t, VCmd_c, "VCmd_c");  
    SimuPlot.plot_xy(Plot_t, VCmd_mag, "VCmd_mag");
    SimuPlot.plot_xy(Plot_t, VCmd_ang, "VCmd_ang");  
    SimuPlot.plot_xy(Plot_t, FreqScale, "FreqScale"); 
  }
  else{
    for(i = 0; i < 20; i++){
      if(TagNamesToPlot[i] == "VCmd_a"){
	SimuPlot.plot_xy(Plot_t, VCmd_a, "VCmd_a");
      }
      else if(TagNamesToPlot[i] == "VCmd_b"){
	SimuPlot.plot_xy(Plot_t, VCmd_b, "VCmd_b");
      }
      else if(TagNamesToPlot[i] == "VCmd_c"){
	SimuPlot.plot_xy(Plot_t, VCmd_c, "VCmd_c");
      }
      else if(TagNamesToPlot[i] == "VCmd_mag"){
	SimuPlot.plot_xy(Plot_t, VCmd_mag, "VCmd_mag");
      }
      else if(TagNamesToPlot[i] == "VCmd_ang"){
	SimuPlot.plot_xy(Plot_t, VCmd_ang, "VCmd_ang");
      }
      else if(TagNamesToPlot[i] == "FreqScale"){
	SimuPlot.plot_xy(Plot_t, FreqScale, "FreqScale");
      }

    }
  }


}

void  VDqCmd::SrcRValueUpdate(void)      
{
  SrcObjItem * pCurSrcItem;

  //Update Rvalues
  pCurSrcItem = pSrcObjRValList;

  ((PwmA *) pCurSrcItem->pSrcObject)->V_xo = V_xo[0];
  pCurSrcItem = pCurSrcItem->pNextSrcItem;       
  ((PwmB *) pCurSrcItem->pSrcObject)->V_xo = V_xo[1];
  pCurSrcItem = pCurSrcItem->pNextSrcItem;       
  ((PwmC *) pCurSrcItem->pSrcObject)->V_xo = V_xo[2];
  pCurSrcItem = pCurSrcItem->pNextSrcItem;       
  ((TriangleWave *) pCurSrcItem->pSrcObject)->PwmFreqScale = PwmFreqScale;


}

void VDqCmd::SpaceVectorControl(void) 
{
  int SectorNumber;  
  int SectorIndex;
  double SectorAngle;
  double CtrlAngle;
  double T0, T1, T2;
  double Amplitude;
  double T_Z_Scaled;
  int i;	
	
  CtrlAngle = vcmd_ang;                  
  SectorIndex = (int) (CtrlAngle / SECTOR_ANGLE);	
  
  
   if(CtrlAngle >= 0){
    SectorNumber = SectorIndex % 6 + 1;
    SectorAngle = CtrlAngle - (double) (SectorIndex / 6) * SECTOR_ANGLE * 6.0; 
  }
  else{
    SectorNumber = 6 + SectorIndex % 6;
    SectorAngle = CtrlAngle + (double) (6 - SectorIndex / 6) * SECTOR_ANGLE * 6.0; 
  }
  
  T_Z_Scaled = (2.0 / 3.0) * T_Z;

  T1 = SQRT_3 * T_Z_Scaled * vcmd_mag * sin((PI * (double) SectorNumber / 3.0) - SectorAngle) / v_bus;
  T2 = SQRT_3 * T_Z_Scaled * vcmd_mag * sin(SectorAngle - (SectorNumber - 1) * PI / 3.0) / v_bus;
  T0 = T_Z_Scaled - T1 - T2; 
  
	
  for(i = 0; i < 3; i++){	
	
    switch(SVTable[SectorNumber-1][i]){
    case TIME_NONE:
      V_xo[i] = 0;
      break;
    case TIME_T1:
      V_xo[i] = T1;
      break;
    case TIME_T2:
      V_xo[i] = T2;
      break;
    case TIME_T1_T2:
      V_xo[i] = T1 + T2;
      break;
    }	
	
  }
  
#ifdef CTRL_PWM_SCALE
  

  PwmFreqScale = PWM_FREQ_GAIN  * v_bus / vcmd_mag;

  

  if(PwmFreqScale < MIN_PWM_FREQ_SCALE){
    PwmFreqScale = MIN_PWM_FREQ_SCALE;
  }
  else if(PwmFreqScale > MAX_PWM_FREQ_SCALE){
    PwmFreqScale = MAX_PWM_FREQ_SCALE;
  }

#endif 
  
	
}

// ******************************************************************


// **** CoefObject Functions ****************************************


// ---- Coef_recp_rSrD11 ---------------------------------------------

Coef_recp_rSrD11::Coef_recp_rSrD11(void)
{
  CoefFuncName = COEF_FUNC_recp_rSrD11;
  LiteralName = "recp_rSrD11"; 
  rS11 = INIT_COEF_RS_RD;
  rD11 = INIT_COEF_RS_RD;

}

Coef_recp_rSrD11::~Coef_recp_rSrD11(void)
{


}

void Coef_recp_rSrD11::CoefFunction(double recp_h, bool DoTrapezoidal)
{

  y = 1/rS11 + 1/rD11;

}



// ------------------------------------------------------------------

// ---- Coef_recp_rSrD12 ---------------------------------------------

Coef_recp_rSrD12::Coef_recp_rSrD12(void)
{
  CoefFuncName = COEF_FUNC_recp_rSrD12;
  LiteralName = "recp_rSrD12"; 
  rS12 = INIT_COEF_RS_RD;
  rD12 = INIT_COEF_RS_RD;

}

Coef_recp_rSrD12::~Coef_recp_rSrD12(void)
{


}

void Coef_recp_rSrD12::CoefFunction(double recp_h, bool DoTrapezoidal)
{

  y = 1/rS12 + 1/rD12;

}



// ------------------------------------------------------------------        


// ---- Coef_C11_h ----------------------------------------------------

Coef_C11_h::Coef_C11_h(void)
{
  CoefFuncName = COEF_FUNC_C11_h;
  LiteralName = "C11_h";

}

Coef_C11_h::~Coef_C11_h(void)
{


}

void Coef_C11_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{

 	y = C11 * recp_h;

}

// ------------------------------------------------------------------

// ---- Coef_C12_h ----------------------------------------------------

Coef_C12_h::Coef_C12_h(void)
{
  CoefFuncName = COEF_FUNC_C12_h;
  LiteralName = "C12_h";

}

Coef_C12_h::~Coef_C12_h(void)
{


}

void Coef_C12_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{

	y = C12 * recp_h;

}

// ------------------------------------------------------------------


// ---- Coef_v1_h_prev_C11 ------------------------------------------

Coef_v1_h_prev_C11::Coef_v1_h_prev_C11(void)
{
  CoefFuncName = COEF_FUNC_v1_h_prev_C11;
  LiteralName = "v1_h_prev_C11";	
	
  v1_ = (VBus_p - VBus_m) / 2.0;	

}

Coef_v1_h_prev_C11::~Coef_v1_h_prev_C11(void)
{
	
	
}

void Coef_v1_h_prev_C11::CoefFunction(double recp_h, bool DoTrapezoidal)
{
	
   y = v1_ * C11 * recp_h;
	
}


// -------------------------------------------------------------------


// ---- Coef_v11_v1_h_prev_C12 --------------------------------------

Coef_v11_v1_h_prev_C12::Coef_v11_v1_h_prev_C12(void)
{
  CoefFuncName = COEF_FUNC_v11_v1_h_prev_C12;
  LiteralName = "v11_v1_h_prev_C12";
	
  v1_ = (VBus_p - VBus_m) / 2.0;
  v11_ = 0;
}

Coef_v11_v1_h_prev_C12::~Coef_v11_v1_h_prev_C12(void)
{
	
	
}


void Coef_v11_v1_h_prev_C12::CoefFunction(double recp_h, bool DoTrapezoidal)
{

  y = (v11_ - v1_) * C12 * recp_h;

}


// ------------------------------------------------------------------

// ---- Coef_L1_h ---------------------------------------------------

Coef_L1_h::Coef_L1_h(void)
{
  CoefFuncName = COEF_FUNC_L1_h;
  LiteralName = "L1_h";	
	
}
	
Coef_L1_h::~Coef_L1_h(void)
{
	
	
}

Coef_L1_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{
  y = L1 * recp_h;
	
}

// ------------------------------------------------------------------

// ---- Coef_M12_h ---------------------------------------------------

Coef_M12_h::Coef_M12_h(void)
{
  CoefFuncName = COEF_FUNC_M12_h;
  LiteralName = "M12_h";	
	
}
	
Coef_M12_h::~Coef_M12_h(void)
{
	
	
}

Coef_M12_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{
  y = M12 * recp_h;
	
}

// ------------------------------------------------------------------


// ---- Coef_M31_h ---------------------------------------------------

Coef_M31_h::Coef_M31_h(void)
{
  CoefFuncName = COEF_FUNC_M31_h;
  LiteralName = "M31_h";	
	
}
	
Coef_M31_h::~Coef_M31_h(void)
{
	
	
}

Coef_M31_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{
  y = M31 * recp_h;
	
}

// ------------------------------------------------------------------


// ---- Coef_L1_M12_M31_h_prev_i12_i22_i32 --------------------------

Coef_L1_M12_M31_h_prev_i12_i22_i32::Coef_L1_M12_M31_h_prev_i12_i22_i32(void)
{
  CoefFuncName = COEF_FUNC_L1_M12_M31_h_prev_i12_i22_i32;	
  LiteralName = "L1_M12_M31_h_prev_i12_i22_i32";
  
  i12_ = 0;
  i22_ = 0;
  i32_ = 0;
  
}
	
Coef_L1_M12_M31_h_prev_i12_i22_i32::~Coef_L1_M12_M31_h_prev_i12_i22_i32(void)
{
	
	
}	

Coef_L1_M12_M31_h_prev_i12_i22_i32::CoefFunction(double recp_h, bool DoTrapezoidal)
{
  y = L1*i12_*recp_h - M12*i22_*recp_h - M31*i32*recp_h;
	
}
	
// ------------------------------------------------------------------	








// ---- Coef_recp_rSrD21 ---------------------------------------------

Coef_recp_rSrD21::Coef_recp_rSrD21(void)
{
  CoefFuncName = COEF_FUNC_recp_rSrD21;
  LiteralName = "recp_rSrD21"; 
  rS21 = INIT_COEF_RS_RD;
  rD21 = INIT_COEF_RS_RD;

}

Coef_recp_rSrD21::~Coef_recp_rSrD21(void)
{


}

void Coef_recp_rSrD21::CoefFunction(double recp_h, bool DoTrapezoidal)
{

  y = 1/rS21 + 1/rD21;

}



// ------------------------------------------------------------------

// ---- Coef_recp_rSrD22 ---------------------------------------------

Coef_recp_rSrD22::Coef_recp_rSrD22(void)
{
  CoefFuncName = COEF_FUNC_recp_rSrD22;
  LiteralName = "recp_rSrD22"; 
  rS22 = INIT_COEF_RS_RD;
  rD22 = INIT_COEF_RS_RD;

}

Coef_recp_rSrD22::~Coef_recp_rSrD22(void)
{


}

void Coef_recp_rSrD22::CoefFunction(double recp_h, bool DoTrapezoidal)
{

  y = 1/rS22 + 1/rD22;

}



// ------------------------------------------------------------------        


// ---- Coef_C21_h ----------------------------------------------------

Coef_C21_h::Coef_C21_h(void)
{
  CoefFuncName = COEF_FUNC_C21_h;
  LiteralName = "C21_h";

}

Coef_C21_h::~Coef_C21_h(void)
{


}

void Coef_C21_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{

 	y = C21 * recp_h;

}

// ------------------------------------------------------------------

// ---- Coef_C22_h ----------------------------------------------------

Coef_C22_h::Coef_C22_h(void)
{
  CoefFuncName = COEF_FUNC_C22_h;
  LiteralName = "C22_h";

}

Coef_C22_h::~Coef_C22_h(void)
{


}

void Coef_C22_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{

	y = C22 * recp_h;

}

// ------------------------------------------------------------------


// ---- Coef_v2_h_prev_C21 ------------------------------------------

Coef_v2_h_prev_C21::Coef_v2_h_prev_C21(void)
{
  CoefFuncName = COEF_FUNC_v2_h_prev_C21;
  LiteralName = "v2_h_prev_C21";	
	
  v2_ = (VBus_p - VBus_m) / 2.0;	

}

Coef_v2_h_prev_C21::~Coef_v2_h_prev_C21(void)
{
	
	
}

void Coef_v2_h_prev_C21::CoefFunction(double recp_h, bool DoTrapezoidal)
{
	
   y = v2_ * C21 * recp_h;
	
}


// -------------------------------------------------------------------


// ---- Coef_v21_v2_h_prev_C22 --------------------------------------

Coef_v21_v2_h_prev_C22::Coef_v21_v2_h_prev_C22(void)
{
  CoefFuncName = COEF_FUNC_v21_v2_h_prev_C22;
  LiteralName = "v21_v2_h_prev_C22";
	
  v2_ = (VBus_p - VBus_m) / 2.0;
  v21_ = 0;
}

Coef_v21_v2_h_prev_C22::~Coef_v21_v2_h_prev_C22(void)
{
	
	
}


void Coef_v21_v2_h_prev_C22::CoefFunction(double recp_h, bool DoTrapezoidal)
{

  y = (v21_ - v2_) * C22 * recp_h;

}


// ------------------------------------------------------------------

// ---- Coef_L2_h ---------------------------------------------------

Coef_L2_h::Coef_L2_h(void)
{
  CoefFuncName = COEF_FUNC_L2_h;
  LiteralName = "L2_h";	
	
}
	
Coef_L2_h::~Coef_L2_h(void)
{
	
	
}

Coef_L2_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{
  y = L2 * recp_h;
	
}

// ------------------------------------------------------------------

// ---- Coef_M12_h ---------------------------------------------------

 	// (Previous defined above.)

// ------------------------------------------------------------------


// ---- Coef_M23_h ---------------------------------------------------

Coef_M23_h::Coef_M23_h(void)
{
  CoefFuncName = COEF_FUNC_M23_h;
  LiteralName = "M23_h";	
	
}
	
Coef_M23_h::~Coef_M23_h(void)
{
	
	
}

Coef_M23_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{
  y = M23 * recp_h;
	
}

// ------------------------------------------------------------------


// ---- Coef_L2_M12_M23_h_prev_i12_i22_i32 --------------------------

Coef_L2_M12_M23_h_prev_i12_i22_i32::Coef_L2_M12_M23_h_prev_i12_i22_i32(void)
{
  CoefFuncName = COEF_FUNC_L2_M12_M23_h_prev_i12_i22_i32;	
  LiteralName = "L2_M12_M23_h_prev_i12_i22_i32";
  
  i12_ = 0;
  i22_ = 0;
  i32_ = 0;
  
}
	
Coef_L2_M12_M23_h_prev_i12_i22_i32::~Coef_L2_M12_M23_h_prev_i12_i22_i32(void)
{
	
	
}	

Coef_L2_M12_M23_h_prev_i12_i22_i32::CoefFunction(double recp_h, bool DoTrapezoidal)
{
  y = L2*i12_*recp_h - M12*i22_*recp_h - M23*i32*recp_h;
	
}
	
// ------------------------------------------------------------------	








// ---- Coef_recp_rSrD31 ---------------------------------------------

Coef_recp_rSrD31::Coef_recp_rSrD31(void)
{
  CoefFuncName = COEF_FUNC_recp_rSrD31;
  LiteralName = "recp_rSrD31";
  rS31 = INIT_COEF_RS_RD;
  rD31 = INIT_COEF_RS_RD;

}

Coef_recp_rSrD31::~Coef_recp_rSrD31(void)
{


}

void Coef_recp_rSrD31::CoefFunction(double recp_h, bool DoTrapezoidal)
{

  y = 1/rS31 + 1/rD31;

}



// ------------------------------------------------------------------

// ---- Coef_recp_rSrD32 ---------------------------------------------

Coef_recp_rSrD32::Coef_recp_rSrD32(void)
{
  CoefFuncName = COEF_FUNC_recp_rSrD32;
  LiteralName = "recp_rSrD32";
  rS32 = INIT_COEF_RS_RD;
  rD32 = INIT_COEF_RS_RD;

}

Coef_recp_rSrD32::~Coef_recp_rSrD32(void)
{


}

void Coef_recp_rSrD32::CoefFunction(double recp_h, bool DoTrapezoidal)
{

  y = 1/rS32 + 1/rD32;

}



// ------------------------------------------------------------------


// ---- Coef_C31_h ----------------------------------------------------

Coef_C31_h::Coef_C31_h(void)
{
  CoefFuncName = COEF_FUNC_C31_h;
  LiteralName = "C31_h";

}

Coef_C31_h::~Coef_C31_h(void)
{


}

void Coef_C31_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{

 	y = C31 * recp_h;

}

// ------------------------------------------------------------------

// ---- Coef_C32_h ----------------------------------------------------

Coef_C32_h::Coef_C32_h(void)
{
  CoefFuncName = COEF_FUNC_C32_h;
  LiteralName = "C32_h";

}

Coef_C32_h::~Coef_C32_h(void)
{


}

void Coef_C32_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{

	y = C32 * recp_h;

}

// ------------------------------------------------------------------


// ---- Coef_v3_h_prev_C31 ------------------------------------------

Coef_v3_h_prev_C31::Coef_v3_h_prev_C31(void)
{
  CoefFuncName = COEF_FUNC_v3_h_prev_C31;
  LiteralName = "v3_h_prev_C31";

  v3_ = (VBus_p - VBus_m) / 2.0;

}

Coef_v3_h_prev_C31::~Coef_v3_h_prev_C21(void)
{


}

void Coef_v3_h_prev_C31::CoefFunction(double recp_h, bool DoTrapezoidal)
{

   y = v3_ * C31 * recp_h;

}


// -------------------------------------------------------------------


// ---- Coef_v31_v3_h_prev_C32 --------------------------------------

Coef_v31_v3_h_prev_C32::Coef_v31_v3_h_prev_C32(void)
{
  CoefFuncName = COEF_FUNC_v31_v3_h_prev_C32;
  LiteralName = "v31_v3_h_prev_C32";

  v3_ = (VBus_p - VBus_m) / 2.0;
  v31_ = 0;
}

Coef_v31_v3_h_prev_C32::~Coef_v31_v3_h_prev_C32(void)
{


}


void Coef_v31_v3_h_prev_C32::CoefFunction(double recp_h, bool DoTrapezoidal)
{

  y = (v31_ - v3_) * C32 * recp_h;

}


// ------------------------------------------------------------------

// ---- Coef_L3_h ---------------------------------------------------

Coef_L3_h::Coef_L3_h(void)
{
  CoefFuncName = COEF_FUNC_L3_h;
  LiteralName = "L3_h";

}

Coef_L3_h::~Coef_L3_h(void)
{


}

Coef_L3_h::CoefFunction(double recp_h, bool DoTrapezoidal)
{
  y = L3 * recp_h;

}

// ------------------------------------------------------------------

// ---- Coef_M31_h ---------------------------------------------------

 	// (Previous defined above.)

// ------------------------------------------------------------------


// ---- Coef_M23_h ---------------------------------------------------

	// (Previous defined above.)

// ------------------------------------------------------------------


// ---- Coef_L3_M31_M23_h_prev_i12_i22_i32 --------------------------

Coef_L3_M31_M23_h_prev_i12_i22_i32::Coef_L3_M31_M23_h_prev_i12_i22_i32(void)
{
  CoefFuncName = COEF_FUNC_L3_M31_M23_h_prev_i12_i22_i32;
  LiteralName = "L3_M31_M23_h_prev_i12_i22_i32";

  i12_ = 0;
  i22_ = 0;
  i32_ = 0;

}

Coef_L3_M31_M23_h_prev_i12_i22_i32::~Coef_L3_M31_M23_h_prev_i12_i22_i32(void)
{


}

Coef_L3_M31_M23_h_prev_i12_i22_i32::CoefFunction(double recp_h, bool DoTrapezoidal)
{
  y = L3*i12_*recp_h - M31*i22_*recp_h - M23*i32*recp_h;

}

// ------------------------------------------------------------------


// ******************************************************************


// **** SwitchObject Functions **************************************

// ---- Switch_rS11 -----------------------------------------------

Switch_rS11::Switch_rS11(void)
{

  CoefObjItem * pCurCoefItem;

  SwitchFuncName = SWITCH_FUNC_rS11;
  LiteralName = "rS11";

  //build the COEF Rvalue list.

  pCoefObjRValList = new CoefObjItem;
  pCurCoefItem = pCoefObjRValList;

  pCurCoefItem->pCoefObject = CoefObjectList[COEF_FUNC_recp_rSrD11];

  IsIgbt = TRUE;
  IsMinusPol = FALSE;

#ifdef PLOT_SWITCHOBJECT_PROBES_rS11
  DoProbes = TRUE;
#ifdef DO_PROBE_rS11_res
  DoProbes_res = TRUE;
#endif
#ifdef DO_PROBE_rS11_cur
  DoProbes_cur = TRUE;
#endif
#ifdef DO_PROBE_rS11_gate
  DoProbes_gate = TRUE;
#endif
#endif


}

Switch_rS11::~Switch_rS11(void)
{

}

void Switch_rS11::CoefRValueUpdate(void)
{
  CoefObjItem * pCurCoefItem;

  //Update Rvalues
  pCurCoefItem = pCoefObjRValList;

  ((Coef_recp_rSrD11 *) pCurCoefItem->pCoefObject)->rS11 = y_igbt;
  ((Coef_recp_rSrD11 *) pCurCoefItem->pCoefObject)->rD11 = y_diode;

}

// ------------------------------------------------------------------


// ---- Switch_rS12 -----------------------------------------------

Switch_rS12::Switch_rS12(void)
{

  CoefObjItem * pCurCoefItem;

  SwitchFuncName = SWITCH_FUNC_rS12;
  LiteralName = "rS12";

  //build the COEF Rvalue list.

  pCoefObjRValList = new CoefObjItem;
  pCurCoefItem = pCoefObjRValList;

  pCurCoefItem->pCoefObject = CoefObjectList[COEF_FUNC_recp_rSrD12];


  IsIgbt = TRUE;
  IsMinusPol = FALSE;


#ifdef PLOT_SWITCHOBJECT_PROBES_rS12
  DoProbes = TRUE;
#ifdef DO_PROBE_rS12_res
  DoProbes_res = TRUE;
#endif
#ifdef DO_PROBE_rS12_cur
  DoProbes_cur = TRUE;
#endif
#ifdef DO_PROBE_rS12_gate
  DoProbes_gate = TRUE;
#endif
#endif


}

Switch_rS12::~Switch_rS12(void)
{

}

void Switch_rS12::CoefRValueUpdate(void)
{
  CoefObjItem * pCurCoefItem;

  //Update Rvalues
  pCurCoefItem = pCoefObjRValList;

  ((Coef_recp_rSrD12 *) pCurCoefItem->pCoefObject)->rS12 = y_igbt;
  ((Coef_recp_rSrD12 *) pCurCoefItem->pCoefObject)->rD12 = y_diode;

}


// ------------------------------------------------------------------


// ---- Switch_rS21 -----------------------------------------------

Switch_rS21::Switch_rS21(void)
{

  CoefObjItem * pCurCoefItem;

  SwitchFuncName = SWITCH_FUNC_rS21;
  LiteralName = "rS21";

  //build the COEF Rvalue list.

  pCoefObjRValList = new CoefObjItem;
  pCurCoefItem = pCoefObjRValList;

  pCurCoefItem->pCoefObject = CoefObjectList[COEF_FUNC_recp_rSrD21];

  IsIgbt = TRUE;
  IsMinusPol = FALSE;

#ifdef PLOT_SWITCHOBJECT_PROBES_rS21
  DoProbes = TRUE;
#ifdef DO_PROBE_rS21_res
  DoProbes_res = TRUE;
#endif
#ifdef DO_PROBE_rS21_cur
  DoProbes_cur = TRUE;
#endif
#ifdef DO_PROBE_rS21_gate
  DoProbes_gate = TRUE;
#endif
#endif


}

Switch_rS21::~Switch_rS21(void)
{

}

void Switch_rS21::CoefRValueUpdate(void)
{
  CoefObjItem * pCurCoefItem;

  //Update Rvalues
  pCurCoefItem = pCoefObjRValList;

  ((Coef_recp_rSrD21 *) pCurCoefItem->pCoefObject)->rS21 = y_igbt;
  ((Coef_recp_rSrD21 *) pCurCoefItem->pCoefObject)->rD21 = y_diode;

}


// ------------------------------------------------------------------


// ---- Switch_rS22 -----------------------------------------------

Switch_rS22::Switch_rS22(void)
{

  CoefObjItem * pCurCoefItem;

  SwitchFuncName = SWITCH_FUNC_rS22;
  LiteralName = "rS22";

  //build the COEF Rvalue list.

  pCoefObjRValList = new CoefObjItem;
  pCurCoefItem = pCoefObjRValList;

  pCurCoefItem->pCoefObject = CoefObjectList[COEF_FUNC_recp_rSrD22];


  IsIgbt = TRUE;
  IsMinusPol = FALSE;

#ifdef PLOT_SWITCHOBJECT_PROBES_rS22
  DoProbes = TRUE;
#ifdef DO_PROBE_rS22_res
  DoProbes_res = TRUE;
#endif
#ifdef DO_PROBE_rS22_cur
  DoProbes_cur = TRUE;
#endif
#ifdef DO_PROBE_rS22_gate
  DoProbes_gate = TRUE;
#endif
#endif



}

Switch_rS22::~Switch_rS22(void)
{

}

void Switch_rS22::CoefRValueUpdate(void)
{
  CoefObjItem * pCurCoefItem;

  //Update Rvalues
  pCurCoefItem = pCoefObjRValList;

  ((Coef_recp_rSrD22 *) pCurCoefItem->pCoefObject)->rS22 = y_igbt;
  ((Coef_recp_rSrD22 *) pCurCoefItem->pCoefObject)->rD22 = y_diode;

}



// ------------------------------------------------------------------


// ---- Switch_rS31 -----------------------------------------------

Switch_rS31::Switch_rS31(void)
{

  CoefObjItem * pCurCoefItem;

  SwitchFuncName = SWITCH_FUNC_rS31;
  LiteralName = "rS31";

  //build the COEF Rvalue list.

  pCoefObjRValList = new CoefObjItem;
  pCurCoefItem = pCoefObjRValList;

  pCurCoefItem->pCoefObject = CoefObjectList[COEF_FUNC_recp_rSrD31];



  IsIgbt = TRUE;
  IsMinusPol = FALSE;


#ifdef PLOT_SWITCHOBJECT_PROBES_rS31
  DoProbes = TRUE;
#ifdef DO_PROBE_rS31_res
  DoProbes_res = TRUE;
#endif
#ifdef DO_PROBE_rS31_cur
  DoProbes_cur = TRUE;
#endif
#ifdef DO_PROBE_rS31_gate
  DoProbes_gate = TRUE;
#endif
#endif



}

Switch_rS31::~Switch_rS31(void)
{

}

void Switch_rS31::CoefRValueUpdate(void)
{
  CoefObjItem * pCurCoefItem;

  //Update Rvalues
  pCurCoefItem = pCoefObjRValList;

  ((Coef_recp_rSrD31 *) pCurCoefItem->pCoefObject)->rS31 = y_igbt;
  ((Coef_recp_rSrD31 *) pCurCoefItem->pCoefObject)->rD31 = y_diode;

}



// ------------------------------------------------------------------


// ---- Switch_rS32 -----------------------------------------------

Switch_rS32::Switch_rS32(void)
{

  CoefObjItem * pCurCoefItem;

  SwitchFuncName = SWITCH_FUNC_rS32;
  LiteralName = "rS32";

  //build the COEF Rvalue list.

  pCoefObjRValList = new CoefObjItem;
  pCurCoefItem = pCoefObjRValList;

  pCurCoefItem->pCoefObject = CoefObjectList[COEF_FUNC_recp_rSrD32];


  IsIgbt = TRUE;
  IsMinusPol = FALSE;


#ifdef PLOT_SWITCHOBJECT_PROBES_rS32
  DoProbes = TRUE;
#ifdef DO_PROBE_rS32_res
  DoProbes_res = TRUE;
#endif
#ifdef DO_PROBE_rS32_cur
  DoProbes_cur = TRUE;
#endif
#ifdef DO_PROBE_rS32_gate
  DoProbes_gate = TRUE;
#endif
#endif

}

Switch_rS32::~Switch_rS32(void)
{

}

void Switch_rS32::CoefRValueUpdate(void)
{
  CoefObjItem * pCurCoefItem;

  //Update Rvalues
  pCurCoefItem = pCoefObjRValList;

  ((Coef_recp_rSrD32 *) pCurCoefItem->pCoefObject)->rS32 = y_igbt;
  ((Coef_recp_rSrD32 *) pCurCoefItem->pCoefObject)->rD32 = y_diode;

}


// ------------------------------------------------------------------



// ******************************************************************



	
// **** SpiceObject Functions ***************************************


// ---- Spice_ThreePhaseBridge ------------------------------------------


Spice_ThreePhaseBridge::Spice_ThreePhaseBridge(void)
{

	  SwitchObjItem * pCurSwitchItem;
	  CoefObjItem * pCurCoefItem;


	  SpiceFuncName = SPICE_FUNC_ThreePhaseBridge;
	  LiteralName = "ThreePhaseBridge";


#ifdef PLOT_SPICEOBJECT_PROBES_solution_vector
  DoProbes = TRUE;
#endif

  InitializeMatrix(31);   //(31 rows, 32 columns)

  //Eq. (1)
  a_CoefObj[0][Ind_v1] = &Coef_recp_rSrD11_i;
  a_Static[0][Ind_v1] = 1.0;
  a_CoefObj[0][Ind_i1st] = 0;
  a_Static[0][Ind_i1st] = -1.0;
  a_CoefObj[0][31] = &Coef_recp_rSrD11_i;
  a_Static[0][31] = VBus_p;

  //Eq. (2)
  a_CoefObj[1][Ind_v11] = &Coef_recp_rSrD12_i;
  a_Static[1][Ind_v11] = 1.0;
  a_CoefObj[1][Ind_v1] = &Coef_recp_rSrD12_i;
  a_Static[1][Ind_v1] = -1.0;
  a_CoefObj[1][Ind_i1sb] = 0;
  a_Static[1][Ind_i1sb] = -1.0;
  a_CoefObj[1][31] = 0;
  a_Static[1][31] = 0;

  //Eq. (3)
  a_CoefObj[2][Ind_i12] = 0;
  a_Static[2][Ind_i12] = 1.0;
  a_CoefObj[2][Ind_i11] = 0;
  a_Static[2][Ind_i11] = 1.0;
  a_CoefObj[2][Ind_i13] = 0;
  a_Static[2][Ind_i13] = -1.0;
  a_CoefObj[2][31] = 0;
  a_Static[2][31] = 0;

   //Eq. (4)
   a_CoefObj[3][Ind_i1st] = 0;
   a_Static[3][Ind_i1st] = 1.0;
   a_CoefObj[3][Ind_i1ct] = 0;
   a_Static[3][Ind_i1ct] = 1.0;
   a_CoefObj[3][Ind_i13] = 0;
   a_Static[3][Ind_i13] = -1.0;
   a_CoefObj[3][31] = 0;
   a_Static[3][31] = 0;

    //Eq. (5)
	a_CoefObj[4][Ind_i1sb] = 0;
	a_Static[4][Ind_i1sb] = 1.0;
	a_CoefObj[4][Ind_i1cb] = 0;
    a_Static[4][Ind_i1cb] = 1.0;
	a_CoefObj[4][Ind_i11] = 0;
	a_Static[4][Ind_i11] = -1.0;
	a_CoefObj[4][31] = 0;
	a_Static[4][31] = 0;

    //Eq. (6)
	a_CoefObj[5][Ind_v1] = &Coef_C11_h_i;
	a_Static[5][Ind_v1] = 1.0;
	a_CoefObj[5][Ind_i1ct] = 0;
	a_Static[5][Ind_i1ct] = -1.0;
	a_CoefObj[5][31] = &Coef_v1_h_prev_C11_i;
	a_Static[5][31] = 1.0;

     //Eq. (7)
	a_CoefObj[6][Ind_v11] = &Coef_C12_h_i;
	a_Static[6][Ind_v11] = 1.0;
	a_CoefObj[6][Ind_v1] = &Coef_C12_h_i;
	a_Static[6][Ind_v1] = -1.0;
	a_CoefObj[6][Ind_i1cb] = 0;
	a_Static[6][Ind_i1cb] = -1.0;
	a_CoefObj[6][31] = &Coef_v11_v1_h_prev_C12_i;
	a_Static[6][31] = 1.0;

    //Eq. (8)
	a_CoefObj[7][Ind_v11] = 0;
	a_Static[7][Ind_v11] = RECEP_R12;
	a_CoefObj[7][Ind_i11] = 0;
	a_Static[7][Ind_i11] = 1.0;;
	a_CoefObj[7][31] = 0;
	a_Static[7][31] = VBus_m*RECEP_R12;;

    //Eq. (9)
	a_CoefObj[8][Ind_i12] = &Coef_L1_h_i;
	a_Static[8][Ind_i12] = 1.0;
	a_CoefObj[8][Ind_i22] = &Coef_M12_h_i;
	a_Static[8][Ind_i22] = -1.0;
	a_CoefObj[8][Ind_i32] = &Coef_M31_h_i;
	a_Static[8][Ind_i32] = -1.0;
	a_CoefObj[8][Ind_v12] = 0;
	a_Static[8][Ind_v12] = -1.0;
	a_CoefObj[8][Ind_v1] = 0;
	a_Static[8][Ind_v1] = 1.0;
	a_CoefObj[8][31] = &Coef_L1_M12_M31_h_prev_i12_i22_i32_i;
	a_Static[8][31] = 1.0;

    //Eq. (10)
	a_CoefObj[9][Ind_v_n] = 0;
	a_Static[9][Ind_v_n] = RECEP_R11;
	a_CoefObj[9][Ind_v12] = 0;
	a_Static[9][Ind_v12] = -RECEP_R11;
	a_CoefObj[9][Ind_i12] = 0;
	a_Static[9][Ind_i12] = -1.0;
	a_CoefObj[9][31] = 0;
	a_Static[9][31] = 0;








	//Eq. (11)
	a_CoefObj[10][Ind_v2] = &Coef_recp_rSrD21_i;
	a_Static[10][Ind_v2] = 1.0;
	a_CoefObj[10][Ind_i2st] = 0;
	a_Static[10][Ind_i2st] = -1.0;
	a_CoefObj[10][31] = &Coef_recp_rSrD21_i;
	a_Static[10][31] = VBus_p;

	//Eq. (12)
	a_CoefObj[11][Ind_v21] = &Coef_recp_rSrD22_i;
	a_Static[11][Ind_v21] = 1.0;
	a_CoefObj[11][Ind_v2] = &Coef_recp_rSrD22_i;
	a_Static[11][Ind_v2] = -1.0;
	a_CoefObj[11][Ind_i2sb] = 0;
	a_Static[11][Ind_i2sb] = -1.0;
	a_CoefObj[11][31] = 0;
	a_Static[11][31] = 0;

	//Eq. (13)
	a_CoefObj[12][Ind_i22] = 0;
	a_Static[12][Ind_i22] = 1.0;
	a_CoefObj[12][Ind_i21] = 0;
	a_Static[12][Ind_i21] = 1.0;
	a_CoefObj[12][Ind_i23] = 0;
	a_Static[12][Ind_i23] = -1.0;
	a_CoefObj[12][31] = 0;
	a_Static[12][31] = 0;

	//Eq. (14)
	a_CoefObj[13][Ind_i2st] = 0;
	a_Static[13][Ind_i2st] = 1.0;
	a_CoefObj[13][Ind_i2ct] = 0;
	a_Static[13][Ind_i2ct] = 1.0;
	a_CoefObj[13][Ind_i23] = 0;
	a_Static[13][Ind_i23] = -1.0;
	a_CoefObj[13][31] = 0;
	a_Static[13][31] = 0;

	//Eq. (15)
	a_CoefObj[14][Ind_i2sb] = 0;
	a_Static[14][Ind_i2sb] = 1.0;
	a_CoefObj[14][Ind_i2cb] = 0;
	a_Static[14][Ind_i2cb] = 1.0;
	a_CoefObj[14][Ind_i21] = 0;
	a_Static[14][Ind_i21] = -1.0;
	a_CoefObj[14][31] = 0;
	a_Static[14][31] = 0;

	//Eq. (16)
	a_CoefObj[15][Ind_v2] = &Coef_C21_h_i;
	a_Static[15][Ind_v2] = 1.0;
	a_CoefObj[15][Ind_i2ct] = 0;
	a_Static[15][Ind_i2ct] = -1.0;
	a_CoefObj[15][31] = &Coef_v2_h_prev_C21_i;
	a_Static[15][31] = 1.0;

	 //Eq. (17)
	a_CoefObj[16][Ind_v21] = &Coef_C22_h_i;
	a_Static[16][Ind_v21] = 1.0;
	a_CoefObj[16][Ind_v2] = &Coef_C22_h_i;
	a_Static[16][Ind_v2] = -1.0;
	a_CoefObj[16][Ind_i2cb] = 0;
	a_Static[16][Ind_i2cb] = -1.0;
	a_CoefObj[16][31] = &Coef_v21_v2_h_prev_C22_i;
	a_Static[16][31] = 1.0;

	//Eq. (18)
	a_CoefObj[17][Ind_v21] = 0;
	a_Static[17][Ind_v21] = RECEP_R22;
	a_CoefObj[17][Ind_i21] = 0;
	a_Static[17][Ind_i21] = 1.0;;
	a_CoefObj[17][31] = 0;
	a_Static[17][31] = VBus_m*RECEP_R22;;

	//Eq. (19)
	a_CoefObj[18][Ind_i22] = &Coef_L1_h_i;
	a_Static[18][Ind_i22] = 1.0;
	a_CoefObj[18][Ind_i12] = &Coef_M12_h_i;
	a_Static[18][Ind_i12] = -1.0;
	a_CoefObj[18][Ind_i32] = &Coef_M23_h_i;
	a_Static[18][Ind_i32] = -1.0;
	a_CoefObj[18][Ind_v22] = 0;
	a_Static[18][Ind_v22] = -1.0;
	a_CoefObj[18][Ind_v2] = 0;
	a_Static[18][Ind_v2] = 1.0;
	a_CoefObj[18][31] = &Coef_L2_M12_M23_h_prev_i12_i22_i32_i;
	a_Static[18][31] = 1.0;

	//Eq. (20)
	a_CoefObj[19][Ind_v_n] = 0;
	a_Static[19][Ind_v_n] = RECEP_R21;
	a_CoefObj[19][Ind_v22] = 0;
	a_Static[19][Ind_v22] = -RECEP_R21;
	a_CoefObj[19][Ind_i22] = 0;
	a_Static[19][Ind_i22] = -1.0;
	a_CoefObj[19][31] = 0;
	a_Static[19][31] = 0;








//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

	//Eq. (21)
	a_CoefObj[20][Ind_v3] = &Coef_recp_rSrD31_i;
	a_Static[20][Ind_v3] = 1.0;
	a_CoefObj[20][Ind_i3st] = 0;
	a_Static[20][Ind_i3st] = -1.0;
	a_CoefObj[20][31] = &Coef_recp_rSrD31_i;
	a_Static[20][31] = VBus_p;

	//Eq. (22)
	a_CoefObj[21][Ind_v31] = &Coef_recp_rSrD32_i;
	a_Static[21][Ind_v31] = 1.0;
	a_CoefObj[21][Ind_v3] = &Coef_recp_rSrD32_i;
	a_Static[21][Ind_v3] = -1.0;
	a_CoefObj[21][Ind_i3sb] = 0;
	a_Static[21][Ind_i3sb] = -1.0;
	a_CoefObj[21][31] = 0;
	a_Static[21][31] = 0;

	//Eq. (13)
	a_CoefObj[12][Ind_i22] = 0;
	a_Static[12][Ind_i22] = 1.0;
	a_CoefObj[12][Ind_i21] = 0;
	a_Static[12][Ind_i21] = 1.0;
	a_CoefObj[12][Ind_i23] = 0;
	a_Static[12][Ind_i23] = -1.0;
	a_CoefObj[12][31] = 0;
	a_Static[12][31] = 0;

	//Eq. (14)
	a_CoefObj[13][Ind_i2st] = 0;
	a_Static[13][Ind_i2st] = 1.0;
	a_CoefObj[13][Ind_i2ct] = 0;
	a_Static[13][Ind_i2ct] = 1.0;
	a_CoefObj[13][Ind_i23] = 0;
	a_Static[13][Ind_i23] = -1.0;
	a_CoefObj[13][31] = 0;
	a_Static[13][31] = 0;

	//Eq. (15)
	a_CoefObj[14][Ind_i2sb] = 0;
	a_Static[14][Ind_i2sb] = 1.0;
	a_CoefObj[14][Ind_i2cb] = 0;
	a_Static[14][Ind_i2cb] = 1.0;
	a_CoefObj[14][Ind_i21] = 0;
	a_Static[14][Ind_i21] = -1.0;
	a_CoefObj[14][31] = 0;
	a_Static[14][31] = 0;

	//Eq. (16)
	a_CoefObj[15][Ind_v2] = &Coef_C21_h_i;
	a_Static[15][Ind_v2] = 1.0;
	a_CoefObj[15][Ind_i2ct] = 0;
	a_Static[15][Ind_i2ct] = -1.0;
	a_CoefObj[15][31] = &Coef_v2_h_prev_C21_i;
	a_Static[15][31] = 1.0;

	 //Eq. (17)
	a_CoefObj[16][Ind_v21] = &Coef_C22_h_i;
	a_Static[16][Ind_v21] = 1.0;
	a_CoefObj[16][Ind_v2] = &Coef_C22_h_i;
	a_Static[16][Ind_v2] = -1.0;
	a_CoefObj[16][Ind_i2cb] = 0;
	a_Static[16][Ind_i2cb] = -1.0;
	a_CoefObj[16][31] = &Coef_v21_v2_h_prev_C22_i;
	a_Static[16][31] = 1.0;

	//Eq. (18)
	a_CoefObj[17][Ind_v21] = 0;
	a_Static[17][Ind_v21] = RECEP_R22;
	a_CoefObj[17][Ind_i21] = 0;
	a_Static[17][Ind_i21] = 1.0;;
	a_CoefObj[17][31] = 0;
	a_Static[17][31] = VBus_m*RECEP_R22;;

	//Eq. (19)
	a_CoefObj[18][Ind_i22] = &Coef_L1_h_i;
	a_Static[18][Ind_i22] = 1.0;
	a_CoefObj[18][Ind_i12] = &Coef_M12_h_i;
	a_Static[18][Ind_i12] = -1.0;
	a_CoefObj[18][Ind_i32] = &Coef_M23_h_i;
	a_Static[18][Ind_i32] = -1.0;
	a_CoefObj[18][Ind_v22] = 0;
	a_Static[18][Ind_v22] = -1.0;
	a_CoefObj[18][Ind_v2] = 0;
	a_Static[18][Ind_v2] = 1.0;
	a_CoefObj[18][31] = &Coef_L2_M12_M23_h_prev_i12_i22_i32_i;
	a_Static[18][31] = 1.0;

	//Eq. (20)
	a_CoefObj[19][Ind_v_n] = 0;
	a_Static[19][Ind_v_n] = RECEP_R21;
	a_CoefObj[19][Ind_v22] = 0;
	a_Static[19][Ind_v22] = -RECEP_R21;
	a_CoefObj[19][Ind_i22] = 0;
	a_Static[19][Ind_i22] = -1.0;
	a_CoefObj[19][31] = 0;
	a_Static[19][31] = 0;






//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX



}
