Curva de daño de un transformador c++

Instituto Politécnico
Nacional
Escuela Superior de Ingeniería
Mecánica y Eléctrica
Departamento de Ingeniería en Control y
Automatización
Programación Orientada a Objetos
Alumno: Profesor:Javier Tenorio Huertas
Jiménez Torres Marco Antonio

Instituto Politécnico Nacional
Escuela Superior de Ingeniería
Mecánica y Eléctrica
Departamento de Ingeniería en Control y
Automatización
Proyecto Final
CALIFICACION

Objetivo:
El alumno realizara un proyecto apreciando los cambios que presenta el
programar con clases y objetos, el uso de herencias y el uso del polimorfismo.
Introducción:
Muchos libros y artículos que se relacionan con la programación orientada a
objetos hablan del polimorfismo, desafortunadamente en sus párrafos se hace
alusión de forma tal que parecen muy difíciles, sin embargo hay que hacer énfasis
en que lo mas difícil del polimorfismo es el termino mismo. Una vez que se logra
comprender el término, los conceptos son muy fáciles.
Para empezar, poli significa muchos. Asimismo, morfismo significa formas.
Cuando se combinas los dos términos se obtiene “muchas formas”. En pocas
palabras, un objeto polimórfico es un objeto que es capaz de tener una o mas
formas.
C++ implementa los polimorfismos usando funciones virtuales. En su aceptación
mas simple, una función virtual es una función miembro que está diseñada para
funcionar virtualmente con cualquier miembro de clase base y derivada, cada uno
de los cuales puede escoger usar la función virtual o una función de su propiedad,
evitando así el problema de tener que escribir varias funciones diferentes cuando
una es suficiente.
class computadora{
public:
computadora( int tipo_procesador );
virtual procesador( sinmarca *instrucciones );
void cargar_programa( char *nombre_programa );
prívate:
int tipo_procesador;
int tamaño_memoria;
};
Si la palabra clave virtual no precede a una función miembro de una clase base,
no habrá polimorfismo. Además si el tipo del resultado o los tipos de parámetros
de una función de una clase derivada no son los mismos, tampoco pues haber

polimorfismo. La abstracción es el proceso de ignorar temporalmente detalles
subalternos de forma que uno se pueda enfocar en el problema mayor inminente.
Una clase abstracta es una definición de clase cuyo propósito es colocar el
fundamento a partir de la cual se puedan derivar otras clases. Por lo general, los
programas que tienen clases abstractas no crean objetos pero si heredan sus
funciones miembro.
class Figura {
private:
float base;
float altura;
public:
void captura();
virtual unsigned float perimetro()=0;
virtual unsigned float area()=0;
};
class Rectangulo: public Figura {
public:
void imprime();
unsigned float perimetro(){return 2*(base+altura);}
unsigned float area(){return base*altura;}
};
class Triangulo: public Figura {
public:
void muestra();
unsigned float perimetro(){return 2*altura+base}
unsigned float area(){return (base*altura)/2;}
};
void Figura::captura()
{
cout << "CALCULO DEL AREA Y PERIMETRO DE UN TRIANGULO
ISÓSCELES Y UN RECTANGULO:" << endl;
cout << "escribe la altura: ";
cin >> altura;
cout << "escribe la base: ";
cin >> base;
cout << "EL PERIMETRO ES: " << perimetro();
cout << "EL AREA ES: " << area();
getchar();
return 0;
}

El polimorfismo puede ser bastante ventajoso a la hora de hacer interfaces ya que
permite crear nuevos tipos sin necesidad de meternos con clases ya existentes.
Desarrollo:
Basándonos en la programación orientada a objetos se realizara un algoritmo que
calcule la curva de daño de un transformador haciendo uso de las clases,
herencias y el polimorfismo.
Ejercicio No. 1
 Realizar un algoritmo que calcule la curva de daño de un transformador
