Modelo Simplificado de Mercado Competitivo e “Workflow” dos Respectivos Processos de Negócios.

José Renato Borelli,  RA: 980 125

Prof.Gudwin, R. R.

 

 

A Tecnologia da Informação tem modificado os processos de negocio dentro e entre as empresas. Cada vez mais, processos reais são conduzidos sobe a supervisão de sistemas de informação que são dirigidos por modelos de processos.  Podemos citar como exemplo sistemas de gerenciamento de “workflow” como o “Staffware”, sistemas de planejamentos de recursos de empresas como SAP e Baan, etc. Em fim, torna-se difícil imaginar um sistema de informação sem a existência de processos. 

Este trabalho apresenta um modelo simplificado de mercado e seus respectivos processos de negócios utilizando uma arquitetura multi-agentes distribuída. Nosso principal objetivo é construir uma plataforma multi-agentes onde se possa simular e analisar processos de negócios, “work flow”, e demonstrar a utilidade e flexibilidade da ferramenta computacional SNTool nesta tarefa. SNTool eh uma ferramenta computacional de Redes de Agentes para a especificação e simulação de sistemas dinâmicos a eventos discretos, dotada de características particularmente interessantes dentro do escopo dos chamados sistemas inteligentes, tais como capacidade de aprendizagem e adaptação.

 

 

1-Introdução:

 

O modelo de processos idealizado para esta aplicação consta basicamente de duas partes distintas: o Mercado e o Sistema de Gerenciamento de Entrega dos Produtos.

            O Mercado deve apresentar as cacteristicas de um mercado competitivo, onde os consumidores (Clientes) possuem diferentes graus de desejo sobre o produto colocado a venda. Nesta primeira etapa do modelo, existe uma falha que seria o estabelecimento da  competição somente entre os Clientes, ou seja, existe apenas um Fornecedor. Numa fase mais avançada, seria interessante estabelecer competição também entre os fornecedores.

            O desejo de cada cliente pelo produto colocado a venda eh gerado a cada interação do modelo através de um gerador de números randômicos.

            Apenas um produto é colocado à venda a cada interação. O fornecedor gera este produto também através de um gerador de números randômicos e um vetor de produtos a serem sorteados.

            O Sistema de Gerenciamento de Entrega dos Produtos teve a sua implementação extremamente simplificada. Inicialmente, o sistema registra a venda da mercadoria através do Registrador, e então verifica o pagamento da mercadoria pelo Cliente comprador. Caso este não tenha sido efetuado, a mercadoria é devolvida ao mercado e o registro de venda é desfeito.

No caso do pagamento efetuado, a mercadoria segue para o processo seguinte que é o Controle de Qualidade. O nível de qualidade de cada produto foi gravado no objeto Produto no momento de sua geração através de números randômicos. O processo ClassQualidade verifica o nível mínimo de qualidade do produto. Caso este seja aceitável, o produto segue a frente, caso contrario, o produto é entregue ao processo RefQualidade com o intuito de ter o seu nível de qualidade melhorado. Assim o produto segue na linha de processos, que numa outra fase terá a sua implementação mais completa, até chegar ao centro Distribuidor, responsável por identificar o Cliente comprador e entregar o produto em sua casa.

 

 

Arquitetura:

Os principais elementos envolvidos no modelo são: Produto, Cliente, Fornecedor, Registrador, ConfPag, Classif_Qualidade e RefQualidade.

As principais características relacionadas a estes elementos estão sumarizadas na tabela a seguir:

 

 

Produto

Cliente

Fornecedor

Registrador

ConfPag

Classif_Qual

RefQalidade

CE

nomeProd

 

nCliente

nCliente

 

 

 

 

 

CD

pago

 

indexQual

 

 

ncarros

ncelulares

nmotos

nbicicletas

 

 

 

 

 

            Mercado: O local onde os produtos são apresentados aos clientes é representado por um simples “place” passivo do tipo Produto, isto é, recebe tokens do tipo Produto. Mas, a praça de mercado como um todo é composta deste place passivo, do Fornecedor que “produz” a mercadoria e a coloca a venda e pelos Clientes que irão, segundo a sua vontade, competir pelo produto.

