Chem Basic

ACD/ChemBasic Versión 5.0 para Microsoft Windows

Tutorial

Comenzando con ChemBasic

Advanced Chemistry Development Inc.

Copyright © 1994-2001 Advanced Chemistry Development Inc.Todos los derechos reservados. ACD/Labs es una marca registrada de Advanced Chemistry Development Inc. Microsoft y Windows son marcas registradas de Microsoft Corporation. Todas las otras marcas mencionadas dentro de este manual son propiedad de sus respectivos dueños.

La información en este documento está sujeta a cambio sin previo aviso y se provee "como se ofrece" sin garantía. Advanced Chemistry Development Inc. no se responsabiliza de nada en cuanto al contenido de este material, incluido su limite a las no garantías de mercadeo y adecuación para un propósito en particular. Advanced Chemistry Development Inc. no será responsable de errores internos o por cualquier daño directo, indirecto, especial, incidental o consecuente al uso de este material. Parte Numero: G14_2805

Notas del Traductor La traducción de este documento fue realizada por CARLOS A. FRANCO R., Licenciado en Química y Magíster en Docencia de la Química en la Universidad Pedagógica Nacional, Facultad de Ciencia y Tecnología, Departamento de Química, Bogotá (Colombia), con la debida autorización de: > Technical Support Manager > Advanced Chemistry Development,Inc.. En esta traducción se mantuvo el esquema del documento original sin alterar su esencia. En algunas oportunidades se da la traducción y entre paréntesis se deja el término original con el fin de que el lector pueda referenciar fácilmente los nombres de los comandos, menús, botones, etc. Cualquier sugerencia al respecto, gustoso la atenderé en mi correo personal, [email protected] o por intermedio del soporte técnico de ACD/labs.

ACD/ChemBasic Getting Started 3

TABLA DE CONTENIDOS 1. Introducción a ChemBasic.................................................................................. 1

1.1 Objetivos........................................................................................................................ 1 1.2 Qué es ChemBasic?...................................................................................................... 1 1.3 Qué hay Nuevo en 5.0 ................................................................................................... 2 1.4 Por Qué Usar ChemBasic?............................................................................................ 2 1.5 Qué es lo que hace?...................................................................................................... 2 1.6 Mostrarme Ejemplos! ..................................................................................................... 3 1.7 Por qué “Basic”? ............................................................................................................ 3 1.8 Cómo Trabaja? ..............................................................................................................3 1.9 Acerca de este Tutorial .................................................................................................. 5

2. Comenzando: Diga Hola!..................................................................................... 6 2.1 Objetivos........................................................................................................................ 6 2.2 Crear el Sistema del Programa...................................................................................... 6 2.3 Hola, Todos! .................................................................................................................. 7 2.4 Objetos en ChemBasic .................................................................................................. 9 2.5 Páginas y Coleccines en ChemSketch........................................................................ 10 2.6 Hola, Sr. Propano! ....................................................................................................... 11 2.7 Hola a diferentes Individuos ........................................................................................ 14

3. Los Frutos del Arbol Molecular ........................................................................ 17 3.1 Objetivos...................................................................................................................... 17 3.2 Informe de Proyectos................................................................................................... 17 3.3 Referencia de Objetos Moleculares............................................................................. 17 3.4 Cómo Crear y Destruir Objetos?.................................................................................. 20 3.5 Elaborar un Arbol Molecular ........................................................................................ 21

3.5.1 Tomar Existencias................................................................................................................ 23 3.5.2 Optimización y Medidas ....................................................................................................... 23 3.5.3 Puliendo la Salida................................................................................................................. 24 3.5.4 Redimensionar el Diagrama Molecular ............................................................................... 25

4. Apéndice. Texto Completo de Muestras.......................................................... 27 4.1 HELLO.BAS................................................................................................................. 27 4.2 OXCARBOX.BAS ........................................................................................................ 28

ACD/ChemBasic Comenzando i

1. Introducción a ChemBasic

1.1 Objetivos

En este Capítulo aprenderá a: • Por qué aparece ACD/ChemBasic; • Qué hay nuevo en la versión 5.0; • Cuáles son las ayudas para resolver las tareas de ChemBasic; • Cuáles son los problemas de ejemplo que se resuelven con ChemBasic; • Cuál es el proyecto detrás del lenguaje de programación; • Cómo correr técnicamente los programas ChemBasic; y • una unión de palabras acerca de este tutorial.

1.2 Qué es ChemBasic?

ChemBasic es un simple, conveniente y funcionalmente rico lenguaje de programación para la presentación y manipulación de estructuras moleculares, que relaciona objetos y todos los contenidos actuales y de futuros programas de ACD/Labs. Se encuentra que ChemBasic es completamente funcional con ACD/Labs. De la misma manera, ChemBasic tiene todas las características que un lenguaje de programación debe tener: variables numéricas y de cadena, arreglos, control de flujo y operadores condicionales, procedimientos de entrada y salida, etc.

ChemBasic ha heradado cosas del BASIC genérico y algunas de sus extensiones. Más evidente es la opción de Microsoft'Visual Basic para Aplicaciones (VBA) y para algunas extensiones, extensiones ANSI del BASIC completo. Sin embargo, hay simplificaciones importantes en el procedimiento principal de la estructura del lenguaje, tal como las extensiones sometidas a partes específicas.

Por ser una aplicación universal que extiende la capacidad de los programas existentes, ChemBasic esta designado como un lenguaje orientado a objetos. Esto significa que toda la situaciones químicas relacionadas se describen como objetos-esto es, que la estructura de datos específicos corresponden a moléculas, conformaciones, etc. Existe un número métodos predefinidos para manipular estos objetos. La herencia de los objetos y de los métodos es la esencia de ChemBasic.

ACD/ChemBasic Comenzando 1

1.3 Qué hay Nuevo en 5.0

• En la versión 5.0, los programas ChemBasic pueden accederse desde la ventana de ChemSketch si esta en el modo Estructura o en el modo Dibujo.

• El Organizador ChemBasic es una nueva herramienta en ChemSketch que le ayuda a guardar pistas de sus programas ChemBasic. Dependiendo de como agrupe su barra de herramientas puede colocar un botón ChemBasic para que este disponible en el modo Estructura, en el modo Dibujo o en ambas o solamente en la barra ChemBasic.

• Las características del Manejador de Formas ahora forma parte del ChemSketch dedicado al ChemBasic. Con el Manejador de Formas puede designar formas de entrada para los programas ChemBasic.

• Anteriormente, el ChemBasic usó una serie de cajas de dialogo de entradas secuenciales simples. Ahora, con el Manejador de Formas, puede diseñar formas de entrada para programas ChemBasic que puedan aceptar todos los datos requeridos en una sola instancia. El dialogo de entradas es sencillo. Un menú emergente define los valores de entrada en cada uno de los campos automáticamente posicionados: todos se disponen fácilmente a través del Manejador de Formas.

1.4 Por Qué Usar ChemBasic?

Igual que cada químico que maneje un computador con una base normal este tiene un conjunto de operaciones rutinarias para mostrar una molécula, una muestra, un espectro, etc. Con el software ACD/Labs, el químico puede reducir significativamente el número de operaciones de rutina, gracias al contenido químico claro y a la interfase intuitiva de los programas ACD. El software ACD/Labs ha probado sucesos en muchas áreas tal como en la manipulación de estructuras moleculares, búsqueda de estructuras, optimización de representaciones gráficas (depuración en 2D), optimización en 3D, cálculo de propiedades moleculares, predicción de espectros RMN, etc.

