automatizaciÓn del proceso de diseÑo de un Álabe de

AUTOMATIZACIÓN DEL PROCESO DE DISEÑO DE UN ÁLABE DE TURBINA PELTON, EN UN SOFTWARE CAD, UTILIZANDO HERRAMIENTAS DE

PARAMETRIZACIÓN

ANDRÉS MAURICIO PÁJARO SOLANO

UNIVERSIDAD SANTO TOMÁS

FACULTAD DE INGENIERÍA MECÁNICA

DEPARTAMENTO DE INEGNIERÍAS

BOGOTÁ

2018

AUTOMATIZACIÓN DEL PROCESO DE DISEÑO DE UN ÁLABE DE TURBINA PELTON, EN UN SOFTWARE CAD, UTILIZANDO HERRAMIENTAS DE

PARAMETRIZACIÓN.

ANDRÉS MAURICIO PÁJARO SOLANO

Trabajo de grado para optar al título de Ingeniero Mecánico

Director

Adriana Fernanda Sierra Alarcón

Ingeniera Mecánica

Codirector

Jorge Andrés García Barbosa

Ingeniero Mecánico

UNIVERSIDAD SANTO TOMÁS

FACULTAD DE INGENIERÍA MECÁNICA

DEPARTAMENTO DE INEGNIERÍAS

BOGOTÁ

2018

Nota de aceptación:

________________________________________ ________________________________________ ________________________________________ ________________________________________ ________________________________________ ________________________________________

_______________________________________ Firma del presidente del jurado

_______________________________________ Firma del jurado

_______________________________________ Firma del jurado

Bogotá 19/05/2018

Dedicatoria

Este trabajo es dedicado a mi familia pues siempre han estado allí para apoyarme. Han sido el motor de mi vida y quienes creyeron en mi al momento de enfrentarme a este gran reto.

Agradecimientos

Agradezco profundamente a mi director y codirector que gracias a su apoyo y a la fe que tuvieron en mi sirvieron como impulso para sacar este proyecto adelante. Realmente sus palabras y guía fueron de gran ayuda pues gracias a ellos se pudieron dar las mejores ideas y resolver los problemas que este reto planteó.

También quiero agradecer a Rocky Zhang, empleado de Autodesk en Shanghái, a quien conocí a través de los foros de Autodesk Inventor y quien se convirtió en un gran aliado para el desarrollo de varias de las líneas de código planteadas en este proyecto.

En medio de las dificultades a las que me enfrenté en este proyecto pude descubrir a través de mi fe en Dios que Él fue mi principal ayudador, quien me orientó y quien formó mi carácter en el desarrollo de este trabajo. Gracias a Él, a través de este trabajo, pude descubrir una faceta que no conocía en mí. Por eso quiero agradecer a Dios por darme toda su ayuda, también a mi familia y en especial a Paola López pues me recordaban todos los días que no estaba solo en esto y por enseñarme que siempre puedo dar una milla extra.

Gracias Dios pues pude verte como un permanente ayudador.

CONTENIDO

1. RESUMEN ...................................................................................................... 1

2. INTRODUCCIÓN ............................................................................................. 2

3. PARÁMETROS NECESARIOS PARA EL DISEÑO DE UN ÁLABE DE TURBINA PELTON ................................................................................................. 4

3.1. Cálculo del diámetro del chorro ................................................................. 4

4. AUTOMATIZACIÓN DEL PROCESO DE CÁLCULO ....................................... 9

4.1. Aplicación de interfaz de programación (API) ............................................ 9

4.2. Programación orientada a objetos ........................................................... 10

4.3. Adquisición y acceso a la API de Inventor ............................................... 11

4.4. Generación de la interfaz de usuario en VBA .......................................... 13

5. GENERACIÓN DEL MODELO PARAMÉTRICO AUTOMATIZADO TRIDIMENSIONAL ............................................................................................... 18

5.1. Referenciación de librerías de Inventor al código VBA ............................ 18

5.2. Interacción del código VBA con la interfaz de Inventor ............................ 19

5.2.1. Acceso al aplicativo de Inventor desde VBA ..................................... 19

5.2.2. Verificación automática de sesiones abiertas de Inventor ................. 21

5.3. Interacción del código VBA con las funciones de Inventor ....................... 24

5.3.1. Función de creación de boceto del arco de elipse de la cuchara ....... 24

5.3.2. Función de creación del boceto y enmallado de la superficie inferior de la cuchara ...................................................................................................... 27

5.3.3. Función de creación de la superficie según enmallado ..................... 33

5.3.4. Función de simetría ........................................................................... 36

5.3.5. Creación de la geometría para la entrada del inyector ...................... 38

6. GENERACIÓN AUTOMÁTICA DE PLANOS (OPCIONAL)............................ 43

7. CONCLUSIONES .......................................................................................... 45

8. RECOMENDACIONES .................................................................................. 47

BIBLIOGRAFÍA ..................................................................................................... 48

ANEXOS .............................................................................................................. 51

A. Código para automatizar el proceso de diseño de álabes de turbinas Pelton 51

B. Código de generación automática de planos ........................................... 66

C. Recomendación para generar el sólido a partir de la superficie ............... 67

D. Ejemplo de la superficie final y el plano ................................................... 73

1

1. RESUMEN

Las turbinas Pelton son una de las alternativas más confiables al momento de generar energía eléctrica debido a que es un modo de transformación de energía renovable y no produce emisiones dañinas al ambiente. Sin embargo, el diseño de los álabes de las turbinas Pelton tiende a ser dispendioso debido a la compleja geometría que esta tiene, además que dicha geometría cambia según las condiciones de trabajo. Es necesario entonces generar un método para el modelado de álabes de turbinas Pelton (o cucharas) con el fin de agilizar el proceso de diseño y el cálculo de variables que intervienen en él. Para esto se utilizará el software CAD Inventor de Autodesk y se creará un programa en lenguaje de programación comercial que permita automatizar el proceso de diseño de superficies de cucharas Pelton.

2

2. INTRODUCCIÓN

En la actualidad existe una gran dependencia de la humanidad por la energía eléctrica. Medios de comunicación, aparatos electrónicos, medios de transporte, hogares, hospitales, etc. dependen de suministro eléctrico, haciendo que las tareas de la vida cotidiana sean más fáciles de ejecutar. El suministro eléctrico ha sido pieza clave para el desarrollo de comunidades y mejoramiento de la calidad de vida.

En Colombia se registra un 53% de zonas carentes de suministro eléctrico [1]. A tales zonas se les conoce como “zonas no interconectadas” (ZNI). Esto dificulta el desarrollo y afecta la calidad de vida de las comunidades ubicadas en ZNI. Estas ZNI en su mayoría se encuentran ubicadas en zonas donde hay ríos y cascadas de caudales importantes [1] que podrían ser usados por máquinas que transformen la energía hídrica en energía eléctrica. Una de las alternativas de solución a la carencia de electricidad en las ZNI es el uso de turbinas Pelton ya que éstas transforman la energía del agua en energía eléctrica.

Debido a que el diseño de las cucharas (álabes) de turbinas Pelton cambia dependiendo de las variables hidráulicas [2] es necesaria la automatización del proceso de cálculo de las variables que afectan su geometría y la automatización del modelado a través de software CAD por medio de una aplicación de lenguaje de programación comercial que permita al diseñador obtener resultados rápidos.

Se propone entonces crear un módulo de diseño para software CAD que desarrolle de manera automática un álabe de turbina pelton mediante la introducción de parámetros de diseño.

El presente trabajo muestra la manera en la cual se automatiza el proceso de diseño de un álabe de turbina Pelton haciendo uso de herramientas de parametrización en un software CAD (Autodesk Inventor). Esto debido a la complejidad al momento de modelar la superficie del álabe de manera manual. La intención es reducir los tiempos de diseño y automatizar el proceso.

Para la ejecución del proceso se hace uso de la aplicación de interfaz de programación de Inventor (API) la cual almacena las operaciones y funciones interactivas a través de códigos de programación en lenguajes comerciales de programación. Para este caso, se hará uso del lenguaje Visual Basic a través de la suite de programación Visual Studio.

Es importante resaltar que muchas de las funciones interactivas de Inventor para modelado de piezas y superficies se encuentran muy limitadas en la API de Inventor, siendo necesario recurrir a códigos más complejos de programación para homologar las funciones deseadas. Algunas operaciones interactivas a través de la API simplemente no existen, este es el caso de operaciones como corte de

3

superficies simples [3] y proyección de puntos tipo sketch [4] que limitan mucho el proceso de automatización.

Al final, lo que se logra es crear una superficie, las operaciones para generar un sólido se deberán hacer manualmente una vez se genera la superficie.

Este trabajo está dirigido para aquellos que no tienen amplia experiencia programando en aplicaciones para Visual Basic en entornos de modelado CAD. Se empezará dando una explicación de los parámetros necesarios para generar un álabe de turbina Pelton y, después de explicar los componentes de la API, se mostrará paso a paso el proceso para crear la superficie a través del lenguaje de programación mencionado.

4

3. PARÁMETROS NECESARIOS PARA EL DISEÑO DE UN ÁLABE DE TURBINA PELTON

La turbina Pelton se regula gracias a un inyector que posee una ojiva cuyo desplazamiento regula la salida del agua a través de esta (figura 1). El desplazamiento de la ojiva varía entonces el diámetro del chorro de fluido que recibe la cuchara en su superficie y en consecuencia la velocidad de la turbina.

Figura 1. Hernández, C. (1988). Configuración de la tobera. [Figura]. Recuperado de Diseño, estandarización y fabricación de equipos para pequeñas centrales hidroeléctricas

Las cucharas alrededor del rodete de la turbina tienen forma de dos semi elipsoides (figura 2) cuya intersección en la mitad se da a través de un nervio con filo y representa la unión entre ambas geometrías. Esta unión (o filo) divide el chorro de agua que entra en contacto con la cuchara, el resto de la geometría se encarga de expulsar el agua en dirección axial al rodete de la turbina.

Figura 2. Geometría de la cuchara. Tomado de Captura de pantalla del autor

3.1. Cálculo del diámetro del chorro

Sabiendo que la forma de la cuchara estará en función del caudal (Q) y de la cabeza (H), se deberá entonces hallar una forma de parametrizar la cuchara en función de estas dos variables (f = (Q, H)).

5

En la figura 3 se pueden observar las variables utilizadas para definir geométricamente todo el perfil de la cuchara [5, 6, 7]. También se puede observar que el punto de partida para definir todo es el diámetro del chorro a la salida del inyector (d0) [8].

Téngase en cuenta que el análisis de la geometría de las distintas superficies que conforman el perfil del álabe fue realizado según los autores Carlos Hernández y Manuel Polo Encinas, los cuales recomiendan que la geometría de la superficie superior de la cuchara sea la intersección de dos elipses [5, 6] (figura 3).

Figura 3. Hernández, C. (1988). Geometría del álabe. [Figura]. Recuperado de Diseño, estandarización y fabricación de equipos para pequeñas centrales hidroeléctricas

Sabiendo que el caudal (Q) se determina con el producto entre la velocidad del fluido y el área de la sección por la cual pasa [9]:

𝑄 = 𝐶 ∗ 𝑆

Donde C es la velocidad del flujo y S es el área.

Considerando que el flujo que proviene de la tobera tiene forma cilíndrica [10]:

𝑄 =𝑑0

2

4∗ 𝜋 ∗ 𝐶

Despejando el diámetro de la ecuación anterior:

6

𝑑0 = √4𝑄

𝜋𝐶 (𝑒𝑐. 1)

Donde C es la velocidad del chorro a la salida del inyector:

𝐶 = 𝐾𝑐√2𝑔𝐻 (𝑒𝑐. 2)

Reemplazando la ecuación 2 en la ecuación 1:

𝑑0 = √4𝑄

𝜋𝐾𝑐√2𝑔𝐻 (𝑒𝑐. 3)

Donde Kc es el coeficiente del inyector. [11, 5]

A continuación, se muestra la forma en la cual se determinó el valor de C (ecuación 2). Para esto se toma como base de estudio un sistema en el cual existe un represamiento de agua a una altura Z1, del cual cae un caudal de agua a una represa que se encuentra a una altura Z2. Ambas represas se encuentran abiertas a la atmosfera, por lo que las presiones en las represas son iguales (figura 4).

Figura 4. Esquema de represas de agua para determinar C. Tomado de Captura de pantalla del autor

7

Según la ecuación de Bernoulli.

𝑃1

𝛿+

𝐶12

2𝑔+ 𝑍1 =

𝑃2

𝛿+

𝐶22

2𝑔+ 𝑍2 + ∆𝐻𝑡 + ∆𝐻𝑖

∆Hi es la pérdida de presión por efectos de la fricción del agua con las paredes de la tubería del inyector. ∆Ht es la pérdida de presión por efecto de la fricción del agua con las paredes de la tubería de presión.

Sabiendo que las presiones son iguales y que la velocidad del fluido en la superficie de la represa de agua superior es cercana a cero, se obtiene la siguiente expresión.

𝑍1 = +𝐶2

2

2𝑔+ 𝑍2 + ∆𝐻𝑡 + ∆𝐻𝑖

Pero Z2 - Z1 = H, por tanto:

𝐶22

2𝑔+ 𝐻 + ∆𝐻𝑡 + ∆𝐻𝑖 = 0

