Institucin:

Universidad Autnoma Metropolitana

Unidad:
Iztapalapa
Grado:
Licenciatura
Titulo del trabajo de Servicio Social:
Simulacin por Mtodos de Monte Carlo de la Liberacin Controlada de Frmacos: Anlisis
del Entrampamiento del Principio Activo
Nombre del Participante:
Mara Elizabeth Adriana Santiago Corts
Nombre de Asesor Interno:
Dra. Minerva Muoz Gutirrez
Dep. Biologa de la Reproduccin (UAM-I)
Nombre del Asesor Externo:
Dr. Carlos Felipe Mendoza
Dep. Fisicoqumica de los Materiales
ICUAP-BUAP
Lugar y Fecha de Realizacin:
Departamento de Biologa de la Reproduccin (UAM-I) y Departamento de Fisicoqumica
de los Materiales (ICUAP-BUAP)
Del 5 de Junio de 2006 al 5 de Diciembre de 2006.

Nombre del Proyecto:

Simulacin por Mtodos de Monte Carlo de la Liberacin Controlada de Frmacos: Anlisis del
Entrampamiento del Principio Activo
Lugar y periodo de Realizacin:
Se llevo a cabo en las instalaciones del Departamento de Biologa de la Reproduccin de la
Universidad Autnoma Metropolitana unidad Iztapalapa y del Departamento de Fisicoqumica de
Materiales del Instituto de Ciencias de la Universidad Autnoma de Puebla. El tiempo de dedicacin
fue de 4 horas diarias, del 05/Junio/2006 al 05/Diciembre/2006, de 08:00 a 12:00 hrs.
Asesores responsables:
1) Dra. Minerva Muoz Gutirrez. Es profesora investigadora Titular CTC en el Departamento
de Biologa de la Reproduccin en la UAM-Iztapalapa; su nmero de empleado es el 15499.
2) Dr. Carlos Felipe Mendoza. Es profesor investigador Titular B-TC en el Departamento de
Fisicoqumica de Materiales del ICUAP en la Benemrita Universidad Autnoma de Puebla; su
nmero de empleado es el 100405133
Introduccin:
El dosificar los frmacos en forma controlada produce grandes beneficios en el tratamiento de
afecciones de tipo crnico, destacndose los agentes quimioteraputicos, inmunosupresores, protenas,
ppticos y hormonas. Recientemente con el desarrollo de la nanotecnologa se utilizan matrices inertes
slidas de escalas nanomtricas para la fabricacin de frmacos; dichas matrices son impregnadas con
el principio activo del frmaco con el afn de regular su accin farmacolgica a travs de su liberacin
controlada al medio o cercanas del lugar en el cual es aplicado. Por otro lado se puede afirmar que la
topologa del frmaco juega un papel clave en la liberacin controlada; ya que, este se puede imaginar
como un medio poroso (conformado por el vehculo excipiente y el principio activo) en el cual existe
ciertos parmetros como la conectividad, tamao y forma de sus poros; los cuales son de suma
importancia en los procesos difusivos del principio activo y por ende de la accin farmacolgica. Por lo
anterior surge la necesidad de conocer tanto terica como experimentalmente los proceso de liberacin
y entrampamiento del principio activo.
Objetivo:
Simular por mtodos de Monte Carlo la liberacin controlada y el entrampamiento del principio activo
de un frmaco, considerando a este ltimo como un medio poroso.

Metodologa:
El estudio realizado fue de carcter terico, por lo que se llevo acabo un estudio del arte sobre
diferentes metodologas existentes para la construccin de medios porosos y la simulacin de la
liberacin controlada de frmacos; as mismo, se elabor un cronograma de actividades para el periodo
de duracin del servicio social. Cabe resaltar que para la ejecucin del servicio se utilizaron los
recursos contenidos en los Departamentos de Biologa de la Reproduccin de la UAM Iztapalapa y de
Fisicoqumica de Materiales del ICUAP-BUAP, algunos de dichos recursos fueron PC Pentium IV
equipada con el siguiente software: Compilador Borland C++ 5.0, editores de texto (Microsoft Word) y
grficos (Origin 7.0).