Sin embargo, con el más actual conjunto de aplicaciones, pensará en un número de situaciones donde pueda repetir algunos pasos continuamente.....Ha pensado cómo hacer esto con un simple menú de opciones y hacer que esta serie de pasos ocurra automáticamente? Una situación común es cuando quiere examinar sistemáticamente el efecto de un cierto sustituyente sobre un compuesto 2D; cuando entra sucesivamente estructuras para hacer constantemente cálculos, adicionar sustituyentes, recalcular e imprimir cada compuesto.

Para resolver el problema esta aquí ACD/ChemBasic! Este tiene la genialidad de nuestro software justo para su computador.

1.5 Qué hace ChemBasic?

ChemBasic está designado (a) para automatizar rutinas sin ACD/Labs y (b) extender la funcionalidad de ACD/Labs. Le permite al usuario acondicionar el software ACD para sus propósitos o para adecuarlos a las interfases externas de la suite de ACD.

Un programa ChemBasic sencillo puede, por ejemplo, obtener una molécula desde la ventana de ACD/ChemSketch, calcular algunas propiedades moleculares, remplazar fragmentos y recalcularlos apropiadamente. O, un programa ChemBasic puede permitir automáticamente el análisis conformacional y representar la estructura 3D más probable para una molécula que haya escogido. O de cualquier forma… esta limitado solo a su imaginación!


En este tutorial, consideraremos los siguiente ejemplos como ilustrativos: • Obtener todos los diagramas desde una página ChemSketch y generar sus nombres según la

IUPAC (en el modo series) [Capítulo 2]. • Crear una serie de ácidos carboxílicos homólogos, ejecutar una optimización 3D, representar

las estructuras resultantes en la ventana de ChemSketch y marcar todas las estructuras en donde el grupo hidroxilo este separado del carboxilo por una distancia menor a 5 Angstroms [Capítulo 3].

1.6 Mostrarme Ejemplos!

Un experto programador sabe que a menudo el mejor camino para empezar es encontrar una plantilla, por ejemplo, un programa elaborado y luego modificarlo. Algunos ejemplos de la vida real (códigos fuente) están asociados con ACD/ChemBasic. Las muestras de programas ChemBasic son las siguientes:

• Etiquetas Impresas (Label Printer) – crea e imprime rótulos para material de vidrio de las estructuras dibujadas en una sesión de ChemSketch.

• Nombres de Azucares (SugarNames) — transforma cadenas cortas de clases específicas de estructuras (azúcares) en una conformación correcta; esto es, que muestra formulas como •GalNAc(alpha1-3)Gal(beta1-4)[Fuc(alpha1-3)]Glc(betaOMe) y le suministra la estructura 3D más probable.

• Predecir el Log de K (LogK Predicto)r – predice constantes de estabilidad para los complejos de aminas y/o carboxilatos que contienen moléculas orgánicas hasta con 31 iones metálicos.

• Editor Molecular 3D (Molecular 3D-editor) – un versátil conjunto de potentes utilidades el cual construye y modifica modelos moleculares en tres dimensiones fácilmente (cambia el ángulo de torsión, invierte los centros enantioméricos, analiza anillos plegados y formas poliédricas, importa y exporta en diferentes formatos moleculares y mucho más).

1.7 Por qué “Basico”?

ACD/ChemBasic esta basado en el antiguo y excelente programa BASIC "Beginners All-purpose Symbolic Instruction Code" (el acrónimo original para BASIC). El Basic es ampliamente aceptado como el lenguaje más conveniente para no programadores. Las versiones modernas de BASIC han provisto sus éxitos en varios campos- — es suficiente mencionar para aplicaciones el Microsoft Visual Basic y el Visual Basic.

ACD/ChemBasic es el programa para química “código para principiantes en todos los campos con instrucción simbólica” "Beginners All-purpose Symbolic Instruction Code". Es heredado del BASIC nativo simple y fácil de usar – para el químico, no para el programador guru; adiciona al BASIC ciertos objetos químicos relacionados de una manera tal que es conocida para los químicos.

1.8 Cómo trabaja?

Técnicamente, ChemBasic no es únicamente un lenguaje de programación, además consiste en un interpretador y ejecutor de librerías (RTL) que están integradas con ACD/ChemSketch. Para ejecutar una aplicación ChemBasic, debe tener corriendo ChemSketch. Puede crear un programa


ChemBasic con cualquier editor de texto y guardarlo como un archivo en un disco. Así que puede ejecutarlo al seleccionar un comando en ChemSketch: Archivo • RunChemBasic.


1.9 Acerca de este Tutorial

Los ejercicios en este tutorial están designados para hacerse en un promedio de 10 a 40 minutos, dependiendo de su familiaridad con los lenguajes de programación y con la interfase ACD. Después de revisar estos ejercicios y con ayuda en línea, será capaz de usar solo el ChemBasic con poca o sin asistencia y con máximo de velocidad y eficiencia.

Este tutorial se provee en forma electrónica legible en los más comunes procesadores de palabra. Si no puede localizar algo que necesite en el índice, escriba una frase para hacer la búsqueda total o de algo que incluya o se relacione con la palabra.

Las fotografías han sido tomadas con la última versión del software.

Este tutorial asume que usted esta familiarizado con el ratón y el manejo de Microsoft Windows.

Gane!!!

Su opinión es importante

para nosotros.

Una vez que ha usado esta guía nos gustaría su retroalimentación. Cómo podemos probar la documentación para este producto? Tenemos un pequeño cuestionario que nos gustaría que contestara. Todos los remitentes enviarán un dibujo para ganar un premio de ACD/ChemFolder (o equivalente descuento en la compra de cualquiera de l software ACD). Por favor use MS Word 6.0 o posterior para abrir el archivo “survey.doc” o use Adobe Acrobat Reader para abrir “survey.pdf” en la documentación del CD que ha recibido con este software, o visite la página “Feedback” en nuestro sitio web, http://www.acdlabs.com/feedback/guides.html. El ganador del dibujo será anunciado al final de cada año calendario.


2. Comenzando: Diga Hola!

2.1 Objetivos

En este capítulo, aprenderá a • Crear un programa ChemBasic; • Cuáles son las variables y tipos de datos en ChemBasic; • Cómo diseñar un dialogo para los usuarios de su programa; • Cómo acceder a las páginas ChemSketch y a su contenido; • Cómo implementar control lógico y ciclos en un programa ChemBasic; • Cómo generar nombres según la IUPAC para las moléculas.

Tradicionalmente, el primer programa debe decir hola. Dado que el ChemBasic no conjuga con moléculas. Permítanos mostrar la primera aplicación, decir hola a las moléculas!

2.2 Crear el esqueleto del Programa

Primero que todo, crearemos un esqueleto de la aplicación. Un programa ChemBasic esta hecho de funciones y sub rutinas (procedimientos). Ellos comienzan con la palabra clave de la Función o Sub Rutina y finaliza con la Función Fin (End) o con End Sub. El programa puede tener muchos procedimientos pero una y solo una función puede empezar con el nombre especial Principal (Main).Puede ser el primer procedimiento en un programa pero no necesariamente tiene que serlo.

Nota Vea la ayuda ChemBasic para la explicación de la diferencia entre una Función y una Sub Función.

En nuestro programa simple, su esqueleto podría ser:

Function Main As String ‘Here will be the code End Function

Importante ChemBasic no toma en cuenta si usa mayúsculas o minúsculas en palabras claves o en nombre de variables. Función, función, FUNCION, y aun fUnCióN significan exactamente lo mismo. Así que es bueno saberlo para saber como escribirlas. En este Tutorial, todas las palabras clave comienzan con mayúscula, que es lo común en varios apartes de BASIC.

