Inorder, preorder, post order traversals using C

TRAVERSALS

#include<stdio.h>

#include<conio.h>

typedef struct node

{

int data;

struct node*left;

struct node*right;

}tree;

tree* createtree();

tree* insert(tree*,tree*);

void preorder(tree*);

void inorder(tree*);

void postorder(tree*);

void main()

{

int ch;

tree*bt;

clrscr();

bt=createtree();

printf("\n \tBINARY TREE TRAVERSAL \n");

printf("\n \t1.traversals \n");

printf("\n \t2.exit\n");

printf("\n \tenter your choice \n");

scanf("%d",&ch);

if(bt==NULL)

{

printf("\nbinary tree is empty\n");

return;

}

switch(ch)

{

case 1:

printf("\n \t preorder traversal \n");

preorder(bt);

printf("\n \t inorder traversal \n");

inorder(bt);

printf("\n \t postorder traversal \n");

postorder(bt);

break;

case 2:

printf("\n exit");

exit(0);

}

getch();

free(bt);

}

tree* createtree()

{

char ch;

tree *bt=NULL,*temp;

do

{

temp=(tree*)malloc(sizeof(struct node));

printf("\n enter the data\n");

scanf("%d",&temp->data);

temp->left=NULL;

temp->right=NULL;

bt=insert(bt,temp);

fflush(stdin);

printf("\n want to add more data y/n :");

scanf("%c",&ch);

}while((ch=='y')||(ch=='Y'));

return bt;

}

tree* insert(tree *bt,tree *temp)

{

if(bt==NULL)

return temp;

else if(temp->data<bt->data)

bt->left=insert(bt->left,temp);

else if(temp->data>bt->data)

bt->right=insert(bt->right,temp);

else if(temp->data==bt->data)

{

printf("\n data is already existing \n");

return bt;

}

return bt;

}

void inorder(tree *bt)

{

if(bt)

{

inorder(bt->left);

printf("%d",bt->data);

inorder(bt->right);

}

}

void preorder(tree *bt)

{

if(bt)

{

printf("%d",bt->data);

preorder(bt->left);

preorder(bt->right);

}

}

void postorder(tree *bt)

{

if(bt)

{

postorder(bt->left);

postorder(bt->right);

printf("%d",bt->data);

}

}

SAMPLE OUTPUT:

Enter the data

5

Want to add more data y/n: Y

Enter the data

2

Want to add more data y/n: Y

Enter the data

3

Want to add more data y/n: Y

Enter the data

4

Want to add more data y/n: N

BINARY TREE TRAVERSAL

1.traversals

2.exit

Enter your choice

1

Preorder traversal 5234

Inorder traversal 2345

Postorder traversal 4325

Implementation of Singly Linked List

//PROGRAM TO IMPLEMENT SINGLY LINKED LIST\\

#include<stdio.h>

#include<conio.h>

#include<alloc.h>

#include<stdlib.h>

struct node

{

int data;

struct node *link;

};

void append(struct node **,int);

void add_at_begin(struct node **,int);

void del(struct node **,int);

void in_middle(struct node **,int,int);

int count(struct node *);

void display(struct node *);

void main()

{

int num,loc;

char choice;

struct node *p;

p=NULL;

do

{

clrscr();

printf("PROGRAM TO IMPLEMENT SINGLY LINKED LIST\n");

printf("---------------------------------------\n");

printf("\n 1. Create/appending the list");

printf("\n 2. Insert node at begining");

printf("\n 3. Insert node in middle");

printf("\n 4. Deleting a node");

printf("\n 5. Counting the no. of nodes");

printf("\n 6. Displaying the list");

printf("\n 7. Exit");

oper:

gotoxy(1,15);printf(" ");

gotoxy(1,11);printf("\n Enter your choice : ");

choice=getch();

switch(choice)

{

char ans;

case '1':

do

{

printf("Enter any number : ");

scanf("%d",&num);

append(&p,num);

printf("Entr more (y/n) : ");

fflush(stdin);

ans=getchar();

}while(ans!='n');

break;

case '2':

printf("Enter the data : ");

scanf("%d",&num);

add_at_begin(&p,num);

break;

case '3':

printf("\n Enter the data position : ");

scanf("%d",&loc);

printf("\n Enter the data : ");

scanf("%d",&num);

in_middle(&p,loc,num);

break;

case '4':

printf("\n Enter the data u want to delete : ");

scanf("%d",&num);

del(&p,num);

break;

case '5':

printf("\n The no. of nodes are %d",count(p));

getch();

break;

case '6':

display(p);

getch();

break;

case '7':

printf("\n Quiting.......");

getch();

exit(0);

break;

default:

gotoxy(1,15);printf("Invalid choice please Enter correct choice");

getch();

goto oper;

}

}while(choice!=7);

}