Actividades Realizadas:
a) Capacitacin en el uso del compilador Borland C++.
b) Simulacin por Mtodos de Monte Carlo del slido poroso conformado por el principio activo y
el vehculo excipiente.
c) Simulacin de la liberacin del principio activo.
d) Anlisis de resultados.
e) Elaboracin del reporte.
Objetivos y metas alcanzadas:
Se consigui simular la construccin de un medio poroso consistente de principio activo y excipiente; y
sobre este medio se simul el proceso difusivo del frmaco, observndose al final del mismo
entrampamiento de frmaco.
Resultados y conclusiones
El medio poroso. Se utiliz la metodologa de trabajos anteriores [1-3] para generar redes cbicas de
conectividad variable, sin restricciones geomtricas y diferentes grados de correlacin. Los elementos
(sitios y enlaces) del arreglo cbico, se suponen de idntica naturaleza qumica. Se consideraron
condiciones peridicas de contorno, un tamao lineal de nodos de 10 (L = 10) usando un mximo de L3
sitios (1000) y 3 L3 enlaces (3000), por lo que el nmero de coordinacin mximo para cada nodo es 6
(Cmax = 6). Se propusieron distribuciones de tamao de poro de tipo gaussianas, tanto para FS y FB, ya
que son las mas comunes en muestras reales; dichas funciones se acotaron por los extremos igual a la
media mas (menos) tres veces el valor de = 15 ; de manera que los tamaos corresponden al
intervalo de los mesoporos.
Algoritmo para la construccin de la red. La metodologa para construir el medio poroso puede
enunciarse en general de la siguiente manera:
1) En base al nmero de elementos, se fijan las funciones de distribucin de tamaos de poro
(uniformes, gaussianas, log-normal, etc.), para los sitios FS(R) y para los enlaces FB(R). Por
simplicidad, los sitios se asumen como esferas de tamao RS y los enlaces como cilindros abiertos por
los extremos de tamao RB.
2) Se genera la red (cuadrada, cbica, hexagonal, etc) de tamao lineal L, asignando aleatoriamente
sobre los nodos, tamaos a los sitios y a los enlaces, de acuerdo a sus correspondientes funciones de
distribucin de tamaos y la conectividad deseada. La red as generada tendr las funciones FS(R) y
FB(R) correctas, pero no as la (RS,RB) (funcin de correlacin de tamaos); ya que, el PC (principio
de construccin de un medio poroso) no es satisfecho [4,5].
3) Se inicia (t = 0 pasos de Monte Carlo) una serie de transiciones mediante el intercambio de tamao
entre dos sitios o dos enlaces elegidos al azar hasta el cumplimiento cabal del PC en toda la red. El
intercambio es realizado (probabilidad de transicin igual a 1), si se verifica el PC, en caso contrario
(probabilidad de transicin igual a 0) el intercambio es rechazado.
4) Se realiza una serie de transiciones (batir la red) cuantas veces sea necesario, pasando por
diferentes posibles configuraciones de la red, hasta alcanzar la configuracin mas probable (equilibrio);
segn lo estipulado por Lpez [2], tomando en cuenta el tipo, dimensin y correlacin de la red (ver
figura 1).
Un paso de Monte Carlo es igual a Ln intentos de transicin (1 MCS = Ln intentos de transicin)

5) Finalmente se transforman todos los enlaces a sitios para tener una matriz consistente nicamente de
sitios.

a) = 0.0

b) =0.5

c) = 0.7

d) = 0.9

Figura 1. Topologa ms probable del medio poroso de acuerdo al grado de correlacin de tamao.
a) y b) correlacin baja, c) correlacin intermedia y d) correlacin alta.

El frmaco. El sistema matriz es representado por la red cbica descrita lneas arriba de 103+3*103
sitios. As, la tableta idealizada es un conglomerado compuesto por un principio activo (soluble en
agua) y un excipiente (material insoluble e inerte). Los sitios son ocupados azarosamente por partculas
esfricas de droga o excipiente de acuerdo a proporciones deseadas.
Algoritmo para la liberacin del frmaco. El proceso difusivo es simulado por el algoritmo del
caminante azaroso [6, 7]. De esta forma un sitio ocupado por principio activo es azarosamente elegido
y despus uno de sus sitios cercanos que lo rodean es elegido al azar tambin y si esta vaci, la droga se
mueve a este nuevo sitio en caso contrario el movimiento del principio activo es rechazado. Esta
secuencia de etapas es repetida hasta que la partcula de droga alcance un sitio expuesto a la superficie
de la tableta o medio de disolucin. De esta forma se asume que la liberacin del principio activo no
esta limitada por la solubilidad. En la figura 2 se puede observar en (a) la matriz consistente de frmaco
y excipiente originalmente construida, mientras que en (b) se ve la topologia de la matriz despus de
llevarse acabo el proceso difusivo; en esa figura se puede observar el frmaco entrampado al final de
del proceso de liberacin. Finalmente se puede decir que las simulaciones de las redes cbicas y los
procesos difusivos del principio activo fueron realizadas con un programa escrito en cdigo ANSI C++
en una PC con un procesador athlon AMD y 512 MB de RAM. El programa de simulacin fue corrido
en el compilador Borland C++ versin 5.0.

a) Matriz consistente de frmaco y

b) Frmaco y excipiente entrampados
excipiente
al final del proceso de difusin
Figura 2. Tableta slida conformada por frmaco y excipiente

Recomendaciones:
Se han dado los primeros pasos para la simulacin de la liberacin controlada de frmaco en un medio
poroso. Se recomienda ampliamente un estudio ms profundo y sistemtico del efecto que podran
causar variables como la conectividad y topologa del medio poroso; as como el tamao de las
partculas de frmaco, en el entrampamiento del mismo al final de un proceso de difusin.