C2 es la velocidad de salida del fluido en la represa inferior, despejando este valor se obtiene:

𝐶2 = √1 −∆𝐻𝑖

𝐻∗ √2𝑔𝐻

𝐶 = 𝐾𝑐 ∗ √2𝑔𝐻 (𝑒𝑐. 4)

8

Ya que se conoce el valor de d0 se pueden determinar las dimensiones del álabe.

Tabla 1. Dimensiones de la cuchara Pelton en función del diámetro del chorro [5]

B L D β1 β2

2,5d0 a 4d0

2,5d0 a 3,5d0

0,85d0 a 1,3d0

10° a 30°

4° a 20°

Con el fin de realizar un estudio más enfocado en la forma de la cuchara, en esta sección no se tendrá en cuenta el material de la cuchara y se asumirá que ésta se encuentra soldada al rodete.

Figura 5. Encinas, M. (1975). Dimensiones de la cuchara de una turbina Pelton. [Figura]. Recuperado de Turbomáquinas hidráulicas: principios fundamentales

La variable principal para tener en cuenta al momento de un diseño de cuchara es el diámetro del chorro (d0) que sale del inyector y choca con la superficie de la cuchara. En la figura 5 se muestra el lugar de impacto en la cuchara.

En este punto, ya se encontró el único parámetro del cual depende la geometría de una cuchara de turbina Pelton. El paso por seguir consiste en automatizar el proceso de cálculo.

9

4. AUTOMATIZACIÓN DEL PROCESO DE CÁLCULO

Como se había mencionado anteriormente, el diámetro del chorro dependerá de Q y H. Para poder realizar los cálculos de manera automática se hará uso de un lenguaje de programación. Debido a que el software que se usará para desarrollar el modelo CAD es Inventor (de la familia de Autodesk), se optará por usar el lenguaje de programación Visual Basic ya que el núcleo de programación de inventor está diseñado con dicho lenguaje. Se hará también uso de la suite de programación Visual Studio, la cual incluye el lenguaje de programación Visual Basic.

4.1. Aplicación de interfaz de programación (API)

La aplicación de interfaz de programación de Inventor hace referencia a las funcionalidades que permiten que el software Inventor pueda ser utilizado a través de lenguaje de programación (también se le conoce como API por sus siglas en inglés). La API tiene la función de permitir automatizar los procesos de modelado que se podrían hacer de manera interactiva con la interfaz gráfica que ofrece Inventor [12].

Con la API es posible agregar funcionalidades a Inventor dependiendo de necesidades específicas con el fin de optimizar operaciones repetitivas. Desde este punto de vista es de interés el poder crear una función que permita la creación de superficies complejas que hechas manualmente con Inventor tomarían mucho tiempo ya que dependerían de cálculos y operaciones muy sofisticadas.

A continuación, se explicará de qué se compone la API de Inventor:

Figura 6. Autodesk. (2017). API de Inventor. [Figura]. Recuperado de: http://help.autodesk.com/view/INVNTOR/2018/ENU/?guid=GUID-4939ABD1-A15E-473E-9376-D8208EC029EB

La figura 6 muestra los elementos de los cuales se compone la API de Inventor.

10

El cilindro azul representa los datos de Inventor a los cuales se puede tener acceso (por ejemplo, documentos de partes, ensambles, planos, etc.). Los cuadros amarillos representan programas escritos por el usuario. El hecho de que la caja “Add-In” y la caja “VBA” estén dentro de la caja “Inventor” significa que esos procesos se están ejecutando con Inventor (o al mismo tiempo con Inventor o dentro de Inventor).

VBA o Visual Basic for Applications (Aplicaciones para Visual Basic en español), es el ambiente de programación al cual se puede acceder independientemente de que Inventor esté ejecutándose o no. Los programas hechos en VBA también se conocen como “macros”. Estos macros se usan para automatizar tareas que pueden ser repetitivas o complejas. Es en el VBA en el cual se escribirá el código para generar automáticamente el modelo de la superficie de la cuchara Pelton.

Los Add-In son aplicativos (o subprogramas) de Inventor que permiten hacer operaciones de manera interactiva. Algunas de estas operaciones se pueden realizar a través de código de programación.

El Standalone EXE (o ejecutable autónomo) hace referencia aquellos programas externos que pueden interactuar con Inventor. Como ejemplo existen opciones para vincular herramientas ofimáticas como Excel a Inventor y así trabajar con ambos programas.

El Apprentice Server (o Servidor Aprendiz) es el núcleo en el cual se encuentran las funciones de Inventor a través de lenguaje de programación.

4.2. Programación orientada a objetos

La programación orientada a objetos se puede definir como la metodología del lenguaje de programación para compilar correctamente un código. La programación orientada a objetos se compone de: clases, objetos y métodos.

Emplea técnicas de programación como: herencia, cohesión, abstracción, polimorfismo, acoplamiento, y encapsulamiento [13].

La programación orientada a objetos se distingue de la tradicional porque los datos y los procedimientos están separados y sin relación debido a que lo que se busca es el procesamiento de datos de entrada para obtener datos de salida. Para esto se definen primero los objetos con el fin de asignarles métodos, los cuales pueden realizar por si mismos [14].

Una clase es un concepto abstracto en el cual se define un universo de componentes (objetos). Cada componente puede realizar ciertas funciones (métodos) y el correcto orden lógico entre objetos y funciones definen el propósito

11

de ese universo llamado clase. Por ejemplo, si se define una clase llamada “extrusión cilíndrica” se compondrá de un objeto llamado “creación de extrusión cilíndrica” en el cual se definirá un boceto circular que se verá afectado por un método, comando o función llamado “extrusión” y que generará un sólido partiendo de dicho boceto. Así el método determinó el comportamiento del objeto dándole así un sentido a la clase.

Tal metodología será la que se aplicará para la creación del programa para automatizar el proceso de modelado de la superficie de la cuchara Pelton. Se podría decir entonces que la clase “superficie de cuchara Pelton” se compondrá de una serie de objetos que definirán la forma de la cuchara (“círculos”, “arcos, “elipses”, etc.) y que se verán afectados por métodos o funciones (“extrusiones de círculos”, “creación de superficies a partir de elipses”, “modelados de superficies existentes”, etc.) que modelarán la forma de la cuchara.

4.3. Adquisición y acceso a la API de Inventor

Para poder crear el modelo de la cuchara se hará uso de los comandos del software CAD Inventor que ofrece la API. Para acceder a dichos comandos se debe importar la API de Inventor al campo de programación en el cual se trabajará.

A continuación, se mostrará una serie de pasos para acceder a la API de Inventor desde Visual Basic:

Una vez Visual Basic se encuentre abierto habrá que dirigirse al recuadro superior derecho y, haciendo clic derecho en el ítem referencias se seleccionará la opción agregar referencias.

Figura 7. Opción agregar referencias. Tomado de: Captura de pantalla del autor

Una vez se ingresa a esta opción, en la barra de buscador se buscará la carpeta en la cual se encuentra instalado Inventor. Una vez se está en la carpeta de instalación

12

se buscará la carpeta Public Assemblies (C:\...\Autodesk\Inventor 2018\Bin\Public Assemblies). Allí se deberá seleccionar y agregar la API (o librería) llamada Autodesk.Inventor.Interop.dll.

Figura 8. Librería de Inventor. Tomado de: Captura de pantalla del autor

Una vez se haga clic en aceptar, ya se tendrán disponibles todas las funciones de la API de Inventor.

13

4.4. Generación de la interfaz de usuario en VBA

Es importante pedir al usuario las variables de caudal (Q) y altura (H) pues de estas se partirá para determinar las dimensiones de la cuchara.

Figura 9. Ejemplo de una interfaz de entrada de datos del usuario. Tomado de: Captura de pantalla del autor

La Figura 9 muestra la interfaz gráfica para digitación de datos generada con VBA para el modelado de cucharas Pelton. En ella solo se introduce el caudal (Q) y la altura (H), el código toma estos valores y los usa para determinar la geometría de la cuchara.

Se recomienda utilizar el siguiente esquema para introducción de datos:

Figura 10. Esquema para introducción de datos en el aplicativo. Tomado de: Captura de pantalla del autor

14

Es necesario nombrar los TextBox de forma correcta, tal que se puedan identificar fácilmente al momento de crear el código y sus funciones. Para este caso, el TextBox para digitar el valor del caudal se identificará como TextBoxCaudal, el TextBox para digitar el valor de la altura se identificará como TextBoxAltura y el TextBox que mostrará el computo de Q y H se identificará como TextBoxd0.

Figura 11. Identificación del objeto TextBox. Tomado de: Captura de pantalla del autor

Ahora, es necesario realizar los cálculos para encontrar el diámetro del chorro (d0) según la ecuación 3. La metodología más cómoda consiste en primero calcular ya sea el numerador o el denominador de la ecuación 3 y después realizar la operación faltante. Se debe primero declarar una constante que tendrá el valor de PI (el cual se asignará con el comando Math.PI). Las líneas de código que se muestran a continuación se deben realizar dentro del Form1.

Public Class Form1

Try Dim PI As Double PI = Math.PI

15

Dim denominadord0 As Double = Math.Sqrt(2 * 9810 * TextBoxHead.Text * 1000) * PI * TextBoxKc.Text Dim numeradord0 As Double = 4 * TextBoxCaudal.Text * 1000000000 Dim d0 As Double = Math.Sqrt(numeradord0 / denominadord0) TextBoxd0.Text = Math.Round(d0) Catch End Try

End Class

El comando Try Catch es útil para capturar excepciones y no mostrarlas en pantalla. Esto en el caso en que el usuario ingrese el valor de cero en los TextBox ya que así no se generará error. El comando Math.Round redondea el valor. Se deben tener en cuenta los factores de conversión en función de las unidades, para este caso, se pedirá que el caudal se introduzca en mm^3/s y la altura en mm.

Se recomienda hacer el uso de un Timer y colocar el código anterior dentro de éste para que se muestre constantemente el resultado de la operación en el TextBoxd0:

Public Class Form1

Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick

Try Dim PI As Double

PI = Math.PI Dim denominadord0 As Double = Math.Sqrt(2 * 9810 * TextBoxHead.Text * 1000) * PI * TextBoxKc.Text Dim numeradord0 As Double = 4 * TextBoxCaudal.Text * 1000000000 Dim d0 As Double = Math.Sqrt(numeradord0 / denominadord0) TextBoxd0.Text = Math.Round(d0) Catch End Try

End Sub

End Class

Se debe activar el Timer desde que se inicia el programa:

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load Timer1.Start() End Sub

Una vez se tenga el valor d0, se crean tres nuevos TextBox en los cuales se ingresará el valor de las constantes B, L y D (tabla 1). Estos valores no estarán ni visibles ni disponibles para el usuario.

16

Figura 12. Creación de nuevos TextBox. Tomado de: Captura de pantalla del autor

Para identificar fácilmente en el código cada TextBox se recomienda identificarlos como TextBoxConstantL, TextBoxConstantB y TextBoxConstantD respectivamente. Se deben ocultar de la interfaz estos TextBox. La razón de poner estos TextBox directamente en la interfaz y no los valores de B, L y D en el código es porque dado el caso en que se quiera modificar una de estas constantes bastará con cambiar el valor desde la interfaz en el modo programador (modo en el cual estará visible para quien programa). Esto valores deberán ser computados una vez se inicie el proceso de diseño, por esa razón se creará el código en el objeto Button. Se crearán también tres variables nuevas: dimL, dimB y dimD. Estas tres harán referencia a la dimensión del largo de la cuchara (L), el ancho de la cuchara (B) y la profundidad (D) respectivamente (figura 2).

Public Class Form1





End Sub

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click

Dim dimL As Double = TextBoxConstantL.Text * TextBoxd0.Text Dim dimD As Double = TextBoxConstantD.Text * TextBoxd0.Text Dim dimB As Double = TextBoxConstantB.Text * TextBoxd0.Text

17

End Sub

End Class

Hasta este punto, ya se ha automatizado el proceso de cálculo del diámetro del chorro y las dimensiones de la cuchara.

18

5. GENERACIÓN DEL MODELO PARAMÉTRICO AUTOMATIZADO TRIDIMENSIONAL

En esta sección se hará énfasis en la creación del código para el aplicativo siguiendo el orden propuesto en el siguiente diagrama de flujo:

Figura 13: Diagrama de flujo para el proceso de dibujo automatizado

5.1. Referenciación de librerías de Inventor al código VBA

Si bien es cierto que ya se ha generado un vínculo entre VBA y la API de inventor, ahora es necesario llamar la API al ambiente de programación con el fin de usar sus funciones [15].

La clase Form1 es la que contiene el código que realizará todos los procesos de cálculo y modelado, fuera de esta se deberá importar la API como se muestra a continuación:

Imports System.Activator Imports System.Runtime.InteropServices Imports System.Type Imports Inventor

Public Class Form1



19



End Sub



End Sub

End Class

5.2. Interacción del código VBA con la interfaz de Inventor

5.2.1. Acceso al aplicativo de Inventor desde VBA

A continuación, se explicará cómo conectar el código en desarrollo en VBA con el aplicativo Inventor. Para esto es necesario hacer uso del comando Marshal para llamar un aplicativo que se encuentre en el sistema. El comando Marshal se usará en un nuevo subproceso público generado como nuevo.