Hay dos cosas más para explicar. Primero, las palabras clave para nuestras funciones COMO CADENAS (As String) aparecen después de la declaración de la Función Principal (Function


Main). Esto significa que la función retornará un valor de cadena. Las funciones siempre retornan algunos valores después de la ejecución, en contraste con las subrutinas.

Así. La variable especial Main tendrá un valor de cadena después que la función sea ejecutada. El valor que retorna la función puede invocarse en el programa para propósitos particulares. El llamar el programa para la Funcion Main es hecha por el mismo ChemBasic; este usará el valor para mostrarlo al usuario en una caja de información, que aparece en la pantalla justo después de completar la aplicación ChemBasic. Un buen hábito de programación en ChemBasic es declarar siempre la función principal como Cadena (puede declararla como entero, doble, etc.) porque esta le da la oportunidad de incluir cualquier mensaje de error o hacer un comentario al final de la cadena.

La segunda cosa, en las tres líneas de código anteriores, es la línea de comentarios. Todo lo que este entre apóstrofos y al final de la línea será ignorado por Basic. Es una característica muy usada, que le permite clarificar sus programas y hacerlos mucho más legibles, sobre todo cuando haga una revisión con mucho tiempo de posterioridad.

Nota Existen otras dos formas de comentarios: la declaración REM y la multilínea de comentarios estilo C /* …. */ ; vea la ayuda de ChemBasic para una descripción completa.

2.3 Hola, Todos!

Ahora, podemos llenar la plantilla con código real.

El camino más simple para decir hola, es justamente el siguiente:

Function Main as String Main="Hello, Molecules!" End Function

De esta forma, para comenzar, cree un archivo de texto hello.bas que contenga exactamente estas tres líneas. Guárdelo e inicie el ACD/ChemSketch. Seleccione Archivo/correr (File/Run) ChemBasic y cuando se le sugiera ejecutar el archivo (en la caja de dialogo estándar “File Open” ), seleccione el archivo hello.bas.

Su Hola aparecerá en la pantalla como:

el truco es que como lo mencionamos arriba, ChemBasic mostrará el valor que retorna la función principal en su “caja de información” (“info box”) después de ejecutar la aplicación.

Naturalmente, este no es un camino honesto. Como un truco puede usarse una vez por programa (porque solo una función principal puede estar presente). Permítanos diseñar nuestro saludo de una manera aplicada más universalmente. ChemBasic tiene una construcción especial de funciones que soporta diálogos con el usuario: MessageBox, UserIOBox y UserIO. Usaremos MessageBox para nuestros propósitos.

Nota Vea la ayuda de ChemBasic para la descripción de otras funciones de entrada/salida


Escribamos el código:

Function Main As String Dim Answer As Integer Answer=MessageBox("Hello, Molecules!","Example #1", MBB_OK +MBI_INFORMATION) End Function

Note Corrientemente, ChemBasic no soporta declaraciones multi-línea. Usted debe escribir textos largos en una sola línea. Sin embargo, en este tutorial, para propósitos de legibilidad, los textos largos pueden aparecer en varias líneas. En tal caso, la primera línea comenzará en la margen izquierda de la página. Tenga cuidado cuando transfiera líneas a archivos ejecutables ChemBasic (.BAS) – usted debe enviar las líneas en una sola.

Una vez que ha transferido el programa a hello.bas y haberlo guardado como archivo de texto (tenga cuidado al declarar líneas múltiples), puede tratar de ejecutar este programa y ver qué pasa:

Exactamente si es lo que deseamos?

En el segundo programa, la declaración Dim que aparece justo después de la función de encabezado, declara la variable “Answer ” que es de tipo Entero. Qué significa esto?

La Variable es un nombre que usted asigna a algún lugar de almacenamiento en la memoria. Una vez introducida, puede ser llenada (o re-llenada) y usada para cualquier propósito. Cada variable puede corresponder a un dato pre definido, que difiere por los formatos internos y permite métodos de manipulación.

Inclusión de datos Convencionales: • Boolean Variable Booleana, valores que son solo Cierto o Falso. • Integer número entero largo 16-bit • Long número entero largo 32-bit • Double número de punto flotante largo 64-bit • String variable de cadena

Nota Vea la ayuda de ChemBasic para la descripción de tipos de datos y declaraciones

En ChemBasic, todas las variables que use deben ser explícitamente declaradas. Si no declara una variable, esta será considerada como un error. Para declarar una variable, puede usar la declaración DIM, exactamente como se muestra arriba para la variable entera Answer.

Regresemos a nuestro programa ejemplo. En la clase de variable Integer, necesitamos tomar el valor retornado por la función MessageBox. Este valor es un código de retorno- indica cuál botón de usuario ha sido presionado en un mensaje de una caja de dialogo. En el momento este valor no nos preocupa. Sin embargo, no hay posibilidad de llamar una función sin la asignación del valor para alguna variable. En el ejemplo siguiente usaremos este código de retorno.


Unos comentarios sobre la función. La caja de mensaje ( MessageBox) muestra una caja de dialogo estándar, que contiene el mensaje (primer parámetro en una llamada de función; aquí "Hola, Moléculas!") y el encabezado (segundo parámetro; "Example #1"). Los botones que aparecen en la caja de dialogo son regulados por el tercer parámetro (en este caso se mostrará solamente el botón “OK” y el signo de exclamación, “!”, indicado en la caja de información).

Nota Vea la ayuda ChemBasic para la lista de parámetros y control de botones de la función caja de mensaje.

2.4 Objetos ChemBasic

Sin embargo, su primer hola para las moléculas no era muy adecuado — esto lo decimos para todo de una vez. Cada uno tiene un nombre, aunque...cómo preguntamos por el nombre de las moléculas y les enviamos un mensaje personalizado?. Digamos “hola propano” tal como decimos “hola, John!”. Antes de hacer esto pensemos que se necesita entender que las moléculas y otras cosas son diferentes a simples números o letras tal como se representa en ChemBasic.

Esto es porque en conjunto el lenguaje de programación BASIC de ACD/ChemBasic incluye no solamente los tipos de datos disponibles en BASIC estandard, sino que también incluye ciertas extensiones que son de propósito general y relacionados con la química. Todas las extensiones son representadas por objetos, esto es, que son estructuras de datos predefinidas usadas para permitir que se hagan en las páginas sketch, moléculas, conformaciones, etc. En pocas palabra, un objeto es cualquier entidad que puede manipular, que no puede ser descrito como una primitiva simple de datos convencionales tales como enteros, simple, booleana, etc.

Hay un tipo de objeto genérico, llamado Objeto, que es usado para manipular una entidad dada. Este se refiere a cualquier objeto de untito predefinido. La naturaleza exacta del objeto esta oculta en tipo de nombre. Los tipos (y nombres) están definidos dentro del mismo ChemBasic; usted no puede crear su propio tipo. A menudo (de hecho, siempre), no debe indicar un tipo de objeto en particular— ChemBasic los determina cuando se llaman funciones o se obtienen objetos. Todo esto repartido en los nombres de variables de objetos, que sirven para manejar entidades. Por ejemplo, la línea

Dim Doc As Object

Reservará una variable al objeto llamado “Doc”.

Cada objeto tiene su propio conjunto de métodos, que son procedimientos que se les pueden aplicar a ellos. Estos procedimientos son cuidadosamente designados para la manipulación fácil de este objeto en particular (tipo), sin detalles engorrosos. Ellos y solamente ellos se aplican a los objetos. Si los trata de otra forma, se generará un error.

