Anexo 1

Algoritmo de creación y exportación de perfiles, código Mathematica7

// INTRODUCIR valores de construcción de la rueda dentada

Z, c, ‫׋‬ha, m, a, b, x, rf
// CALCULAR
k, ‫׋‬hr, rp, inv‫׋‬ha, inv‫׋‬hr, ', Xat, Xrt, rba, rbr, rea, rec, roa,
ror, șmaxa, șmaxr, rta, rtr, invXa, invXr
// DEFINIR FUNCIONES PARAMÉTRICAS POLARES DE LA TROCOIDE Y
EVOLVENTE PARA LOS LADOS DE ATAQUE Y RESPALDO, usando las
ecuaciones (2.12), (2.14),(2.27) y (2.28)
// ENCONTRAR VALORES To Y ijo, EN INTERSECCION DE LAS FUNCIONES
PARAMETRICAS POLARES DE LA TROCOIDE Y EVOLVENTE PARA LOS LADOS DE
DIENTE
// RESPALDO
{Revr[Ti]mRtrr[Mi],Eevr[Ti]mEtrr[Mi]}
Tor ĸ Ti
Mor ĸ Mi
// ATAQUE
{Reva[Ti]mRtra[Mi],Eeva[Ti]mEtra[Mi]}
Toa ĸ Ti
Moa ĸ Mi
//PARTICIONAR FUNCIONES PARA EXPORTACION

//(*** LINEA RESPALDO ***************)

//DEFINIR FUNCIONES PARAMETRICAS CARTESIANAS
Xlinr[x_]:=x
Ylinr[x_]:=Sin[Etrr[Pi/2]+ 2 Pi]/Cos[Etrr[Pi/2]+2 Pi]*x
//PARTICIONAR FUNCION LINEA RESPALDO
//DEFINIR PASO DE PHI, calcular puntos de partición, guardar data
i=0
inx=Rtrr[Pi/2] Cos[Etrr[Pi/2]+ 2 Pi]
Hacer para ix = 0 hasta Rtrr[Pi/2] Cos[Etrr[Pi/2]+ 2 Pi], con paso
inx
xlinr=Xlinr[ix]
arrXlinr[i]=xlinr
ylinr= Ylinr[ix]
arrYlinr[i]=ylinr
imax=i
i++
Fin Hacer

// crear tabla DATA

A1
XLinr=Table[arrXlinr[i],{i,1,imax}]
YLinr=Table[arrYlinr[i],{i,1,imax}]

//(***TROCOIDE RESPALDO*****************)
//DEFINIR FUNCIONES PARAMETRICAS CARTESIANAS, según
Xtrr[M_] := Rtrr[M]*Cos[Etrr[M]]
Ytrr[M_] := Rtrr[M]*Sin[Etrr[M]]
//PARTICIONAR FUNCIONES TROCOIDE RESPALDO
//DEFINIR paso incremental ni, PASO DE PHI, inicio contador i,
calcular puntos de partición, guardar data
ni = entero
i=1;
inM=(MRr-Pi/2)/ni
Hacer para iM= Pi/2 hasta Mor, con paso inM
xtd=Xtrr[iM]
arrXtrr[i]=xtr
ytd= Ytrr[iM]
arrYtrr[i]=ytr
imax=i
i++
Fin Hacer
// crear tabla DATA
XTrr=Table[arrXtrr[i],{i,1,imax}]
YTrr=Table[arrYtrr[i],{i,1,imax}]
// ENCONTRAR EXPORTAR PENDIENTES INICIAL Y FINAL RESPALDO
deltaXi=-D[Xtrr[M],M] /.M!Pi/2
deltaXf=-D[Xtrr[M],M] /.M!MRr
deltaYi=-D[Ytrr[M],M] /.M!Pi/2
deltaYf=-D[Ytrr[M],M] /.M->Mor
deltaTrr={deltaXi,deltaYi,deltaXf,deltaYf}//TableForm