Public Class Form1

Dim _invApp As Inventor.Application Dim partDoc As PartDocument Dim partDef As PartComponentDefinition

Public Sub New()

InitializeComponent()

Try _invApp = Marshal.GetActiveObject("Inventor.Application")

20

Catch ex As Exception Try Dim invAppType As Type = GetTypeFromProgID("Inventor.Application") MsgBox("Se procederá a ejecutar la aplicación de Inventor", MsgBoxStyle.Information, "MÓDULO DE DISEÑO DE ÁLABES DE TURBINAS PELTON") _invApp = CreateInstance(invAppType) _invApp.Visible = True Catch ex2 As Exception MsgBox(ex2.ToString()) MsgBox("Inventor no está instalado", MsgBoxStyle.Critical, "MÓDULO DE DISEÑO DE ÁLABES DE TURBINAS PELTON") Me.Close() End Try End Try

End Sub





End Sub



End Sub

End Class

La función Marshal.GetActiveObject(“Inventor.Application”) se encargará de buscar la aplicación de Inventor una vez se ejecute el código VBA [16]. En el caso de que la aplicación de Inventor no se encuentre abierta, la función GetTypeFromProgID que busque el aplicativo de Inventor. Una vez lo encuentra, almacena el aplicativo de Inventor como un objeto dentro de la variable _invApp (gracias a la función

21

CreateInstance(invAppType)) y la ejecuta. De ahora en adelante Inventor pasará a ser una instancia (u objeto) dentro de la clase Form1. En este punto ya se ha creado el enlace entre el código VBA en desarrollo y la aplicación de Inventor. En el caso en que no se encuentre el aplicativo de Inventor instalado en el sistema, la función Try Catch capturará el error y en su lugar mostrará un mensaje que indicará que Inventor no se encuentra instalado.

5.2.2. Verificación automática de sesiones abiertas de Inventor

Una vez el aplicativo de Inventor esté abierto, se deberá identificar si existe una sesión para iniciar con el modelado. Para esto se agregará la siguiente línea:

If _invApp.Documents.Count = 0 Then MsgBox("Se necesita abrir un nuevo documento", MsgBoxStyle.Exclamation, "MÓDULO DE DISEÑO DE ÁLABES DE TURBINAS PELTON") partDoc = _invApp.Documents.Add(DocumentTypeEnum.kPartDocumentObject, _invApp.FileManager.GetTemplateFile(DocumentTypeEnum.kPartDocumentObject, SystemOfMeasureEnum.kMetricSystemOfMeasure)) partDef = partDoc.ComponentDefinition End If

If _invApp.ActiveDocument.DocumentType = DocumentTypeEnum.kPartDocumentObject Then partDoc = _invApp.Documents.Add(DocumentTypeEnum.kPartDocumentObject, _invApp.FileManager.GetTemplateFile(DocumentTypeEnum.kPartDocumentObject, SystemOfMeasureEnum.kMetricSystemOfMeasure)) partDef = partDoc.ComponentDefinition End If

La línea If _invApp.Documents.count = 0 Then cuenta las sesiones que se encuentran activas en el aplicativo de Inventor. En el caso de que no haya ninguna se creará una nueva. Esta nueva sesión se almacenará en la variable partDoc y será del tipo documento de objeto (o .ipt) y con formato en sistema métrico.

La línea If _invApp.ActiveDocument.DocumentType=DocumentTypeEnum.kPartDocumentObject Then se usa para el caso en que ya haya una sesión activa. De ser así, se generará una nueva para no afectar a la sesión anterior.

En Inventor existen los componentes de definición, estos son el grupo de operaciones que se han realizado durante el proceso de modelado. En los componentes de definición también están las funciones que definen el modelado de una pieza.

22

Figura 14. Componentes de definición. Tomado de: Captura de pantalla del autor

Los componentes de definición, en cuanto a la API se refiere, también se interpretan como el árbol de operaciones.

En la variable partDef se almacenará toda la información relacionada a los componentes de definición.

Hasta este punto, el código deberá estar así:


Public Class Form1

Dim _invApp As Inventor.Application Dim partDoc As PartDocument Dim partDef As PartComponentDefinition

Public Sub New()

InitializeComponent()

Try _invApp = Marshal.GetActiveObject("Inventor.Application") Catch ex As Exception Try Dim invAppType As Type = GetTypeFromProgID("Inventor.Application")

23

MsgBox("Se procederá a ejecutar la aplicación de Inventor", MsgBoxStyle.Information, "MÓDULO DE DISEÑO DE ÁLABES DE TURBINAS PELTON") _invApp = CreateInstance(invAppType) _invApp.Visible = True Catch ex2 As Exception MsgBox(ex2.ToString()) MsgBox("Inventor no está instalado", MsgBoxStyle.Critical, "MÓDULO DE DISEÑO DE ÁLABES DE TURBINAS PELTON") Me.Close() End Try End Try

End Sub





End Sub


If _invApp.Documents.Count = 0 Then MsgBox("Se necesita abrir un nuevo documento", MsgBoxStyle.Exclamation, "MÓDULO DE DISEÑO DE ÁLABES DE TURBINAS PELTON") partDoc = _invApp.Documents.Add(DocumentTypeEnum.kPartDocumentObject, _invApp.FileManager.GetTemplateFile(DocumentTypeEnum.kPartDocumentObject, SystemOfMeasureEnum.kMetricSystemOfMeasure)) partDef = partDoc.ComponentDefinition End If

If _invApp.ActiveDocument.DocumentType = DocumentTypeEnum.kPartDocumentObject Then partDoc = _invApp.Documents.Add(DocumentTypeEnum.kPartDocumentObject, _invApp.FileManager.GetTemplateFile(DocumentTypeEnum.kPartDocumentObject, SystemOfMeasureEnum.kMetricSystemOfMeasure)) partDef = partDoc.ComponentDefinition End If


24

End Sub

End Class

5.3. Interacción del código VBA con las funciones de Inventor

A partir de este punto se mostrarán los códigos usados para homologar las operaciones interactivas de Inventor. Se explicará el código por cada operación y en los anexos se encontrará el código formalmente terminado.

5.3.1. Función de creación de boceto del arco de elipse de la cuchara

En la API de Inventor una elipse se define por un centro, un eje mayor, las medidas de sus ejes, el ángulo de comienzo y el ángulo de barrido.

Para crear un sketch se debe elegir primero el plano en el cual se trabajará:

Dim sketchXY As PlanarSketch sketchXY = partDef.Sketches.Add(partDef.WorkPlanes.Item(3))

Dim tg As TransientGeometry tg = _invApp.TransientGeometry

'Creación del centro en 0,0 Dim oCenter As Point2d oCenter = tg.CreatePoint2d(0, 0)

'Creación del eje mayor en el eje Y Dim oMajorAxis As UnitVector2d oMajorAxis = tg.CreateUnitVector2d(0, 1)

Se define la variable sketchXY como un boceto plano (o Planar Sketch) y se le asigna el plano XY, o ítem 3 en la carpeta de planos de trabajo (figura 14). Se debe tener en cuenta que la variable partDef es la que almacena todos los componentes de definición.

La variable tg es del tipo TransientGeometry. En ella se almacenan todos los objetos como puntos, planos, vectores y Spline. Con la variable tg se creará el punto en la coordenada (0, 0) de la primera elipse y el vector paralelo al eje Y que definirá la dirección del eje mayor de la elipse. Es necesario definir el ángulo en el cual una elipse corte con otra para generar la geometría superior de la cuchara. Debido a que la API de Inventor no permite crear arcos de elipse definidas entre un punto inicial y final, es necesario definirla con el ángulo de comienzo y ángulo de barrido.

25

Figura 15. Ángulo de corte entre elipses. Tomado de: Captura de pantalla del autor

En la figura 15 se muestra un triángulo punteado. Las dimensiones de los catetos se definen en función de B y L (tabla 1). Teniendo en cuenta la figura 3, la dimensión del cateto paralelo al eje menor de la elipse se define en función de B como:

𝐶𝑎𝑡𝑒𝑡𝑜 𝑒𝑗𝑒 𝑚𝑒𝑛𝑜𝑟 = 𝑑𝑖𝑚𝐵 ∗ 0.45 ∗ 0.5

En ese orden, la dimensión del cateto más largo del triángulo punteado de define en función de L como:

𝐶𝑎𝑡𝑒𝑡𝑜 𝑒𝑗𝑒 𝑚𝑎𝑦𝑜𝑟 = 𝑑𝑖𝑚𝐿 ∗ 0.5 ∗ 𝑎

Donde a es una variable que define el largo de ese cateto. Este largo será el que defina el punto de corte entre ambas elipses. No se recomienda dejar la variable a a discreción del usuario, sino que sea un valor fijo para evitar inconvenientes futuros al momento de modelar la cuchara.

Nótese que todos los triángulos que se forman en esta configuración (figura 15) serán semejantes [17]. Por tal razón para cualquier dimensión del eje de la elipse que es más largo (dimL*0.5), a representará 0.575 veces su longitud total. Por tanto, el cateto más largo del triángulo punteado se definirá como:

𝐶𝑎𝑡𝑒𝑡𝑜 𝑒𝑗𝑒 𝑚𝑎𝑦𝑜𝑟 = 𝑑𝑖𝑚𝐿 ∗ 0.5 ∗ 0.575

26

Conociendo los valores de ambos catetos se puede determinar el ángulo en el cual se cortan ambas elipses (figura 16):

∅ = 𝐴𝑡𝑎𝑛 (𝐶𝑎𝑡𝑒𝑡𝑜 𝑒𝑗𝑒 𝑚𝑒𝑛𝑜𝑟

𝐶𝑎𝑡𝑒𝑡𝑜 𝑒𝑗𝑒 𝑚𝑎𝑦𝑜𝑟) = 𝐴𝑡𝑎𝑛 (𝑑𝑖𝑚𝐵 ∗ 0.45 ∗

0.5

𝑑𝑖𝑚𝐿 ∗ 0.5 ∗ 0.575)

En el código, el ángulo de corte se definirá como se muestra a continuación:

Dim ang As Double ang = Math.Atan((dimB * 0.45 * 0.5) / (dimL * 0.5 * 0.57493264))

Las medidas del eje mayor y menor se definen como dimL/2 y dimB*0.275 según la figura 16. Para poder dibujar la elipse se debe crear una variable tipo SketchEllipticalArc. A esta variable se le asignará el boceto del arco de elipse en el plano XY (que ya se había definido como sketchXY).

Teniendo los parámetros que definen a la elipse a través de la API de Inventor se puede generar el código:

Dim oEllipticalArc As SketchEllipticalArc oEllipticalArc = sketchXY.SketchEllipticalArcs.Add(oCenter, oMajorAxis, dimL / 2, dimB * 0.275, -ang, PI + 2 * ang)

El paso siguiente consiste en crear la línea que cerrará el arco de elipse que se acaba de crear. Las líneas rectas en la API de inventor se definen por un punto de inicio y un punto final. Para esto se creará una variable de tipo SketchLine y que comenzará y terminará en el punto de inicio del arco de la elipse y en su punto final.

Dim lineEllipticalArc As SketchLine lineEllipticalArc=sketchXY.SketchLines.AddByTwoPoints(oEllipticalArc.StartSketchPoit, oEllipticalArc.EndSketchPoint)

27

Figura 16. Geometría del arco de elipse. Tomado de: Captura de pantalla del autor

5.3.2. Función de creación del boceto y enmallado de la superficie inferior de la cuchara

De la misma forma en que se creó el sketchXY también se creará un boceto plano en el plano YZ.

Dim sketchYZ As PlanarSketch sketchYZ = partDef.Sketches.Add(partDef.WorkPlanes.Item(1))

Figura 17. sketchYZ en el plano YZ. Tomado de: Captura de pantalla del autor

28

Figura 18. Boceto de la superficie inferior de la cuchara. Tomado de: Captura de pantalla del autor

Se creará un cuarto de arco de circunferencia de radio dimD, identificado como arcYZ1 en el código, para la primera sección y se unirá con un arco tangente a ella, identificado como arcYZ2 en el código.

Un arco de circunferencia se define en la API de inventor por un centro, un punto de inicio y un punto final. Siguiendo la metodología para la creación del boceto elíptico, se definirán los puntos de control del arco. Se creará una variable para cada punto del tipo Point2d y se definirán sus coordenadas en el plano YZ:

'Creación de los puntos de control del primer arco: Dim centerPointArcYZ1 As Point2d centerPointArcYZ1 = tg.CreatePoint2d((dimL / 2 - dimD), 0) Dim startPointArcYZ1 As Point2d startPointArcYZ1 = tg.CreatePoint2d(dimL / 2, 0) Dim endPointArcYZ1 As Point2d endPointArcYZ1 = tg.CreatePoint2d((dimL / 2 - dimD), dimD)

'Creación del primer arco: arcYZ1 Dim arcYZ1 As SketchArc arcYZ1=sketchYZ.SketchArcs.AddByCenterStartEndPoint(centerPointArcYZ1, startPointArcYZ1, endPointArcYZ1)

Para la creación del arco tangente (arcYZ2) se definirá una colección de puntos para definir su trazado. Se creará una variable llamada pnts del tipo ObjectCollection que guardará los puntos que definen al arcYZ2. La línea que unirá tales puntos será una Spline con vértices de control.