void append(struct node **q,int num)

{

struct node *temp,*r;

temp=*q;

if(*q==NULL)

{

temp=(struct node *)malloc(sizeof(struct node));

temp->data=num;

temp->link=NULL;

*q=temp;

}

else

{

temp=*q;

while(temp->link!=NULL)

{

temp=temp->link;

}

r=(struct node *)malloc(sizeof(struct node));

r->data=num;

r->link=NULL;

temp->link=r;

}

}

void display(struct node *q)

{

if(q==NULL)

{

printf("\nEmpty link list can't display the data");

getch();

goto last;

}

while(q!=NULL)

{

printf("\n%d",q->data);

q=q->link;

}

last:

}

int count(struct node *q)

{

int c=0;

if(q==NULL)

{

printf("Empty link list \n");

getch();

goto last;

}

while(q!=NULL)

{

c++;

q=q->link;

}

last:

return c;

}

void add_at_begin(struct node **q,int num)

{

struct node *temp;

if(*q==NULL)

{

printf("Link list is empty can't insert");

getch();

goto last;

}

else

{

temp=(struct node *)malloc(sizeof(struct node));

temp->data=num;

temp->link=*q;

*q=temp;

}

last:

getch();

}

void in_middle(struct node **q,int loc,int num)

{

struct node *temp,*n;

int c=1,flag=0;

temp=*q;

if(*q==NULL)

{

printf("\nLink List is empty can't insert");

getch();

goto last;

}

else

while(temp!=NULL)

{

if(c==loc)

{

n=(struct node *)malloc(sizeof(struct node));

n->data=num;

n->link=temp->link;

temp->link=n;

flag=1;

}

c++;

temp=temp->link;

}

if(flag==0)

{

printf("\nNode specified doesn't Exist can't Enter the Data");

getch();

}

else

{

printf("Data Inserted");

getch();

}

last:

getch();

}

void del(struct node **q,int num)

{

if(*q==NULL)

{

printf("\n Empty linked list cant delete the data");

getch();

goto last;

}

else

{

struct node *old,*temp;

int flag=0;

temp=*q;

while(temp!=NULL)

{

if(temp->data==num)

{

if(temp==*q)

*q=temp->link;

else

old->link=temp->link;

free(temp);

flag=1;

}

else

{

old=temp;

temp=temp->link;

}

}

if(flag==0)

printf("\n Data not found...");

else

printf("\n Data deleted...Tap a key to continue");

getch();

}

last:

getch();

}

Sample output:

PROGRAM TO IMPLEMENT SINGLY LINKED LIST

---------------------------------------

1. Create/appending the list

2. Insert node at beginning

3. Insert node in middle

4. Deleting a node

5. Counting the no. of nodes

6. Displaying the list

7. Exit

Enter your choice : Enter any number : 12

Entr more (y/n) : y

Enter any number : 23

Entr more (y/n) : y

Enter any number : 34

Enter more (y/n) :n

Enter your choice :6

12

23

34

Enter your choice :5

The no. of nodes are 3

Enter your choice :4

Enter the data u want to delete : 25

Data not found...

Enter your choice :3

Enter the data position : 2

Enter the data : 00

Data Inserted

Enter your choice :6

12

23

0

34

Enter your choice :7

Quiting.......

Queue implementation using C

The readers are requested to check for any errors in the program (as the program is typed and copied from MS Word)

QUEUE IMPLEMENTATION USING ARRAYS

#include<stdio.h>

#include<conio.h>

void create(void);

void display(void);

void queue_in(void);

void queue_out(void);

void front_rear(void);

int front,rear;

int q[25];

void create()

{

int n;

printf("Enter the number of elements in the queue \n");

scanf("%d",&n);

printf("Enter the elements \n");

for(rear=0;rear<n;rear++)

{

scanf("%d",&q[rear]);

}

front=0;

}

void display()

{

if(rear!=0)

{

printf("The elements in queue \n");

for(front=0;front<rear;front++)

{

printf("%d",q[front]);

}

front=0;

}

else if(rear==0)

printf("The queue is empty \n");

else if(rear==25)

printf("The queue is full \n");

}