Considere una analogía con números convencionales. Imagine que tiene dos variables de cadena tradicionales, a y b. Asigne a la variable a "bueno " y a la b "trabajo". Aplicándole la operación de adición, a+b, resulta "buen trabajo". Sin embargo, si trata de dividir, a/b, resulta una acción absurda y se generará un error. De hecho, la adición es un método que el BASIC convencional permite para aplicarse a cadenas, mientras que la división no se permite en este tipo de variables. El BASIC estrictamente define todas las operaciones y funciones (métodos) que son aplicables a los objetos de cadena. De esta forma usted debe distinguir entre operaciones legales y operaciones prohibidas. Por ejemplo, si escoge las variables a y b de tipo entero convencional, ellas podrían tener los valores "10" y "2". Tanto la suma como la división son permitidas para este tipo de variable. De esta forma ChemBasic permite que se hagan ciertas cosas para unas y se restrinjan para otras.

Los métodos son simplemente una clase especial de funciones y subprogramas BASIC que se toman como argumentos de los Objetos. Ellos se llaman tecleando un punto seguido del nombre del método exactamente después del nombre del objeto:

SomeObject.ThisObjectMethod(parameters)


Esto puede verse como una digresión, pero estamos interesados en objetos ChemBasic que representen moléculas en la ventana de ChemSketch. Para acceder a ellos necesitamos objetos que sean representados con sus contenidos en ChemSketch.

2.5 Páginas y Colecciones en ChemSketch

En términos de ChemBasic su documento ChemSketch actual esta representado por el objeto Document, que es una colección de objetos de tipo página (collection of objects of type Page). Esto significa que Document es un conjunto de miembros objeto, cada uno de los cuales es una página (Page); puede fácilmente contarlos, encontrar cualquier miembro, borrarlo o adicionar uno nuevo, llamando el método de colección (aquí, se refiere a Document)

Nota Vea la ayuda ChemBasic para una discusión más detallada sobre colecciones.

Por ejemplo, el texto

DocumentObject.Count

Exige a ChemBasic contar los miembros de la colección.

Usted puede escribir algo como:

Dim Npages As Integer ‘reserve an integer variable Dim Doc As Object ‘reserve an object variable ‘Get Doc somewhere Npages=Doc.Count ‘count pages Doc.AddEmpty ‘add blank page Doc.AtRemove(1) ‘remove 1st page of document

Nota Ver la ayuda ChemBasic para la descripción de los métodos de colección adicionar página vacía (AddEmpty), remover (AtRemove), y alejar (so far).

Una recomendación: la declaración especial con (UIT) drásticamente reduce el volumen del código. Después que haya escrito With SomeObject , no necesita mencionar SomeObject cuando invoque su método. Solamente necesita simplificar el nombre del método precedido por un punto. Reescriba nuestro ejemplo: Dim Npages as Integer ‘reserve an integer variable Dim Doc as Object ‘reserve an object variable ‘Get Doc somewhere … With Doc Npages=.Count ‘count pages .AddEmpty ‘add blank page .AtRemove(1) ‘remove first page of document End With

Nota Corrientemente no puede usar anidaciones con las asignaciones en ChemBasic.

La función especial ActiveDocument rle retorna una dirección del documento activo. Así, el código de abajo hace las siguientes acciones en su documento actual:

Dim Npages As Integer ‘reserve an integer variable


With ActiveDocument Npages=.Count ‘count pages .AddEmpty ‘add blank page .AtRemove(1) ‘remove first page of document End With

(Note que hemos omitido la variable objeto y simplemente la mencionamos en la asignación ActiveDocument. Si define ActiveDocument usando “Dim ActiveDocument as Object” entonces observará un mensaje de error en la variable inicializada.)

Suficiente en los documentos; ahora en las páginas. El objeto Página (Page) es un miembro de una colección, como lo ha podido ver. Pero es en sí una colección misma, sin embargo, contiene un número de colecciones correspondiente a diferentes clases de dibujos ChemSketch (cajas de texto, rectángulos, etc.). Hay métodos para los objetos Página, que retornan las colecciones hijos. El interés para nosotros ahora es el método Diagramas de Página que retorna al objeto Diagramas – una colección de todos los diagramas moleculares dibujados en la página. Una vez que haya la colección, puede adicionar, remover o encontrar cualquier miembro de un objeto en particular.

2.6 Hola, Sr. Propano!

Regresemos a nuestro objetivo. Como un primer intento, acogeremos la primera molécula en la ventana activa de ChemSketch. Para ejecutar esta tarea, accederemos a la página activa del documento y obtenemos su primer diagrama molecular. Por conveniencia, encapsularemos todos los trabajos con diagramas en una subrutina separada; nuestra función principal será responsable de preguntar al usuario si direcciona la molécula ChemSketch personalmente para luego llamar el procedimiento tratamiento de diagramas (diagram-treating). Mire como:

Function Main as String Dim Answer as Integer ‘Say hello to all Answer=MessageBox("Hello, Molecules!","Example #1", MBB_OK + MBI_INFORMATION) ‘Ask user if (s)he want to pronounce the name(s) Answer=MessageBox("Say Hello to all? ","Example #1", MBB_YESNO + MBI_QUESTION) If Answer= MBR_YES Then ‘yes, (s)he wants Call GreetByName Main=” Everybody welcomed.” Else ‘No, leave this Main=”Sorry, we leave them.” End If End Function


Note, que usamos el valor sin usar que se retorna de la caja de mensaje. También implementamos una asignación de condicional si...entonces… (conditional statement If … Then … Else) para trabajar respuetas alternativas del usuario.

Nota Vea la ayuda ChemBasic para más detalles de condicionales si...entonces...(If … Then … Else) y seleccione el caso (Case…)

Si crea un nuevo archivo de texto llamado “hello.bas” desde el ejemplo anterior y selecciona archivo/correr (File/Run) en ChemBasic cuando entre en la ventana ChemSketch recibirá un mensaje de error acerca de un identificador no declarado:

significa esto que estamos errados en la subrutina GreetByName. He aquí un primer diseño de como planeamos tratar el diagrama:

Sub GreetByName Dim Diagram as Object, Answer as Integer, MolName as String With ActiveDocument.ActivePage.Diagrams MolName=.Item(1).GetIUPACName Answer=MessageBox("Hello, "+MolName+"!","Example #1", MBB_OK+MBI_EXCLAMATION) End With

End Sub

Adicione esta subrutina a la función principal en hello.bas, dibuje una molécula tal como el propano en ChemSketch y ejecute el programa ChemBasic. Verá al inicio una pregunta:

haga clic en Yes y después de una pausa verá:

Observemos la subrutina GreetByname un poco más de fondo. Primero obtendremos los diagramas invocando ActiveDocument.ActivePage.Diagrams con la asignación With. Después obtendremos un diagrama estructural desde una colección usando el ítem método (method). Qué es


un diagrama estructural? Lo primero como ve, el número entre paréntesis: “Item(1)”. Y finalmente aplicamos el método llamado GetIUPACName para el Objeto Diagrama (Diagram object). Este método retorna la cadena que contiene el nombre IUPAC generado al correr la rutina de Librería de ACD/ChemBasic (en verdad la mayoría si no todos los métodos de objetos son internamente trasladados a las llamadas RTL). Note que nuestro código es totalmente equivalente a una forma completa (sin la abreviatura With):

MolName=ActiveDocument.ActivePage.Diagrams.Item(1).GetIUPACName

Nota El método GetIUPACName retorna el nombre correcto solamente si tiene instalado el paquete ACD/Name, de otra forma se retorna una cadena vacía.