haciendo uso de las clases y objetos.
int categoria;
class caracter{
public:
void valor(),imprimir(),discriminar(),conexion();
void tof(),op();
double Vp,Vs,P,Zt,In,I,Ir,Ir_2,Ir_3,Ir_4,Im,Cat,Ansi,T1,T2,T3,T4;
//int categoria;
};
void caracter::valor(){
cout<<"Caracteristicas del transformador:"<<endl;
cout<<"Recuerda que no debes usar notacion cientifica ny la potencia debe
estar expresada en KVA"<<endl;
cout<<"Y el voltaje en KV "<<endl;
cout<<"Ingresa valor del voltaje principal: ";
cin>>Vp;
cout<<"Ingresa valor del voltaje secundario: ";

cin>>Vs;
cout<<"Ingresa valor de la potencia: ";
cin>>P;
cout<<"Ingresa valor de Zt en decimal: ";
cin>>Zt;
}
void caracter::imprimir(){
cout<<"Tus datos son:"<<endl;
cout<<"-Transformador Trifasicon-60Hzn-Vp= "<<Vp<<"
n-Vs= "<<Vs<<"n-Potencia= "<<P<<"n-Zt= "<<Zt;
}
void caracter::discriminar(){
cout<<"nn";
if(P>=5.0 && P<=500.0){
cout<<"Tu transformador es de Categoria I"<<endl;
categoria=1;
}
if(P>=501.0 && P<=5000.0){
cout<<"Tu transformador es de Categoria II"<<endl;
categoria=2;
}
if(P>=5001.0&&P<=30000.0){
cout<<"Tu transformador es de Categoria III"<<endl;

categoria=3;
}
if(P>=30001.0){
cout<<"Tu transformador es de Categoria IV"<<endl;
categoria=4;
}
}
void caracter::conexion(){
if(categoria==1){
cout<<"Cotejando valores....."<<endl;
cout<<"Recuerde que bajo la norma Zt es predeterminada, cambiara
en el proceso"<<endl;
if(P>=15&&P<=75){
Zt=0.0250;
cout<<"Cambia Zt= 0.0250";
}
else if(P>=112.5&&P<=300){
Zt=0.0286;
}
else if(P>300&&P<500){
P=0;
Zt=0;

}
else if(P==500){
Zt=0.0400;
}
else {
cout<<"Usar un transformador fuera de norma puede resultar
peligroso"<<endl;
cout<<"Se determinara la curva"<<endl;
}
}
cout<<"Si desea hacer calculos fuera de norma comprar llave de
desbloqueo"<<endl;
}
void caracter::tof(){
if(categoria>=1&&categoria<=2){
cout<<"Elija el tipo de conexion: "<<endl;
cout<<"1.Delta-Deltan2.Delta-Estrella aterrizada
n3.Delta-Estrellan4.Estrella aterrizada-Estrella
n5.Estrella aterrizada-Estrella aterrizada
n6.Estrella-Estrella aterrizada-CORE TYPE
n7.Estrella-Estrella aterrizada-SHELL TYPE
n8.Estrella-Estrellan9.Estrella aterrizada-Delta
n10.Estrella-DeltanOpcion --> ";

cin>>Cat;
}
if(categoria==3){
n10.Estrella-Deltan11.Delta-Delta-Estrella aterrizada
n12.Estrella aterrizada-Delta-Estrella aterrizada
n13.Estrella-Delta-Estrella aterrizada
n14.Estrella-Delta-EstrellanOpcion --> ";
cin>>Cat;
}
if(categoria==4){
cout<<"11.Delta-Delta-Estrella aterrizada
cin>>Cat;
}
if(Cat==1)

Ansi=0.87;
else if(Cat==2)
Ansi=0.58;
else if(Cat==3)
Ansi=1;
else if(Cat==4)
Ansi=1;
else if(Cat==5)
Ansi=1;
else if(Cat==6)
Ansi=0.67;
else if(Cat==7)
Ansi=1;
else if(Cat==8)
Ansi=1;
else if(Cat==9)
Ansi=1;
else if(Cat==10)
Ansi=1;
else if(Cat==11)
Ansi=1;
else if(Cat==12)
Ansi=0.67;
else if(Cat==13)
Ansi=0.67;

else if(Cat==14)
Ansi=1;
else
cout<<"Opcion invalida...."<<endl;
}
void caracter::op(){
if(categoria==1){
In=P/(sqrt(3)*Vp);
I=In/Zt;
Ir=I*Ansi;
T1=1250*pow(Zt,2);
T4=50;
Ir_4=5*In*Ansi;
cout<<"Su curva de daño se presenta en los puntos "<<endl;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
if(categoria==2){
In=P/(1.732050808*Vp);

I=In/Zt;
Ir=I*Ansi;
T1=2;
Ir_2=((0.7*In)/Zt)*Ansi;
T2=4.08;
Ir_3=Ir_2;
T3=(2551)*pow(Zt,2);
Ir_4=5*In*Ansi;
T4=50;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
if(categoria==3){
In=P/(1.732050808*Vp);
I=In/(Zt+Zs);
Ir=I*Ansi;
cout<<"IR= "<<Ir<<endl;

T1=2;
Ir_2=((0.5*In)/(Zt+Zs))*Ansi;
T2=8;
Ir_3=Ir_2;
T3=(5000)*pow(Zt+Zs,2);
Ir_4=5*In*Ansi;
T4=50;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
if(categoria==4){
In=P/(1.732050808*Vp);
I=In/(Zt+Zs);
Ir=I*Ansi;
T1=2;

T2=8;
Ir_3=Ir_2;
T3=(5000)*pow(Zt+Zs,2);
Ir_4=5*In*Ansi;
T4=50;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
}
int main()
{
int z;
do{
system("cls");
cout<<"Transformadores trifasicos"<<endl;
cout<<"Este programa calcula la curva de daño de los transformadores"<<endl;

cout<<"Ingrese los siguientes datos "<<endl;
caracter obj;
obj.valor();
obj.imprimir();
obj.discriminar();
obj.conexion();
obj.tof();
obj.op();
cout<<"Quieres volver a intentarlo? 1..si 0..no ";
cin>>z;
}while(z>=1);
cout<<"nn";
system("pause");
}
En este ejemplo podemos apreciar que hacemos uso de una sola clase llamada
carácter la cual tiene elementos miembro y funciones miembro que nos ayudaran
a realizar el programa. Podemos apreciar que se le piden los valores al usuario
los cuales son voltaje primario, voltaje secundario, potencia e impedancia, si uno
es observador en el código el voltaje secundario no se utiliza en los cálculos por lo
que es candidato a salir del programa pero para términos prácticos se pide y así
el usuario puede verlo en la impresión de datos para confirmar.
De igual forma se aprecia que una variable no esta declara ni como global ni
como miembro de la clase y es Zs importante para realizar los cálculos en los
transformadores de categoría III y IV y esto es por que gracias a la directiva
#define Zs es declarada como constante y en estos términos adquiere un valor de
0.0345

Otra cosa que cabe destacar es que este programa no realiza cálculos fuera de
norma, esto quiere decir que si la impedancia no es la correcta la cambia y
proporciona los puntos con los mismos datos de voltaje y potencia pero con la
impedancia que la norma define.
Ejercicio No.2
haciendo uso de herencias.
#include <cstdlib>
#include <iostream>
#include <cmath>
#define Zs 0.0345
using namespace std;
int categoria;
class caracter{
public:
void valor(),imprimir(),discriminar(),conexion();
void tof(),op();
double Vp,Vs,P,Zt,In,I,Ir,Ir_2,Ir_3,Ir_4,Im,Cat,Ansi,T1,T2,T3,T4;
//int categoria;
};
class derivada:public caracter{
public:

void aviso();
};
void caracter::valor(){
cin>>Vp;
cin>>Vs;
cin>>P;
cin>>Zt;
}
void caracter::imprimir(){
cout<<"Tus datos son:"<<endl;
cout<<"-Transformador Trifasicon-60Hzn-Vp= "<<Vp<<"
n-Vs= "<<Vs<<"n-Potencia= "<<P<<"n-Zt= "<<Zt;
}
void caracter::discriminar(){

cout<<"nn";
if(P>=5.0 && P<=500.0){
categoria=1;
}
if(P>=501.0 && P<=5000.0){
categoria=2;
}
if(P>=5001.0&&P<=30000.0){
categoria=3;
}
if(P>=30001.0){
categoria=4;
}
}
void caracter::conexion(){
if(categoria==1){
//cout<<"Cotejando valores....."<<endl;
cout<<"Recuerde que bajo la norma Zt es predeterminada, cambiara
en el proceso"<<endl;

if(P>=15&&P<=75){
Zt=0.0250;
cout<<"Cambia Zt= 0.0250"<<endl;
}
else if(P>=112.5&&P<=300){
Zt=0.0286;
}
else if(P>300&&P<500){
P=0;
Zt=0;
}
else if(P==500){
Zt=0.0400;
}
else {
cout<<"Usar un transformador fuera de norma puede resultar
peligroso"<<endl;
//cout<<"Se determinara la curva"<<endl;
}
}
//cout<<"Si desea hacer calculos fuera de norma comprar llave de
desbloqueo"<<endl;
}

void caracter::tof(){
cout<<"nElija el tipo de conexion: "<<endl;
cin>>Cat;
}
if(categoria==3){

cin>>Cat;
}
if(categoria==4){
cin>>Cat;
}
if(Cat==1)
Ansi=0.87;
else if(Cat==2)
Ansi=0.58;
else if(Cat==3)
Ansi=1;
else if(Cat==4)
Ansi=1;
else if(Cat==5)
Ansi=1;
else if(Cat==6)
Ansi=0.67;
else if(Cat==7)
Ansi=1;
else if(Cat==8)

Ansi=1;
else if(Cat==9)
Ansi=1;
else if(Cat==10)
Ansi=1;
else if(Cat==11)
Ansi=1;
else if(Cat==12)
Ansi=0.67;
else if(Cat==13)
Ansi=0.67;
else if(Cat==14)
Ansi=1;
else
}
void caracter::op(){
if(categoria==1){
In=P/(sqrt(3)*Vp);
I=In/Zt;
Ir=I*Ansi;
T1=1250*pow(Zt,2);

T4=50;
Ir_4=5*In*Ansi;
cout<<"nnSu curva de daño se presenta en los puntos "<<endl;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
if(categoria==2){
In=P/(1.732050808*Vp);
I=In/Zt;
Ir=I*Ansi;
T1=2;
T2=4.08;
Ir_3=Ir_2;
T3=(2551)*pow(Zt,2);
Ir_4=5*In*Ansi;
T4=50;

cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
if(categoria==3){
In=P/(1.732050808*Vp);
I=In/(Zt+Zs);
Ir=I*Ansi;
T1=2;
T2=8;
Ir_3=Ir_2;
T3=(5000)*pow(Zt+Zs,2);
Ir_4=5*In*Ansi;
T4=50;

cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
if(categoria==4){
In=P/(1.732050808*Vp);
I=In/(Zt+Zs);
Ir=I*Ansi;
T1=2;
T2=8;
Ir_3=Ir_2;
T3=(5000)*pow(Zt+Zs,2);
Ir_4=5*In*Ansi;
T4=50;

cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
}
void derivada::aviso(){
cout<<"nnn";
if(categoria==1){
cout<<"Recuerde que bajo la norma Zt es predeterminada,
cambiara en el proceso"<<endl;
cout<<"Para Transformadores de Potencia 15-75 nZt cambiara a
0.0250"<<endl;
cout<<"Para Transformadores de Potencia 112.5-300 nZt cambiara
a 0.0286"<<endl;
cout<<"Para Transformadores de Potencia 500 Zt cambiara a
0.0400"<<endl;
cout<<"Para Transformadores fuera de Potencia nZt cambiara a
0"<<endl;
cout<<"ntTome sus precausiones.... Si desea calcular la
curvanLlame al servidor"<<endl;
cout<<"Cambiando Zt....."<<endl;
cout<<"nntListo. ;) "<<"nn"<<endl;
}
else{

cout<<""<<endl;
}
}
int main()
{
int z;
do{
system("cls");
cout<<"Ingrese los siguientes datos "<<endl;
derivada obj;
obj.valor();
obj.imprimir();
obj.discriminar();
obj.aviso();
obj.conexion();
obj.tof();
obj.op();
cin>>z;
}while(z>=1);
cout<<"nn";

system("pause");
}
Nuevamente nos encontramos con un programa muy similar al anterior, pero en
este tenemos el uso de una herencia, cabe destacar que no es el ejemplo mas
importante
Podemos observar que la clase derivada cuenta con una función miembro propia
de tipo public la cual nos ayuda a mostrarle un mensaje a nuestro usuario que
usar transformadores de categoría I con impedancia fuera de norma puede
producir daños y Zt será cambiada.
Asimismo se vuelve a emplear la directiva #define para hacer constante el uso de
Zs importante para el calculo de transformadores categoría III y IV, si se observa y
como ya se sabe para poder tener acceso a las funciones heredadas hace falta un
objeto de la clase base o hacer uso de un apuntador de tipo de la clase base y
redeferenciar al objeto de la clase derivada cambiando el operador punto por el
operador flecha.
Aquí podemos darnos cuenta que las clases derivadas pueden tener acceso a las
funciones miembro heredadas y tener sus funciones propias y estas heredarlas.
En conclusión los datos de cálculos no cambian mucho ya que se busca un mismo
fin.
Ejercicio No.3
haciendo uso del polimorfismo.
int categoria=0;
double v,p,z,Ansi;
class var{
public:
virtual void funcion()=0;

double Vp,Vs,P,Zt,In,I;
};
class Tra1:public var{
public:
virtual void funcion();
void sacudida();
Tra1(double,double,double);
double T1,T4,Ir,Ir_4;
};
public:
double T1,T2,T3,T4,Ir,Ir_2,Ir_3,Ir_4,;
};
public:
};

public:
};
Tra1::Tra1(double vp,double p,double zt){
Vp=vp;
P=p;
Zt=zt;
}
void Tra1::sacudida(){
0.0250"<<endl;
a 0.0286"<<endl;
0.0400"<<endl;
0"<<endl;

if(P>=15&&P<=75){
Zt=0.0250;
}
else if(P>=112.5&&P<=300){
Zt=0.0286;
}
else if(P>300&&P<500){
P=0;
Zt=0;
}
else if(P==500){
Zt=0.0400;
}
else if(P>500){
Zt=0;
cout<<"Cambia Zt= 0"<<endl;
}
}
void Tra1::funcion(){

In=P/(sqrt(3)*Vp);
I=In/Zt;
Ir=I*Ansi;
T1=1250*pow(Zt,2);
T4=50;
Ir_4=5*In*Ansi;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
Vp=vp;
P=p;
Zt=zt;
}
In=P/(1.732050808*Vp);
I=In/Zt;
Ir=I*Ansi;

T1=2;
T2=4.08;
Ir_3=Ir_2;
T3=(2551)*pow(Zt,2);
Ir_4=5*In*Ansi;
T4=50;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
Vp=vp;
P=p;
Zt=zt;
}

In=P/(1.732050808*Vp);
I=In/(Zt+Zs);
Ir=I*Ansi;
T1=2;
T2=8;
Ir_3=Ir_2;
T3=(5000)*pow(Zt+Zs,2);
Ir_4=5*In*Ansi;
T4=50;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
Vp=vp;
P=p;
Zt=zt;

}
In=P/(1.732050808*Vp);
I=In/(Zt+Zs);
Ir=I*Ansi;
T1=2;
T2=8;
Ir_3=Ir_2;
T3=(5000)*pow(Zt+Zs,2);
Ir_4=5*In*Ansi;
T4=50;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}

void valor(),discriminar(),tof();
int main()
{
int r;
double c;
do{
system("cls");
valor();
discriminar();
tof();
if(categoria==1){
Tra1 obj1=Tra1(v,p,z);
obj1.sacudida();
obj1.funcion();
}
else if(categoria==2){
obj2.funcion();
}
obj3.funcion();

}
obj4.funcion();
}
cin>>r;
}while(r>=1);
cout<<"nn";
system("pause");
}
void valor(){
double s;
cin>>v;
cin>>s;

cin>>p;
cin>>z;
}
void discriminar(){
cout<<"nn";
if(p>=5 && p<=500){
categoria=1;
}
if(p>=501 && p<=5000){
categoria=2;
}
if(p>=5001 && p<=30000){
categoria=3;
}
if(p>=30001){
categoria=4;
}
cout<<"R= "<<categoria<<endl;

}
void tof(){
int Cat;
cin>>Cat;
}
cin>>Cat;
}
if(Cat==1)
Ansi=0.87;