Bibliografa
1) S. Cordero, F. Rojas, J. L. Ricardo; Simulation of Three-Dimensional Porous Networks;
Colloids and Surfaces A: Physicochemical and Engineering Aspects; 187-188 (2001) 425-438.
2) R. H. Lpez; Caracterizacin de Medios Porosos y Procesos Percolativos y de Transporte;
Tesis de Doctorado en Fsica, Universidad Nacional de San Luis Argentina (2004).
3) S. Cordero; Modelado de Solidos Mesoporosos y de Fenmenos de Porcin de Nitrgeno; tesis
de Doctorado en Ciencias, Universidad Autnoma Metropolitana Iztapalapa, Mxico (2002).
4) V. Mayagoitia, I. Kornhauser; Capillary Processes in Porous Networks: 2. Capillary
Condensation and Evaporation; En Principles and Applications of Pore Structural
Characterization; Haynes J. M., Rossi-Doria P., Eds.; J. W. Arrowsmith Ltd, Bristol (1985), 27-35.
5) V. Mayagoitia, I. Kornhauser; Capillary Processes in Porous Networks: 1. Models of Porous
Structures; En Principles and Applications of Pore Structural Characterization; Haynes J. M., RossiDoria P., Eds.; J. W. Arrowsmith Ltd, Bristol, Milan (1985), 15-26
6) A Bunde, S. Havlin, R. Nossal, H. E. Stanley, G. H. Weiss; On controlled diffusion-limited drug
release from a leaky matrix; Journal of Chemical Physics, 83(11), (1985) 5909 5913.
7) D. Stauffer, A. Aharony; Introduction to Percolation Theory 2nd ed. (revised). London:
Taylor and Francis. (1994).

Anexo 1
/*Programa que genera redes correlacionadas 3D:
*Distribucion Gaussiana de la forma (table curve):
y=a+b*exp(-0.5((x-c)/d)^2)
*Conectividad constante (C=6)
*Sin restricciones geometricas (version windows)
*Graba los histogramas de sitios y enlaces
*Graba redes en .bin
*Graba parametros de distribuciones gausianas .dat
*/
/*________________________Directivas__________________________*/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<string.h>
#include<conio.h>
#include<dos.h>
#include<iostream.h>
/*__________________________Grabado de Archivos____________________*/
/* Red */
char outfile_red[100]="f:/simulacionstanpore/porosimetria/redes/RA_";
/* Histograma */
char outfile_His[100]="f:/simulacionstanpore/porosimetria/histogramas/HA.dat";
/* Parametros distribucion */
char outfile_param[100]="f:/simulacionstanpore/porosimetria/parametros/PA_";
/* fotos de los sitios de la red en to y teq */
char file_out[100],str[4];
FILE *filered,*archivo,*fileparam;
/*_________________________Parametros de Red___________*/
#define L 32
#define x_size L
#define y_size L
#define z_size L
#define vol (x_size*y_size*z_size)
#define prom 1.0
/*_____________________Parametros de la Distribucin Gaussiana________*/
const float xmb=266.0;
const float xms=768.0;
const float sigma=15.0;
const float lim_inf_B=(xmb-3.0*sigma);

const float lim_sup_B=(xmb+3.0*sigma);

const float lim_inf_S=(xms-3.0*sigma);
const float lim_sup_S=(xms+3.0*sigma);
const float alturaS=1.0;
const float alturaB=1.0;
const double deltaS=lim_sup_S-lim_inf_S;
const double deltaB=lim_sup_B-lim_inf_B;
/*_____________________Numero de barras de histograma_______________*/
const int NHS=30;
const int NHB=30;
/*________________________Variables Globales____________________*/
struct elemento {float site,xb,yb,zb;} red[x_size][y_size][z_size];
long int nviolT;
double hi,mi,si,ci,hf,mf,sf,cf; /* Tiempo de Calculo */
int day,month,year;
/* Fecha
*/
double MCS, contadorMCS;;
int Xmas[x_size],Xmen[x_size],
Ymas[y_size],Ymen[y_size],
Zmas[z_size],Zmen[z_size];
int Cluster[(int)(2*x_size)][(int)(2*y_size)][(int)(2*z_size)];
int p, num;
int Histovector_B[NHB+1],HB[NHB+1];
int Histovector_S[NHS+1],HS[NHS+1];
/*______________________Rutinas Del Generador Random____________*/
const double long_max=2147483648.0;
const double dos_long_max=4294967296.0;
unsigned int condi_55(int);
int mas1_55[55],mas31_55[55];
long int randi[55];
int j_ran,j_ran2; /* las usa el generador de random*/
/*_________________________Funciones Globales___________________*/
void contorno(void);
unsigned int condi_55(int z);
void randomizar(void);
void CContorno(void);
void gen_red(void);
void violac(void);
double ran01(void);
float SortediB(void);
float SortediS(void);
int cuenta_vioS(int X,int Y,int Z);

int cuenta_vioBx(int X,int Y,int Z);

