Modelo Sir

De Física Computacional
Ir para: navegação, pesquisa

A primeira parte do código consiste na chamada das bibliotecas e na definição das constantes que serão utilizadas, o arquivo "mc.h" serve como suporte para gerar os números aleatórios e se encontra no projeto criado no Replit.

#include <stdio.h>
#include <math.h>
#include <time.h>
#include "mc.h"
#include <limits.h>
#include <string.h>


// ***************** CONSTANTES ************************************************************//

#define L           1000
#define L2          (L*L)   // número total de indivíduos
#define TEMPO    	100     // quantidade de passos
#define S           2		// estado dos suscetíveis
#define I           0		// estado dos infectados
#define R           1		// estado dos recuperados
#define BETA		0.1		// taxa de transmissão da doença
#define GAMA		0.3		// taxa de remoção da doença

// *****************************************************************************************//


A segunda parte do código define as funções SIR(), inicializacao(), openfiles(), plot_func(). A primeira função implementa a dinâmica do modelo SIR apresentada no fluxograma da WIKI, a segunda função inicializa os estados dos indivíduos do sistema e identifica a posição dos vizinhos de todos os sítios, a terceira função abre um arquivo pra escrever os resultados ao longo do tempo e a última função plota e salva a imagem da saída dos arquivos. Nesta parte do código também definimos as variáveis globais, onde s[] e viz[][], respectivamente, armazenam os estados dos indivíduos e a posição dos vizinhos. As variáveis infectado, suscetível e recuperado dão a fração dos indivíduos infectados, suscetíveis e recuperados.


// ***************** FUNÇÕES ***************************************************************//

void SIR(void);  // implementa a dinâmica SIR mostrado no fluxograma da WIKI
void inicializacao(int m); // inicializa os estados dos indivíduos do sistema e identifica a posição dos vizinhos de todos os sítios
void openfiles(int tempo); // abre um arquivo pra escrever os resultados ao longo do tempo
void plot_func(void); // plota e salva a imagem da saída dos arquivos 

// ****************************************************************************************//


// ***************** VARIÁVEIS GLOBAIS ****************************************************//

int s[L2],viz[L2][5];  // s[L2] armazena os estados dos indivíduos // viz[L2][5] armazena a posição dos vizinhos
float infectado, suscetivel, recuperado; // fração de indivíduos infectados, suscetíveis e recuperados

// ****************************************************************************************//

A estrutura principal do código é dada pelo laço temporal onde a cada tempo é chamado o modelo SIR, antes de entrar no loop é realizada a inicialização do sistema definindo o estado SIR. A medida que o tempo avança é escrito os dados dos estados da fração da população em um arquivo texto, posteriormente após o loop é gerado um gráfico.

// ***************** MAIN *****************************************************************//

int main (void){

	unsigned t;
  	seed = start_randomic();
	
    inicializacao(0);
    openfiles(0);
    
    for (t=0;t<TEMPO;t++){
    	
    	// ----- Cálculo dos estados dos indíviduos no instante de tempo t ------
    	SIR();

    	// ----- Armazenamento em um arquivo texto da fração dos estados dos indivíduos no tempo t ------
    	openfiles(j+1);	
    }


    // ----- Plot dos dados ------
    plot_func();

  	return 1;
}

// ****************************************************************************************//
// ****************** DEFINICAO DE FUNCOES ************************************************//



// PLOTA A FRAÇÃO DOS INDIVÍDUOS S. I. R. // OS PRINTF COMENTADOS PLOTAM A  FUNÇÃO i(s)  
void plot_func(void){

	printf("plot \"output.txt\" u 1:2 w l title \"suscetivel s(t)\", \"output.txt\" u 1:3 w l title \"infectados i(t)\", \"output.txt\" u 1:4 w l title \"recuperados r(t)\"\n");
	//printf("plot \"output.txt\" u 2:3 w l title \"i(s) numérico\" \n");
	printf("set title \"Modelo SIR - β = 0.1 - γ = 0.3 - R0 = 0.333*s0\" \n");
	//printf("f(x) = 0.25*log(x) -x +1 \n");
	//printf("replot f(x) title \" i(s) analítico\"\n");
	printf("set xlabel \"Tempo\" \n");
	printf("set ylabel \"Fração da População N\" \n");
	printf("set yrange [-0.3:1.1] \n");
	printf("set term eps \n");
	printf("set output \"imagem.eps\"\n");
	printf("replot\n");
	printf("set terminal wxt;\n"); 
}