'Creación de los puntos de control del segundo arco (arcYZ2): Dim endPointArcYZ2 As Point2d endPointArcYZ2 = tg.CreatePoint2d(-dimL / 2, 0)

Dim pnts As ObjectCollection pnts = _invApp.TransientObjects.CreateObjectCollection Call pnts.Add(arcYZ1.EndSketchPoint) Call pnts.Add(tg.CreatePoint2d((-dimD / 2), dimD)) Call pnts.Add(endPointArcYZ2)

29

En el código se crearon tres puntos que son el de inicio, el de control (Call pnts.Add(tg.CreatePoint2d((-dimD / 2), dimD))) y el final. El punto de control debe estar ubicado de forma tal que la línea que une a este punto con el punto final del arcYZ1 sea paralelo al eje Y (figura 18).

'Creación del arco: arcYZ2 Dim controlPointSpline As SketchControlPointSpline controlPointSpline = sketchYZ.SketchControlPointSplines.Add(pnts)

Después de esto, se recomienda crear un plano paralelo a al plano YZ y que pase por la línea que cierra el arco elíptico creado en la sección anterior. Para definir un plano en la API de inventor se debe crear una variable del tipo WorkPlane y definir un plano paralelo y un punto por el que pasará.

'Creación de nuevo plano para crear el mirror de la cuchara Dim newPlane1 As WorkPlane = partDef.WorkPlanes.AddByPlaneAndPoint(partDef.WorkPlanes.Item(1), oEllipticalArc.StartSketchPoit)

newPlane1.Visible = False

Esto se hace con la intención de replicar el modelo generado en los pasos siguientes y que conformarán el otro ovoide de la cuchara.

Figura 19. Plano para la creación de la operación de simetría. Tomado de: Captura de pantalla del autor

Ahora será necesario crear el enmallado que define la forma de ovoide de la superficie inferior de la cuchara.

30

Figura 20. Enmallado para la creación de la superficie inferior. Tomado de: Captura de pantalla del autor

Para este proceso se crearán dos planos y se usará también el plano XY para definir la geometría del enmallado haciendo uso de la opción que ofrece la API de agregar planos paralelos a uno existente y a una distancia determinada de ellos:

'Creación de nuevos planos para la creación del enmallado de la superficie inferior. Dim newPlane3 As WorkPlane = partDef.WorkPlanes.AddByPlaneAndOffset(partDef.WorkPlanes.Item(2), dimL / 2 - dimD)

newPlane3.Visible = False Dim sketchnewPlan3 As PlanarSketch sketchnewPlan3 = partDef.Sketches.Add(partDef.WorkPlanes.Item(5))

Dim newPlane4 As WorkPlane = partDef.WorkPlanes.AddByPlaneAndOffset(partDef.WorkPlanes.Item(2), -(dimL / 2 - dimD))


En cada uno de los planos creados se ha generado un PlanarSketch para definir las geometrías necesarias.

A continuación, se muestra el proceso para crear el primer arco (en azul en la figura 20) del enmallado.

El arco en azul de la figura 20 se compone por dos arcos. Para crear el primer arco se debe crear un punto de trabajo que se define por la intersección del arcYZ1 con el plano newPlane3 (este plano está a una distancia tal que pasa por el punto final

31

del arco arcYZ1 y es paralelo al plano XZ), tal punto será el punto de inicio del primer arco que compone al arco azul:

Figura 21. Boceto del arco en el newPlane3. Tomado de: Captura de pantalla del autor

'Creación de punto de inicio del primer arco que compone al arco azul en el plano newPlane3 Dim skA1 As SketchLine skA1 = partDoc.ComponentDefinition.Sketches(1).SketchLines(1) Dim newWPA1 As WorkPoint newWPA1 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA1, newPlane3) Dim startpointA1 As SketchPoint startpointA1 = sketchnewPlan3.AddByProjectingEntity(newWPA1)

Debido a que el punto creado anteriormente será el punto de inicio del arco, este debe ser del tipo SketchPoint, por esa razón el punto de trabajo newWPA1 se proyecta en el boceto plano del newPlane3.

Ahora es necesario crear el punto final del arco. Este punto debe ser el que interseca la línea que une los puntos final e inicial del arco elíptico y el newPlane3:

'Creación de punto final del arco Dim skA11 As SketchArc skA11 = partDoc.ComponentDefinition.Sketches(2).SketchArcs(1) Dim newWPA11 As WorkPoint newWPA11 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA11, newPlane3) Dim endpointA1 As SketchPoint endpointA1 = sketchnewPlan3.AddByProjectingEntity(newWPA11)

32

Una vez se tienen los puntos definidos, es necesario crear un punto de control para poder variar el ángulo de entrada (β1) del filo por el cual entra el chorro de agua.

Figura 22. Ángulos de entrada y salida del agua. Tomado de: Captura de pantalla del autor

Este ángulo se puede controlar con el uso de un Spline con vértices de control:

Figura 23. Uso del Spline con vértices de control para definir los ángulos de entrada y salida del agua. Tomado de: Captura de pantalla del autor

El ángulo β1 será definido por el diseñador, para eso se recomienda crear un TextBox en el cual se pueda introducir el ángulo. Se recomienda identificar el TextBox de tal manera que sea fácil de recordar en el código. Para efectos de esta explicación, el TextBox se identificará como TextBoxInAngle.

La coordenada en Z del punto de control se define por la distancia de la intersección entre el arco arcYZ1 o el arco arcYZ2 con el plano newPlane3 (figuras 21 y 23) y el plano XY. El valor de X del punto mostrado en la figura 23 se define como:

𝑥 = 𝐴𝑡𝑎𝑛(𝛽1) ∗ 𝑧

'Creación de x Dim dist As Double

dist = _invApp.MeasureTools.GetMinimumDistance(newWPA1, partDef.WorkPlanes.Item(3))

33

Dim x As Double x = Math.Atan(TextBoxinAngle.text) * dist

Una vez definido el valor de x se puede generar el primer arco teniendo en cuenta los puntos startpointA1 y endpointA1 creados anteriormente:

'Creación del arco Dim pnts1 As ObjectCollection Pnts1 = _invApp.TransientObjects.CreateObjectCollection

Call pnts1.Add(tg.CreatePoint2d(0, startpointA1.Geometry.Y)) Call pnts1.Add(tg.CreatePoint2d(startpointA1.Geometry.X - x,

startpointA1.Geometry.Y)) Call pnts1.Add(tg.CreatePoint2d(endpointA1.Geometry.X,

endpointA1.Geometry.Y)) Dim controlPointSpline2 As SketchControlPointSpline controlPointSpline2 = sketchnewPlan3.SketchControlPointSplines.Add(pnts1)

Figura 24. Creación del primer arco. Tomado de: Captura de pantalla del autor

Esta misma metodología deberá ser aplicada para cada uno de los arcos que se crearán con el fin de definir el enmallado de la superficie inferior. Se pueden usar tantos arcos como el programador desee.

5.3.3. Función de creación de la superficie según enmallado

Una vez el enmallado esté definido, se debe definir la operación de creación de superficie en función del arco elíptico definido en la sección 4.3.1. Para esto se creará una variable del tipo PlanarSketch en la cual se almacenarán los límites que definirán la superficie [18].

Dim oSk1 As PlanarSketch

oSk1 = partDoc.ComponentDefinition.Sketches(1)

34

La variable oSk1 almacena el boceto 1 (boceto del arco elíptico). El número en paréntesis del código anterior indica la posición del boceto en el componente de definición (o en el árbol de operaciones), obsérvese que la figura 25 muestra que el boceto del arco elíptico corresponde al ítem 1 de los bocetos.

Figura 25. Ítems del árbol de operaciones. Tomado de: Captura de pantalla del autor

Ahora se debe definir como un perfil que será usado para crear una superficie.

Dim oProfile1 As Profile oProfile1 = oSk1.Profiles.AddForSurface

Después de esto, se deben crear las variables que tomarán el perfil creado anteriormente y lo definirán como límites de la superficie. Esta variable será del tipo BoundaryPatchDefinition.

Dim oBPDef1 As BoundaryPatchDefinition oBPDef1 = partDoc.ComponentDefinition.Features.BoundaryPatchFeatures.CreateBoundaryPatchDefinition

oBPDef1.BoundaryPatchLoops.Add(oProfile1)

El paso por seguir es crear una variable que se encargará de ejecutar la operación de creación de superficie según el perfil almacenado en oBPDef1. Esta variable será del tipo BoundaryPatchFeature.

Dim oBP1 As BoundaryPatchFeature

oBP1 = partDoc.ComponentDefinition.Features.BoundaryPatchFeatures.Add(oBPDef1)

35

Figura 26. Creación de superficie. Tomado de: Captura de pantalla del autor

La superficie generada anteriormente debe ser moldeada de tal forma que se acomode al enmallado creado en la sección 4.3.2. Por tal razón es necesario volver a definir los límites por los cuales se verá modificada la superficie creada. Para este fin se creará otra variable de tipo BoundaryPatchDefinition. En esta variable es necesario declarar que la superficie que se modificará será la oBP1.

Dim oBPDef2 As BoundaryPatchDefinition

oBPDef2= partDoc.ComponentDefinition.Features.BoundaryPatchFeatures.CreateBoundaryPatchDefinition oBPDef2.BoundaryPatchLoops.Add(oBP1.Faces(1).EdgeLoops(1))

Ahora es necesario crear una variable que almacenará cada uno de los arcos del enmallado. Esta variable será la encargada de restringir el moldeado de la superficie en función del enmallado.

Dim oGuideRails As ObjectCollection

oGuideRails = _invApp.TransientObjects.CreateObjectCollection

Es importante almacenar cada arco del enmallado en variables que serán posteriormente usadas para el moldeado de la superficie. El número de variables generadas dependerá de la cantidad de arcos creados para el enmallado. Suponiendo que solo se crea un arco para el enmallado:

oSk2 As PlanarSketch

Del mismo modo que para la variable oSk2 se almacenará el boceto del arco en esta variable:

oSk2 = partDoc.ComponentDefinition.Sketches(2)

36

También se recomienda crear otra restricción a la operación del moldeado de la superficie y es Spline que se encuentra dibujado en el plano YZ. Para esto se creará una variable tipo Path.

Dim oPath As Path

oPath= partDoc.ComponentDefinition.Features.CreatePath(oSk2.SketchControlPointSplines(1))

Ahora se almacenará en el objeto de colección oGuideRails los bocetos del enmallado:

oGuideRails.Add(oSk2.SketchArcs(1)) oGuideRails.Add(oSk2.SketchControlPointSplines(1))

Siendo oSk2.SketchArcs(1) el cuarto de arco del plano YZ y oSk2.SketchControlPointSplines(1) el Spline del mismo plano. Una vez se almacenen todos los arcos del enmallado en la variable oGuideRails se procede a ejecutar la operación. Del mismo modo que la primera superficie, será necesario crear una variable del tipo BoundaryPatchFeature, la cual será la responsable de ejecutar la operación. También será necesario definir a la variable oBPDef2 la colección de arcos almacenados en oGuideRails.

oBPDef2.GuideRails = oGuideRails

Dim oBP2 As BoundaryPatchFeature

oBP2 = partDoc.ComponentDefinition.Features.BoundaryPatchFeatures.Add(oBPDef2)

Figura 27. Modificación de superficie según el enmallado. Tomado de: Captura de pantalla del autor

5.3.4. Función de simetría

En la sección 4.3.2. se había creado el plano newPlane1 para usarlo como referencia de la operación de simetría. Para poder utilizar la función de simetría

37

desde la API es necesario definir un plano de simetría y los objetos a copiar. Para definir los objetos a copiar se creará primero una variable que almacenará los objetos a copiar. Dicha variable será del tipo ObjectCollection.

Dim oColl As ObjectCollection oColl = _invApp.TransientObjects.CreateObjectCollection

Ahora se debe identificar cada superficie a copiar para guardarlas en la variable oColl, para esto se creará una variable del tipo WorkSurface que será de ayuda para identificar cada superficie existente. También se debe crear otra variable del tipo PartFeature que se encargará de ejecutar la operación de simetría.

Dim oSurface As WorkSurface

Dim oFeature As PartFeature

Para el proceso de identificación de las superficies en el documento activo se hará uso de la función For Each. Con esta función se le pedirá a la variable oSurface que identifique cada superficie y la almacene en la variable oFeature:

For Each oSurface In partDef.WorkSurfaces oFeature = oSurface.SurfaceBodies(1).CreatedByFeature Call oColl.Add(oFeature)

Next

Obsérvese que en el objeto oColl se almaceno cada superficie a través de la variable oFeature. Esto se hace con el fin de especificar a la API que las superficies almacenadas en oFeature serán usadas para una operación de simetría. En este punto se han definido todos los parámetros necesarios para ejecutar la operación de simetría. A continuación, se muestra el comando para llamar a la operación de simetría:

Call partDef.Features.MirrorFeatures.Add(oColl, newPlane1, PatternComputeTypeEnum.kIdenticalCompute)

En el código anterior se ha especificado que la operación de simetría copie de manera idéntica la superficie existente.

38

Figura 28. Operación de simetría. Tomado de: Captura de pantalla del autor

5.3.5. Creación de la geometría para la entrada del inyector