int cuenta_vioBy(int X,int Y,int Z);
int cuenta_vioBz(int X,int Y,int Z);
void batidot0(void);
void batidotEq(void);
void swap(float *X1,float *X2);
void grabarHist(void);
void Ini_Histo(void);
void Histograma(void);
void Save_Red(void);
void SaveParametersDist(int);
void foto(int tiempo);
void clockI(void);
void clockF(void);
void DoCluster(void);
/*________________________Funcion Principal______________________*/
int main(void)
{
clockI();
contorno(); randomizar(); CContorno();
printf("
Red correlacionada 3D \n ");
printf("
L= %d \n ",L);
p=1;
gen_red();
violac();
printf ("Inicio - nviol=%ld \n",nviolT);
printf ("Inired t0\n");
do
{
batidot0();
}while (nviolT!=0);
num=1;
Save_Red();
DoCluster();
foto(num);
SaveParametersDist(num);
printf ("Red lista a t0 \n");
Ini_Histo();
Histograma();
cout<<"MCS= "<<MCS<<endl;
contadorMCS=5;
num=num+1;
while(MCS<=100)
{
batidotEq();
}

violac();
Save_Red();
DoCluster();
foto(num);
SaveParametersDist(num);
clockF();
}/*Fin Main*/
void contorno(void)
{
for(j_ran2=0 ; j_ran2<55 ; j_ran2++)
{
mas1_55[j_ran2]=condi_55(j_ran2+1);
mas31_55[j_ran2]=condi_55(j_ran2+31);
}
}
unsigned int condi_55(int z)
{ int w;
if ((z>=0)*(z<55)) w=z;
if (z<0)
w=55+z;
if (z>=55)
w=z-55;
return w;
}
void randomizar(void)
{
int i_ran,j_ran2;
j_ran=0;
for(i_ran=0;i_ran<55;i_ran++)
randi[i_ran]=rand();
for(i_ran=0;i_ran<1000;i_ran++)
for(j_ran2=0;j_ran2<1000;j_ran2++)
{
j_ran=mas1_55[j_ran];
randi[j_ran]=randi[j_ran]+randi[mas31_55[j_ran]];
}
}
void CContorno(void)
{
int i;
for(i=0;i<x_size;i++){Xmas[i]=(i+1)%x_size;Xmen[i]=(i-1+x_size)%x_size;}
for(i=0;i<y_size;i++){Ymas[i]=(i+1)%y_size;Ymen[i]=(i-1+y_size)%y_size;}
for(i=0;i<z_size;i++){Zmas[i]=(i+1)%z_size;Zmen[i]=(i-1+z_size)%z_size;}
}
double ran01(void)
{
j_ran=mas1_55[j_ran];
randi[j_ran]=randi[j_ran]+randi[mas31_55[j_ran]];
return (((double)randi[j_ran]+long_max)/dos_long_max);

}
void gen_red(void)
{
register int i,j,k;
for(i=0;i<x_size;i++)
{
for(j=0;j<y_size;j++)
{
for(k=0;k<z_size;k++)
{
red[i][j][k].site=SortediS();
red[i][j][k].xb=SortediB();
red[i][j][k].yb=SortediB();
red[i][j][k].zb=SortediB();}}}
}
float SortediB()
{
register double xsorteo,ysorteo,yvalor;
register int resultado;
resultado=0;
while(resultado==0)
{
xsorteo=ran01()*deltaB+lim_inf_B;
ysorteo=ran01()*alturaB;
yvalor=alturaB*exp(-(xsorteo-xmb)*(xsorteo-xmb)/(2.0*sigma*sigma)); /* Distrib.
Gaussiana */
if (yvalor>ysorteo)
resultado=1;
}
return (xsorteo);
}
float SortediS()
{
register double xsorteo,ysorteo,yvalor;
register int resultado;
resultado=0;
while(resultado==0)
{
xsorteo=ran01()*deltaS+lim_inf_S;
ysorteo=ran01()*alturaS;
yvalor=alturaS*exp(-(xsorteo-xms)*(xsorteo-xms)/(2.0*sigma*sigma));
/*
Distribucion Gaussiana */
if (yvalor>ysorteo)
resultado=1;
}
return (xsorteo);
}
void violac(void)
{
int i,j,k;
nviolT=0;
for(i=0;i<x_size;i++)
{
for(j=0;j<y_size;j++)
{
for(k=0;k<z_size;k++)
{
if (red[i][j][k].xb>red[i][j][k].site) nviolT++;
if (red[i][j][k].yb>red[i][j][k].site) nviolT++;
if (red[i][j][k].zb>red[i][j][k].site) nviolT++;

if (red[Xmas[i]][j][k].xb>red[i][j][k].site) nviolT++;
if (red[i][Ymas[j]][k].yb>red[i][j][k].site) nviolT++;
if (red[i][j][Zmas[k]].zb>red[i][j][k].site) nviolT++;}}}
}
void batidot0(void)
{
register int i1,j1,k1,i2,j2,k2,e1t,e2t,control;
control=(int) (12*ran01());
i1=(int)(x_size*ran01());
j1=(int)(y_size*ran01());
k1=(int)(z_size*ran01());
i2=(int)(x_size*ran01());
j2=(int)(y_size*ran01());
k2=(int)(z_size*ran01());
switch(control)
{
case 0: /* site - site */
{
e1t=cuenta_vioS(i1,j1,k1)+cuenta_vioS(i2,j2,k2);
swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site); /* Cambio los sitios */
e2t=cuenta_vioS(i1,j1,k1)+cuenta_vioS(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site);/*Re-Cambio los sitios
*/
else nviolT=nviolT-(e1t-e2t);
}
break;
case 1: /* bond_x - bond_x' */
{
e1t=cuenta_vioBx(i1,j1,k1)+cuenta_vioBx(i2,j2,k2);
swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].xb); /* Cambio los bond */
e2t=cuenta_vioBx(i1,j1,k1)+cuenta_vioBx(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].xb); /*Re-Cambio los Bond*/
else nviolT=nviolT-(e1t-e2t);
}
break;
case 2: /* bond_x - bond_y' */
{
e1t=cuenta_vioBx(i1,j1,k1)+cuenta_vioBy(i2,j2,k2);
swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].yb); /* Cambio los bond */
e2t=cuenta_vioBx(i1,j1,k1)+cuenta_vioBy(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].yb);/*Re-Cambio los Bond*/
else nviolT=nviolT-(e1t-e2t);
}
break;
case 3: /* bond_x - bond_z' */
{
e1t=cuenta_vioBx(i1,j1,k1)+cuenta_vioBz(i2,j2,k2);

swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].zb); /* Cambio los bond */