//(*EVOLVENTE RESPALDO **************)

//DEFINIR FUNCIONES PARAMETRICAS CARTESIANAS
Xevr[T_]:=Revr[T] Cos[Eevr[T]]
Yevr[T_]:=Revr[T] Sin[Eevr[T]]

//PARTICIONAR FUNCIONES EVOLVENTE RESPALDO

//DEFINIR paso incremental ni, PASO DE PHI, inicio contador i,
calcular puntos de partición, guardar data
ni= entero
i=1
inT=(Tmaxr-T0r)/ni

A2
Hacer para iT TRr hasta Tmaxr, con paso inT
xer=Xevr[iT]
arrXevr[i]=xer
yed= Yevr[iT]
arrYevr[i]=yer
imax=i
i++
Fin Hacer

// crear tabla DATA

XEvr=Table[arrXevr[i],{i,1,imax}]
YEvr=Table[arrYevr[i],{i,1,imax}];

// ENCONTRAR PENDIENTES INICIAL Y FINAL RESPALDO

deltaXi=D[Xevr[T],T] /.T!TRr
deltaXf=D[Xevr[T],T] /.T!Tmaxr
deltaYi=D[Yevr[T],T] /.T!TRr
deltaYf=D[Yevr[T],T] /.T->Tmaxr
deltaEvr={deltaXi,deltaYi,deltaXf,deltaYf}//TableForm

// EXPORTAR DATA
Export["XLinr.dat",xLinr]
Export["YLinr.dat",YLinr]
Export["XTrr.dat",XTrr]
Export["YTrr.dat",YTrr]
Export["deltaTrr.dat",deltaTrr]
Export["XEvr.dat",XEvr]
Export["YEvr.dat",XEvr]
Export["deltaEvr.dat",deltaEvr]
Export["XPta.dat",XPta]
Export["YPta.dat",YPta]
Export["deltaPta.dat",deltaPta]
Export["YEva.dat",YEva]
Export["XEva.dat",XEva]
Export["deltaEva.dat",deltaEva]
Export["XTra.dat",XTra]
Export["YTra.dat",YTra]
Export["deltaTra.dat",deltaTra]
Export["XLina.dat",XLina]
Export["YLina.dat",XLina]

A3
Anexo 2
Subrutina Carga(), código VBA

Sub Carga()
Open "C:\Users\jc\Documents\Xtrr.dat" For Input As #1 ' Abre el archivo.
i=1
Do While Not EOF(1) ' Repite el bucle hasta el final del archivo.
Line Input #1, LíneaTexto ' Lee el carácter en la variable.
X(i, j) = Val(LíneaTexto)
imax2 = i
i=i+1
Loop
Close #1 ' Cierra el archivo.
Open "C:\Users\jc\Documents\Ytrr.dat" For Input As #1 ' Abre el archivo.
i=1
Do While Not EOF(1) ' Repite el bucle hasta el final del archivo.
Line Input #1, LíneaTexto ' Lee el carácter en la variable.
Y(i, j) = Val(LíneaTexto)
i=i+1
Loop
Close #1 ' Cierra el archivo.

Open "C:\Users\jc\Documents\deltaTrr.dat" For Input As #1 ' Abre el archivo.

i=1
Do While Not EOF(1) ' Repite el bucle hasta el final del archivo.
Line Input #1, LíneaTexto ' Lee el carácter en la variable.
delta(i, j) = Val(LíneaTexto)
imaxd2 = i
i=i+1
Loop
Close #1 ' Cierra el archivo.
End Sub

A4
Anexo 3

Subrutina CreaSplinesAtaque(), código VBA

