Manual de ACD

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 ................................................................................................... 24
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!
ACD/ChemBasic
Comenzando
2
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
ACD/ChemBasic
Comenzando
3
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.
ACD/ChemBasic
Comenzando
4
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.
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
Gane!!!
para abrir el archivo “survey.doc” o use Adobe Acrobat Reader para
Su opinión es abrir “survey.pdf” en la documentación del CD que ha recibido con
importante
este software, o visite la página “Feedback” en nuestro sitio web,
http://www.acdlabs.com/feedback/guides.html. El ganador del
para
dibujo será anunciado al final de cada año calendario.
nosotros.
ACD/ChemBasic
Comenzando
5
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
ACD/ChemBasic
Comenzando
6
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
ACD/ChemBasic
Comenzando
7
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
ACD/ChemBasic
Comenzando
8
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.
ACD/ChemBasic
Comenzando
9
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
.AddEmpty
.AtRemove(1)
‘count pages
‘add blank page
‘remove first page of document
End With
ACD/ChemBasic
Comenzando
10
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
.AddEmpty
.AtRemove(1)
‘count pages
‘add blank page
‘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
ACD/ChemBasic
Comenzando
11
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á:
ACD/ChemBasic
Comenzando
12
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
ACD/ChemBasic
Comenzando
13
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
ACD/ChemBasic
Comenzando
14
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:
ACD/ChemBasic
Comenzando
15
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.
ACD/ChemBasic
Comenzando
16
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.
ACD/ChemBasic
Comenzando
17
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?)
ACD/ChemBasic
Comenzando
18
Arbol Molecular ChemBasic
Enlace
Atomo
Punto
Arreglo
Moleculas
Conformaciones
Molecula
Conformacion
Estructura
Estructuras
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.
ACD/ChemBasic
Comenzando
19
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
ACD/ChemBasic
Comenzando
20
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-(CH 2)nCOOH 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)
:
:
:
Ent.Add(Cox)
Ent.Add(O1ox)
Ent.Add(O2ox)
'Add COOH
Cox=NewAtom(6)
O1ox=NewAtom(8)
O2ox=NewAtom(8)
ACD/ChemBasic
Comenzando
21
'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)
:
:
:
Ent.Add(Cox)
Ent.Add(O1ox)
Ent.Add(O2ox)
'Add COOH
Cox=NewAtom(6)
O1ox=NewAtom(8)
O2ox=NewAtom(8)
ACD/ChemBasic
Comenzando
22
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)
ACD/ChemBasic
Comenzando
23
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:
ACD/ChemBasic
Comenzando
24
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
ACD/ChemBasic
Comenzando
25
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].
ACD/ChemBasic
Comenzando
26
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
ACD/ChemBasic
Then Exit For
Comenzando
27
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
ACD/ChemBasic
Comenzando
28
'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)
Cox=NewAtom(6)
:
Ent.Add(Cox)
O1ox=NewAtom(8)
:
Ent.Add(O1ox)
O2ox=NewAtom(8)
:
Ent.Add(O2ox)
'Add COOH
'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
ACD/ChemBasic
Comenzando
29
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
ACD/ChemBasic
Comenzando
30