Repetimos por claridad, que es lo que hace aquí ChemBasic: 1. obtiene el documento activo ACD/ChemSketch; 2. obtiene su página activa (la ventana visible de ChemSketch); 3. obtiene todos los diagramas moleculares de la página: 4. extrae el primer diagrama de la colección: 5. aplica el método GetIUPACName al diagrama; 6. saca el nombre y saluda.

Nota Vea la ayuda ChemBasic para los métodos del objeto Diagrama


2.7 Hola a varios Individuos

El paso final que debemos hacer es direccionar todas las moléculas en la página, no solamente la primera. Para hacer esto, se debe implementar la construcción de un ciclo en ChemBasic. La forma más común en otros lenguajes de programación es la asignación For … To:

Dim i As Integer For i=1 To 10 Do_Something Next I

Esto significa que todas las asignaciones encerradas entre el For .. To y Next se repetirán diez veces y la variable i (contador cíclico) se irá incrementando de uno en uno, comenzando desde uno hasta llegar al valor de diez, en donde el ciclo termina. En nuestro ejemplo, podríamos repetir un ciclo para cada diagrama. De esta forma, primero contamos el número de diagramas:

Sub GreetByName Dim Answer as Integer, MolName as String Dim i,Ndiagrams as Integer With ActiveDocument.ActivePage.Diagrams ‘Count the diagrams Ndiagrams=.Count For i=1 To Ndiagrams MolName=.Item(i).GetIUPACName Answer=MessageBox("Hello, "+MolName+"!","Example #1",MBB_OKCANCEL+MBI_EXCLAMATION) If Answer= MBR_CANCEL Then Exit For Next i End With End Sub

Remplace la subrutina en hello.bas por la subrutina anterior, y guarde el archivo de texto. Dibuje otra molécula en la misma página ChemSketch page como la que contiene el propano. Cuando ejecute el programa, verá el saludo individual de cada molécula.

Note, sin embargo, que no tenemos necesidad de aplicar el ciclo i en la subrutina. Todo lo que se necesita es tener los miembros de una colección. Para cada caso, ChemBasic tiene el llamado object-loop para cada uno:

For Each MemberObject In CollectionObject MemberObject.CallSomeMethod Next MemberObject


Esto significa que todas las asignaciones entre cada For … y Next se repetirán con cada miembro de una colección, de tal forma que al rescribir el código quedaría:

Sub GreetByName Dim Diagram as Object, Answer as Integer Dim NextName,Tail as String Tail=Chr(13)+Chr(13)+Chr(13)+"Greet the next?" With ActiveDocument.ActivePage.Diagrams For Each Diagram In .Self NextName=Diagram.GetIUPACName Answer=MessageBox("Hello, "+NextName+"!"+Tail,"Example #1", MBB_OKCANCEL+MBI_EXCLAMATION) If Answer= MBR_CANCEL Then Exit For Next Diagram End With End Sub

Guarde el archivo y córralo después de dibujar para que diga, propano, etano y metano en una sola pagina ChemSketch. El primer saludo será el siguiente:


observe el método .Self en la subrutina anterior. Si intenta retornar el objeto mismo cuando se aplica sobre cualquier objeto– es aceptable cuando se combina con la construcción With exactamente como se mostró.

Nota Vea la ayuda ChemBasic para una descripción de la asignación bucle (ciclo)

Ahora el paso final. La situación puede ocurrir donde el RTL no retorne el nombre IUPAC, por alguna razón. En tal caso, GetIUPACName retornará una cadena vacía o una cadena que contiene espacios. Se debe chequear esto y aun trasladar la molécula o llamarla con otro nombre. Esto se implementa como sigue:

if Trim(MoltName)="" then MolName=" though I can not pronounce your name"

(La función Basic Trim remueve permitiendo y colocando espacios desde un argumento cadena).

Finalmente… se encuentra que le decimos hola a todas ellas! Felicitaciones!

Nota Vea el texto completo del programa en el Apéndice.


3. Los frutos del Arbol Molecular

3.1 Objetivos

En este capítulo aprenderá • Cuál es el objeto del árbol molecular ChemBasic; • Cómo acceder a sus ramas; • Cómo crear nuevos objetos moleculares; • Cómo vincular objetos moleculares con páginas ChemSketch; • Cómo analizar conformaciones y moléculas.

3.2 Designar Asignaciones (Relaciones)

Consideremos un ejemplo de la vida real. Suponga que estamos interesados en qué ácidos carboxílicos de la familia HO-(CH2)n-COOH, tienen una corta distancia entre el carbono carboxílico y el oxígeno del grupo hidróxido. Esta situación es concebible si designamos receptores para esos ácidos y estamos interesados en enlazar simultáneamente moléculas por los grupos finales carboxi e hidroxi.

con ChemBasic, se permite hacer las siguientes asignaciones: • Generar las moléculas HO-(CH2)n-COOH con n átomos, decimos, 1 hasta 10; • Hacer las estructuras de forma optimizada; • Hallar las distancias (H)O --- C(OOH) y si la distancia es menor a 5 Angstroms, marcar la

estructura; • Mostrar todas las estructuras en un sola página ChemSketch.

Para acompañar la misión, observe los objetos moleculares en ChemBasic.

3.3 Referencia de Objetos Moleculares

Para describir el mundo molecular ChemBasic usa un árbol de sus propios objetos moleculares. Ellos están relacionados, pero no son idénticos, con los diagramas moleculares ChemSketch (Objetos Diagrama ). Nosotros permitimos "sombras" en 2D y en 3D en ChemSketch, para algunas pinturas de moléculas. Los Átomos en los diagramas de ChemSketch tienen etiquetas, coordenadas de la pantalla (en centímetros o pulgadas), y mucho más. Los átomos en moléculas ChemBasic tienen carga nuclear y masas atómicas, las coordenadas 3D (en Angstrom), etc. Naturalmente, estos objetos están relacionados y esto asegura la oportunidad de crear un modelo molecular en ChemSketch. Pero para tratar con este modelo como con una molécula real nosotros debemos convertirlo en una entidad de ChemBasic.


Nota Las diferencias entre los objetos moleculares de ChemSketch y de ChemBasic fueron creadas intencionalmente. ChemSketch contiene muchas características, tal como control automático de valencia, que es muy conveniente para la aplicación de dibujo. Sin embargo, estas características controladas restringen la libertad de operación con moléculas, las cuales son necesarias en el manejo del lenguaje de moléculas. Así, los diagramas ChemSketch y los árboles moleculares ChemBasic están claramente separados pero existe un riguroso mecanismo de avance y retroceso entre ellos.

En el mundo ChemBasic, todo esta compuesto de átomos (objeto Atom). Los átomos se pueden coleccionar en grupos llamados objetos ensamblados (Assembly). El esquema de conexión de los átomos de un ensamble dado se llama una Molécula. Una colección de coordenadas atómicas (x,y,z, Angstroms) se llama Conformación. cualquier Molécula o Conformación se basa en Arreglos (Assembly).

ChemBasic automáticamente rastrea y actualiza la colección de Moléculas y Conformaciones (auto colecciones), que contienen todas las moléculas y conformaciones ligadas al arreglo particular. puede asociar algunos objetos de Moléculas y Conformaciones ligados al mismo Arreglo. Los objetos compuestos que resultan se llaman Estructuras. Objetos Estructura están también reunidos en objetos Estructuras, ligados al Arreglo. Finalmente, todos los objetos de Arreglos en esta sesión están auto reunidos dentro del objeto Arreglos. De esta forma, puede acceder a cualquier Arreglo (y a su árbol derivado) como Arreglos. Item (i).