Se creará un boceto en el plano XY en forma de círculo para generar la extrusión que cortará a las superficies existentes. Para esto se debe crear una variable del tipo SketchCircle. En la API, un boceto de círculo se define por un punto de centro y un radio.

Figura 29. Ubicación del boceto del círculo en el plano XY. Tomado de: Captura de pantalla del autor

El centro del círculo se define de la siguiente manera (según la figura 29):

Dim circleCenter As Point2d

39

circleCenter = tg.CreatePoint2d(dimB * 0.45 / 2, -dimL / 2)

El radio del círculo llegará hasta el punto de corte de ambas elipses (o hasta el punto final del arco de elipse creado en la sección 4.3.1). Para esto se definirá una variable del tipo Double que medirá la distancia entre el centro del círculo y el punto de corte:

Dim circleRad As Double = _invApp.MeasureTools.GetMinimumDistance(circleCenter, startsketchptn)

Definidos el radio y el punto final del arco de elipse, se procede a crear el círculo:

Dim oCircle As SketchCircle

oCircle = sketchXY.SketchCircles.AddByCenterRadius(circleCenter, circleRad)

El paso siguiente consiste en guardar el círculo como un perfil para generar una extrusión de corte de superficie.

' Creación del perfil Dim oProfile As Profile oProfile = sketchXY.Profiles.AddForSurface(oCircle)

Para generar la extrusión, se debe crear primero una variable de tipo ExtrudeDefinition. En esta variable se almacenarán los parámetros que definen la operación de extrusión en la API.

Dim oExtrudeDef As ExtrudeDefinition oExtrudeDef = partDef.Features.ExtrudeFeatures.CreateExtrudeDefinition(oProfile, PartFeatureOperationEnum.kSurfaceOperation) Call oExtrudeDef.SetDistanceExtent(dimD,PartFeatureExtentDirectionEnum.kPositiveExtentDirection)

Por último, se creará la operación de extrusión con la variable de tipo ExtrudeFeature:

Dim oExtrude As ExtrudeFeature oExtrude = partDef.Features.ExtrudeFeatures.Add(oExtrudeDef) oExtrude.SurfaceBodies(1).Visible = False

40

Figura 30. Generación de superficie cilíndrica para la geometría del inyector. Tomado de: Captura de pantalla del autor

Ahora se debe generar el corte. Para esto se usará la superficie creada como herramienta de corte. Se deberá crear primero una variable que almacenará la superficie de corte. Tal variable será del tipo WorkSurface [3, 19]:

Dim oCutTool As WorkSurface ' Get the work surface from the cylinder extrusion oCutTool = oDoc.ComponentDefinition.WorkSurfaces(3)

Téngase en cuenta que el ítem entre paréntesis de la línea anterior dependerá de la ubicación en la carpeta de superficies de trabajo del cilindro generado anteriormente.

Se creará también una variable que almacenará las superficies a cortar. Esta variable será del tipo ObjectCollection:

Dim oFacesToSplit As ObjectCollection oFacesToSplit = _invApp.TransientObjects.CreateObjectCollection

Con la función For Each se buscarán todas las secciones de superficie que se desean cortar. También se creará una variable del tipo Face que será la encargada de reconocer cara sección en las superficies creadas anteriormente y que se cortarán después:

Dim oFace As Face For Each oFace In oBP2.Faces oFacesToSplit.Add(oFace) Next

Ahora se creará una variable del tipo SplitFeature que generará la operación de corte:

41

Dim oSplit As SplitFeature

oSplit=partDoc.ComponentDefinition.Features.SplitFeatures.SplitFaces(oCutTool, oFacesToSplit

Una vez se ha cortado la superficie, será necesario eliminar los cortes realizados. Siguiendo la metodología para corte de superficies se genera el siguiente código [19]:

Dim oFacesToDelete As FaceCollection oFacesToDelete = _invApp.TransientObjects.CreateFaceCollection ' judge which faces should be deleted. Dim oCylinder As Cylinder oCylinder = oCutTool.SurfaceBodies(1).Faces(1).Geometry Dim oLine As Line oLine = _invApp.TransientGeometry.CreateLine(oCylinder.BasePoint,oCylinder.AxisVector.AsVector) For Each oFace In oSplit.Faces

Dim oPt As Point oPt = oFace.PointOnFace Dim dDist As Double dDist = _invApp.MeasureTools.GetMinimumDistance(oPt, oCylinder,InferredTypeEnum.kInferredPoint, InferredTypeEnum.kInferredLine) If dDist < oCylinder.Radius Then oFacesToDelete.Add(oFace) End If

Next

Figura 31. Creación del corte de la geometría de entrada del inyector. Tomado de: Captura de pantalla del autor

Para eliminar el cilindro que se usó como herramienta de corte, basta poner las siguientes líneas de código:

42

Dim oDeleteFace As DeleteFaceFeature oDeleteFace=oDoc.ComponentDefinition.Features.DeleteFaceFeatures.Add(oFacesToDelete)

Figura 32. Resultado final. Tomado de: Captura de pantalla del autor

43

6. GENERACIÓN AUTOMÁTICA DE PLANOS (OPCIONAL)

Existe una forma de generar el plano de la cuchara de forma automática. En el anexo B se mostrará el código formal terminado [20]. A continuación, se presenta el código relacionado con esta función.

Se recomienda crear un CheckBox para que la generación de planos sea opcional:

Figura 33. Ejemplo de CheckBox. Tomado de Captura de pantalla del autor

Por conveniencia, el CheckBox relacionado a la generación de planos se identificará como CheckBoxPlane. La idea es que, si el CheckBoxPlane está activado, se proceda a la generación del plano.

Para generar el plano, se debe guardar el modelo generado para que la API pueda tener una referencia de la cual obtener las vistas:

If Me.CheckBoxPlane.Checked = True Then 'Primero se guarda el documento de parte Dim oSaveDoc As Document oSaveDoc = _invApp.ActiveDocument If oSaveDoc Is Nothing Then Exit Sub oSaveDoc.Save()

Después se crea el nuevo documento de tipo Drawing (o plano de dibujo):

' Creación de nuevo documento. Dim oDrawDoc As DrawingDocument oDrawDoc = _invApp.Documents.Add( DocumentTypeEnum.kDrawingDocumentObject, _invApp.FileManager.GetTemplateFile(

DocumentTypeEnum.kDrawingDocumentObject, SystemOfMeasureEnum.kMetricSystemOfMeasure, DraftingStandardEnum.kISO_DraftingStandard))

Dim oSheet As Sheet oSheet = oDrawDoc.ActiveSheet

Ahora se debe especificar de manera automática la ruta en la que se guardó el archivo de parte, con el fin de poder abrirlo en el nuevo plano creado:

44

' Abrir el documento Dim oPartDoc As PartDocument oPartDoc = _invApp.Documents.Open(oSaveDoc.FullFileName)

En la variable oSaveDoc se almacena el documento de parte guardado junto con su ubicación en el sistema.

Ahora se debe crear la vista frontal, para esto se creará una variable tipo DrawingView que será la responsable de generar la vista. Para definir la vista se debe especificar el documento, el punto en el cual se ubicará en el plano, la escala deseada, la vista deseada, y el estilo de vista:

'Creación de vista frontal Dim oFrontView As DrawingView

oFrontView=oSheet.DrawingViews.AddBaseView(oPartDoc, tg.CreatePoint2d(12,19.2),scale, ViewOrientationTypeEnum.kFrontViewOrientation, DrawingViewStyleEnum.kHiddenLineDrawingViewStyle)

Esta misma metodología se deberá utilizar para cada vista que se desee crear:

' Creación de vista de planta. Dim oTopView As DrawingView oTopView = oSheet.DrawingViews.AddProjectedView( oFrontView, tg.CreatePoint2d(35, 19.2), DrawingViewStyleEnum.kFromBaseDrawingViewStyle)

'Creación de vista isométrica Dim oBackView As DrawingView oBackView = oSheet.DrawingViews.AddProjectedView( oFrontView, tg.CreatePoint2d(12, 5), DrawingViewStyleEnum.kFromBaseDrawingViewStyle)

End If

Una vez se determinen las vistas que se desean crear, es necesario cerrar la función IF que se creó al principio (véase el anexo B).

En el anexo D

45

7. CONCLUSIONES

Se identificaron las variables de las cuales depende la geometría de la cuchara (ecuación 3) y se pudo generar un software tal que automatizara el proceso de cálculo y de creación de la superficie de la cuchara.

Las ventajas de este método para generar superficies es que reduce los errores de diseño, de cálculos y ahorra tiempos de modelado.

Cuando el diseño se hace de forma manual en software CAD se pueden cometer errores de modelado que el software pasará por alto pero que pueden afectar a futuras simulaciones. Con el método automatizado no se presentarán estos problemas debido a que la API no permite avanzar en el modelado desde que exista la menor inconsistencia en el modelo. Por eso es de destacar que el programador que pretenda hacer cambios a este programa debe ser exacto en sus cálculos y métodos usados, de lo contrario la API no se ejecutará correctamente y no generará el modelo. Este tipo de restricciones de programación permiten que el modelo final sea muy exacto. Es por eso (y por las ventajas mencionadas en el párrafo anterior) que el proceso automatizado es de confianza y de gran ayuda al momento de diseñar álabes de turbinas Pelton.

Con el fin de solventar los problemas que se generan en el proceso de dibujo al emular a través del código el proceso manual para generar superficies se hizo uso de la estructura SI-ENTONCES. Gracias a esto se puede simular el comportamiento de toma de decisiones de dibujo y generar la superficie deseada. Debido a que la estructura de SI-ENTONCES a veces se limita a pocas alternativas de solución, se utilizó un seudocódigo adicional generado a través del método de red neuronal PERCEPTRON para simular en el nivel más básico la toma de decisiones que un humano ejecutaría al momento de generar trayectorias de bocetos y generación de superficies [21]. Cabe aclarar que en el código anexo (Anexo A) no se hizo uso del método de perceptrón, sino que se tomó como base para generar una serie de seudocódigos que simulaban la toma de decisiones.

Gracias a las luces arrojadas por el método de perceptrón al momento de simular la toma de decisiones se pudieron superar retos planteados por el proceso automático de dibujo. Algunos de estos fueron:

• El código debe ser capaz de enfrentar los errores ocasionados en el proceso de dibujo, sea por incompatibilidad de tarjetas de vídeo o por faltante de parches de actualización que no permiten un correcto funcionamiento de la API de Inventor.

• El código debe ser capaz de simular la toma de decisiones frente a errores encontrados en el proceso de dibujo.

46

• El código debe ser capaz de encontrar una solución al problema planteado sin necesidad de que intervenga el usuario.

• Crear un código fácil de entender para cualquier programador con conocimiento en la API de Inventor.

47

8. RECOMENDACIONES

A diferencia de realizar modelos con las opciones interactivas de Inventor, el modelado automatizado a través de la API será más estricto en cuanto a exactitud de cálculos y medidas. Si bien un error en la generación de superficies cuando se hace de manera manual puede ser omitido, la API no lo permitirá.

Este tipo de restricciones obliga a que el programador sea cuidadoso a la hora de programar en base al código presentado (véase el anexo A).

48

BIBLIOGRAFÍA

[1] IPSE, «Ministerio de Minas y Energía,» Julio 2014. [En línea]. Available: https://www.minminas.gov.co/documents/10180/742159/09C-SolucionesEnergeticasZNI-IPSE.pdf/2871b35d-eaf7-4787-b778-ee73b18dbc0e. [Último acceso: Enero 2016].

[2] E. M. Dominguez Gil, «DISEÑO Y CONSTRUCCIÓN DE UNA TURBINA PELTON PARA GENERACIÓN ELÉCTRICA, CAPACIDAD 2KW».

[3] Autodesk, «Autodesk Forums: Trim between surfaces,» Abril 2018. [En línea]. Available: https://forums.autodesk.com/t5/inventor-customization/how-to-make-a-trim-between-surfaces-with-vba-for-inventor/m-p/7983799#M84017. [Último acceso: 27 Abril 2018].

[4] Autodesk, «Autodesk Forums: intersection point between an sketch and a WorkPlane with VBA,» 27 Abril 2018. [En línea]. Available: https://forums.autodesk.com/t5/inventor-customization/help-intersection-point-between-an-sketch-and-a-workplane-with/m-p/7997767#M84220. [Último acceso: 27 Abril 2018].

[5] C. Hernandez y E. Indacochea, Diseño, estandarización y fabricación de equipos para pequeñas centrales hidroeléctricas, vol. II, 1988, pp. 11-13.

[6] M. Polo Encinas, Turbomáquinas hidráulicas: principios fundamentales, Limusa, 1975, p. 208.

[7] J. I. Larios Lagos, «DISEÑO, MONTAJE Y PRUEBAS DE UN PROTOTIPO DE MICROCENTRAL HIDROELÉCTRICA CON TURBINA PELTON,» Santiago de Chile, 2007.

[8] L. A. Ferrada Sepúlveda, DISEÑO DE RODETE DE TURBINA HIDRÁULICA TIPO PELTON PARA MICROGENERACIÓN, vol. I, Santiago de Chile: Diciembre, 2012, pp. 35-38.

[9] C. Mataix, Mecánica de fluidos y máquinas hidráulicas, Segunda ed., Milofe: Ediciones del Castillo, S.A., 1986, pp. 92-93.