else if(Cat==2)
Ansi=0.58;
else if(Cat==3)
Ansi=1;
else if(Cat==4)
Ansi=1;
else if(Cat==5)
Ansi=1;
else if(Cat==6)
Ansi=0.67;
else if(Cat==7)
Ansi=1;
else if(Cat==8)
Ansi=1;
else if(Cat==9)
Ansi=1;
else if(Cat==10)
Ansi=1;
else if(Cat==11)
Ansi=1;
else if(Cat==12)
Ansi=0.67;
else if(Cat==13)
Ansi=0.67;
else if(Cat==14)

Ansi=1;
else
}
Este programa tiene una cualidad especial ya que combina la programación
orientada a objetos con la programación estructurada, el uso de polimorfismo es
una herramienta muy practica ya que nos permite usar herramientas de la
programación ya sea como funciones de usuario, clases, herencias, funciones
virtuales, clases abstractas entre otros, al usar polimorfismo la programación se
vuelve mas fácil ya que se crea un efecto copy-paste y este hace que el
programador solo tenga que cambiar el nombre de las variables.
En este caso tenemos una función virtual denominada “función” en nuestra clase
base la cual nos sirve para heredar y que nuestras clases derivadas, al ser una
función pura no es necesario tener una método como antes fue explicado.
Se aprecia que es un programa sencillo con muchas condicionales, a diferencia de
los otros dos programas este tiene mas variables globales esenciales para la
discriminación de los casos ya sea con el factor ANSI, el tipo de categoría y sobre
todo la norma en la impedancia. Cabe destacar que estos programas calculan la
curva de daño de transformadores categoría I solo bajo la norma establecida, con
un sencillo cambio se podría calcular la curva fuera de norma y mandar el aviso de
precaución.
 Llave para solucionar el problema para resolver curvas de daño del