Sub CreaSplinesAtaque()
' Crea el objeto spline en el model space, escritorio o pantalla del CAD.
' Declara variables
Dim splineObj5 As AcadSpline
Dim splineObj6 As AcadSpline
Dim startTan(1 To 3) As Double
Dim endTan(1 To 3) As Double
Dim fitPoints(1 To 18) As Double
j=5
nfp = imax5 * 3
' Definir variables
i=1
startTan(1) = delta(i, j): startTan(2) = delta(i + 1, j): startTan(3) = 0
endTan(1) = delta(i + 2, j): endTan(2) = delta(i + 3, j): endTan(3) = 0
For k = 1 To nfp - 2 Step 3
fitPoints(k) = X(i, j): fitPoints(k + 1) = Y(i, j): fitPoints(k + 2) = 0
i=i+1
Next k
' Crear spline de la evolvente
Set splineObj5 = ThisDrawing.ModelSpace.AddSpline(fitPoints, startTan, endTan)
j=6
nfp = imax6 * 3
' Crear spline trocoide
' Define variables
i=1
startTan(1) = delta(i, j): startTan(2) = delta(i + 1, j): startTan(3) = 0
endTan(1) = delta(i + 2, j): endTan(2) = delta(i + 3, j): endTan(3) = 0
i=1
For k = 1 To nfp - 2 Step 3
fitPoints(k) = X(i, j): fitPoints(k + 1) = Y(i, j): fitPoints(k + 2) = 0
i=i+1
Next k
Set splineObj6 = ThisDrawing.ModelSpace.AddSpline(fitPoints, startTan, endTan)
ZoomExtents
End Sub

A5
Anexo 4
Subrutina PerfilCompleto(), código VBA

Sub PerfilCompleto()
Dim extrusion As Acad3DSolid
Dim altura, angulo As Double
Dim solido(0 To 1) As Variant
Dim sset As AcadSelectionSet
altura = 4
angulo = 0
‘Carga de los perfiles + la data
Carga
CreaSplinesRespaldo
Lineas
CreaSplinesAtaque
CreaSplinePta
ReDim ssobjs(0 To ThisDrawing.ModelSpace.Count - 1) As AcadEntity
For i = 0 To ThisDrawing.ModelSpace.Count - 1
Set ssobjs(i) = ThisDrawing.ModelSpace.Item(i)
Next
' Add the array of objects to the selection set
Dim perfil As Variant
perfil = ThisDrawing.ModelSpace.AddRegion(ssobjs)
Set extrusion = ThisDrawing.ModelSpace.AddExtrudedSolid(perfil(0), altura, angulo)
ReDim ultimo(0 To ThisDrawing.ModelSpace.Count - 2) As AcadEntity
For i = 0 To ThisDrawing.ModelSpace.Count - 2
Set ultimo(i) = ThisDrawing.ModelSpace.Item(i)
Next i
For i = 0 To ThisDrawing.ModelSpace.Count - 2
ultimo(i).Delete
Debug.Print Count
Next i
' Change the viewing direction of the viewport
Dim NewDirection(0 To 2) As Double
NewDirection(0) = -1: NewDirection(1) = -1: NewDirection(2) = 1
ThisDrawing.ActiveViewport.Direction = NewDirection
ThisDrawing.ActiveViewport = ThisDrawing.ActiveViewport
ZoomExtents
End Sub

A6
$QH[R$$OJRULWPRGHHVWLPDFLyQGH<)

// Definición de funciones y parámetros de referencia
riaLn (3.17), I Lna (3.21), xsfa Ma  (3.22), ysfa Ma  (3.24), ys (3.25), xsfre Tr  (3.26),

xsfrt Mr  (3.27) ysfre Tr  (3.29), ysfrt Ma  (3.30),