49

[10] L. A. Ferrada Sepúlveda, DISEÑO DE RODETE DE TURBINA HIDRÁULICA TIPO PELTON PARA MICROGENERACIÓN, vol. I, Santiago de Chile, 2012, p. 18.

[11] C. Mataix, Mecánica de fluidos y máquinas hidráulicas, Segunda ed., vol. I, Madrid: Ediciones del Castillo, S. A., 1986, pp. 450-469.

[12] Autodesk, «Autodesk Inventor,» 2018. [En línea]. Available: http://help.autodesk.com/view/INVNTOR/2018/ENU/?guid=GUID-5901102A-F148-4CD4-AF50-26E2AFDEE6A7. [Último acceso: Febrero 2018].

[13] R. Pérez Chávez, A. Fernández Orquín, A. Pérez Suárez y R. Hernández León, «Programación orientada a objetos con C#,» 2003.

[14] Alegsa, «Alegsa,» Alegsa, 19 01 2015. [En línea]. Available: http://www.alegsa.com.ar/Dic/programacion_orientada_a_objetos.php. [Último acceso: 18 06 2018].

[15] Autodesk, «Autodesk Inventor My First Plug-In,» [En línea]. Available: https://www.autodesk.com/. [Último acceso: Enero 2018].

[16] Microsoft, «Microsoft Developer Network,» [En línea]. Available: https://msdn.microsoft.com/en-us/library/system.runtime.interopservices.marshal(v=vs.71).aspx. [Último acceso: Febrero 2018].

[17] S. Clemens y O. Phares, «Semejanza de triángulos y construcción de elipses,» de Geometría, Primera ed., Illinois, Pearson Education, 1998, pp. 304-326, 530-535.

[18] Autodesk Inventor, «Autodesk Forum Boundary patch with guide rails,» 1 Mayo 2018. [En línea]. Available: https://forums.autodesk.com/t5/inventor-customization/boundary-patch-with-guide-rails-using-vba-api/m-p/7979333#M83993. [Último acceso: 1 Mayo 2018].

[19] R. Zhang, «Trim between surfaces using VBA for Inventor,» 27 Abril 2018. [En línea]. Available: https://forums.autodesk.com/t5/notes/privatenotespage/tab/inbox/notes-view-mode/single/note-id/152641. [Último acceso: 27 Abril 2018].

[20] P. Leefsma, «Manufacturing DevBlog,» 06 Junio 2012. [En línea]. Available: http://adndevblog.typepad.com/manufacturing/2012/06/creating-a-drawing-from-scratch-with-the-inventor-api.html. [Último acceso: Marzo 2018].

50

[21] P. Ponce Cruz, INTELIGENCIA ARTIFICIAL CON APLICACIONES A LA INGENIERÍA, vol. I, Ciudad de México: Alfaomega, 2010.

51

ANEXOS

A. Código para automatizar el proceso de diseño de álabes de turbinas Pelton


Public Class Form1


Public Sub New() 'Aquí es donde voy a conectar a mi programa con una sesión abierta de Inventor. ' Esta llamada es exigida por el diseñador. InitializeComponent() 'Esto llama a lo que está inmediatamente debajo de él. Try 'Si no se encuentra una sesión activa en inventor, Try lo detecta y lo guarda como excepción en la variable ex. _invApp = Marshal.GetActiveObject("Inventor.Application") 'La FUNCIÓN GetActiveObject nos ayuda a encontrar una sesión activa de Inventor. Catch ex As Exception Try Dim invAppType As Type = GetTypeFromProgID("Inventor.Application") 'Esto le dice a la función GetActiveObject el tipo de objeto que se trata de encontrar. Esta información se guarda en la variable invAppType. MsgBox("Se procederá a ejecutar la aplicación de Inventor", MsgBoxStyle.Information, "MÓDULO DE DISEÑO DE ÁLABES DE TURBINAS PELTON") _invApp = CreateInstance(invAppType) 'A la variable _invApp se le agrega el objeto "Inventor.Application" (o, el objeto Application de la clase Inventor) la cual fue guardada en la variable invAppType. _invApp.Visible = True 'Si la encuentra, haga visible una sesión. Catch ex2 As Exception MsgBox(ex2.ToString()) MsgBox("No se puede comenzar Inventor", MsgBoxStyle.Critical, "MÓDULO DE DISEÑO DE ÁLABES DE TURBINAS PELTON") Me.Close() End Try End Try End Sub


52

'Inicio de la aplicación If _invApp.Documents.Count = 0 Then '"Si no se cuenta por lo menos un documento en el objeto Application de la clase Inventor, entonces

MsgBox("Se necesita abrir un nuevo documento", MsgBoxStyle.Exclamation, "MÓDULO DE DISEÑO DE ÁLABES DE TURBINAS PELTON")

partDoc = _invApp.Documents.Add(DocumentTypeEnum.kPartDocumentObject, _invApp.FileManager.GetTemplateFile(DocumentTypeEnum.kPartDocumentObject, SystemOfMeasureEnum.kMetricSystemOfMeasure))

partDef = partDoc.ComponentDefinition End If If _invApp.ActiveDocument.DocumentType <> DocumentTypeEnum.kPartDocumentObject Then '"Si dentro del objeto Application de la clase Inventor hay un documento activo y éste no es de tipo ensamblaje, entonces:

MsgBox("Se necesita un documento de parte activo", MsgBoxStyle.Exclamation, "MÓDULO DE DISEÑO DE ÁLABES DE TURBINAS PELTON")

partDoc = _invApp.Documents.Add(DocumentTypeEnum.kPartDocumentObject, _invApp.FileManager.GetTemplateFile(DocumentTypeEnum.kPartDocumentObject, SystemOfMeasureEnum.kMetricSystemOfMeasure))

partDef = partDoc.ComponentDefinition Return End If If _invApp.ActiveDocument.DocumentType = DocumentTypeEnum.kPartDocumentObject Then

partDoc = _invApp.Documents.Add(DocumentTypeEnum.kPartDocumentObject, _invApp.FileManager.GetTemplateFile(DocumentTypeEnum.kPartDocumentObject,SystemOfMeasureEnum.kMetricSystemOfMeasure))

partDef = partDoc.ComponentDefinition End If

'Declaración de las constantes para posteriores cálculos: Dim PI As Double PI = Math.PI Dim dimL As Double = TextBoxConstantL.Text * TextBoxFlowDiameter.Text / 10 Dim dimD As Double = TextBoxConstantD.Text * TextBoxFlowDiameter.Text / 10 Dim dimB As Double = TextBoxConstantB.Text * TextBoxFlowDiameter.Text / 10 Dim angleoutrad As Double = TextBoxOutAngle.Text * PI / 180 Dim angleinrad As Double = TextBoxInAngle.Text * PI / 180

' CREACIÓN DE SKETCH 1 EN PLANO X-Y (Elipse) Dim sketchXY As PlanarSketch sketchXY = partDef.Sketches.Add(partDef.WorkPlanes.Item(3)) Dim tg As TransientGeometry tg = _invApp.TransientGeometry 'Creación del centro en 0,0 Dim oCenter As Point2d oCenter = tg.CreatePoint2d(0, 0) 'Creación del eje mayor en el eje Y Dim oMajorAxis As UnitVector2d oMajorAxis = tg.CreateUnitVector2d(0, 1)

53

Dim angle As Double angle = Math.Atan((dimB * 0.45 * 0.5) / (dimL * 0.5 * 0.57493264)) 'Creación del arco elíptico Dim oEllipticalArc As SketchEllipticalArc

oEllipticalArc = sketchXY.SketchEllipticalArcs.Add(oCenter, oMajorAxis, dimL/ 2, dimB * 0.275, -angle, PI + 2 * angle)

'CREACIÓN DE LA GEOMETRÍA DE EMPALME CON LA OTRA CUCHARA 'Creación de puntos de control Dim startsketchptn As SketchPoint startsketchptn = oEllipticalArc.StartSketchPoint 'En la variable tipo SketchPoint guardé las coordenadas del punto de inicio del oEllipticalArc Debug.Print(startsketchptn.Geometry.X) Debug.Print(startsketchptn.Geometry.Y) Dim endsketchptn As SketchPoint endsketchptn = oEllipticalArc.EndSketchPoint Debug.Print(endsketchptn.Geometry.X) Debug.Print(endsketchptn.Geometry.Y) 'Creación de línea Dim lineEllipticalArc As SketchLine

lineEllipticalArc = sketchXY.SketchLines.AddByTwoPoints(startsketchptn, endsketchptn)

' CREACIÓN DE SKETCH 2 EN PLANO YZ 'SELECCIÓN DEL PLANO Dim sketchYZ As PlanarSketch sketchYZ = partDef.Sketches.Add(partDef.WorkPlanes.Item(1)) 'CREACIÓN DEL PRIMER ARCO 'Creación de los puntos de control del primer arco: Dim centerPointArcYZ1 As Point2d centerPointArcYZ1 = tg.CreatePoint2d((dimL / 2 - dimD), 0) Dim startPointArcYZ1 As Point2d startPointArcYZ1 = tg.CreatePoint2d(dimL / 2, 0) Dim endPointArcYZ1 As Point2d endPointArcYZ1 = tg.CreatePoint2d((dimL / 2 - dimD), dimD) 'Creación del primer arco: arcYZ Dim arcYZ1 As SketchArc

arcYZ1 = sketchYZ.SketchArcs.AddByCenterStartEndPoint(centerPointArcYZ1, startPointArcYZ1, endPointArcYZ1)

'Creación de los puntos de control del segundo arco:

54

Dim endPointArcYZ2 As Point2d endPointArcYZ2 = tg.CreatePoint2d(-dimL / 2, 0) Dim pnts As ObjectCollection pnts = _invApp.TransientObjects.CreateObjectCollection Call pnts.Add(arcYZ1.EndSketchPoint) Call pnts.Add(tg.CreatePoint2d((-dimD / 2), dimD)) Call pnts.Add(endPointArcYZ2) 'Creación del arco: arcYZ2 Dim controlPointSpline As SketchControlPointSpline controlPointSpline = sketchYZ.SketchControlPointSplines.Add(pnts) 'Creación de nuevo plano para crear el mirror de la cuchara

Dim newPlane1 As WorkPlane = partDef.WorkPlanes.AddByPlaneAndPoint(partDef.WorkPlanes.Item(1), startsketchptn)

newPlane1.Visible = False ' CREACIÓN DEL ENMALLADO 'Creación de nuevos planos para la creación de los arcos de la superficie inferior.

Dim newPlane3 As WorkPlane = partDef.WorkPlanes.AddByPlaneAndOffset(partDef.WorkPlanes.Item(2), dimL / 2 - dimD)


Dim newPlane4 As WorkPlane = partDef.WorkPlanes.AddByPlaneAndOffset(partDef.WorkPlanes.Item(2), -(dimL / 2 - dimD))

newPlane4.Visible = False Dim sketchnewPlan4 As PlanarSketch sketchnewPlan4 = partDef.Sketches.Add(partDef.WorkPlanes.Item(6)) 'CREACIÓN DEL ARCO 1 EN newPlane3 'Creación de punto de inicio del arco Dim skA1 As SketchLine skA1 = partDoc.ComponentDefinition.Sketches(1).SketchLines(1) Dim newWPA1 As WorkPoint

newWPA1 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA1, newPlane3)

Dim startpointA1 As SketchPoint startpointA1 = sketchnewPlan3.AddByProjectingEntity(newWPA1) 'Creación de punto final del arco Dim skA11 As SketchArc skA11 = partDoc.ComponentDefinition.Sketches(2).SketchArcs(1)

55

Dim newWPA11 As WorkPoint newWPA11 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA11, newPlane3)

Dim endpointA1 As SketchPoint endpointA1 = sketchnewPlan3.AddByProjectingEntity(newWPA11) 'Creación de control del ángulo Dim anglecontrolA1 As Double anglecontrolA1 = Math.Atan(angleinrad) * dimD 'Creación del arco Dim pnts3 As ObjectCollection pnts3 = _invApp.TransientObjects.CreateObjectCollection

Call pnts3.Add(tg.CreatePoint2d(startpointA1.Geometry.X, startpointA1.Geometry.Y)) Call pnts3.Add(tg.CreatePoint2d(startpointA1.Geometry.X + anglecontrolA1, dimD)) Call pnts3.Add(tg.CreatePoint2d(endpointA1.Geometry.X, endpointA1.Geometry.Y))

Dim controlPointSpline3 As SketchControlPointSpline controlPointSpline3 = sketchnewPlan3.SketchControlPointSplines.Add(pnts3) 'CREACIÓN DEL ARCO 2 EN newPlane3 'Creación del punto final del arco Dim skA2 As SketchEllipticalArc skA2 = partDoc.ComponentDefinition.Sketches(1).SketchEllipticalArcs(1) Dim newWPA2 As WorkPoint

newWPA2 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA2, newPlane3)

Dim endpointA2 As SketchPoint endpointA2 = sketchnewPlan3.AddByProjectingEntity(newWPA2) 'Creación de control del ángulo Dim anglecontrolA2 As Double anglecontrolA2 = Math.Atan(angleoutrad) * dimD

'Creación del arco Dim pnts4 As ObjectCollection pnts4 = _invApp.TransientObjects.CreateObjectCollection