transformador categoría I
int categoria=0;
double v,p,z,Ansi;
class var{
public:
virtual void funcion()=0;
double Vp,Vs,P,Zt,In,I;

};
public:
void sacudida(),compra();;
double T1,T4,Ir,Ir_4;
};
public:
};
public:
};

public:
};
Vp=vp;
P=p;
Zt=zt;
}
void Tra1::sacudida(){
0.0250"<<endl;
a 0.0286"<<endl;
0.0400"<<endl;
0"<<endl;

if(P>=15&&P<=75){
compra();
Zt=0.0250;
}
else if(P>=112.5&&P<=300){
compra();
Zt=0.0286;
}
else if(P>300&&P<500){
compra();
P=0;
Zt=0;
}
else if(P==500){
compra();
Zt=0.0400;
}
else if(P>500){
compra();
Zt=0;
cout<<"Cambia Zt= 0"<<endl;

}
}
void Tra1::compra(){
cout<<"nnTus Resutados fuera de norma son: n";
In=P/(sqrt(3)*Vp);
I=In/Zt;
Ir=I*Ansi;
T1=1250*pow(Zt,2);
T4=50;
Ir_4=5*In*Ansi;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
cout<<"nn";
}
In=P/(sqrt(3)*Vp);
I=In/Zt;
Ir=I*Ansi;