// Límite superior ataque
yLs (3.31)
WKHWD/LPLWH6XSHULRUSDUDHOUHVSDOGRHQFRQWUDUș/VUFRPRODUD íz en la condición
ysfr Tr  yLs (3.32) , T Lsr Tr (3.33)
// Limite intermedio, intersección trr con evr
yLint
r ysfr T or  (3.34)
// Limite inferior del respaldo en r para radio de salida en la base del diente r0r
ror Rtrr M ir  (3.36) , M Lir M i r (3.39) yLir (3.37)
// PhiLinfAta Límite inferior del ataque en la condición
yLi Rtra M ia  Cos ª«¬ E tra M ia º»¼ (3.38) M Lia M ia (3.39)
// Definir paso de Phi, inicio de contador i, paso incremental n
ni = entero ; i = 1 ; incM § M Li M o · ni (3.40)
¨ a a¸
© ¹
Hacer para inPhi = M0a hasta MLia, con paso incPhi
Scam xsfa  inMa  (3.23) ys ysfa  inMa  (3.25)
// calcular respaldo Scmr de los ángulos șHYROYHQWH\M (evolvente)
m e t
Sc r  
xsf r T r ‰ xsf r Mr (3.28)  
Si ys •\UHQWRQFHV
HQFRQWUDUșLFRPRODUD íz en la condición
ysfre Tr  Rev r Tr  Cos ª¬invXr  E ev r Tr º¼ (3.29) Scrm xsfre Tr 
Sino
// encontrar Mi como la raíz en la condición
ysfrt Ma  Rtrr Mr  Cos ª¬invXr  E trr Mr  º¼ (3.30) xsfrt Mr  Rtrr Mr  Sen ª¬ invXr  E trr Mr  º¼ (3.27)

Scrm xsfrt Mr 
Fin Si
//Calcular
hca (3.18), Sc (3.19), e (3.20), YF (3.16)
// Guardar data necesaria
arregloSc[i] = Sc; arregloys[i] = ys; arregloScmr[i] = Scmr; arregloScma[i] = Scma;
arregloYF[i] = YF; arreglohcr[i] = hcra; arregloe[i] = e; arregloMLna[i] = MnLa;
arregloriLa[i] = riLa; arregloincPhi[i] = incPhi
imax = i; i++
Fin Hacer

 

$

Anexo 6.B. Codificación de algoritmo de estimación de YF y J en
Mathematica7.0

ClearAll["Global`*"]
GR2RAD = Pi/180;

(*Inicialización de índices y parametros*)

aa=1; bb=1; cc=1; dd=1; ee=1; ff=1; ii=1; jj=1; kk=1; mm=1; nn=1;
oo=1; a=1; ll=1; F=1; Wnb=1; m=1; Z0=10; Zf=100; w=1; pasoPhi=200;

(*Rutina de estimación de YF, J, V *)