// INICIALIZAÇÃO DOS DADOS
void inicializacao(int m){
	
	unsigned long i,n1,n2,n3,n4;
  	int sitio;

  	//inicializando estados dos indivíduos na rede REDE
    for(i=0;i<L2;i++){
    	if(FRANDOM < 0.998) s[i]= S;
    	else s[i]= I;
    } 


    //contagem do número de estados S. I. R. na REDE
    for(i=0;i<L2;i++){

		if( s[i] == I){
			infectado += 1; 
		}

		if(s[i] == S){
			suscetivel += 1; 
		}

		if(s[i] == R){
			recuperado += 1; 
		}
	}

	//Fração do número de indivíduos S. I. R.
	suscetivel = suscetivel/L2;
	infectado = infectado/L2;
	recuperado = 0;


	//identifica a posição dos vizinhos de todos os sítios
  	for (i=0;i<L2;i++) {
    	
  		n1 = (i-L+L2)%L2;
	    n2 = (i+1)%L + (i/L)*L;
	    n3 = (i+L)%L2;
	    n4 = (i-1+L)%L + (i/L)*L;
	    //printf("%d %d %d %d %d\n",i,n1,n2,n3,n4);

    	sitio = i; 
	    viz[i][0] = i;
	    viz[i][1] = n1;
	    viz[i][2] = n2;
	    viz[i][3] = n3;
	    viz[i][4] = n4;
	    //printf("%d %d %d %d %d\n",viz[i][0],viz[i][1],viz[i][2],viz[i][3],viz[i][4]);
  	}
  
  	return;
}


//FUNÇÃO DINÂMICA SIR
void SIR(void){

	int celula,i,j,estado,chave;
	float prob;
	
	chave == 0;

	for(i=0;i<L2;i++){
		

		celula = FRANDOM*L2;   //sorteia um indivíduo na REDE
		estado = s[celula];    // determina o estado do indivíduo na REDE


		for(j=1;j<5;j++) {			//verifica se um dos vizinhos do indivíduo sorteado está infectado
      		if(s[viz[celula][j]] == I){
      			chave =1;			//condição para verificar se um indivíduo suscetível pode se tornar infectado
      		}
      	}

		if(chave == 1){				

			if(estado == S){
			
				if(FRANDOM < BETA) 	//sorteia um número --> probabilidade do indivíduo S tornar-se I 
					s[celula] = I;
			}

		chave = 0;
		}

		if(estado == I){      //sorteia um número --> probabilidade do indivíduo I tornar-se R
			if(FRANDOM < GAMA) 
				s[celula] = R;
		}
	}

	//Zera o número de indivíduos sucsetível, infectado e recuperado
	infectado = 0;
	suscetivel = 0;
	recuperado = 0;

	//contagem do número de estados S. I. R. na REDE
	for(i=0;i<L2;i++){

		if( s[i] == I){
			infectado += 1; 
		}

		if(s[i] == S){
			suscetivel += 1; 
		}

		if(s[i] == R){
			recuperado += 1; 
		}
	}

	//Fração do número de indivíduos S. I. R.
	suscetivel = suscetivel/L2;
	infectado = infectado/L2;
	recuperado = recuperado/L2;

	return;
}
  	
 /*ESCREVER NO ARQUIVO TEXTO OS DADOS OBTIDOS*/
void openfiles(int tempo){
	
	FILE *fp;

	char output[100];
    sprintf(output,"output.txt");

    fp = fopen(output,"a");
  	fprintf(fp,"%d %lf %lf %lf \n",tempo,suscetivel,infectado,recuperado);
  	fclose(fp);
}