void front_rear()

{

if(rear!=0)

{

printf("the front element is : %d \n",q[front]);

printf("the rear element is : %d \n",q[rear-1]);

}

else

printf("Queue is empty \n");

}

void queue_in()

{

if(rear<25)

{

printf("Enter the elements \n");

scanf("%d",&q[rear]);

++rear;

}

else

printf("Queue is full \n");

}

void queue_out()

{

if(rear!=0)

{

printf("The deleted element is : %d \n ",q[front]);

for(front=0;front<rear-1;++front)

q[front]=q[front+1];

rear--;

front=0;

}

}

int main()

{

int ch=0;

clrscr();

printf("QUEUE MANIPULATION \n");

printf("creation \n");

create();

display();

getch();

do

{

clrscr();

printf("Queue operations \n");

printf("---------------- \n");

printf("1. Inserting in to the Queue \n");

printf("2. Deletion from queue \n");

printf("3. Front and rear element \n");

printf("4. Displaying the queue \n");

printf("5. Exit \n");

printf("Enter your choice \n");

scanf("%d\n",&ch);

switch(ch)

{

case 1 :queue_in();

display();

break;

case 2 :queue_out();

display();

break;

case 3 :front_rear();

break;

case 4 :display();

break;

case 5 :printf("END \n");

break;

default: printf("Invalid Entry \n");

}

getch();

}

while(ch!=5);

return (0);

}

Sample output:

QUEUE MANIPULATION

Creation

Enter the number of elements in the queue

4

Enter the elements

1

2

3

4

The elements in queue

1234

Queue operations

----------------

1. Inserting in to the Queue

2. Deletion from queue

3. Front and rear element

4. Displaying the queue

5. Exit

Enter your choice

1

5

Enter the elements

The elements in queue

12345

Enter your choice

3

the front element is : 1

the rear element is : 5

Enter your choice

4

The elements in queue

12345

Enter your choice

2

The deleted element is: 1

The elements in queue

2345

Enter your choice

5

END

 

QUEUE USING LINKED LIST

#include<stdio.h>

typedef struct node

{

int data;

struct node*link;

}queue;

queue*getnode();

void releasenode(queue*p);

int isfull();

int isempty(queue*front);

void enqueue(queue**frontptr,queue**rearptr,int value);

void dequeue(queue**frontptr,queue**rearptr,int*value);

void peek(queue*front,int*value);

void view(queue*front);

int size(queue*front);

void displaymenu(void);

void main()

{

queue*front=NULL,*rear=NULL;

int choice,item;

displaymenu();

while(1)

{

printf("\n?");

scanf("%d",&choice);

switch(choice)

{

case 1:

if(isfull())

printf("\nQueue overflow on ENQUEUE");

else

{

printf("\nEnter the element:");

fflush(stdin);

scanf("%d",&item);

enqueue(&front,&rear,item);

}

break;

case 2:

if(isempty(front))

printf("\n Queue underflow on DEQUEUE");

else

{

dequeue(&front,&rear,&item);

printf("\nThe dequeued value is %d",item);

}

break;

case 3:

if(!isempty(front))

{

peek(front,&item);

printf("\nThe front value is %d",item);

}

else

printf("\nQueue is empty");

break;

case 4:

printf("\nCount of queue elements=%d",size(front));

break;

case 5:

view(front);

break;

default:

printf("\nEnd of run of your program..");

exit(0);

}

}

}

void displaymenu()

{

printf("\nRepresentation of queue using linked list...");

printf("\n\t1.enqueue");

printf("\n\t2.dequeue");

printf("\n\t3.peek");

printf("\n\t4.size");

printf("\n\t5.view");

printf("\n\t6.exit");

}

void releasenode(queue*p)

{

free(p);

}

queue*getnode()

{

int size;

queue*newnode;

size=sizeof(queue);

newnode=(queue*)malloc(size);

return(newnode);

}

int isempty(queue*front)

{

if(front==NULL)

return 1;

else

return 0;

}

int isfull()

{

queue*newnode;

newnode=getnode();

if(newnode==NULL)

return 1;

releasenode(newnode);

return 0;

}

void enqueue(queue**frontptr,queue**rearptr,int value)