Em um ambiente multi-agentes o processo de coordenação entre os agentes é dado por processos de cooperação e/ou competição. Nos processos de cooperação, os agentes compartilham informações e/ou resultados com a finalidade de obter um objetivo ou meta global comum. Nos processos de competição, os agentes disputam por um recurso ou por executar alguma tarefa que resulte na satisfação de seus objetivos ou metas.

No caso do Mercado, a coordenação é dada a través do processo de competição, onde cada agente compete com os agentes vizinhos por um recurso que não pode ser compartilhado, sendo este recurso o produto colocado a venda no centro desta praça de mercado.

 

 
 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


Uma vez adquirido o produto, o Cliente deve colocar um carimbo de sua identificação no produto e enviá-lo para o Sistema de Entregas.

 

 

Produto: Trata-se de uma classe com as propriedades “numeroCliente” onde é identificado o cliente comprador do produto, “nomeProd” que armazena o nome do produto,  “pago” que indica se o produto foi pago (valor 1) ou não (valor 0) – estes valores são atribuídos pelo cliente, no momento da aquisição, através de um gerador de números randômicos, e, o “indexQual” que representa o índice de qualidade do produto, sendo atribuído pelo fornecedor, no momento de sua “produção”, também através de um gerador de números randômicos.

 

Cliente: A classe cliente deve possuir uma identificação específica para cada place onde foi inicializada. Esta identificação é registrada na propriedade “numeroCliente”. Como já mencionado, os clientes devem competir de forma diferenciada, conforme seus desejos, pelas mercadorias colocadas à venda. Para simular tal comportamento, a cada interação, os clientes sorteiam qual o produto que merecerá o seu interesse:

 

String [] produto = {"celular", "bicicleta", "carro", "moto"};

Produto prod = read_in1();

int i = (int) (Math.random() * 4);

 