e2t=cuenta_vioBx(i1,j1,k1)+cuenta_vioBz(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].zb); /*Re-Cambio los Bond
*/
else nviolT=nviolT-(e1t-e2t);
}
break;
case 4: /* bond_y - bond_x' */
{
e1t=cuenta_vioBy(i1,j1,k1)+cuenta_vioBx(i2,j2,k2);
swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].xb); /* Cambio los bond */
e2t=cuenta_vioBy(i1,j1,k1)+cuenta_vioBx(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].xb);/*Re-Cambio los Bond */
else nviolT=nviolT-(e1t-e2t);
}
break;
case 5: /* bond_y - bond_y' */
{
e1t=cuenta_vioBy(i1,j1,k1)+cuenta_vioBy(i2,j2,k2);
swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].yb); /* Cambio los bond */
e2t=cuenta_vioBy(i1,j1,k1)+cuenta_vioBy(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].yb); /*Re-Cambio los
Bond_x */
else nviolT=nviolT-(e1t-e2t);
}
break;
case 6: /* bond_y - bond_z' */
{
e1t=cuenta_vioBy(i1,j1,k1)+cuenta_vioBz(i2,j2,k2);
swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].zb); /* Cambio los bond */
e2t=cuenta_vioBy(i1,j1,k1)+cuenta_vioBz(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].zb); /*Re-Cambio */
else nviolT=nviolT-(e1t-e2t);
}
break;
case 7: /* bond_z - bond_z' */
{
e1t=cuenta_vioBz(i1,j1,k1)+cuenta_vioBz(i2,j2,k2);
swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].zb); /* Cambio los bond */
e2t=cuenta_vioBz(i1,j1,k1)+cuenta_vioBz(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].zb); /*Re-Cambio
Bond_x */
else nviolT=nviolT-(e1t-e2t);
}
break;
case 8: /* bond_z - bond_y' */
{
e1t=cuenta_vioBz(i1,j1,k1)+cuenta_vioBy(i2,j2,k2);
swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].yb); /* Cambio los bond */

los

e2t=cuenta_vioBz(i1,j1,k1)+cuenta_vioBy(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].yb);

/*Re-Cambio

los

else nviolT=nviolT-(e1t-e2t);
}
break;
case 9: /* bond_z - bond_x' */
{
e1t=cuenta_vioBz(i1,j1,k1)+cuenta_vioBx(i2,j2,k2);
swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].xb); /* Cambio los bond */
e2t=cuenta_vioBz(i1,j1,k1)+cuenta_vioBx(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].xb); /*Re-Cambio

los

Bond_x */

