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 place
“p3” 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.