{

queue*newnode;

if(isfull())

{

printf("\nMemory not available");

return;

}

newnode=getnode();

newnode->data=value;

newnode->link=NULL;

if(*frontptr==NULL)

*frontptr=newnode;

else

(*rearptr)->link=newnode;

*rearptr=newnode;

}

void dequeue(queue**frontptr,queue**rearptr,int*value)

{

queue*tempnode;

if(isempty(*frontptr))

return;

tempnode=*frontptr;

*frontptr=(*frontptr)->link;

if(*frontptr==NULL)

*rearptr=NULL;

*value=tempnode->data;

releasenode(tempnode);

}

void peek(queue*front,int*value)

{

if(isempty(front))

{

printf("\nThe queue is empty!!!");

return;

}

*value=front->data;

}

void view(queue*front)

{

if(isempty(front))

{

printf("\nThe queue is empty!!!");

return;

}

printf("\nQueue contains...front->");

while(front!=NULL)

{

printf("%d-->",front->data);

front=front->link;

}

printf("rear/n");

}

int size(queue*front)

{

int count=0;

if(front==NULL)

return count;

for(;front!=NULL;)

{

count++;

front=front->link;

}

return count;

}

Sample output:

Representation of queue using linked list..

1. enqueue

2. dequeue

3. peek

4. size

5. view

6. exit

?2

Queue underflow on DEQUEUE

?3

Queue is empty

?4

Count of queue elements=0

?5

The queue is empty!!!

?1

Enter the element:11

?1

Enter the element:22

?1

Enter the element:33

?5

Queue contains...front->11-->22-->33-->rear/n

?4

Count of queue elements=3

?2

The dequeued value is 11

?6

Stack Implementation using C

The following two programs for the stack implementation using Array and Linked List, the readers are requested to report if there are any errors (syntax or semantic)

//STACK IMPLEMENTATION USING ARRAYS\\

#include<stdio.h>

#include<conio.h>

void create(void);

void push(0void);

void pop(void);

void display(void);

void topelement(void);

int a[25];

int top;

void create()

{

int i;

printf("Enter the number of elements in the stack \n");

scanf("%d",&top);

printf("Enter the elements \n");

for(i=0;i<top;++i)

{

scanf("%d",&a[i]);

}

return;

}

void display()

{

int i;

if((top!=0) && (top!=25))

{

printf("The elements in the stack are \n");

for(i=top-1;i>=0;--i)

printf("%d",a[i]);

getch();

}

}

void push()

{

if(top==25)

{

printf("The stack is full \n");

}

else

{

printf("Enter the element \n");

scanf("%d",&a[top]);

top++;

}

return;

}

void pop()

{

if(top==0)

{

printf("the stack is empty \n");

}

else

{

printf("The popped element is %d",a[--top]);

}

return;

}

void topelement()

{

int t;

if(top==0)

{

printf("There is no top element \n");

}

else

{

t=top-1;

printf("The top element is %d\n",a[t]);

}

return;

}

void main()

{

int ch;

clrscr();

create();

display();

do{

clrscr();

printf("Stack operations \n");

printf("----------------\n");

printf("1. PUSH \n");

printf("2. POP \n");

printf("3. TOP ELEMENT \n");

printf("4. Displaying the stack \n");

printf("5. Quit \n");

printf("Enter your choice \n");

scanf("%d\n",&ch);

switch(ch)

{

case 1: push();

display();

break;

case 2: pop();

display();

break;

case 3: topelement();

// display();

break;

case 4: display();

break;

case 5: printf("END \n");

break;

default: printf("Invalid Entry \n");

}

getch();

}while(ch !=5);

}

Sample output:

Enter the number of elements in the stack

4

Enter the elements

1

2

3

4

The elements in the stack are

4321

Stack operations

----------------

1. PUSH

2. POP

3. TOP ELEMENT

4. Displaying the stack

5. Quit

Enter your choice

1

0

Enter the element

The elements in the stack are

04321

Enter your choice

3

The top element is 0

Enter your choice

2

The popped element is 0

Enter your choice

1

Enter the element

1

The elements in the stack are

14321

Enter your choice

5

END

 

STACK USING LINKED LIST

#include<stdio.h>

#include<conio.h>

#include<stdlib.h>

typedef struct node

{

int data;

struct node *next;

}stack;

int size();

void view();

int isFull();

int isEmpty();

void displayMenu();

int push(int value);

int pop(int *value);

int peek(int *value);

stack *getNode();

void releaseNode(stack *newnode);

stack *topstk=NULL;

void main()