Bond_x */
else nviolT=nviolT-(e1t-e2t);
}
break;
case 10: /* site - site */
{
e1t=cuenta_vioS(i1,j1,k1)+cuenta_vioS(i2,j2,k2);
swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site); /* Cambio los sitios */
e2t=cuenta_vioS(i1,j1,k1)+cuenta_vioS(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site);/*Re-Cambio los sitios
*/
else nviolT=nviolT-(e1t-e2t);
}
break;
case 11: /* site - site */
{
e1t=cuenta_vioS(i1,j1,k1)+cuenta_vioS(i2,j2,k2);
swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site); /* Cambio los sitios */
e2t=cuenta_vioS(i1,j1,k1)+cuenta_vioS(i2,j2,k2);
if (e1t<e2t) swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site);/*Re-Cambio los sitios
*/
else nviolT=nviolT-(e1t-e2t);
}
break;
}
}
int cuenta_vioS(int X,int Y,int Z)
{
register int nviol;
nviol=0;
if (red[X][Y][Z].xb>red[X][Y][Z].site) nviol++;
if (red[X][Y][Z].yb>red[X][Y][Z].site) nviol++;
if (red[X][Y][Z].zb>red[X][Y][Z].site) nviol++;
if (red[Xmas[X]][Y][Z].xb>red[X][Y][Z].site) nviol++;
if (red[X][Ymas[Y]][Z].yb>red[X][Y][Z].site) nviol++;
if (red[X][Y][Zmas[Z]].zb>red[X][Y][Z].site) nviol++;
return(nviol);

}
int cuenta_vioBx(int X,int Y,int Z)
{
register int nviol;
nviol=0;
if (red[X][Y][Z].xb>red[X][Y][Z].site) nviol++;
if (red[Xmen[X]][Y][Z].site<red[X][Y][Z].xb) nviol++;
return(nviol);
}
int cuenta_vioBy(int X,int Y,int Z)
{
register int nviol;
nviol=0;
if (red[X][Y][Z].yb>red[X][Y][Z].site) nviol++;
if (red[X][Ymen[Y]][Z].site<red[X][Y][Z].yb) nviol++;
return(nviol);
}
int cuenta_vioBz(int X,int Y,int Z)
{
register int nviol;
nviol=0;
if (red[X][Y][Z].zb>red[X][Y][Z].site) nviol++;
if (red[X][Y][Zmen[Z]].site<red[X][Y][Z].zb) nviol++;
return(nviol);
}
void swap(float *X1,float *X2)
{
float aux;
aux=*X1;
*X1=*X2;
*X2=aux;
}
void batidotEq(void)
{
register int i1,j1,k1,i2,j2,k2,e1t,e2t,control;
control=(int) (12*ran01());
i1=(int)(x_size*ran01());
j1=(int)(y_size*ran01());
k1=(int)(z_size*ran01());
i2=(int)(x_size*ran01());
j2=(int)(y_size*ran01());
k2=(int)(z_size*ran01());
contadorMCS=contadorMCS+1;
if(contadorMCS==x_size*y_size*z_size)
{
MCS=MCS+1;
cout<<"MCS= "<<MCS<<endl;

contadorMCS=0;
}
switch(control)
{
case 0: /* site - site */
{
e1t=0;
swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site); /* Cambio los sitios */
e2t=cuenta_vioS(i1,j1,k1)+cuenta_vioS(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site);/*Re-Cambio los
sitios */
}
break;
case 1: /* bond_x - bond_x' */
{
e1t=0;
swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].xb); /* Cambio los bond */
e2t=cuenta_vioBx(i1,j1,k1)+cuenta_vioBx(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].xb); /*Re-Cambio los
Bond*/
}
break;
case 2: /* bond_x - bond_y' */
{
e1t=0;
swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].yb); /* Cambio los bond */
e2t=cuenta_vioBx(i1,j1,k1)+cuenta_vioBy(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].yb);/*Re-Cambio los
Bond*/
}
break;
case 3: /* bond_x - bond_z' */
{
e1t=0;
swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].zb); /* Cambio los bond */
e2t=cuenta_vioBx(i1,j1,k1)+cuenta_vioBz(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].xb,&red[i2][j2][k2].zb); /*Re-Cambio los Bond
*/
}
break;
case 4: /* bond_y - bond_x' */
{
e1t=0;
swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].xb); /* Cambio los bond */
e2t=cuenta_vioBy(i1,j1,k1)+cuenta_vioBx(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].xb);/*Re-Cambio los Bond
*/
}

break;
case 5: /* bond_y - bond_y' */
{
e1t=0;
swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].yb); /* Cambio los bond */
e2t=cuenta_vioBy(i1,j1,k1)+cuenta_vioBy(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].yb); /*Re-Cambio los
Bond_x */
}
break;
case 6: /* bond_y - bond_z' */
{
e1t=0;
swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].zb); /* Cambio los bond */
e2t=cuenta_vioBy(i1,j1,k1)+cuenta_vioBz(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].yb,&red[i2][j2][k2].zb); /*Re-Cambio */
}
break;
case 7: /* bond_z - bond_z' */
{
e1t=0;
swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].zb); /* Cambio los bond */
e2t=cuenta_vioBz(i1,j1,k1)+cuenta_vioBz(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].zb); /*Re-Cambio

los

Bond_x */
}
break;
case 8: /* bond_z - bond_y' */
{
e1t=0;
swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].yb); /* Cambio los bond */
e2t=cuenta_vioBz(i1,j1,k1)+cuenta_vioBy(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].yb); /*Re-Cambio los
Bond_x */
}
break;
case 9: /* bond_z - bond_x' */
{
e1t=0;
swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].xb); /* Cambio los bond */
e2t=cuenta_vioBz(i1,j1,k1)+cuenta_vioBx(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].zb,&red[i2][j2][k2].xb); /*Re-Cambio los
Bond_x */
}
break;
case 10: /* site - site */
{
e1t=0;
swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site); /* Cambio los sitios */