Nota De hecho, ChemBasic maneja su propio pool de datos moleculares y de colecciones. Todas sus operaciones se trasladan dentro de operaciones con objetos de su pool justamente como lo hace ChemSketch con sus páginas y dibujos. Esto le permite guardar lo tratado anteriormente sobre colecciones. Los niveles moleculares predefinidos crean una capa abstractiva que custodia sus objetos, la capa maneja memoria, rastrea objetos desaparecidos, su mutua influencia, etc. Sin embargo, no se debe preocupar con el mecanismo interno, usted trata solamente con sus árboles moleculares.

Este paradigma, aunque alguna veces inusual en primera instancia, sigue las rutas que hemos descrito verbalmente para el mundo molecular. Las bases generales se refieren a átomos y sus grupos. El mismo grupo de átomos puede tener diferente conectividad. Esto significa que tiene un adecuado camino para describir átomos de enlaces isoméricos diferentes en objetos Molécula unidos al mismo Arreglo. Además, los átomos en el grupo pueden tener diferentes coordenadas de tal forma que tiene una ruta adecuada para describir confórmeros diferentes en los objetos Conformación unidos al mismo Arreglo. Note que ninguna conformación se refiere al esquema enlazante ni al esquema de valencia referido a las coordenadas atómicas. Para integrar esta clase de datos se debe introducir más de un objeto Estructura.

Como puede ver, todos los objetos forman una especie de árbol. (O mejor enarbolar sería más apropiado?)


Atomo

Arreglo

Molecula Conformacion

Estructura

Arbol Molecular ChemBasic

Estructuras

ConformacionesMoleculas

Enlace Punto

Examinemos las ramas del árbol con más detalle.

Atomo

Es el objeto fundamental en la jerarquía, este representa átomos aislados no conectados. Los átomos pueden coleccionarse dentro del objeto Arreglo.

Enlace

Indica la conexión de dos átomos. Los enlaces pueden colectarse dentro del objeto Molécula. El mismo enlace puede incluirse en muchas moléculas. Para crear un enlace, use la función ChemBasic Nuevo enlace (NewBond). Para destruir un enlace, use la función Destruir (Kill). Para hacer o romper el enlace en una molécula particular, use el método de objeto Molécula.

Punto

Representa un punto en el espacio ocupado por un átomo. Los puntos se coleccionan dentro de un objeto Conformación. Los puntos no pueden ser removidos o adicionados a la colección Conformación. El usuario puede incluir puntos directamente o a través de una Conformación.

Arreglo

Es un grupo de objetos Átomos que sirven como para todas las entradas moleculares. Cualquier átomo puede asociarse con muchos ensambles. Uno puede repartir simultáneamente el naftaleno con su benceno constitutivo como tres moléculas diferentes basadas en tres ensambles hechos de los mismos átomos (por ejemplo. Teniendo los mismos repartos). Cualquier Arreglo puede tener múltiples uniones en objetos Conformación, Molécula y Estructura, todos los cuales son (auto) colleccionados dentro de las colecciones Conformaciones, Moléculas, y Estructuras. Si el Arreglo base es modificado, este involucra todos los objetos chicos. Por ejemplo, removiendo un Átomo del Arreglo automáticamente destruye todos los Puntos y Enlaces relacionados y actualiza todos los objetos.


Molécula

Es un esquema de valencia construido al inicio del Arreglo atómico. Típicamente, esta conectado pero puede desconectarse si se quiere. Aunque Molécula encapsula significados químicos de información sobre enlaces de átomos, no se incluye información acerca de la estructura 3D. Para acceder posteriormente, debe referirse a un objeto separado Conformación. Técnicamente hablando, Molécula es, primariamente, una (auto) colección de objetos Enlaces. Esta colección esta estrictamente asociada con su base Arreglo. Este cambia si el arreglo asociado se modifica. Por ejemplo, removiendo un Átomo de un Arreglo automáticamente borra todos los objetos enlace relacionados y actualiza la Molécula (colección enlaces).

Conformación

Representa la posición del Arreglo átomos en el espacio. La razón para separar la conformación de su arreglo es que este puede tener muchas conformaciones. De hecho, lo que queremos decir aquí por conformación es que es sólo un instantánea de posiciones atómicas (qué no puede ser estable o químicamente razonable). El arreglo puede tener tantas conformaciones como usted desee. La Conformación esta estrictamente asociada con un Arreglo simple (objeto base). Cualquier Arreglo puede tener múltiples asignaciones a objetos Conformación, todos ellos están colectados automáticamente dentro de unos objetos Conformaciones que están siempre ligados al arreglo. Las Conformaciones de objetos derivados (hijos) son objetos Estructura. Cualquier Conformación puede tener múltiples objetos Estructura asignados todos los cuales están auto colectados dentro de los objetos Estructuras los cuales siempre están disponibles para unirlos a un Arreglo. La Conformación cambia si el Arreglo patrón se modifica. Si se borra el último, todas las conformaciones se destruyen inmediatamente. Los cambios en las Conformaciones modifican todas sus Estructuras derivadas. Por ejemplo, removiendo un Átomo desde un Arreglo automáticamente borra todos los objetos Punto relacionados y actualiza todos los objetos Conformación derivados (colecciones Punto). Cambiando las coordenadas atómicas en la Conformación tendrá influencia en todas las Estructuras derivadas. Técnicamente hablando, la Conformación es, primariamente, una (auto) colección de objetos Punto.

Estructura

Es el hijo de una Conformación y una Molécula basada en un Arreglo común de átomos. Para acceder a los objetos padre, use los métodos de referencia de Estructura (vea abajo).

3.4 Cómo Crear y Destruir Objetos?

Para crear un átomo, use la función ChemBasic Nuevo Átomo (NewAtom). Dado que el Átomo está debajo de todos los otros objetos moleculares, destruirlo es permitido pero es peligroso. Atom.Kill modificará todos los arreglos relacionados con moléculas, estructuras, y conformaciones. Los objetos Enlace y Punto que usen este átomo se destruirán. Así, para destruir un átomo, use la función destruir (Kill). Para quitar un átomo de un arreglo particular, use la función .AtRemove. Crear un enlace o un punto, use Nuevo enlace o Nuevo punto (NewBond o NewPoint).

Para crear un nuevo Arreglo, use el método Adicionar vacío (AddEmpty) en la auto colección Arreglos de ChemBasic. Los Arreglos también pueden crearse al importarlos. Note que una vez creados, los Arreglos ChemBasic relacionan todas las referencias a las Moléculas y a las Conformaciones.

Para crear un nuevo objeto Molécula para un Arreglo dado, use el método AddEmpty para la colección Moléculas vinculada a este arreglo.

Para crear un nuevo objeto Conformación para un Arreglo dado, use el método AddEmpty para la colección Conformaciones unidas a este arreglo. Note que el objeto Punto de una Conformación vacía tiene llenos los campos de Átomos y del cero de coordenadas. Puede crear también un objeto Conformación invocando el optimizador 3D o importando un archivo con coordenadas.


Para crear una nueva Estructura, use el método derivado (Derive) de la colección Estructuras asociadas con un Arreglo dado.

3.5 Elaborar un Árbol Molecular

Ahora, regresaremos a nuestra misión. Nuestra primera tarea es generar las moléculas HO-(CH2)n-COOH con n, desde 1 hasta 10.

Como en el ejemplo anterior ubiquemos todo el trabajo molecular en una Sub especial llamada GenerateAndAnalyze:

Function Main As String Call GenerateAndAnalyze Main="Completed OK." End Function