Call pnts4.Add(tg.CreatePoint2d(endpointA1.Geometry.X, endpointA1.Geometry.Y)) ' Son los mismos del final del arco 1 Call pnts4.Add(tg.CreatePoint2d(endpointA2.Geometry.X - anglecontrolA2, dimD))

Call pnts4.Add(tg.CreatePoint2d(endpointA2.Geometry.X, 0))

56

Dim controlPointSpline4 As SketchControlPointSpline controlPointSpline4 = sketchnewPlan3.SketchControlPointSplines.Add(pnts4) 'CREACIÓN DEL ARCO 3 EN plano XZ Dim sketchXZ As PlanarSketch sketchXZ = partDef.Sketches.Add(partDef.WorkPlanes.Item(2)) 'Creación del punto inicial del arco Dim skA3 As SketchLine skA3 = partDoc.ComponentDefinition.Sketches(1).SketchLines(1) Dim newWPA3 As WorkPoint newWPA3 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA3, partDef.WorkPlanes.Item(2)) Dim startpointA3 As SketchPoint startpointA3 = sketchXZ.AddByProjectingEntity(newWPA3) 'Creación del punto de control del arco Dim skA33 As SketchControlPointSpline skA33 = partDoc.ComponentDefinition.Sketches(2).SketchControlPointSplines(1) Dim newWPA33 As WorkPoint newWPA33 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA33, partDef.WorkPlanes.Item(2)) Dim controlpointA3 As SketchPoint controlpointA3 = sketchXZ.AddByProjectingEntity(newWPA33) 'Creación de control del ángulo Dim distA3 As Double 'Para medir la distancia entre el punto y el suelo distA3 = _invApp.MeasureTools.GetMinimumDistance(newWPA33, partDef.WorkPlanes.Item(3)) Dim anglecontrolA3 As Double anglecontrolA3 = Math.Atan(angleinrad) * distA3 'Creación del arco Dim pnts5 As ObjectCollection pnts5 = _invApp.TransientObjects.CreateObjectCollection Call pnts5.Add(tg.CreatePoint2d(startpointA3.Geometry.X, startpointA3.Geometry.Y)) Call pnts5.Add(tg.CreatePoint2d(startpointA3.Geometry.X + anglecontrolA3, controlpointA3.Geometry.Y)) 'Este es el punto de control de la curvatura de la zona inferior. A mayor el factor de curvatura más suave la transición. 0.1<=fC<=1 Call pnts5.Add(tg.CreatePoint2d(0, controlpointA3.Geometry.Y)) Dim controlPointSpline5 As SketchControlPointSpline

57

controlPointSpline5 = sketchXZ.SketchControlPointSplines.Add(pnts5) 'CREACIÓN DEL ARCO 4 EN plano XZ 'Creación del punto final del arco Dim skA4 As SketchEllipticalArc skA4 = partDoc.ComponentDefinition.Sketches(1).SketchEllipticalArcs(1) Dim newWPA4 As WorkPoint newWPA4 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA4, partDef.WorkPlanes.Item(2)) Dim endpointA4 As SketchPoint endpointA4 = sketchXZ.AddByProjectingEntity(newWPA4) 'Creación de control del ángulo Dim anglecontrolA4 As Double anglecontrolA4 = Math.Atan(angleoutrad) * distA3 'Creación del arco Dim pnts6 As ObjectCollection pnts6 = _invApp.TransientObjects.CreateObjectCollection Call pnts6.Add(tg.CreatePoint2d(0, controlpointA3.Geometry.Y)) Call pnts6.Add(tg.CreatePoint2d(endpointA4.Geometry.X - anglecontrolA4, controlpointA3.Geometry.Y)) Call pnts6.Add(tg.CreatePoint2d(endpointA4.Geometry.X, endpointA4.Geometry.Y)) Dim controlPointSpline6 As SketchControlPointSpline controlPointSpline6 = sketchXZ.SketchControlPointSplines.Add(pnts6) 'CREACIÓN DEL ARCO 5 EN plano newPlane4 'Creación del punto inicial del arco Dim skA5 As SketchLine skA5 = partDoc.ComponentDefinition.Sketches(1).SketchLines(1) Dim newWPA5 As WorkPoint newWPA5 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA5, newPlane4) Dim startpointA5 As SketchPoint startpointA5 = sketchnewPlan4.AddByProjectingEntity(newWPA5) 'Creación del punto de control del arco Dim skA55 As SketchControlPointSpline skA55 = partDoc.ComponentDefinition.Sketches(2).SketchControlPointSplines(1) Dim newWPA55 As WorkPoint

58

newWPA55 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA55, newPlane4) Dim controlpointA5 As SketchPoint controlpointA5 = sketchnewPlan4.AddByProjectingEntity(newWPA55) 'Creación de control del ángulo Dim distA5 As Double 'Para medir la distancia entre el punto y el suelo distA5 = _invApp.MeasureTools.GetMinimumDistance(newWPA55, partDef.WorkPlanes.Item(3)) Dim anglecontrolA5 As Double anglecontrolA5 = Math.Atan(angleinrad) * distA5 'Creación del arco Dim pnts7 As ObjectCollection pnts7 = _invApp.TransientObjects.CreateObjectCollection Call pnts7.Add(tg.CreatePoint2d(startpointA5.Geometry.X, startpointA5.Geometry.Y)) Call pnts7.Add(tg.CreatePoint2d(startpointA5.Geometry.X + anglecontrolA5, controlpointA5.Geometry.Y)) Call pnts7.Add(tg.CreatePoint2d(0, controlpointA5.Geometry.Y)) Dim controlPointSpline7 As SketchControlPointSpline controlPointSpline7 = sketchnewPlan4.SketchControlPointSplines.Add(pnts7) 'CREACIÓN DEL ARCO 6 en plano newPlan4 'Creación del punto final del arco Dim skA6 As SketchEllipticalArc skA6 = partDoc.ComponentDefinition.Sketches(1).SketchEllipticalArcs(1) Dim newWPA6 As WorkPoint newWPA6 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA6, newPlane4) Dim endpointA6 As SketchPoint endpointA6 = sketchnewPlan4.AddByProjectingEntity(newWPA6) 'Creación de control del ángulo Dim anglecontrolA6 As Double anglecontrolA6 = Math.Atan(angleoutrad) * distA5 'Creación del arco Dim pnts8 As ObjectCollection pnts8 = _invApp.TransientObjects.CreateObjectCollection Call pnts8.Add(tg.CreatePoint2d(0, controlpointA5.Geometry.Y)) Call pnts8.Add(tg.CreatePoint2d(endpointA6.Geometry.X - anglecontrolA6, controlpointA5.Geometry.Y))

59

Call pnts8.Add(tg.CreatePoint2d(endpointA6.Geometry.X, endpointA6.Geometry.Y)) Dim controlPointSpline8 As SketchControlPointSpline controlPointSpline8 = sketchnewPlan4.SketchControlPointSplines.Add(pnts8) 'CREACIÓN DEL ARCO 7 en newPlane11 Dim newPlane11 As WorkPlane = partDef.WorkPlanes.AddByPlaneAndOffset(partDef.WorkPlanes.Item(2), -(dimL / 2 - dimD) + (dimL / 2 - dimD) / 2) newPlane11.Visible = False Dim sketchnewPlan11 As PlanarSketch sketchnewPlan11 = partDef.Sketches.Add(partDef.WorkPlanes.Item(7)) 'Creación del punto inicial del arco Dim skA7 As SketchEllipticalArc skA7 = partDoc.ComponentDefinition.Sketches(1).SketchEllipticalArcs(1) Dim newWPA7 As WorkPoint newWPA7 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA7, newPlane11) Dim startpointA7 As SketchPoint startpointA7 = sketchnewPlan11.AddByProjectingEntity(newWPA7) 'Creación del punto de control del arco Dim skA77 As SketchControlPointSpline skA77 = partDoc.ComponentDefinition.Sketches(2).SketchControlPointSplines(1) Dim newWPA77 As WorkPoint newWPA77 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA77, newPlane11) Dim controlpointA77 As SketchPoint controlpointA77 = sketchnewPlan11.AddByProjectingEntity(newWPA77) 'Creación de control del ángulo Dim distA7 As Double 'Para medir la distancia entre el punto y el suelo distA7 = _invApp.MeasureTools.GetMinimumDistance(newWPA77, partDef.WorkPlanes.Item(3)) Dim anglecontrolA7 As Double anglecontrolA7 = Math.Atan(angleoutrad) * distA7 'Creación del arco Dim pnts17 As ObjectCollection pnts17 = _invApp.TransientObjects.CreateObjectCollection

60

Call pnts17.Add(tg.CreatePoint2d(startpointA7.Geometry.X, startpointA7.Geometry.Y)) Call pnts17.Add(tg.CreatePoint2d(startpointA7.Geometry.X - anglecontrolA7, controlpointA77.Geometry.Y)) Call pnts17.Add(tg.CreatePoint2d(0, controlpointA77.Geometry.Y)) Dim controlPointSpline17 As SketchControlPointSpline controlPointSpline17 = sketchnewPlan11.SketchControlPointSplines.Add(pnts17) 'CREACIÓN DEL ARCO 8 en newPlane11 'Creación del punto final del arco Dim skA8 As SketchLine skA8 = partDoc.ComponentDefinition.Sketches(1).SketchLines(1) Dim newWPA8 As WorkPoint newWPA8 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA8, newPlane11) Dim endpointA8 As SketchPoint endpointA8 = sketchnewPlan11.AddByProjectingEntity(newWPA8) 'Creación de control del ángulo Dim anglecontrolA8 As Double anglecontrolA8 = Math.Atan(angleinrad) * distA7 'Creación del arco Dim pnts18 As ObjectCollection pnts18 = _invApp.TransientObjects.CreateObjectCollection Call pnts18.Add(tg.CreatePoint2d(0, controlpointA77.Geometry.Y)) Call pnts18.Add(tg.CreatePoint2d(endpointA8.Geometry.X + anglecontrolA8, controlpointA77.Geometry.Y)) Call pnts18.Add(tg.CreatePoint2d(endpointA8.Geometry.X, 0)) Dim controlPointSpline18 As SketchControlPointSpline controlPointSpline18 = sketchnewPlan11.SketchControlPointSplines.Add(pnts18) 'CREACIÓN DEL ARCO 9 en newPlane10 Dim newPlane10 As WorkPlane = partDef.WorkPlanes.AddByPlaneAndOffset(partDef.WorkPlanes.Item(2), -(dimL / 2 - dimD) - (dimL / 2 - dimD) / 2) newPlane10.Visible = False Dim sketchnewPlan10 As PlanarSketch sketchnewPlan10 = partDef.Sketches.Add(partDef.WorkPlanes.Item(8)) 'Creación del punto inicial del arco Dim skA9 As SketchEllipticalArc skA9 = partDoc.ComponentDefinition.Sketches(1).SketchEllipticalArcs(1)

61

Dim newWPA9 As WorkPoint newWPA9 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA9, newPlane10) Dim startpointA9 As SketchPoint startpointA9 = sketchnewPlan10.AddByProjectingEntity(newWPA9) 'Creación del punto de control del arco Dim skA99 As SketchControlPointSpline skA99 = partDoc.ComponentDefinition.Sketches(2).SketchControlPointSplines(1) Dim newWPA99 As WorkPoint newWPA99 = partDoc.ComponentDefinition.WorkPoints.AddByCurveAndEntity(skA99, newPlane10) Dim controlpointA99 As SketchPoint controlpointA99 = sketchnewPlan10.AddByProjectingEntity(newWPA99) 'Creación de control del ángulo Dim distA9 As Double 'Para medir la distancia entre el punto y el suelo distA9 = _invApp.MeasureTools.GetMinimumDistance(newWPA99, partDef.WorkPlanes.Item(3)) Dim anglecontrolA9 As Double anglecontrolA9 = Math.Atan(angleinrad) * distA9 'Creación del arco Dim pnts19 As ObjectCollection pnts19 = _invApp.TransientObjects.CreateObjectCollection Call pnts19.Add(tg.CreatePoint2d(startpointA9.Geometry.X, startpointA9.Geometry.Y)) Call pnts19.Add(tg.CreatePoint2d(startpointA9.Geometry.X + anglecontrolA9, controlpointA99.Geometry.Y)) Call pnts19.Add(tg.CreatePoint2d(0, controlpointA99.Geometry.Y)) Dim controlPointSpline19 As SketchControlPointSpline controlPointSpline19 = sketchnewPlan10.SketchControlPointSplines.Add(pnts19) 'CREACIÓN DEL ARCO 10 en newPlane10 'Creación de control del ángulo Dim anglecontrolA10 As Double anglecontrolA10 = Math.Atan(angleoutrad) * distA9 'Creación del arco Dim pnts20 As ObjectCollection pnts20 = _invApp.TransientObjects.CreateObjectCollection

62