e2t=cuenta_vioS(i1,j1,k1)+cuenta_vioS(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site);/*Re-Cambio

los

sitios */
}
break;
case 11: /* site - site */
{
e1t=0;
swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site); /* Cambio los sitios */
e2t=cuenta_vioS(i1,j1,k1)+cuenta_vioS(i2,j2,k2);
if (e2t!=e1t) swap(&red[i1][j1][k1].site,&red[i2][j2][k2].site);/*Re-Cambio
sitios */
}
break;
}
}
void Ini_Histo(void)
{
int u,v;
for(u=0;u<(NHB+1);u++) {Histovector_B[u]=0;}
for(v=0;v<(NHS+1);v++) {Histovector_S[v]=0;}
}
void Histograma(void)
{
int i,j,k;
for(i=0;i<x_size;i++){
for(j=0;j<y_size;j++){
for(k=0;k<z_size;k++){
Histovector_S[(int)((NHS*(red[i][j][k].site-lim_inf_S))/deltaS)+1]+=1;
Histovector_B[(int)(((float)NHB*(red[i][j][k].xblim_inf_B))/(float)deltaB)+1]+=1;
Histovector_B[(int)(((float)NHB*(red[i][j][k].yblim_inf_B))/(float)deltaB)+1]+=1;
Histovector_B[(int)(((float)NHB*(red[i][j][k].zb-lim_inf_B))/(float)deltaB)+1]+=1;
}}}
}
void grabarHist(void)
{
int ii;
if((archivo=fopen(outfile_His,"wt"))==NULL)
{printf("Error al abrir el archivo\n");
exit(0);
}
fprintf(archivo,"DATOS del HISTOGRAMA para SITIOS\n");
fprintf(archivo,"Radio<= ; Ctdad de sitios\n");
for(ii=0;ii<(NHS+1);ii++){
fprintf(archivo,"%f
%f\n",((ii*deltaS)/NHS)+lim_inf_S,(float)(Histovector_S[ii]/((float)p*vol)));
}

los

fprintf(archivo,"Radio<= ; Ctdad de enlaces\n");

for(ii=0;ii<(NHB+1);ii++){
fprintf(archivo,"%f
%f\n",((ii*deltaB)/NHB)+lim_inf_B,(float)(Histovector_B[ii]/((float)p*3.0*vol)));
}
fprintf(archivo,"%d \n",p);
fclose(archivo);
}
void Save_Red(void)
{
gcvt(num,3,str); /* Transformo el nro. de red a alfanumerico */
char *tipo=".bin";
strcpy(file_out,outfile_red);
strcat(file_out,str);
strcat(file_out,tipo);
if ((filered =fopen (file_out,"wb"))== NULL ){
printf("Error al guardar la red ...\n");
getch();
exit(0);
}
fwrite(&red,sizeof(elemento),vol,filered);
printf("Archivo %s Guardado \n ",file_out);
fclose(filered);
}
void SaveParametersDist(int num)
{
gcvt(num,3,str); /* Transformo el nro. de red a alfanumerico */
char *tipo=".dat";
strcpy(file_out,outfile_param);
strcat(file_out,str);
strcat(file_out,tipo);
struct datos{float b1, rmb, b2, s1, rms, s2,desviacion;} paramdist;
paramdist.b1= lim_inf_B;
paramdist.rmb= xmb;
paramdist.b2= lim_sup_B;
paramdist.s1= lim_inf_S;
paramdist.rms= xms;
paramdist.s2= lim_sup_S;
paramdist.desviacion=sigma;
if ((fileparam =fopen (file_out,"wb"))== NULL ){
printf("Error al guardar los parametros ...\n");
getch();
exit(0);
}
fwrite(&paramdist,sizeof(datos),1,fileparam);
fclose(fileparam);
}
void DoCluster(void)
{
for(int i=0;i<x_size;i++)

{ for(int j=0;j<y_size;j++)
{
for(int k=0;k<y_size;k++)
{
Cluster[2*i+1][2*j+1][2*k+1]=red[i][j][k].site;
Cluster[2*i][2*j+1][2*k+1]=red[i][j][k].xb;
Cluster[2*i+1][2*j][2*k+1]=red[i][j][k].yb;
Cluster[2*i+1][2*j+1][2*k]=red[i][j][k].zb;
}} }
}
void foto(int tiempo)
{
gcvt(tiempo,3,str); /* Transformo el Rc a alfanumerico
char *tipo=".xyz";
strcpy(file_out,outfile_foto);
strcat(file_out,str);
strcat(file_out,tipo);
if ((filered =fopen (file_out,"wt"))== NULL ){
printf("Error al guardar la foto ...\n");
getch();
exit(0);
}
fprintf(filered,"%d \n\n",(4*L*L*L));
for(int i=0;i<x_size;i++)
{
for(int j=0;j<y_size;j++)
{ for(int k=0;k<z_size;k++)
{

*/

if((Cluster[2*i+1][2*j+1][2*k+1]>=lim_inf_S)&&(Cluster[2*i+1][2*j+1][2*k+1]<lim_inf_S+delt
aS/3))
fprintf(filered,"A %d %d %d\n",2*i+1,2*j+1,2*k+1);

if((Cluster[2*i+1][2*j+1][2*k+1]>=lim_inf_S+deltaS/3)&&(Cluster[2*i+1][2*j+1][2*k+1]<lim_in
f_S+deltaS*2/3))
fprintf(filered,"B %d %d %d\n",2*i+1,2*j+1,2*k+1);

if((Cluster[2*i+1][2*j+1][2*k+1]>=lim_inf_S+deltaS*2/3)&&(Cluster[2*i+1][2*j+1][2*k+1]<=li
m_sup_S))
fprintf(filered,"C %d %d %d\n",2*i+1,2*j+1,2*k+1);
/*Xb*/
if((Cluster[2*i][2*j+1][2*k+1]>=lim_inf_B)&&(Cluster[2*i][2*j+1][2*k+1]<lim_inf_B+d
eltaB/3))
fprintf(filered,"D %d %d %d\n",2*i,2*j+1,2*k+1);

if((Cluster[2*i][2*j+1][2*k+1]>=lim_inf_B+deltaB/3)&&(Cluster[2*i][2*j+1][2*k+1]<lim_inf_B

+deltaB*2/3))
fprintf(filered,"E %d %d %d\n",2*i,2*j+1,2*k+1);

if((Cluster[2*i][2*j+1][2*k+1]>=lim_inf_B+deltaB*2/3)&&(Cluster[2*i][2*j+1][2*k+1]<=lim_su
p_B))
fprintf(filered,"F %d %d %d\n",2*i,2*j+1,2*k+1);
/*Yb*/
if((Cluster[2*i+1][2*j][2*k+1]>=lim_inf_B)&&(Cluster[2*i+1][2*j][2*k+1]<lim_inf_B+d
eltaB/3))
fprintf(filered,"D %d %d %d\n",2*i+1,2*j,2*k+1);

if((Cluster[2*i+1][2*j][2*k+1]>=lim_inf_B+deltaB/3)&&(Cluster[2*i+1][2*j][2*k+1]<lim_inf_B
+deltaB*2/3))
fprintf(filered,"E %d %d %d\n",2*i+1,2*j,2*k+1);

if((Cluster[2*i+1][2*j][2*k+1]>=lim_inf_B+deltaB*2/3)&&(Cluster[2*i+1][2*j][2*k+1]<=lim_su
p_B))
fprintf(filered,"F %d %d %d\n",2*i+1,2*j,2*k+1);
/*Zb*/
if((Cluster[2*i+1][2*j+1][2*k]>=lim_inf_B)&&(Cluster[2*i+1][2*j+1][2*k]<lim_inf_B+d
eltaB/3))
fprintf(filered,"D %d %d %d\n",2*i+1,2*j+1,2*k);

if((Cluster[2*i+1][2*j+1][2*k]>=lim_inf_B+deltaB/3)&&(Cluster[2*i+1][2*j+1][2*k]<lim_inf_B
+deltaB*2/3))
fprintf(filered,"E %d %d %d\n",2*i+1,2*j+1,2*k);

if((Cluster[2*i+1][2*j+1][2*k]>=lim_inf_B+deltaB*2/3)&&(Cluster[2*i+1][2*j+1][2*k]<=lim_su
p_B))
fprintf(filered,"F %d %d %d\n",2*i+1,2*j+1,2*k);
}
}
}
printf("Archivo %s Guardado \n ",file_out);
fclose(filered);
}
void clockI(void)
{
struct time t;gettime(&t);hi= t.ti_hour;
mi= t.ti_min; si=t.ti_sec;
struct date d;
getdate(&d);
day=d.da_day;
month=d.da_mon;
year=d.da_year;
srand(time(NULL));
printf ("Comienzo - Fecha:%d/%d/%d Hora:%g:%g:%g:%g \n\n"
,d.da_day,d.da_mon,d.da_year,hi,mi,si,ci);
printf("
Red correlacionada 2D \n ");

ci=t.ti_hund;

printf("

L= %d \n ",L);

}
void clockF(void)
{
struct time t;
gettime(&t);
hf= t.ti_hour;mf= t.ti_min;sf= t.ti_sec;cf= t.ti_hund;
struct date d;
getdate(&d);
printf ("Comienzo: Fecha:%d/%d/%d Hora:%g:%g:%g:%g \n"
,day,month,year,hi,mi,si,ci);
printf ("Fin:
Fecha:%d/%d/%d Hora:%g:%g:%g:%g \n"
,d.da_day,d.da_mon,d.da_year,hf,mf,sf,cf);
printf ("Fin \n");
}