Sub GenerateAndAnalyze 'Generate - optimize - depict – analyze End Sub

Ahora escriba lo siguiente: el código que sigue crea los 10 ácidos carboxílicos que se necesitan:

Sub GenerateAndAnalyze 'Generate - optimize - depict – analyze Dim n,i as Integer Dim Ent,Mol,Oh, Cox,O1ox,O2ox,AtomCurr,AtomPrev As Object Const nmax=10 'In a loop .... For n=1 To nmax 'Generate 'Create a new assembly Ent=Assemblies.AddEmpty Mol=Ent.Molecules.AddEmpty 'Add OH (note that we will not add implicit hydrogen) Oh=NewAtom(8) : Ent.Add(Oh) 'Add COOH Cox=NewAtom(6) : Ent.Add(Cox) O1ox=NewAtom(8) : Ent.Add(O1ox) O2ox=NewAtom(8) : Ent.Add(O2ox) 'Make bonds Mol.AddBond(Cox,O1ox,2) Mol.AddBond(Cox,O2ox,1) AtomPrev=Oh


'Add (CH2)n

For i=1 To n AtomCurr=NewAtom(6) Mol.AddBond(AtomCurr,AtomPrev,1) AtomPrev=AtomCurr Next i Mol.AddBond(AtomPrev,Cox,1) Next n End Sub

Para examinar este bucle, cree un nuevo archivo oxycarb.bas que contenga la función simple principal y la subrutina GenerateAndAnalyze como se mostró. Cuando se este ejecutando, encontrará un código de retorno claro, pero no se sorprenda si no aparecen moléculas…hasta ahora no hemos indicado como pueden mostrarse las moléculas.

Qué toma lugar aquí? Incrementamos el bucle en un ciclo con un contador n, que expresa el número de metilenos entre los extremos de una molécula. En cada paso del ciclo, primero se crea un nuevo arreglo:

Ent=Assemblies.AddEmpty

Y una molécula nueva

Mol=Ent.Molecules.AddEmpty

En el momento, ambos están vacíos. Ahora se pueden adicionar átomos al arreglo. Para hacer esto, creamos un átomo y se adicionan otros. (Note que NewAtom recibe como un parámetro el número del elemento del átomo que se ha creado):

'Add OH (note that we will not add implicit hydrogen) Oh=NewAtom(8) : Ent.Add(Oh) 'Add COOH Cox=NewAtom(6) : Ent.Add(Cox) O1ox=NewAtom(8) : Ent.Add(O1ox) O2ox=NewAtom(8) : Ent.Add(O2ox)

entonces, adicionamos enlaces a la construcción de la molécula al inicio del arreglo. Podríamos hacer esto como con los átomos a través de subsecuentes iteraciones de NewBond y de MoleculeObject.Add. Sin embargo, mostramos un camino más rápido (note que AddBond permite las dos funciones y recibe como parámetro el orden de enlace del enlace que se ha creado):

'Make bonds Mol.AddBond(Cox,O1ox,2) Mol.AddBond(Cox,O2ox,1)


Nota Vea la ayuda ChemBasic para la explicación de NewAtom, NewBond, AddBond y funciones relacionadas.

Agregamos tanto las mitades del oxígeno y del grupo carboxi como los enlaces a lo último. Adicionar y conectar los grupos metileno es algo más engañoso:

AtomPrev=Oh 'Add (CH2)n For i=1 to n AtomCurr=NewAtom(6) Mol.AddBond(AtomCurr,AtomPrev,1) AtomPrev=AtomCurr Next i Mol.AddBond(AtomPrev,Cox,1)

Qué significa esto?. Adicionamos carbonos consecutivos en un ciclo (For i=1 To n) y conectamos cada uno de ellos al átomo previo (AtomPrev) de la cadena. Observe el código. Antes de comenzar el ciclo, el primer átomo era el oxígeno del hidroxilo. Así que el primer metileno será conectado a este oxígeno. Antes de que el metileno se coloque AtomPrev. De esta forma el siguiente metileno se adicionará en el Segundo paso del ciclo y aparecerá conectado al primero y así sucesivamente hasta que el límite de carbonos (n) se alcance. Finalmente, formaremos un enlace entre el ultimo metileno en la cadena para conectar al carbono carboxilo (Cox).

3.5.1 La Acción tomar Existencias

A estas alturas, usted podría querer ver su molécula en la Ventana de ChemSketch. Para hacer esto, pueden hacerse dos modificaciones a su archivo oxycarb.bas que creó anteriormente. 1. escoja un máximo entre uno y 10; note que esto es temporal y para propósitos de ensayo; 2. inserte el tipo de declaración Dim Page, Diagram as Object dentro de la subrutina

GenerateAndAnalyze; 3. inserte las siguientes cuatro líneas de código antes de finalizar la subrutina:

Page=ActiveDocument.ActivePage

Diagram=Page.Diagrams.AddEmpty

Diagram.Depict(Mol)

Ahora, cuando corra oxycarb.bas, verá una molécula creada en la parte superior izquierda de la página de ChemSketch. Esto de hecho no es elegante, todos los átomos quedan entre si uno encima del otro, pero la molécula existe. ¡Es un consuelo grande, y ahora nosotros podemos seguir el resto de la tarea! Usted puede poner el n máximo (nmax) hasta 10..

3.5.2 Optimización y Medida

Estamos listos para hacer la próxima tarea—optimizando la estructura y calculando la distancia (H)O --- C(OOH). El código necesario es bien simple. Primero, haremos el método Do3Doptimize, el cual se aplica al objeto Molécula. Este método invoca al Optimizador (ACD/3Doptimizer), exactamente


igual que en ChemSketch. Se crea el objeto Conformación complete con las coordenadas atómicas optimizadas, asociandolas a la Molécula original y retorna la Estructura resultante:

'Optimize a structure Struc=Mol.Do3DOptimize(0.1)

Luego aplicamos un método para un objeto Estructura, llamado GetDist, para calcular la distancia interatómica (esto es que donde sea, al comienzo de la Sub, podríamos declarar una variable necesaria r):

'Check out the distance r=Struc.GetDist(Cox,Oh)

Nota Vea la ayuda ChemBasic para una descripción más detallada del Do3Doptimize, GetDist y de los métodos relacionados.

Y, finalmente, marcamos los átomos con un rótulo ($) si la distancia es menor a 5 A:

If (r<=5.0) Then Cox.SetName("$") Oh.SetName("$") End If

El método SetName asigna el nombre del objeto. Para un átomo, el nombre es un rotulo de cadena, que esta típicamente vacío, pero puede contener un texto arbitrario. El texto se mostrará en el diagrama molecular del ChemSketch, cuando traslademos nuestra Estructura al Diagrama.

Importante Asegurarse que el nombre del átomo no tiene nada en común con los elementos número de los átomos.

3.5.3 Refinando la Salida

Ahora podemos hacer la traslación de la estructura a un diagrama y podemos crear un dibujo apropiado. Esto se hace para remplazar las líneas del diagrama que se agregaron anteriormente.. Los pasos necesarios son:

1. Crear un diagrama (por defectot) ChemSketch vacío

'Depict as a ChemSketch diagram Diagram=ActiveDocument.ActivePage.Diagrams.AddEmpty

2. Pintar la estructura sobre este diagrama

Diagram.Depict(Struc)

3. y redimensionar el diagrama para que sea más legible:


'Set diagram size to fit all diagrams to a page Page=ActiveDocument.ActivePage 'Read out page parameters ph=Page.GetHeight pw=Page.GetWidth l=Int(pw/3) t=200+(n-1)*Int(ph/(nmax+1)) w=Int(pw/6) h=Int(0.9*ph/(nmax+1)) Diagram.SetBound(l,t,w,h)