Call pnts20.Add(tg.CreatePoint2d(-startpointA9.Geometry.X, startpointA9.Geometry.Y)) Call pnts20.Add(tg.CreatePoint2d(-startpointA9.Geometry.X - anglecontrolA10, controlpointA99.Geometry.Y)) Call pnts20.Add(tg.CreatePoint2d(0, controlpointA99.Geometry.Y)) Dim controlPointSpline20 As SketchControlPointSpline controlPointSpline20 = sketchnewPlan10.SketchControlPointSplines.Add(pnts20) ' CREACIÓN DE BOUNDARY PATCH Dim oPath As Path 'Creación de superficie según riel guía (CON AYUDA DE https://forums.autodesk.com/t5/user/viewprofilepage/user-id/532715) Dim oSk1 As PlanarSketch, oSk2 As PlanarSketch, oSk3 As PlanarSketch, oSk4 As PlanarSketch, oSk5 As PlanarSketch, oSk6 As PlanarSketch, oSk7 As PlanarSketch oSk1 = partDoc.ComponentDefinition.Sketches(1) oSk2 = partDoc.ComponentDefinition.Sketches(2) oSk3 = partDoc.ComponentDefinition.Sketches(3) 'A oSk3 se le asigna el boceto 3 (ahí están el arco 1 y 2 del newPlane3) oSk4 = partDoc.ComponentDefinition.Sketches(5) oSk5 = partDoc.ComponentDefinition.Sketches(4) oSk6 = partDoc.ComponentDefinition.Sketches(6) oSk7 = partDoc.ComponentDefinition.Sketches(7) Dim oProfile1 As Profile oProfile1 = oSk1.Profiles.AddForSurface Dim oBPDef1 As BoundaryPatchDefinition Dim oBP1 As BoundaryPatchFeature oBPDef1 = partDoc.ComponentDefinition.Features.BoundaryPatchFeatures.CreateBoundaryPatchDefinition oBPDef1.BoundaryPatchLoops.Add(oProfile1) oBP1 = partDoc.ComponentDefinition.Features.BoundaryPatchFeatures.Add(oBPDef1) oBP1.SurfaceBodies(1).Visible = True Dim oBPDef2 As BoundaryPatchDefinition Dim oBP2 As BoundaryPatchFeature Dim oGuideRails As ObjectCollection oBPDef2 = partDoc.ComponentDefinition.Features.BoundaryPatchFeatures.CreateBoundaryPatchDefinition oBPDef2.BoundaryPatchLoops.Add(oBP1.Faces(1).EdgeLoops(1)) oGuideRails = _invApp.TransientObjects.CreateObjectCollection oPath = partDoc.ComponentDefinition.Features.CreatePath(oSk2.SketchControlPointSplines(1)) oGuideRails.Add(oSk2.SketchArcs(1))

63

oGuideRails.Add(oSk2.SketchControlPointSplines(1)) oGuideRails.Add(oSk3.SketchControlPointSplines(1)) oGuideRails.Add(oSk3.SketchControlPointSplines(2)) Try oBP2 = partDoc.ComponentDefinition.Features.BoundaryPatchFeatures.Add(oBPDef2) Catch ex3 As Exception Dim oDeleteoBP1 As DeleteFaceFeature oDeleteoBP1 = partDoc.ComponentDefinition.Features.DeleteFaceFeatures.Add(oBP1.SurfaceBodies(1).FaceShells(1)) ' CREACIÓN DE OPERACIÓN DEL MIRROR newPlane1.Visible = True Dim oColl As ObjectCollection oColl = _invApp.TransientObjects.CreateObjectCollection Dim oSurface As WorkSurface Dim oFeature As PartFeature For Each oSurface In partDef.WorkSurfaces oFeature = oSurface.SurfaceBodies(1).CreatedByFeature Call oColl.Add(oFeature) Next Call partDef.Features.MirrorFeatures.Add(oColl, newPlane1, False, PatternComputeTypeEnum.kIdenticalCompute) ' CREACIÓN DE LA GEOMETRÍA DE ENTRADA DEL INYECTOR 'CREACIÓN DEL CÍRCULO Dim circleCenter As Point2d circleCenter = tg.CreatePoint2d(dimB * 0.45 / 2, dimL / 2) Dim circleRadio As Double = _invApp.MeasureTools.GetMinimumDistance(circleCenter, startsketchptn) Dim oCircle As SketchCircle oCircle = sketchXY.SketchCircles.AddByCenterRadius(circleCenter, circleRadio - 0.1) ' Creación del perfil Dim oProfile As Profile oProfile = sketchXY.Profiles.AddForSurface(oCircle) ' Creación de la extrusión Dim oExtrudeDef As ExtrudeDefinition oExtrudeDef = partDef.Features.ExtrudeFeatures.CreateExtrudeDefinition(oProfile, PartFeatureOperationEnum.kSurfaceOperation)

64

Call oExtrudeDef.SetDistanceExtent(dimD, PartFeatureExtentDirectionEnum.kPositiveExtentDirection) Dim oExtrude As ExtrudeFeature oExtrude = partDef.Features.ExtrudeFeatures.Add(oExtrudeDef) oExtrude.SurfaceBodies(1).Visible = False End If 'REALIZACIÓN DEL CORTE (con ayuda de Autodesk: https://forums.autodesk.com/t5/inventor-customization/how-to-hide-surface-bodies-in-a-drawing-using-the-api/td-p/6222484) 'Corte oBP2 Dim oDoc As PartDocument oDoc = _invApp.ActiveDocument If Me.CheckBoxCreateSolid.Checked = False Then Dim oCutTool As WorkSurface ' Get the work surface from the cylinder extrusion oCutTool = oDoc.ComponentDefinition.WorkSurfaces(3) Dim oSplit As SplitFeature Dim oFacesToSplit As ObjectCollection oFacesToSplit = _invApp.TransientObjects.CreateObjectCollection Dim oFace As Face For Each oFace In oBP2.Faces oFacesToSplit.Add(oFace) Next oSplit = oDoc.ComponentDefinition.Features.SplitFeatures.SplitFaces(oCutTool, False, oFacesToSplit) Dim oFacesToDelete As FaceCollection oFacesToDelete = _invApp.TransientObjects.CreateFaceCollection ' judge which faces should be deleted. Dim oCylinder As Cylinder oCylinder = oCutTool.SurfaceBodies(1).Faces(1).Geometry Dim oLine As Line oLine = _invApp.TransientGeometry.CreateLine(oCylinder.BasePoint, oCylinder.AxisVector.AsVector) For Each oFace In oSplit.Faces Dim oPt As Point oPt = oFace.PointOnFace Dim dDist As Double dDist = _invApp.MeasureTools.GetMinimumDistance(oPt, oCylinder, InferredTypeEnum.kInferredPoint, InferredTypeEnum.kInferredLine) If dDist < oCylinder.Radius Then oFacesToDelete.Add(oFace) End If Next

65

Dim oDeleteFace As DeleteFaceFeature oDeleteFace = oDoc.ComponentDefinition.Features.DeleteFaceFeatures.Add(oFacesToDelete) End If End Sub Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick If Me.CheckBoxModelLevel.Checked = False Then LabelWarn.Visible = False PictureBoxCardList.Visible = False CheckBoxForceModel.Visible = False End If If Me.CheckBoxModelLevel.Checked = True Then LabelWarn.Visible = True PictureBoxCardList.Visible = True CheckBoxForceModel.Visible = True End If 'Aquí se calcula el d0 Try Dim PI As Double PI = Math.PI Dim denominadord0 As Double = Math.Sqrt(2 * 9810 * TextBoxHead.Text * 1000) * PI * TextBoxKc.Text Dim numeradord0 As Double = 4 * TextBoxCaudal.Text * 1000000000 Dim d0 As Double = Math.Sqrt(numeradord0 / denominadord0) TextBoxFlowDiameter.Text = Math.Round(d0) Catch End Try 'Acá termina el cálculo de d0. Try If TextBoxFlowDiameter.Text > 0 Then TextBoxDimB.Text = Math.Round(TextBoxFlowDiameter.Text * TextBoxConstantB.Text) TextBoxDimL.Text = Math.Round(TextBoxFlowDiameter.Text * TextBoxConstantL.Text) TextBoxDimD.Text = Math.Round(TextBoxFlowDiameter.Text * TextBoxConstantD.Text) End If Catch End Try End Sub End Class

66

B. Código de generación automática de planos

If Me.CheckBoxPlane.Checked = True Then Try MsgBox("Proceso terminado. Para la generación del plano deberá guardar el documento", MsgBoxStyle.Information, "MÓDULO DE DISEÑO DE ÁLABES DE TURBINAS PELTON") 'Primero se guarda el documento de parte Dim oSaveDoc As Document oSaveDoc = _invApp.ActiveDocument If oSaveDoc Is Nothing Then Exit Sub oSaveDoc.Save() ' Creación de nuevo documento. Dim oDrawDoc As DrawingDocument oDrawDoc = _invApp.Documents.Add( DocumentTypeEnum.kDrawingDocumentObject, _invApp.FileManager.GetTemplateFile( DocumentTypeEnum.kDrawingDocumentObject, SystemOfMeasureEnum.kMetricSystemOfMeasure, DraftingStandardEnum.kISO_DraftingStandard)) Dim oSheet As Sheet oSheet = oDrawDoc.ActiveSheet

' Abrir el documento Dim oPartDoc As PartDocument oPartDoc = _invApp.Documents.Open(oSaveDoc.FullFileName) 'Creación de vista frontal Dim oFrontView As DrawingView oFrontView = oSheet.DrawingViews.AddBaseView(oPartDoc, tg.CreatePoint2d(12, 19.2), scale, ViewOrientationTypeEnum.kFrontViewOrientation, DrawingViewStyleEnum.kHiddenLineDrawingViewStyle) ' Creación de vista de planta. Dim oTopView As DrawingView oTopView = oSheet.DrawingViews.AddProjectedView( oFrontView, tg.CreatePoint2d(35, 19.2), DrawingViewStyleEnum.kFromBaseDrawingViewStyle)

'Creación de vista isométrica Dim oBackView As DrawingView oBackView = oSheet.DrawingViews.AddProjectedView( oFrontView, tg.CreatePoint2d(12, 5), DrawingViewStyleEnum.kFromBaseDrawingViewStyle) Catch End Try End If

67

C. Recomendación para generar el sólido a partir de la superficie

Debido a que la API de inventor tiene muchas limitaciones en cuanto a modelado de superficies [3, 4, 12], se hace necesario crear el sólido a partir de la superficie generada anteriormente manualmente. Si bien el diseñador está en libertad de generar el sólido de la manera que mejor le parezca, acá se mostrarán una forma sencilla de hacerlo, a manera de recomendación.

A continuación, se mostrará una serie de pasos para poder generar el sólido.

Se seleccionará la opción Thicken/Offset en la sección de modificación de sólido:

Figura 34. Operación Thicken/Offset (Grosor/Desfase). Tomado de Captura de pantalla del autor

Después se selecciona una de las ovoides de la cuchara y en la opción desplegada se elige una distancia lo suficientemente pequeña como para que el offset (desfase) de superficie sea tan cercano que se pueda generar un sólido con la opción de Stitch Surface (coser superficie).

68

Figura 35. Generación de Offset. Tomado de Captura de pantalla del autor

Figura 36. Operación coser superficie. Tomado de Captura de pantalla del autor

Se debe tener en cuenta que la operación de cosido de superficie se facilita si se seleccionan las superficies desde el árbol de operaciones (figura 36). Una vez más, seleccione una tolerancia máxima lo más pequeña posible con el fin de no generar cambios en el sólido.

Una vez se da aceptar, se generará el sólido.

69

Figura 37. Sólido generado en función de la superficie. Tomado de Captura de pantalla del autor

Este mismo proceso se deberá repetir para la otra ovoide con el fin de generar el sólido por completo.

Figura 38. Sólido a partir de la superficie. Tomado de Captura de pantalla del autor

Una vez se complete este paso, el sólido ya estará disponible para ser usado en un software de simulación de fluidos o para la generación de un código CNC en función del software usado para tal fin.

Se recomienda nuevamente que en la operación de Desfase se elija la mínima distancia posible para no generar un espesor, así mismo en la operación de Cosido de superficie se recomienda usar una tolerancia que sea la mínima posible.

Otro paso interesante para generar un sólido de mayor volumen es encerrar el sólido ya generado en el paso anterior en otro a partir de una extrusión:

70

Figura 39. Operación de extrusión sobre el sólido generado anteriormente. Tomado de Captura de pantalla del autor

Después se usa la opción de combinar sólidos. Se selecciona la extrusión como base y el sólido de la cuchara como herramienta de corte. La operación debe ser de corte y se debe seleccionar la opción para mantener las herramientas de corte:

Figura 40. Operación de combinación de sólido. Tomado de Captura de pantalla del autor

Una vez hecho esto, se generará un sólido como el de la figura 41:

71

Figura 41. Resultado de la operación de corte. Tomado de Captura de pantalla del autor

El mismo procedimiento se deberá realizar para la otra ovoide.

Con este proceso se obtendrá el sólido con mayor volumen para poder ser modelado a mano. Las figuras 42, 43 y 44 muestran un ejemplo del modelado final de la cuchara a través de este método:

Figura 42. Modelado final renderizado vista superior. Tomado de Captura de pantalla del autor

72

Figura 43. Modelado final renderizado. Tomado de Captura de pantalla del autor

Figura 44. Sección de corte del sólido. Tomado de Captura de pantalla del autor

73

D. Ejemplo de la superficie final y el plano

A continuación, se muestra el resultado obtenido por el aplicativo al generar la superficie y el plano con unos valores específicos:

Figura 45: Valores de ejemplo

74

Figura 46: Superficie final

Figura 47: Plano generado a partir de la superficie