Do[
Do[
Do[
Do[
Do[
Do[
apa=Iha;
apa=c*apa;
kc=Cos[apa]/Cos[apr];
Ihr = ArcCos[Cos[Iha]/kc];
Ifr = ArcTan[Tan[Ihr]/Cos[\]];
Ifa = ArcTan[Tan[Iha]/Cos[\]];
rp=m*Z/(Cos[\]*2);
rbr=1.*rp*Cos[Ifr];
Do[(
aa=1;

(*Ang.Evolvente Ataque Respaldo*)

invIha=Tan[Iha]-Iha;
invIhr=Tan[Ihr]-Ihr;

(*Ang.Suscrito por Espesor*)

t=Pi*m/2.+m*x*(Tan[Ihr]+Tan[Iha]);
at=Pi*m/(2.*rp);
V=Pi/Z+invIhr+invIha+2 x Tan[Ihr]/Z+2 x Tan[Iha]/Z;

(*Ang.Punta*)
fr[Qr_]:=-V+Tan[Qr]-Qr+Tan[ArcCos[kc*Cos[Qr]]]-
ArcCos[kc*Cos[Qr]];
Qrt=FindRoot[fr[Qr],{Qr,1}];
Qrt0=Qr/.Qdt;
Qat0=ArcCos[kc*Cos[Qrt0]];
invQr=Tan[Qrt0]-Qrt0;
invQa=Tan[Qat0]-Qat0;
rbr = rp*Cos[Ifr];
rba= rp*Cos[Ifa];

A10
(*Radio de cabeza*)
rer=rp+m*(a+x);
rea=rp+m*(a+x);

(*Radio de punta*)
rta=rba/Cos[Qat0];
rtr=rbr/Cos[Qrt0];
ra=rp+m*(x+a);
Dar0=ArcCos[rbr/ra];
Daa0=ArcCos[kc*Cos[Dar0]];

(*Angulo de cabeza*)
aAden=invQr+invQa-(Tan[Dar0]-Dar0)-
(Tan[ArcCos[kc*Cos[Dar0]]]-
ArcCos[kc*Cos[Dar0]]);
invDad=Tan[Dar0]-Dar0;
invDac=Tan[Daa0]-Daa0;

(*Espesor de cabeza*)
Ta=ra*aAden;

(*Razón de espesor de cabeza*)

Lar=Ta/(2*rbr);
Laa=Ta/(2*rba);
La=Laa;
rer=ra;
rea=ra;
4maxr = Sqrt[(rer/rbr)^2 - 1];
4maxa = Sqrt[(rec/rba)^2 - 1];

(*Evolvente respaldo*)
Revr[T_]:=rb*Sqrt[1+T^2] ;
Eevr[T_]:=T-ArcTan[T] ;
Xevr[T_]:=Revr[T]*Cos[Eevr[T]];
Yevr[T_]:=Revr[T]*Sin[Eevr[T]];

(*Indicador angular evolvente trocoide*)

Kr=-Ifr+ArcCos[(rp+m*(x-b+rf*(1-Sin[Ifr])))/rbr];
Ka=-Ifa+ArcCos[(rp+m*(x-b+rf*(1-Sin[Ifa])))/rba];

(*Trocoide respaldo*)
r0r=rp+m*(x-b+rf*(1-Sin[Ihr]));

Rtrr[M_]:=Sqrt[(r0r-m*rf*(Sin[M]-Sin[Ihr]))^2+((Cos[\]*(rp-
r0r+m*rf*(Sin[M]-Sin[Ihr])))/Tan[M])^2];
Etrr[M_]:=ArcTan[(Cos[\]*(rp-r0r+m*rf*(Sin[M]-
Sin[Ihr])))/(Tan[M]*(r0r-m*rf*(Sin[M]-Sin[Ihr])))]-Ifr–

A11
 ((rp-r0r+m*rf*(Sin[M]-Sin[Ihr]))*Cos[\])/(rp*Tan[M])-
(m*rf*(Cos[Ihr]–Cos[M]))/(rp*Cos[\])+(r0r*Tan[Ifr])/rp;

Xtrr[M_]:= Rtrr[M]*Cos[Etrr[M]];
Ytrr[M_]:= Rtrr[M]*Sin[Etrr[M]];
re=ra;

(*Evolvente ataque*)
Reva[T_]:=rbc*Sqrt[1+T^2] ;
Eeva[T_]:=T-ArcTan[T] ;
Xeva[T_]:=Reva[T] Cos[Eeva[T]];
Yeva[T_]:=Reva[T] Sin[Eeva[T]];

(*Trocoide ataque*)
r0a=rp+m*(-b+x+rf*(1-Sin[Iha]));

Rtra[M_]:=Sqrt[(r0a-rf*m*(Sin[M]-Sin[Iha]))^2+((Cos[\]*(rp-
r0a+rf*m*(Sin[M]-Sin[Iha])))/Tan[M])^2];
Etra[M_]:=ArcTan[(Cos[\]*(-r0a+rp+rf*m*(Sin[M]-
Sin[Iha])))/(Tan[M]*(r0a-rf*m*(Sin[M]-Sin[Iha])))]-Ifa-
(rf*m*(Cos[Iha]-Cos[M]))/(rp*Cos[\])-((-r0a+rp+rf*m*(Sin[M]-
Sin[Iha]))*Cos[\])/(rp*Tan[M])+(r0a*Tan[Ifa])/rp;

Xtra[M_]:= Rtra[M]*Cos[Etra[M]];
Ytra[M_]:= Rtra[M]*Sin[Etra[M]];

(*Angulos paramétricos intersección*)

parr=FindRoot[{Revr[T]mRtrr[M],Eevr[T]mEtrr[M]},{T,Ihr},
{M,Ihr/2}];
T0r=T/.parr;
M0r=M/.parr;
para=FindRoot[{Reva[T]mRtra[M],Eeva[T]mEtra[M]},{T,Iha},
{M,Iha/2}];
T0a=T/.para;
M0a=M/.para;

(*Distancias angulares entre dientes*)

'=S/Z+2 x Tan[Ihr]/Z+2 x Tan[Iha]/Z+invIfr+invIfa;
G=2 S/Z-'+ Etrr[S/2]+Etra[S/2];

(*Estimacion YF*)
(*Ataque Límite superior *)
ys=Rtra[M0a]*Cos[invQa-Etra[M0a]];
xscm=ys*Tan[invQa-Etra[M0a]];
ysf[Mc_]:=Rtra[Mc]*Cos[invQa-Etra[Mc]];
xscmf[Mc_]:=Rtra[Mc]*Sin[invQa-Etra[Mc]];

(*Respaldo thetaLimiteSuperior*)
A12
theLsr=FindRoot[ysmRevr[Ti]*Cos[invQr-Eevr[Ti]],
{Ti,Ihr/2}];
TLsr=Ti/.theLsr;
xsdevm[Td_]:=Revr[Td]*Sin[invQr-Eevr[Td]];

(*Límite intermedio*)
y0r=Revr[T0r]*Cos[invQr-Eevr[T0r]];
xsdtrm[Mr_]:=Rtrr[Mr]*Sin[invQr-Etrr[Mr]];
theLir=FindRoot[y0rmRevr[Ti]*Cos[invQr-Eevr[Ti]],
{Ti,Ihr/2}];
theLia=FindRoot[y0rmRtra[Mmc]*Cos[invQa-Eeva[Mmc]],
{Mmc,Tan[Iha/2]}];
yi=Revr[T0r]*Cos[invQr-Eevr[T0r]];
yif[Tr_]:=Revr[Tr]*Cos[invQr-Eevr[Tr]];

(*Límite inferior*)
phiLina=FindRoot[r0rmRtra[Mi],{Mi,M0a}];
MLina=Mi/.phiLina;
phiLinr=FindRoot[r0rmRtrr[Mid],{Mid,M0r}];
MLinr=Mir/.phiLinr;

(*Calculo de YF en zona de interés*)

aa=1;
inPhi=(MLina-M0a)/pasoPhi;
Do[
(InLa=Tan[Daa0]-invQa;
riLa=rba/Cos[InLc];
Scma=xscmf[incPhi];
ys=ysf[incPhi];
tabInLa[bb]=InLa;
If[ys–y0r,
(ther=FindRoot[ysmRevr[Ti]*Cos[invQr-Eevr[Ti]],
{Ti,Tan[Ihr]}];
Tsr=Ti/.ther;
Scmr=xsdevm[Tsr];),
(theda=FindRoot[ysmRtrr[Mi]*Cos[invQr-Etrr[Mi]],
{Mi,Ihr}];
Msd=Mi/.theda;
Scmd=ys*Tan[invQr-Etrr[Msr]];)
];
Sc=Scma+Scmr;
hara=riLa-ys;
e=Scmr-Sc/2;
YFcaIn=(6/m)*(hara*Cos[InLa]-InLa])/((Sc/m)^2*Cos[Iha]);
YFca=1/YFcaIn;

arregloSc[aa]=Sc; arregloYFca[aa]=YFca;
arregloincPhi[aa]=incPhi; arregloInLa[aa]=InLa;
A13
 arreglohara[aa]=hara; arregloys[aa]=ys;
arregloe[aa]=e; arregloScma[aa]=Scma;
arregloScmr[aa]=Scmr;
aamax=aa;
aa++;),
{incPhi,M0a,MLina,inPhi}];

tabYFca=Table[arregloYFca[aa],{aa,1,aamax}];
tabincPhi=Table[arregloincPhi[aa],{aa,1,aamax}];
tabSc=Table[arregloSc[aa],{aa,1,aamax}];
tabhar=Table[arreglohar[aa],{aa,1,aamax}];
tabysca=Table[arregloys[aa],{aa,1,aamax}];
tabe=Table[arregloe[aa],{aa,1,aamax}];
tabScma=Table[arregloScma[aa],{aa,1,aamax}];
tabScmr=Table[arregloScmr[aa],{aa,1,aamax}];
g=Flatten[Position[tabYFca,Min[tabYFca]]]//TableForm;
pos=g[[1]];
tmin=pos[[1]];

(*ESTIMACION J*)
(*RADIO CURVATURA*)
MYFm=tabincPhi[[tmin]];
ysm=tabysca[[tmin]];
es=tabe[[tmin]];
Scmas=tabScma[[tmin]];
Scmrs=tabScmr[[tmin]];
DytraM=Ytra'[M]/.M‘MYFm;
D2ytraM=Ytra''[M]/.M‘MYFm;
DxtraM=Xtra'[M]/.M‘MYFm;
D2xtraM=Xtra''[M]/.M‘MYFm;
Rho=(DytraM^2+DxtraM^2)^1.5/Abs[DxtraM*D2ytraM-
D2xtraM*DytraM];

(*Kf*)
H=.331-.436*Iha;
L=.324-.492*Iha;
M=.261+.545*Iha;
wfa=tabSc[[tmin]];
rfa=Rho;
hfa=tabhar[[tmin]];
Kf=H+(wfa/rfa)^L*(wfa/hfa)^M;

(*J*)
Y=Min[tabYFca];
C<=1;
mN=1;
J=Y*C</(Kf*mN);

(*Vfb*)

A14
 Vfb=Wnb*Cos[InLa]/(m*J*F);

(*Almacenamiento de data*)
arregloM0rt[cc]=M0r; arregloT0rt[cc]=T0r;
arregloM0at[cc]=M0a; arregloT0at[cc]=T0a;
arregloKrt[cc]=Kr; arregloKat[cc]=Ka;
arregloZt[cc]=Z; arregloIhrt[cc]=Ihr; arregloIhat[cc]=Iha;
arreglomit[cc]=m; arreglorft[cc]=rf; arreglorfit[cc]=rf*m;
arreglor0irt[cc]=r0r;arreglor0iat[cc]=r0a;
arreglorbat[cc]=rba;
arreglorbrt[cc]=rbr; arregloRtramint[cc]=Rtra[Pi/2];
arregloRtrrmint[cc]=Rtrr[Pi/2]; arreglorpt[cc]=rp;
arregloret[cc]=re;arreglorat[cc]=ra; arregloxt[cc]=x;
arregloTmaxrt[cc]=4maxr; arregloTmaxat[cc]=4maxa;
arregloat[cc]=c; arreglokat[cc]=kc;
arregloVfbt[cc]=Vfb;arregloYFt[cc]=Y;arregloJt[cc]=J;
arregloLa[cc]=La; arregloLaa[cc]=Laa;
arregloLar[cc]=Lar;arregloPhinLat[cc]=InLa;
arregloPsit[cc]=\; arreglobt[cc]=b; arreglobit[cc]=b*m;
arregloxit[cc]=x*m; arregloSat[cc]=wfa; arregloRho[cc]=rfa;
arreglohfa[cc]=hfa;arregloKf[cc]=Kf;arregloDaa0[cc]=Daa0;
arregloQat0[cc]=Qat0; arregloQdt0[cc]=Qdt0;
arregloinvQat0[cc]=invQa; arregloinvQrt0[cc]=invQr;
arregloMYFm[cc]=MYFm;arregloZmina[cc]=Zminc;
arregloTa[cc]=Ta;arregloysm0[cc]=ysm;
arregloRitra[cc]=Rtra[M0a]; arregloRitrr[cc]=Rtrr[M0r];
arreglot[cc]=t; arreglo'[cc]='; arregloG[cc]=G;
arregloes[cc]=es;
ccmax=cc;cc++;
(*xxxxxxxxxXXXXXXXXXXXXXXxxxxxxxxxxxxxXXXXXXXXXXXXxxxxxxxxxxxxxx*)
arregloM0rg[oo,nn,mm,ll,jj,kk,ii]=M0r;
arregloT0rg[oo,nn,mm,ll,jj,kk,ii]=T0r;
arregloM0ag[oo,nn,mm,ll,jj,kk,ii]=M0a;
arregloT0ag[oo,nn,mm,ll,jj,kk,ii]=T0a;
arregloKrg[oo,nn,mm,ll,jj,kk,ii]=Kr;
arregloKag[oo,nn,mm,ll,jj,kk,ii]=Ka;
arregloZg[oo,nn,mm,ll,jj,kk,ii]=Z;
arregloIhrg[oo,nn,mm,ll,jj,kk,ii]=Ihr;
arregloIhag[oo,nn,mm,ll,jj,kk,ii]=Iha;
arreglomig[oo,nn,mm,ll,jj,kk,ii]=m;
arreglorfg[oo,nn,mm,ll,jj,kk,ii]=rf;
arreglorfig[oo,nn,mm,ll,jj,kk,ii]=rf*m;
arreglor0irg[oo,nn,mm,ll,jj,kk,ii]=r0r;
arreglor0iag[oo,nn,mm,ll,jj,kk,ii]=r0a;
arreglorbag[oo,nn,mm,ll,jj,kk,ii]=rba;
arreglorbrg[oo,nn,mm,ll,jj,kk,ii]=rbr;
arregloRtraming[oo,nn,mm,ll,jj,kk,ii]=Rtra[Pi/2];
arregloRtrrming[oo,nn,mm,ll,jj,kk,ii]=Rtrr[Pi/2];

A15
 arreglorpg[oo,nn,mm,ll,jj,kk,ii]=rp;
arregloreg[oo,nn,mm,ll,jj,kk,ii];
arreglorag[oo,nn,mm,ll,jj,kk,ii]=ra;
arregloxg[oo,nn,mm,ll,jj,kk,ii]=x;
arregloTmaxrg[oo,nn,mm,ll,jj,kk,ii]=4maxr;
arregloTmaxag[oo,nn,mm,ll,jj,kk,ii]=4maxa;
arreglocg[oo,nn,mm,ll,jj,kk,ii]=c;
arregloVfbg[oo,nn,mm,ll,jj,kk,ii]=Vfb;
arregloYFg[oo,nn,mm,ll,jj,kk,ii]=Y;
arregloJg[oo,nn,mm,ll,jj,kk,ii]=J;
arregloScg[oo,nn,mm,ll,jj,kk,ii]=Sc;
arregloPhinLag[oo,nn,mm,ll,jj,kk,ii]=InLa;
arregloMYFm[oo,nn,mm,ll,jj,kk,ii]=MYFm;
aa++ ;
iimax=ii;ii++;),
{Z,Z0,Zf,w}];
ii=1;kkmax=kk;kk++;,
{rf,0.0,0,25,.25}];
kk=1;jjmax=jj;jj++;,
{x,-0.5,0.5,.1}}];
jj=1;llmax=ll;ll++;,
{b,1,1.25,.25}];
ll=1;mmmax=mm;mm++;,
{c,1,1.5,.1}];
mm=1;nnmax=nn;nn++;,
{Iha,{20*GR2RAD}}];
nn=1;oomax=oo;oo++;,
{\,{0}}]

A16