if((prod.read_nomeProd().getValue())== produto[i]){…

 

 

Da mesma forma, para o produto sorteado, deve-se gerar um nível de desejo ou necessidade para o mesmo:

 

setBid((int)(Math.random()));

access_in1(Action.CONSUMPTION);

 

Desta forma, todos os clientes que participam da praça de mercado terão chance de fazer suas compras e o mercado fica mais dinâmico.

 

 

Fornecedor: O fornecedor deverá sortear qual o produto deverá colocar a venda a cada interação. Cada produto terá um nível diferente de qualidade:

 

String[] produtos = {"bicicleta", "celular", "carro", "moto"};

int i = (int)(Math.random()*4);

 

Sting ficha = new Sting(produtos[i]);

Produto Prod = new Produto();

Prod.put_nomeProd(ficha);

 

 

 

//Qualidade:

int x = (int) (Math.random() * 11);

Prod.put_indexQualidade(new Int(x));

 

put_out1(Prod);

 

 

 

Registrador: O registrador representa o inicio do Sistema de Gerenciamento de Entregas. Em síntese, com base no nome do produto, registra as vendas e as devoluções, por falta de pagamento. Para tanto foram elaboradas duas funções.

F1 registra a venda antes da verificação do pagamento. Para tanto, apenas verifica o nome do produto:

 

Produto prod = get_in1();

 

if((prod.read_nomeProd().getValue())== "celular"){ read_ncelulares().inc();}

if((prod.read_nomeProd().getValue())== "carro") {read_ncarros().inc();}

if((prod.read_nomeProd().getValue())== "moto") {read_nmotos().inc();}

if((prod.read_nomeProd().getValue())== "bicicleta") {read_nbicicletas().inc();}

 

put_out1(prod);

 

 

F2 registra a devolução do produto ao mercado, realizada pelo processo “ConfPag”. Este registro é feito através do recebimento de um “token” vindo do processo “ConfPag” que indica o nome do produto devolvido:

 

Sting prodNaoPg = get_in2();  // Sting é do tipo String…

 

if((prodNaoPg.getValue())== "celular"){ read_ncelulares().dec();}

if((prodNaoPg.getValue())== "carro") {read_ncarros().dec();}

if((prodNaoPg.getValue())== "moto") {read_nmotos().dec();}

if((prodNaoPg.getValue())== "bicicleta") {read_nbicicletas().dec();}

 

obs: o Registrador vai aceitar apenas um produto de cada vez, para tanto, foi setado bid = 0.1

 

ConfPag: Este processo confere o pagamento do produto. Caso o pagamento não tenha sido efetuado, o produto é devolvido para o mercado e um token é enviado para o registrador de forma a registra a devolução.

 

Classif_Qualidade: Verifica se o produto possui a qualidade mínima para a entrega. Caso contrário, é enviado a RefQualidade de forma melhorar o seu índice de qualidade.

 

 

 

RefQualidade: Este processo representa uma intervenção externa no produto de forma a melhorar sua qualidade. Esta ação pode ocorrer com sucesso ou pode, com menor probabilidade, acabar piorando o estado do produto. Portanto, é utilizado um gerador de números randômicos de forma a sortear um novo índice de qualidade para o produto. O índice mínimo admitido pelo processo Classif_Qualidade é 4, neste processo sorteamos um novo índice de 0 a 20, portanto, com maior probabilidade de melhoramento da qualidade:

 

Produto prod = get_in1();

 

int x = (int) (Math.random() * 20);

prod.put_indexQualidade(new Int(x));

 

put_out1(prod);

 

 

Distribuidor:  Após a aprovação do produto nos processos anteriores, o Distribuidor tem a imcumbência de entregar cada produto na casa do respectivo comprador. Para tanto, é analisado o numero de identificação do cliente estampado no produto:

 

Produto prod = get_in1();

 

int x = prod.read_numeroCliente().getValue();

 

switch (x){

 

            case 111: put_out1(prod);

                      break;

            case 222: put_out2(prod);

                     break;

            case 333: put_out3(prod);

                     break;

            case 444: put_out4(prod);

                     break;

            case 555: put_out5(prod);

                     break;

            case 666: put_out6(prod);

                 break;

            case 777: put_out7(prod);

                      break;

            case 888 put_out8(prod);

                     break;

            }

 

 

 

 

A seguir, temos uma visão completa da estrutura de todo o modelo:

 

                                   

           

 

 

Distribuição

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


Obs: A inicialização dos “placesé efetuada no main() da rede de agentes. Observe que o placep3” aloja 8 clientes que são inicializados antes com as respectivas identificações:  

 

getPlace("p1").putObject(new Fornecedor());

 

Cliente C1 = new Cliente();

C1.put_numeroCliente(new Int(111));

getPlace("p3").putObject(C1);

 

Cliente C2 = new Cliente();

C2.put_numeroCliente(new Int(222));

getPlace("p3").putObject(C2);

 

Cliente C3 = new Cliente();

C3.put_numeroCliente(new Int(333));

getPlace("p3").putObject(C3);

 

Cliente C4 = new Cliente();

C4.put_numeroCliente(new Int(444));

getPlace("p3").putObject(C4);

 

Cliente C5 = new Cliente();

C5.put_numeroCliente(new Int(555));

getPlace("p3").putObject(C5);

 

Cliente C6 = new Cliente();

C6.put_numeroCliente(new Int(666));

getPlace("p3").putObject(C6);

 

Cliente C7 = new Cliente();

C7.put_numeroCliente(new Int(777));

getPlace("p3").putObject(C7);

 

Cliente C8 = new Cliente();

C8.put_numeroCliente(new Int(888));

getPlace("p3").putObject(C8);

 

 

getPlace("p12").putObject(new Registrador());

 

getPlace("p14").putObject(new ConfPag());

getPlace("p17").putObject(new Classif_Qual());

getPlace("p20").putObject(new RefQualidade());

getPlace("p21").putObject(new Distribuidor());

 

 

 

 

Conclusões:

A ferramenta SNTool se mostra bastante útil na modelagem de processos com mais de um estado e funções. Além disso, notam-se as facilidades de simulação e analise dos resultados através das interfaces que oferecem as Redes de Agentes.

 

 

 

Referencias:

1.Making Work Flow: On the Application of Petri Nets to Business Process Management
Lecture Notes in Computer Science, Vol. 2360, p. 1-??, 2002.