T1=1250*pow(Zt,2);
T4=50;
Ir_4=5*In*Ansi;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
Vp=vp;
P=p;
Zt=zt;
}
In=P/(1.732050808*Vp);
I=In/Zt;
Ir=I*Ansi;
T1=2;
T2=4.08;

Ir_3=Ir_2;
T3=(2551)*pow(Zt,2);
Ir_4=5*In*Ansi;
T4=50;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
Vp=vp;
P=p;
Zt=zt;
}
In=P/(sqrt(3)*Vp);
cout<<"In= "<<In<<endl;
I=In/(Zt+Zs);
cout<<"I= "<<I<<endl;

Ir=I*Ansi;
cout<<"Ansi= "<<Ansi<<endl;
cout<<"Ir= "<<Ir<<endl;
T1=2;
T2=8;
Ir_3=Ir_2;
T3=(5000)*pow(Zt+Zs,2);
Ir_4=5*In*Ansi;
T4=50;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
Vp=vp;
P=p;
Zt=zt;
}

In=P/(sqrt(3)*Vp);
I=In/(Zt+Zs);
Ir=I*Ansi;
T1=2;
T2=8;
Ir_3=Ir_2;
T3=(5000)*pow(Zt+Zs,2);
Ir_4=5*In*Ansi;
T4=50;
cout<<"P1( "<<Ir<<" , "<<T1<<" ) y P2( "<<Ir_2<<" , "<<T2<<" )
"<<endl;
cout<<"P3( "<<Ir_3<<" , "<<T3<<" ) y P4( "<<Ir_4<<" , "<<T4<<" )
"<<endl;
}
void valor(),discriminar(),tof();