{

int data,status,choice;

displayMenu();

while(1)

{

printf("\n\n ?");

scanf("%d",&choice);

switch(choice)

{

case 1:

printf("\nenter the element:");

fflush(stdin);

scanf("%d",&data);

status=push(data);

if(status == -1)

printf("\n memory is not available.....");

break;

case 2:

status=pop(&data);

if(status == -1)

printf("\nstack is underflow on pop");

else

printf("\n the popped elementis %d",data);

break;

case 3:

status=peek(&data);

if(status == -1)

printf("\nstack is empty!!!");

else

printf("\n the top element is %d",data);

break;

case 4:

printf("\ncurrent stack element = %d",size());

break;

case 5:

view();

break;

default:

printf("\n end of run program");

exit(0);

}

}

}

void displayMenu()

{

printf("\nrepresentation of stack using single linked list");

printf("\n\t1.push");

printf("\n\t2.pop");

printf("\n\t3.peek");

printf("\n\t4.size");

printf("\n\t5.view");

printf("\n\t6.exit");

}

stack *getNode()

{

return((stack *)malloc(sizeof(stack)));

}

void releaseNode(stack *newnode)

{

free(newnode);

}

int push(int value)

{

extern stack *topstk;

stack *newptr;

if(isFull())

return -1;

newptr=getNode();

newptr->data=value;

newptr->next=topstk;

topstk=newptr;

return 0;

}

int pop(int *value)

{

extern stack *topstk;

stack *temp;

if(isEmpty())

return -1;

temp=topstk;

topstk=topstk->next;

*value=temp->data;

releaseNode(temp);

return 0;

}

int peek(int *value)

{

extern stack *topstk;

stack *temp;

if(isEmpty())

return -1;

temp=topstk;

*value=temp->data;

return 0;

}

int isEmpty()

{

extern stack *topstk;

if(topstk==NULL)

return 1;

else

return 0;

}

int isFull()

{

extern stack *topstk;

stack *temp;

temp=getNode();

if(temp==NULL)

return 1;

else

{

releaseNode(temp);

return 0;

}

}

int size()

{

extern stack *topstk;

stack *top;

int count=0;

for(top=topstk;top!=NULL;top=top->next)

count++;

return count;

}

void view()

{

extern stack *topstk;

stack *top;

if(isEmpty())

{

printf("\nthe stack is empty!!!");

return;

}

printf("\n the content of the stack is......TOP");

for(top=topstk;top!=NULL;top=top->next)

printf("-->%d",top->data);

}

Sample output:

Representation of stack using linked list

1. Push

2. Pop

3. Peek

4. Size

5. View

6. Exit

?2

stack underflow on POP

?3

stack is empty

?4

stack is elements=0

?1

enter the element:11

?1

enter the element:22

?5

the content of the stack is……TOPà22à11

?4

stack elements=2

?2

the popped value is 22

?6

end of run of your program

Electrical Machine Design (equations)

Factors

DC Machine

Transformers

Induction Machines

Synchronous Machines