Presentamos algunas palabras de explicación. La construcción

Diagram=ActiveDocument.ActivePage.Diagrams.AddEmpty Diagram.Depict(Struc)

está en idioma ChemBasic para mostrar un objeto Estructura en la ventana ChemSketch.

Un idioma relacionado para la tarea contraria,, convertir desde un Diagrama a una Estructura, requiere el método de Arreglos AddFromCS para extraer la primera Estructura unida al Arreglo que justamente se ha recibido:

Structure=Assemblies.AddFromCS(DiagramObject).Structures.Item(1)

Nota Vea la ayuda ChemBasic para una descripción más detallada sobre pintar (Depict) y GetFromCS.

3.5.4 Redimensionar el Diagrama Molecular

Redimensionar un diagrama molecular requiere obtener la posición (el que se da por defecto) y dimensionar el rectángulo incluido en el diagrama o en un marco. Esto se acompaña del método GetBound que es aplicable a cualquier objeto dibujo de ChemSketch, porque como cualquier objeto esta localizado dentro de un marco invisible. Los parámetros del método están arriba a la izquierda de las coordenadas del marco, así como el ancho y el alto. Después de obtenerlos, puede calcular el tamaño y posición más apropiado para el marco, y redimensionarlo con SetBound. La matemática presentada en el código anterior sirve simplemente para colocar nuestro máximo de moléculas (nmax) para la página ChemSketch (cuyas dimensiones están disponibles a través de los métodos y GetHeight).

Nota Vea la ayuda ChemBasic para ampliar una descripción detallada de los métodos SetBound, GetBound y GetFont, SetFont, SetFontSize.

Finalmente, por conveniencia, podemos adicionar texto, indicando la distancia interatómica de interés cerca de la imagen de la molécula. Para esto, adicionamos a la página ChemSketch un objeto vacío TextBox, y lo llenamos con la información necesaria y la redimensionamos para un presentación adecuada:

'Add a textbox indicating the distance ‘carbonyl carbon ---- hydroxy oxygen


TBox=Page.TextBoxes.AddEmpty TBox.SetContent("Cox---Ooh "+FStr(r,10,4)) TBox.SetBound(l+Int(1.1*w),t+Int(h/2),w,h)

Nota Vea la ayuda ChemBasic para ampliar la información sobre los métodos TextBoxes, SetContent, y GetContent y la función FStr (que simplemente convierte el número a cadena (carácter)).

Nuestro viaje ha finalizado. El texto complete del programa se presenta en el Apéndice (contiene otras líneas de código con declaraciones y chequeos para algunos casos de potenciales errores). Por favor, ejecute y vea que pasa.

Diviértase!

Nota Este Tutorial se da como una guía para su primer paseo por ChemBasic. Esperamos que haya adquirido una buena impresión sobre este potente y simple lenguaje de manipulación de moléculas. Para una referencia más detallada, use la ayuda en línea o contáctenos en [email protected].


4. Apéndice. Texto completo de los programas de muestra

4.1 HELLO.BAS

' Este programa ' presenta todas las moléculas en la ventana actual de ChemSketch; ' genera sus nombres IUPAC ‘ y dice Hola a todas ellas

Function Main As String

Dim Answer As Integer

Answer=MessageBox("Hola, Moléculas!","Example #1", MBB_OK +MBI_EXCLAMATION)

Answer=MessageBox("Decir Hola a todas? ","Example #1", MBB_YESNO + MBI_QUESTION)

if Answer= MBR_YES Then

Call GreetThemAll

Main=" Bienvenido todo el Mundo."

Else

Main=" Lo siento, nosotros los dejamos."

End If

End Function

Sub GreetThemAll

Dim Diagram as Object, Answer as Integer, MolName,Tail as String

Tail=Chr(13)+Chr(13)+Chr(13)+"Greet the next?"

With ActiveDocument.ActivePage.Diagrams

For Each Diagram In .Self

MolName=Diagram.GetIUPACName

If Trim(MolName)="" Then MolName=" aunque yo no puedo pronunciar su nombre"

Answer=MessageBox("Hola, "+MolName+"!"+Tail,"Example #1", MBB_OKCANCEL+MBI_EXCLAMATION)

if Answer= MBR_CANCEL Then Exit For

Next Diagram


End With

End sub

4.2 OXCARBOX.BAS

' Este programa

' (i) coloca en la ventana actual de ChemSketch las moléculas

' de fórmula general HO-(CH2)n-COOH, n=1-10,

' (ii) permite la optimización 3D para todas ellas y

' (iii) marca aquellas que contienen un grupo hidroxilo con el oxígeno

' del carbonilo menor a 3 Angstroms

Const nmax=10

Function Main As String

Dim Entities (1) As Object

Call GenerateAndAnalyze

Main="Terminado."

End Function

Sub GenerateAndAnalyze

'Generate - optomize - depict - analyze

Dim n,i,ph,pw,l,t,w,h as Integer, r As Double

Dim Ent,Mol,Oh, Cox,O1ox,O2ox,AtomCurr,AtomPrev, Page,Diagram, Struc,Font, TBox As Object

'Hacer una página

Page=ActiveDocument.ActivePage

'Si la página no esta vacía, crea una nueva

If Page.Drawings.Count>0 Then Page=ActiveDocument.AddEmpty

'Leer los parámetros de la página

ph=Page.GetHeight

pw=Page.GetWidth

'In a loop ....


For n=1 to nmax

'Generar

'Crea un nuevo arreglo

Ent=Assemblies.AddEmpty

Mol=Ent.Molecules.AddEmpty

'Add OH (note que no adicionamos hidrógenos implícitos)

Oh=NewAtom(8) : Ent.Add(Oh)

'Add COOH

Cox=NewAtom(6) : Ent.Add(Cox)

O1ox=NewAtom(8) : Ent.Add(O1ox)

O2ox=NewAtom(8) : Ent.Add(O2ox)

'Hacer enlaces

Mol.AddBond(Cox,O1ox,2)

Mol.AddBond(Cox,O2ox,1)

AtomPrev=Oh

'Add (CH2)n

For i=1 To n

AtomCurr=NewAtom(6)

Mol.AddBond(AtomCurr,AtomPrev,1)

AtomPrev=AtomCurr

Next i

Mol.AddBond(AtomPrev,Cox,1)

'Optimizar una estructura

Struc=Mol.Do3DOptimize(0.1)

'Cheque la distancia

r=Struc.GetDist(Cox,Oh)

If (r<=5.0) Then

Cox.SetName("$")

Oh.SetName("$")

End If

'Dibujar como un diagrama ChemSketch

Diagram=Page.Diagrams.AddEmpty

Diagram.Depict(Struc)

'Escoja el tamaño del diagrama para llenarlos todos en la página


l=Int(pw/3)

t=200+(n-1)*Int(ph/(nmax+1))

w=Int(pw/6)

h=Int(0.9*ph/(nmax+1))

Diagram.SetBound(l,t,w,h)

'Escoja la fuente para los símbolos atómicos

Font=Diagram.GetFont

Font.SetFontSize(24)

Diagram.SetFont(Font)

'Adicionar cajas de texto indicando las distancias ‘carbono carbonilo ---- oxígeno del hidroxi

TBox=Page.TextBoxes.AddEmpty

TBox.SetContent("Cox---Ooh "+FStr(r,10,4))

TBox.SetBound(l+Int(1.1*w),t+Int(h/2),w,h) Next n End Sub


Documents

Chem Basic