int main()
{
int r;
double c;
do{
system("cls");
valor();
discriminar();
tof();
if(categoria==1){
obj1.sacudida();
obj1.funcion();
}
obj2.funcion();
}
obj3.funcion();
}

obj4.funcion();
}
cin>>r;
}while(r>=1);
cout<<"nn";
system("pause");
}
void valor(){
double s;
cin>>v;
cin>>s;
cin>>p;

cin>>z;
}
void discriminar(){
cout<<"nn";
if(p>=5 && p<=500){
categoria=1;
}
if(p>=501 && p<=5000){
categoria=2;
}
if(p>=5001 && p<=30000){
categoria=3;
}
if(p>=30001){
categoria=4;
}
cout<<"R= "<<categoria<<endl;
}

void tof(){
int Cat;
cin>>Cat;
}
if(categoria==3){

cin>>Cat;
}
if(categoria==4){
cin>>Cat;
}
if(Cat==1)
Ansi=0.87;
else if(Cat==2)
Ansi=0.58;
else if(Cat==3)
Ansi=1;
else if(Cat==4)
Ansi=1;
else if(Cat==5)
Ansi=1;
else if(Cat==6)
Ansi=0.67;
else if(Cat==7)

Ansi=1;
else if(Cat==8)
Ansi=1;
else if(Cat==9)
Ansi=1;
else if(Cat==10)
Ansi=1;
else if(Cat==11)
Ansi=1;
else if(Cat==12)
Ansi=0.67;
else if(Cat==13)
Ansi=0.67;
else if(Cat==14)
Ansi=1;
else
}
Se puede observar una gran similitud con el ejercicio No.3 pero aquí se observa
que se tiene una función miembro propia la clase derivada Tra1 la cual permite
hacer el calculo sin ningún inconveniente y después mandar la advertencia y
calcular la curva de daño con forme a la norma.