Output Equation Pa=CoD2Ln, where Pa=P/h for generators, Pa=P for motors For Single Phase
Q=2.22 f Bm Ai Kw Aw d 10-3
For Three Phase
Q=3.33 f Bm Ai Kw Aw d 10-3
Q=CoD2 L ns
KVA Input Q=
HP * 0.746 / Cos f * h
Q=CoD2 L ns
KVA Input Q=
HP * 0.746 / Cos f * h
For Turbo alternators
Q=1.11Bavac KwsVa2 L 10-3/ns
Output Coefficient Co=Bav ac* 10-3 where Bav-magnetic loading and ac - electric loading DNA Co=11 Kws Bav ac 10-3 Co=11 Kws Bav ac 10-3
Choice of Magnetic Loading
Flux Density in Teeth Frequency of Flux Reversals Size of machine DNA Magnetizing current, Flux Density, Iron loss Iron loss, Stability, Voltage Rating, Parallel Operation, Transient ShortCircuit current
Choice of Electric Loading
Temperature rise,
speed of machine, Voltage, Armature reaction, Commutation
DNA Overload Capacity, Copper losses, Temperature rise, Leakage Reactance Copper loss, Synchronous reactance, Temperature rise, Stray Load losses,
Voltage rating
Flux Density
Yoke – 1.3 to 1.6 Wb/m2
Pole – 1.2 to 1.7
Air Gap – 0.4 to 0.6
Armature teeth – 1.5 – 2.2
Armature core – 1.0 to 1.5
1. 0 to 1.4 wb/m2 for Distribution Transformer
1.2 to 1.5 for power Transformers
Stator tooth
1.3 to 1.7 Wb/m2
Rotor tooth
1.3 to 1.7 Wb/m2
Current Density
Large Machine with strap wound conds – 4.5A/mm2
Small M/c with wire wound conds – 5A/mm2
High speed - 6 to 7A/mm2
General - 4 to 7A//mm2
1.1 to 2.2 A/mm2- small Tr..
2.2 to 3.2 – large power Tr..
5.4 to 6.2 – Large power Tr with Forced circulation
In rotor bar 4 to 7A/mm2 Current density in armature conductor
d = 3 to 5A/mm2
Main Dimension D- Diameter of the armature, L- Armature Length Hw (Height of window) and Ww (width of Window) D –diameter of stator bore
L- Length of Stator core
D –diameter of stator bore
L- Length of Stator core
L/τ Ratio
0.45 to 1.1
b/τ =0.64 to 0.72
(for Square pole face and Square Pole Section)
DNA minimum cost L/t =1.5- 2
good pf L/t = 1 – 1.25
good h L/t =1.5
overall design L/t =1
best pf t =Ö0.18L
L/t = 0.6 to 0.7
L/t = 1 to 5
Choice of Number of Poles Frequency Between 25 to 50 HZ
Current per parallel path is limited to 200A.
The Armature MMF Should not be large.
DNA DNA
For Bolted pole
Va = 50 m/s
Dovetail & T Head
Va=80 m/s
Length of Air Gap lg=(0.5 to 0.7)* ac* τ * 1.6*106 Bg Kg DNA Lg= 0.2 + 2ÖDL
Lg=0.2 + D
Lg=0.125+0.35D+L+0.015Va
Lg=(1.6ÖD) – 0.25
M/c with open type slots
L g/t = 0.01 to 0.015
M/c with maximum o/p
L g /t = 0.02
Turbo Alternator
Lg=0.5SCR act Kf10-6/Kg Bav
Slot Information Slot Area = Conductor area/ slot space Factor DNA Stator Slot Pitch Yss=p D/Ss Values of Stator slot pitch
Yss < 25mm – Low Volt M/c
Yss < 40mm – for 6KV & less
Yss < 60mm - m/c upto 15kV
Tooth Information DNA DNA width of stator tooth
Wts min = fm / 1.7(Ss/p) Li
Width of rotor tooth
Wtr min = fm / 1.7(Sr/p) Li
DNA
Core D=Di+2dc+2ds
Di Inner Dia.of armature
dc Depth of core
ds Depth of slot
Square Core Kc = 0.45
Two stepped core Kc = 0.56
Three stepped core Kc=0.6
Kc – core area factor = Ai/d2
Depth of stator core
dcs = fm / 2 Bcs Li
Depth of rotor core
dcr = fm / 2 Bcr Li
DNA
Armature MMF/Pole Up to 100Kw- 5000 or less
100 to 200Kw- 5000 –7000
500 to1000Kw 7500-10000
over1500Kw –Upto 12,500
DNA DNA
Armature MMF/pole
ATa = 2.7 Ip Tph Kws / p
Field MMF
ATf =SCR * Ata
Dispersion Coefficient DNA DNA s = Im/Isci
Im-Magnetizing current
Isci – ideal Short ckt current
DNA
Short Circuit Ratio
DNA DNA DNA The ratio of field current required to produce rated voltage on OC to field current required to circulate rated current at SC.
SCR = 1/Xd
Slot Loading DNA DNA Slot Loading = Zss Is
Conds/slot Zss=6Ts/Ss
Stator Conds = Ss Zss
DNA
Additional Information Current/Parallel path = Ia/p
For Wave Winding Ia/2
number of tubes =
[(Pi +Pc/q)-12.5 St] /8.8p dt lt
Rotor Bar current
Ib = 0.85 6Is Ts/Sr
End ring current
Ie=Sr Ib/p p
(Ss-Sr) should not be equal to
0,±p, ±2p, ±3p, ±5p, ±1, ±2, ±(p±1) ±(p±2)
Current thru the conductor
Iz = Iph/a
Peripheral Speed
Va = p D ns
DNA - Data Not Available (Data or the concept may not be there).
Reference: Electrical Machine design by A. K Sawhney