Resultados:
En base a la realización de los 3 algoritmos se muestra que el polimorfismo ayuda
a los programadores a simplificar su código con métodos mas cortos y similares,
sin la necesidad de aplicar varios para cada clase.
Tomando en cuenta los siguientes ejemplos de transformadores se pone a prueba
los algoritmos y se comprueban los resultados con la prueba de escritorio y su
curva característica dependiendo categoría y la norma establecida.
1. Transformador
 Transformador trifásico
 60 Hz
 Vp=23000 V
 Vs=420 V
 300 kVA
 Z = 5.0 %
 Conexión: Estrella aterrizada – Estrella aterrizada
Para P1
In =
𝐾𝑉𝐴
√3∗𝐾𝑉
=
300
√3∗23
= 7.53 A
I =
7.53
0.05
= 150.61 A P1 ( 150.61 , 3.125 )
I = I*ANSI = 150.61 A
T = 1250 (Zt)^2 = 3.125 s
Para P2
I =( 5 * In * ANSI ) = 37.65 A P2 (37.65 , 50 )
T = 50 s

Esta grafica pertenece a la curva de daño de un transformador de categoría I con
impedancia fuera de norma
Esta grafica pertenece a la curva de daño de un transformador de categoría I con
impedancia dentro de norma

2. Transformador
 60 Hz
 Vp = 23000 V
 Vs = 400 V
 1250 kVA
 Z = 6.26 %
 Conexión: Estrella – Delta
Para P1
In =
𝐾𝑉𝐴
√3∗𝐾𝑉
=
1250
√3∗23
= 31.37 A
I =
31.37
0.0626
= 501.11 A P1 ( 501.11 , 2 )
I = I*ANSI = 501.11 A
T = 2s
Para P2
I =
0.7∗31.37
0.0626
= 350.78 A P2 (350.78 , 4.08 )
T=4.08s
Para P3
I =
0.7∗31.37
0.0626
= 350.78 A P3 ( 350.78 , 10 )
T = 2551(Zt)^2 = 10s
Para P4
I= (In * 5 * ANSI ) = 156.85 A P4 ( 156.85 , 50 )
T = 50s

3. Transformador
 60 Hz
 Vp = 23000 V
 Vs = 3450 V
 10000 kVA
 Z = 5.92 %
 Conexión: Delta – Estrella aterrizada
Para P1
In =
𝐾𝑉𝐴
√3∗𝐾𝑉
=
10000
√3∗23
= 251.02 A
I =
1553 .8
0.0937
= 2678.97 A P1 ( 1553.8 , 2 )
I = I*ANSI = 1553.8 A
T = 2s
Para P2
I =
0.5∗251.02
0.0937
∗ 𝐴𝑁𝑆𝐼 = 776.9 A P2 (776.9 , 8 )
T=8s
Para P3
I = 776.9 A P3 ( 776.9 , 43.89 )
T = 5000(0.0937)^2 = 43.89s
Para P4
I= (In * 5 * ANSI ) = 727.95 A P4 ( 727.95 , 50 )
T = 50s

4. Transformador
 60 Hz
 Vp = 220000 V
 Vs = 23000 V
 Vt = 7560 V
 37500 kVA
 Z = 6.78 %
 Conexión:
Primario: Estrella aterrizada
Secundario: Estrella aterrizada
Terciario: Delta

Curva de daño:
Conclusion:
Después de realizar los algoritmos podemos darnos cuenta de que el uso del
polimorfismo es más fácil ya que no se necesitan tantas funciones de usuario
para llegar a una misma tarea y que gracias a esta modalidad los códigos son más
rápidos y son mucho más cortos.
Cabe destacar la gran importancia de teoría y práctica antes realizada con la
programación estructurada y la orientada a objetos ya que sin las herramientas
que ofrece esto sería muy complicado, aunque en todos los programas se
presentan datos miembro de tipo public también se puede añadir en tipo prívate o
protected, por cuestión de facilidad se optó por public de igual manera se viene
nota el escaso o nulo uso de apuntadores pero de igual forma es posible utilizarlo
en el polimorfismo.
Muchos libros hablan sobre el polimorfismo pero pocos dan ejemplos prácticos
que lleven a que el programador entienda su relativo y sencillo uso.
Adentrándonos un poco en el proyecto, resulta sencillo teniendo las ecuaciones
que caracterizan la magnitud de la corriente y del tiempo en un transformador,
donde nos podríamos perder es a la hora de discriminar y tener que elegir entre un
caso u otro o el que es crear un objeto de una clase derivada y tener acceso a los
diferentes casos hablando en categorías del transformador.
Con esto se demuestra que la programación es un recurso indiscutible para un
ingeniero optimizando tiempo en cálculos complejos haciendo más rápido un plan
de acción en caso de requerirlo.
Bibliografía:
 C++ programación exitosa. Kris Jamsa. Editorial Alfaomega.
México D.F. pp 271-293.

Curva de daño de un transformador c++

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Destacado

Destacado (7)

Similar a Curva de daño de un transformador c++

Similar a Curva de daño de un transformador c++ (20)

Curva de daño de un transformador c++