import java.util.*;
import javax.persistence.EntityManager;
+import javax.persistence.NoResultException;
import org.ufcspa.simdecs.entities.*;
import org.ufcspa.simdecs.util.DbUtil;
import org.ufcspa.simdecs.util.NodoBean;
private boolean exameComplementarExcessivo = false;
private boolean perguntouBogus = false;
+ private Paciente paciente;
+ private SessaoUsuario sessaoUsuario;
+
private void populaEstrategia() throws Exception {
// Carrega o endereço do diagrama de influencia do banco e abre a rede no disco
exameComplementarExcessivo = false;
perguntouBogus = false;
-
- // Define a probabilidade do nodo Anamnese
- {
- if (logExecucao.getPerguntasDisponiveis() > 0) {
- ProbabilisticNode nodoAnamnese = (ProbabilisticNode) diagramaInfluencia.getNodeByName("Anamnese");
- float pcPerguntasAnamnese = logExecucao.getPerguntasRealizadas() / logExecucao.getPerguntasDisponiveis() * 100;
-System.out.println("PERCENTUAL ANAMNESE: " + pcPerguntasAnamnese);
- if (pcPerguntasAnamnese <= 20) {
- diagramaInfluencia.setNodeState(nodoAnamnese, "Insuficiente", 1, "Suficiente", 0, "Excessiva", 0);
- anamneseInsuficiente = true;
- }
- else if (pcPerguntasAnamnese > 20 && pcPerguntasAnamnese <= 80)
- diagramaInfluencia.setNodeState(nodoAnamnese, "Insuficiente", 0, "Suficiente", 1, "Excessiva", 0);
- else {
- diagramaInfluencia.setNodeState(nodoAnamnese, "Insuficiente", 0, "Suficiente", 0, "Excessiva", 1);
- anamneseExcessiva = true;
+ if (logExecucao.isConcluiuInvestigacao()) {
+ // Define a probabilidade do nodo Anamnese
+ {
+ if (logExecucao.getPerguntasDisponiveis() > 0) {
+ ProbabilisticNode nodoAnamnese = (ProbabilisticNode) diagramaInfluencia.getNodeByName("Anamnese");
+ float pcPerguntasAnamnese = logExecucao.getPerguntasRealizadas() / logExecucao.getPerguntasDisponiveis() * 100;
+ //System.out.println("PERCENTUAL ANAMNESE: " + pcPerguntasAnamnese);
+ if (pcPerguntasAnamnese <= 25) {
+ diagramaInfluencia.setNodeState(nodoAnamnese, "Insuficiente", 1, "Suficiente", 0, "Excessiva", 0);
+ anamneseInsuficiente = true;
+ }
+ else if (pcPerguntasAnamnese > 25 && pcPerguntasAnamnese <= 75)
+ diagramaInfluencia.setNodeState(nodoAnamnese, "Insuficiente", 0, "Suficiente", 1, "Excessiva", 0);
+ else {
+ diagramaInfluencia.setNodeState(nodoAnamnese, "Insuficiente", 0, "Suficiente", 0, "Excessiva", 1);
+ anamneseExcessiva = true;
+ }
}
}
- }
-
- // Define a probabilidade do nodo Exame Fisico
- {
- if (logExecucao.getExamesFisicosDisponiveis() > 0) {
- ProbabilisticNode nodoExameFisico = (ProbabilisticNode) diagramaInfluencia.getNodeByName("ExameFisico");
- float pcExameFisico = logExecucao.getExamesFisicosRealizados() / logExecucao.getExamesFisicosDisponiveis() * 100;
-System.out.println("PERCENTUAL EXAME FISICO: " + pcExameFisico);
-
- if (pcExameFisico <= 20) {
- diagramaInfluencia.setNodeState(nodoExameFisico, "Insuficiente", 1, "Suficiente", 0, "Excessiva", 0);
- exameFisicoInsuficiente = true;
- }
- else if (pcExameFisico > 20 && pcExameFisico <= 80)
- diagramaInfluencia.setNodeState(nodoExameFisico, "Insuficiente", 0, "Suficiente", 1, "Excessiva", 0);
- else {
- diagramaInfluencia.setNodeState(nodoExameFisico, "Insuficiente", 0, "Suficiente", 0, "Excessiva", 1);
- exameFisicoExcessivo = true;
+
+ // Define a probabilidade do nodo Exame Fisico
+ {
+ if (logExecucao.getExamesFisicosDisponiveis() > 0) {
+ ProbabilisticNode nodoExameFisico = (ProbabilisticNode) diagramaInfluencia.getNodeByName("ExameFisico");
+ float pcExameFisico = logExecucao.getExamesFisicosRealizados() / logExecucao.getExamesFisicosDisponiveis() * 100;
+ //System.out.println("PERCENTUAL EXAME FISICO: " + pcExameFisico);
+
+ if (pcExameFisico <= 25) {
+ diagramaInfluencia.setNodeState(nodoExameFisico, "Insuficiente", 1, "Suficiente", 0, "Excessiva", 0);
+ exameFisicoInsuficiente = true;
+ }
+ else if (pcExameFisico > 25 && pcExameFisico <= 75)
+ diagramaInfluencia.setNodeState(nodoExameFisico, "Insuficiente", 0, "Suficiente", 1, "Excessiva", 0);
+ else {
+ diagramaInfluencia.setNodeState(nodoExameFisico, "Insuficiente", 0, "Suficiente", 0, "Excessiva", 1);
+ exameFisicoExcessivo = true;
+ }
}
}
- }
-
- // Define a probabilidade do nodo Exame Complementar
- {
- if (logExecucao.getExamesComplementaresProfessor() > 0) {
- ProbabilisticNode nodoExameComplementar = (ProbabilisticNode) diagramaInfluencia.getNodeByName("ExameComplementar");
- float pcExameComplementar = logExecucao.getExamesComplementaresRealizados() / logExecucao.getExamesComplementaresProfessor() * 100;
-System.out.println("PERCENTUAL EXAME COMPLEMENTAR: " + pcExameComplementar);
-
- if (pcExameComplementar <= 20) {
- diagramaInfluencia.setNodeState(nodoExameComplementar, "Insuficiente", 1, "Suficiente", 0, "Excessiva", 0);
- exameComplementarInsuficiente = true;
- }
- else if (pcExameComplementar > 20 && pcExameComplementar <= 80)
- diagramaInfluencia.setNodeState(nodoExameComplementar, "Insuficiente", 0, "Suficiente", 1, "Excessiva", 0);
- else {
- diagramaInfluencia.setNodeState(nodoExameComplementar, "Insuficiente", 0, "Suficiente", 0, "Excessiva", 1);
- exameFisicoExcessivo = true;
+
+ // Define a probabilidade do nodo Exame Complementar
+ {
+ if (logExecucao.getExamesComplementaresProfessor() > 0) {
+ ProbabilisticNode nodoExameComplementar = (ProbabilisticNode) diagramaInfluencia.getNodeByName("ExameComplementar");
+ float pcExameComplementar = logExecucao.getExamesComplementaresRealizados() / logExecucao.getExamesComplementaresProfessor() * 100;
+ // System.out.println("PERCENTUAL EXAME COMPLEMENTAR: " + pcExameComplementar);
+
+ if (pcExameComplementar <= 25) {
+ diagramaInfluencia.setNodeState(nodoExameComplementar, "Insuficiente", 1, "Suficiente", 0, "Excessiva", 0);
+ exameComplementarInsuficiente = true;
+ }
+ else if (pcExameComplementar > 25 && pcExameComplementar <= 7)
+ diagramaInfluencia.setNodeState(nodoExameComplementar, "Insuficiente", 0, "Suficiente", 1, "Excessiva", 0);
+ else {
+ diagramaInfluencia.setNodeState(nodoExameComplementar, "Insuficiente", 0, "Suficiente", 0, "Excessiva", 1);
+ exameFisicoExcessivo = true;
+ }
}
}
- }
-
- // Define a probabilidade do nodo abriu ficha do paciente
- {
- ProbabilisticNode nodoAbriuFichaPaciente = (ProbabilisticNode) diagramaInfluencia.getNodeByName("AbriuFichaPaciente");
- if (logExecucao.isAbriuFichaPaciente())
- diagramaInfluencia.setNodeState(nodoAbriuFichaPaciente, "Sim", 1, "Nao", 0);
- else
- diagramaInfluencia.setNodeState(nodoAbriuFichaPaciente, "Sim", 0, "Nao", 1);
- }
-
- // Define a probabilidade do nodo Bogus
- {
- if (logExecucao.getPerguntasDisponiveis() > 0) {
- ProbabilisticNode nodoBogus = (ProbabilisticNode) diagramaInfluencia.getNodeByName("Bogus");
- float pcNodoBogus = logExecucao.getPerguntasBogusRealizadas() / logExecucao.getPerguntasDisponiveis() * 100;
-System.out.println("PERCENTUAL BOGUS: " + pcNodoBogus);
-
- if (pcNodoBogus <= 10)
- diagramaInfluencia.setNodeState(nodoBogus, "Presente", 0, "Ausente", 1);
- else if (pcNodoBogus > 10 && pcNodoBogus <= 30) {
- diagramaInfluencia.setNodeState(nodoBogus, "Presente", 0.4f, "Ausente", 0.6f);
- perguntouBogus = true;
- }
- else {
- diagramaInfluencia.setNodeState(nodoBogus, "Presente", 1, "Ausente", 0);
- perguntouBogus = true;
+ // Define a probabilidade do nodo abriu ficha do paciente
+ {
+ ProbabilisticNode nodoAbriuFichaPaciente = (ProbabilisticNode) diagramaInfluencia.getNodeByName("AbriuFichaPaciente");
+
+ if (logExecucao.isAbriuFichaPaciente())
+ diagramaInfluencia.setNodeState(nodoAbriuFichaPaciente, "Sim", 1, "Nao", 0);
+ else
+ diagramaInfluencia.setNodeState(nodoAbriuFichaPaciente, "Sim", 0, "Nao", 1);
+ }
+
+ // Define a probabilidade do nodo Bogus
+ {
+ if (logExecucao.getPerguntasDisponiveis() > 0) {
+ ProbabilisticNode nodoBogus = (ProbabilisticNode) diagramaInfluencia.getNodeByName("Bogus");
+ float pcNodoBogus = logExecucao.getPerguntasBogusRealizadas() / logExecucao.getPerguntasDisponiveis() * 100;
+// System.out.println("PERCENTUAL BOGUS: " + pcNodoBogus);
+
+ if (pcNodoBogus <= 10)
+ diagramaInfluencia.setNodeState(nodoBogus, "Presente", 0, "Ausente", 1);
+ else if (pcNodoBogus > 10 && pcNodoBogus <= 30) {
+ diagramaInfluencia.setNodeState(nodoBogus, "Presente", 0.4f, "Ausente", 0.6f);
+ perguntouBogus = true;
+ }
+ else {
+ diagramaInfluencia.setNodeState(nodoBogus, "Presente", 1, "Ausente", 0);
+ perguntouBogus = true;
+ }
}
}
}
- // Define a probabilidade de hesitação diagnostica
- {
- ProbabilisticNode nodoHestiacaoDiagnostico = (ProbabilisticNode) diagramaInfluencia.getNodeByName("HesitacaoDiagnostico");
-
- if (logExecucao.getDesmarcacoesDiagnostico() == 0)
- diagramaInfluencia.setNodeState(nodoHestiacaoDiagnostico, "Presente", 0, "Ausente", 1);
- else if (logExecucao.getDesmarcacoesDiagnostico() == 1)
- diagramaInfluencia.setNodeState(nodoHestiacaoDiagnostico, "Presente", 0.6f, "Ausente", 0.4f);
- else
- diagramaInfluencia.setNodeState(nodoHestiacaoDiagnostico, "Presente", 1, "Ausente", 0);
+
+ if (logExecucao.isConcluiuDiagnostico()) {
+ // Define a probabilidade de hesitação diagnostica
+ {
+ ProbabilisticNode nodoHestiacaoDiagnostico = (ProbabilisticNode) diagramaInfluencia.getNodeByName("HesitacaoDiagnostico");
+
+ if (logExecucao.getDesmarcacoesDiagnostico() == 0)
+ diagramaInfluencia.setNodeState(nodoHestiacaoDiagnostico, "Presente", 0, "Ausente", 1);
+ else if (logExecucao.getDesmarcacoesDiagnostico() == 1)
+ diagramaInfluencia.setNodeState(nodoHestiacaoDiagnostico, "Presente", 0.6f, "Ausente", 0.4f);
+ else
+ diagramaInfluencia.setNodeState(nodoHestiacaoDiagnostico, "Presente", 1, "Ausente", 0);
+ }
}
- // Define a probabilidade de hesitação na conduta
- {
- ProbabilisticNode nodoHestiacaoConduta = (ProbabilisticNode) diagramaInfluencia.getNodeByName("HesitacaoConduta");
-
- if (logExecucao.getDesmarcacoesConduta() == 0)
- diagramaInfluencia.setNodeState(nodoHestiacaoConduta, "Presente", 0, "Ausente", 1);
- else if (logExecucao.getDesmarcacoesConduta() == 1)
- diagramaInfluencia.setNodeState(nodoHestiacaoConduta, "Presente", 0.6f, "Ausente", 0.4f);
- else
- diagramaInfluencia.setNodeState(nodoHestiacaoConduta, "Presente", 1, "Ausente", 0);
+ if (logExecucao.isConcluiuConduta()) {
+ // Define a probabilidade de hesitação na conduta
+ {
+ ProbabilisticNode nodoHestiacaoConduta = (ProbabilisticNode) diagramaInfluencia.getNodeByName("HesitacaoConduta");
+
+ if (logExecucao.getDesmarcacoesConduta() == 0)
+ diagramaInfluencia.setNodeState(nodoHestiacaoConduta, "Presente", 0, "Ausente", 1);
+ else if (logExecucao.getDesmarcacoesConduta() == 1)
+ diagramaInfluencia.setNodeState(nodoHestiacaoConduta, "Presente", 0.6f, "Ausente", 0.4f);
+ else
+ diagramaInfluencia.setNodeState(nodoHestiacaoConduta, "Presente", 1, "Ausente", 0);
+ }
}
- // Define a probabilidade de hesitação na conduta
+ // Define o nodo confianca
{
ProbabilisticNode nodoConfianca = (ProbabilisticNode) diagramaInfluencia.getNodeByName("Confianca");
else if (logExecucao.getConfiancaAtual().equals(Log.CONFIANCA_ALTA))
diagramaInfluencia.setNodeState(nodoConfianca, "Baixa", 0, "Media", 0, "Alta", 1);
}
-
+/*
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("ExameComplementar"));
+ System.out.println("NODO: EXAME COMPLEMENTAR");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("ExameFisico"));
+ System.out.println("NODO: EXAME FISICO");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("Anamnese"));
+ System.out.println("NODO: ANAMNESE");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("Investigacao"));
+ System.out.println("NODO: INVESTIGACAO");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("AbriuFichaPaciente"));
+ System.out.println("NODO: ABRIU FICHA PACIENTE");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("Bogus"));
+ System.out.println("NODO: Bogus");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("ResultadoInvestigacao"));
+ System.out.println("NODO: RESULTADO INVESTIGACAO");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("Credibilidade"));
+ System.out.println("NODO: CREDIBILIDADE");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("HesitacaoDiagnostico"));
+ System.out.println("NODO: HESITACAO DIAGNOSTICO");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("HesitacaoConduta"));
+ System.out.println("NODO: HESITACAO CONDUTA");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("Confianca"));
+ System.out.println("NODO: CONFIANCA");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+
+// Debug das probabilidades do DI:
+{
+ List<ProbabilisticBean> pd = diagramaInfluencia.getProbabilidadesDescOrder((TreeVariable) diagramaInfluencia.getNodeByName("Estrategia"));
+ System.out.println("NODO: ESTRATEGIA");
+ for (ProbabilisticBean p : pd) {
+ System.out.println(p.getState() + ": " + p.getProbability());
+ }
+}
+*/
// Mostra o resultado do diagrama de influencia
- DecisionNode nodoTatica = (DecisionNode) diagramaInfluencia.getNodeByName("Tatica");
+ DecisionNode nodoTatica = (DecisionNode) diagramaInfluencia.getNodeByName("Estrategia");
List<ProbabilisticBean> probs = diagramaInfluencia.getProbabilidadesDescOrder(nodoTatica);
for (ProbabilisticBean prob : probs) {
}
}
- public UnBBayesUtil processaRedeAluno(Paciente paciente) throws Exception {
+ private String getResultadoDiagnostico() throws Exception {
+ // Nao selecionou o primeiro diagnostico
+ if (logExecucao.getPrimeiroDiagnosticoCaso() != null && !logExecucao.getDiagnostico().equals(logExecucao.getPrimeiroDiagnosticoCaso()))
+ if (logExecucao.getSegundoDiagnosticoCaso() != null && logExecucao.getDiagnostico().equals(logExecucao.getSegundoDiagnosticoCaso()))
+ return DIAGNOSTICO_INCORRETO_PLAUSIVEL;
+ else
+ return DIAGNOSTICO_INCORRETO_IMPLAUSIVEL;
- UnBBayesUtil unBUtil = new UnBBayesUtil(paciente.getRede());
+ return DIAGNOSTICO_ADEQUADO;
+ }
- List<NodoPaciente> nodosPaciente = em.createQuery("From NodoPaciente np Where np.paciente.id=:pPaciente")
- .setParameter("pPaciente", paciente.getId())
- .getResultList();
-
- for(NodoPaciente nodo : nodosPaciente) {
- ProbabilisticNode pn = (ProbabilisticNode) unBUtil.getNodeByName(nodo.getNodo().getNome());
- if (pn != null)
- unBUtil.setNodeState(pn, "Yes", 1, "Not", 0);
+ private String getResultadoConduta() throws Exception {
+
+ // Caso o diagnóstico esteja adequado verifica se a conduta foi excessiva, insuficiente ou adequada!
+ if (getResultadoDiagnostico().equals(DIAGNOSTICO_ADEQUADO)) {
+
+ // Verifica se a conduta está certa ou errada!
+ boolean diferente=false;
+ for(Nodo conduta : logExecucao.getCondutas().values()) {
+ if (!logExecucao.getCondutasIdeaisDiagnostico().contains(conduta)) {
+ diferente=true;
+ break;
+ }
+ }
+
+ // Esta errada
+ if (diferente)
+ return CONDUTA_INCORRETA_INCOERENTE;
+
+ // Esta certa, agora verifica se é excessiva ou adequada!
+ if (logExecucao.getCondutas().size() > logExecucao.getCondutasIdeaisDiagnostico().size())
+ return CONDUTA_EXCESSIVA;
+ else if (logExecucao.getCondutas().size() < logExecucao.getCondutasIdeaisDiagnostico().size())
+ return CONDUTA_INSUFICIENTE;
+ else
+ return CONDUTA_ADEQUADA;
+ }
+ // Caso o diagnóstico esteja errado
+ else {
+ // Verifica se a conduta está certa ou errada (avalia somente a primeira)
+ for(Nodo conduta : logExecucao.getCondutas().values()) {
+ if (logExecucao.getCondutasIdeaisDiagnostico().contains(conduta))
+ return CONDUTA_INCORRETA_COERENTE;
+ else
+ return CONDUTA_INCORRETA_INCOERENTE;
+ }
}
- return unBUtil;
+ return null;
+ }
+
+ private String getResultadoCustoConduta() {
+ float custoRealizado=0;
+ float custoPrevisto=0;
+
+ for(Nodo conduta : logExecucao.getCondutas().values())
+ custoRealizado+=conduta.getCusto();
+
+ for(Nodo conduta : logExecucao.getCondutasIdeaisDiagnostico())
+ custoPrevisto+=conduta.getCusto();
+ if (custoPrevisto > 0) {
+ float pcCusto = custoRealizado / custoPrevisto * 100;
+
+ if (pcCusto >= 150)
+ return CONDUTA_DISPENDIOSA;
+ }
+
+ return null;
}
- private List<NodoBean> getProbabilidades(UnBBayesUtil unBUtil, String tipoNodo) {
- Iterator<Nodo> itNodos = em.createNamedQuery("Nodo.getByTipo")
- .setParameter("pTipo", tipoNodo)
- .getResultList().iterator();
+ private String getResultadoTempoConduta() {
+ float tempoRealizado=0;
+ float tempoPrevisto=0;
- ArrayList nodos = new ArrayList<NodoBean>();
+ for(Nodo conduta : logExecucao.getCondutas().values())
+ tempoRealizado+=conduta.getTempo();
- while(itNodos.hasNext()) {
- Nodo nodo = itNodos.next();
- NodoBean nodoBean = new NodoBean(nodo, (Float) unBUtil.getProbabilidadeByState((TreeVariable) unBUtil.getNodeByName(nodo.getNome()), "Yes"));
- nodos.add(nodoBean);
- }
+ for(Nodo conduta : logExecucao.getCondutasIdeaisDiagnostico())
+ tempoPrevisto+=conduta.getTempo();
- Collections.sort(nodos, new Comparator() {
- @Override
- public int compare(Object o1, Object o2) {
- NodoBean nodo1 = (NodoBean) o1;
- NodoBean nodo2 = (NodoBean) o2;
-
- if (nodo1.getProbabilidade() > nodo2.getProbabilidade())
- return -1;
- else if (nodo1.getProbabilidade() < nodo2.getProbabilidade())
- return 1;
- else
- return 0;
- }
- });
+ if (tempoPrevisto > 0) {
+ float pcTempo = tempoRealizado / tempoPrevisto * 100;
+
+ if (pcTempo >= 150)
+ return CONDUTA_DEMORADA;
+ }
+
+ return null;
+ }
+
+ private String getResultadoCustoInvestigacao() {
+ // Verifica se a anamnese teve alto custo!
+ if (logExecucao.getExamesComplementaresCustoProfessor() > 0) {
+ float pcCusto = logExecucao.getExamesComplementaresCustoRealizado() / logExecucao.getExamesComplementaresCustoProfessor() * 100;
+ if (pcCusto > 150)
+ return INVESTIGACAO_DISPENDIOSA;
+ }
- return nodos;
+ return null;
}
+ private String getResultadoTempoInvestigacao() {
+ if (logExecucao.getExamesComplementaresTempoProfessor() > 0 || logExecucao.getExamesFisicosTempoProfessor() > 0) {
+ float pcTempo = (logExecucao.getExamesComplementaresTempoRealizado() + logExecucao.getExamesFisicosTempoRealizado()) /
+ (logExecucao.getExamesComplementaresTempoProfessor() + logExecucao.getExamesFisicosTempoProfessor()) * 100;
+
+ if (pcTempo > 150)
+ return INVESTIGACAO_DEMORADA;
+ }
+
+ return null;
+ }
- private void populaResultadoSimulacao(Paciente paciente) throws Exception {
+ private void populaResultadoSimulacao() throws Exception {
+
+ populaEstrategia();
+
resultadosSimulacao = new ArrayList<String>();
if (logExecucao.isConcluiuInvestigacao()) {
resultadosSimulacao.add(INVESTIGACAO_BOGUS);
// Verifica se a anamnese teve alto custo!
- if (logExecucao.getExamesComplementaresCustoProfessor() > 0) {
- float pcCusto = logExecucao.getExamesComplementaresCustoRealizado() / logExecucao.getExamesComplementaresCustoProfessor() * 100;
- if (pcCusto > 150)
- resultadosSimulacao.add(INVESTIGACAO_DISPENDIOSA);
- }
-
- // Verifica se a anamnese foi demorada!
- if (logExecucao.getExamesComplementaresTempoProfessor() > 0 || logExecucao.getExamesFisicosTempoProfessor() > 0) {
- float pcTempo = (logExecucao.getExamesComplementaresTempoRealizado() + logExecucao.getExamesFisicosTempoRealizado()) /
- (logExecucao.getExamesComplementaresTempoProfessor() + logExecucao.getExamesFisicosTempoProfessor()) * 100;
+ String resultadoCustoInvestigacao = getResultadoCustoInvestigacao();
+ if (resultadoCustoInvestigacao != null)
+ resultadosSimulacao.add(resultadoCustoInvestigacao);
- if (pcTempo > 150)
- resultadosSimulacao.add(INVESTIGACAO_DEMORADA);
- }
+ String resultadoTempoInvestigacao = getResultadoTempoInvestigacao();
+ if (resultadoTempoInvestigacao != null)
+ resultadosSimulacao.add(resultadoTempoInvestigacao);
}
- boolean diagnosticoCorreto = false;
-
-
// Verifica se o diagnóstico foi adequado
if (logExecucao.isConcluiuDiagnostico()) {
- UnBBayesUtil redeAluno = processaRedeAluno(paciente);
- List<NodoBean> diagnosticos = getProbabilidades(redeAluno, Nodo.DIAGNOSTICO);
- Nodo primeiroDiagnostico=null;
- Nodo segundoDiagnostico=null;
- int i=0;
- for(NodoBean nodo : diagnosticos) {
- if (i == 0)
- primeiroDiagnostico = nodo.getNodo();
- else if (i == 1)
- segundoDiagnostico = nodo.getNodo();
-
- if (++i == 2)
- break;
- }
-
-System.out.println("PRIMEIRO: " + primeiroDiagnostico);
-System.out.println("LOG: " + logExecucao.getDiagnostico());
- // Nao selecionou o primeiro diagnostico
- if (primeiroDiagnostico != null && !logExecucao.getDiagnostico().equals(primeiroDiagnostico))
- if (segundoDiagnostico != null && logExecucao.getDiagnostico().equals(segundoDiagnostico))
- resultadosSimulacao.add(DIAGNOSTICO_INCORRETO_PLAUSIVEL);
- else
- resultadosSimulacao.add(DIAGNOSTICO_INCORRETO_IMPLAUSIVEL);
-
- // Registra se o diagnóstico está correto
- if (primeiroDiagnostico.equals(logExecucao.getDiagnostico()))
- diagnosticoCorreto = true;
+ String resultadoDiagnostico = getResultadoDiagnostico();
+ resultadosSimulacao.add(resultadoDiagnostico);
}
- // Ativa condutas do diagnostico proposto
+ // Verifica as condutas
if (logExecucao.isConcluiuConduta()) {
- UnBBayesUtil unBUtil = new UnBBayesUtil(paciente.getRede());
- unBUtil.setNodeState((ProbabilisticNode)unBUtil.getNodeByName(logExecucao.getDiagnostico().getNome()), "Yes", 1, "Not", 0);
- List<NodoBean> condutas = getProbabilidades(unBUtil, Nodo.CONDUTA);
-
-
- // Se o diagnóstico for incorreto verifica o tipo da conduta
- if (!diagnosticoCorreto) {
-
- // Neste caso (diagnóstico incorreto) avalia somente a primeira conduta.
- for(NodoBean nodo : condutas) {
- if (logExecucao.getCondutas().containsValue(nodo.getNodo())) {
- resultadosSimulacao.add(CONDUTA_INCORRETA_COERENTE);
- return;
- }
- else {
- resultadosSimulacao.add(CONDUTA_INCORRETA_INCOERENTE);
- return;
- }
- }
- } else {
- // Caso o diagnostico esteja incorreto verifica se a conduta foi suficiente ou insuficiente
- int i=1;
- int condutasAdotadas=0;
- int condutasPossiveis=0;
- for(NodoBean nodo : condutas) {
- condutasPossiveis++;
-
- if (!logExecucao.getCondutas().containsValue(nodo.getNodo())) {
- if (i == 1) {
- resultadosSimulacao.add(CONDUTA_INCORRETA_INCOERENTE);
- return;
- }
- } else
- condutasAdotadas++;
-
- if (i++ == 2)
- break;
- }
-
- if (condutasAdotadas < condutasPossiveis)
- resultadosSimulacao.add(CONDUTA_INSUFICIENTE);
- else if (condutasAdotadas > condutasPossiveis)
- resultadosSimulacao.add(CONDUTA_EXCESSIVA);
- }
+ // Verifica a adequacao da conduta
+ String resultadoConduta = getResultadoConduta();
+ resultadosSimulacao.add(resultadoConduta);
- // AVALIAR O TEMPO E CUSTO DA CONDUTA
- int c=1;
- float custoTotalCondutas=0;
- int tempoTotalConudtas=0;
- for(NodoBean nodo : condutas) {
- custoTotalCondutas+=nodo.getNodo().getCusto();
- tempoTotalConudtas+=nodo.getNodo().getTempo();
- if (c++ == 2)
- break;
- }
-
- float custoRealizadoCondutas=0;
- int tempoRealizadoCondutas=0;
- for(Nodo nodoConduta : logExecucao.getCondutas().values()) {
- custoRealizadoCondutas+=nodoConduta.getCusto();
- tempoRealizadoCondutas+=nodoConduta.getTempo();
- }
-
- if (custoTotalCondutas > 0) {
- float pcCustoConduta = custoRealizadoCondutas / custoTotalCondutas * 100;
- if (pcCustoConduta >= 150)
- resultadosSimulacao.add(CONDUTA_DISPENDIOSA);
- }
-
+ // Verifica o custo
+ String resultadoCondutaCusto = getResultadoCustoConduta();
+ if (resultadoCondutaCusto != null)
+ resultadosSimulacao.add(resultadoCondutaCusto);
+
+ // Verifica o tempo
+ String resultadoCondutaTempo = getResultadoTempoConduta();
+ if (resultadoCondutaTempo != null)
+ resultadosSimulacao.add(resultadoCondutaTempo);
+ }
- if (tempoRealizadoCondutas > 0) {
- float pcTempoConduta = tempoRealizadoCondutas / tempoTotalConudtas * 100;
- if (pcTempoConduta >= 150)
- resultadosSimulacao.add(CONDUTA_DEMORADA);
+ // Após a execução da procura das falhas. Caso não haja problema da a simulação como correta
+ if (logExecucao.isConcluiuInvestigacao()) {
+ if (!resultadosSimulacao.contains(INVESTIGACAO_BOGUS) && !resultadosSimulacao.contains(INVESTIGACAO_DEMORADA) &&
+ !resultadosSimulacao.contains(INVESTIGACAO_DISPENDIOSA) && !resultadosSimulacao.contains(INVESTIGACAO_EXCESSIVA) &&
+ !resultadosSimulacao.contains(INVESTIGACAO_INSUFICIENTE) ) {
+
+ resultadosSimulacao.add(INVESTIGACAO_ADEQUADA);
}
-
}
}
+
+ public NegociacaoPedagogica(long idSessao, Paciente paciente) throws Exception {
+ em = DbUtil.getInstance().getEntityManager();
+ SessaoUsuario sessaoUsuario = em.find(SessaoUsuario.class, idSessao);
+ this.sessaoUsuario = sessaoUsuario;
+ this.paciente = paciente;
- public NegociacaoPedagogica(long idSessao, Paciente paciente) throws Exception {
- em = DbUtil.getInstance().getEntityManager();
-
// Busca o log de execução
- logExecucao = new LogExecucao(idSessao, paciente.getCaso().getId(), paciente.getRede().getId());
+ logExecucao = new LogExecucao(sessaoUsuario, paciente);
+ }
+
+ public String getIntervencao(String etapa) throws Exception {
System.out.println(logExecucao);
- populaEstrategia();
- populaResultadoSimulacao(paciente);
-
+ populaResultadoSimulacao();
+
System.out.println("ESTRATÉGIA: " + estrategia);
System.out.println("RESULTADOS:");
for(String resultado : resultadosSimulacao) {
- System.out.println(resultado);
-/*
- IntervencaoPedagogica intervencao = new IntervencaoPedagogica();
+ System.out.println(resultado + " - " + etapa);
+
+ // Registra somente resultados referentes a posicao atual do simulador
+ if (etapa.equals(Log.ETAPA_INVESTIGACAO) && !resultado.startsWith("INVESTIGACAO") && !resultado.equals(NAO_ABRIU_FICHA_PACIENTE))
+ continue;
+ // Registra somente resultados referentes a posicao atual do simulador
+ if (etapa.equals(Log.ETAPA_DIAGNOSTICO) && !resultado.startsWith("DIAGNOSTICO"))
+ continue;
+
+ // Registra somente resultados referentes a posicao atual do simulador
+ if (etapa.equals(Log.ETAPA_CONDUTA) && !resultado.startsWith("CONDUTA"))
+ continue;
+
+
+
+ try {
+ IntervencaoPedagogica testarExistencia = (IntervencaoPedagogica) em.createQuery("From IntervencaoPedagogica where sessaoUsuario.id=:pSessao and estrategia=:pEstrategia and resultado=:pResultado")
+ .setParameter("pSessao", sessaoUsuario.getId())
+ .setParameter("pEstrategia", estrategia)
+ .setParameter("pResultado", resultado)
+ .getSingleResult();
+ continue;
+ } catch(NoResultException e) { }
+
if (!em.getTransaction().isActive())
em.getTransaction().begin();
+ IntervencaoPedagogica intervencao = new IntervencaoPedagogica();
intervencao.setAplicada(false);
intervencao.setDataGeracao(new Date());
intervencao.setEstrategia(estrategia);
intervencao.setResultado(resultado);
- intervencao.setSessaoUsuario(em.find(SessaoUsuario.class, idSessao));
+ intervencao.setSessaoUsuario(sessaoUsuario);
TaticaPedagogica tatica = (TaticaPedagogica) em.createQuery("From TaticaPedagogica where resultado=:pResultado and estrategia=:pEstrategia")
.setParameter("pResultado", resultado)
intervencao.setTatica(tatica);
em.persist(intervencao);
+
em.getTransaction().commit();
+ }
+
+ // Busca as intervencoes a serem mostradas agora!
+ {
+ StringBuilder retorno = new StringBuilder();
+
+ Iterator<IntervencaoPedagogica> itIntervencoes = em.createQuery("From IntervencaoPedagogica where sessaoUsuario.id=:pSessao and aplicada=false order by dataGeracao desc")
+ .setParameter("pSessao", sessaoUsuario.getId())
+ .getResultList()
+ .iterator();
+
+ if (!itIntervencoes.hasNext())
+ return " <resposta_acao_mediador acao=\"nao\" />";
+
+ retorno.append(" <resposta_acao_mediador acao=\"sim\" mensagem=\"Atenção\" problema=\"");
-*/
+ while(itIntervencoes.hasNext()) {
+ IntervencaoPedagogica intervencao = itIntervencoes.next();
+ retorno.append(intervencao.getTatica().getMensagem());
+ retorno.append("\n\n");
+
+ if (!em.getTransaction().isActive())
+ em.getTransaction().begin();
+
+
+ intervencao.setAplicada(true);
+ em.merge(intervencao);
+
+ em.getTransaction().commit();
+
+ }
+
+ retorno.append("\" />");
+ return retorno.toString();
}
+ }
+
+ public String getMensagemFinal() throws Exception {
+ StringBuilder retorno = new StringBuilder();
+
+ retorno.append("PACIENTE: " + paciente.getNome() + "\n\n");
+
+ retorno.append("RESUMO:\n");
+
+
+ // Diagnostico
+ String resultadoDiagnostico = getResultadoDiagnostico();
+ if (resultadoDiagnostico.equals(DIAGNOSTICO_ADEQUADO))
+ retorno.append("-Você chegou ao diagnóstico previsto para esta simulação!\n");
+ else if (resultadoDiagnostico.equals(DIAGNOSTICO_INCORRETO_PLAUSIVEL))
+ retorno.append("-Você não chegou ao diagnóstico previsto para esta simulação! Porém, seu diagnóstico é plausível!\n");
+ else
+ retorno.append("-Você não chegou ao diagnóstico previsto para esta simulação! Seu diagnóstico não é plausível!\n");
+
+ // Conduta
+ String resultadoConduta = getResultadoConduta();
+ if (resultadoConduta.equals(CONDUTA_ADEQUADA))
+ retorno.append("-A conduta selecionada esta adequada ao previsto pela simulação!\n");
+ else if (resultadoConduta.equals(CONDUTA_EXCESSIVA))
+ retorno.append("-A conduta selecionada esta adequada ao previsto pela simulação, porém existem procedimentos em excesso!\n");
+ else if (resultadoConduta.equals(CONDUTA_INSUFICIENTE))
+ retorno.append("-A conduta selecionada esta adequada ao previsto pela simulação, porém a quantidade de procedimentos é insuficiente em relação ao previsto!\n");
+ else if (resultadoConduta.equals(CONDUTA_INCORRETA_COERENTE))
+ retorno.append("-A conduta selecionada esta inadequada ao previsto pela simulação, porém é coerente com o diagnóstico selecionado!\n");
+ else if (resultadoConduta.equals(CONDUTA_INCORRETA_INCOERENTE))
+ retorno.append("-A conduta selecionada esta inadequada e incoerente com o diagnóstico selecionado!\n");
+
+ String resultadoTempoConduta = getResultadoTempoConduta();
+ String resultadoTempoInvestigacao = getResultadoTempoInvestigacao();
+ if (resultadoTempoConduta != null || resultadoTempoInvestigacao != null) {
+ retorno.append("-Quanto a utilização do tempo ");
+ if (resultadoTempoInvestigacao != null && resultadoTempoConduta != null)
+ retorno.append("sua investigação e conduta foram demoradas");
+ else if (resultadoTempoInvestigacao != null)
+ retorno.append("sua investigação foi demorada");
+ else if (resultadoTempoConduta != null)
+ retorno.append("sua conduta foi demorada");
+ retorno.append("!\n");
+ }
+
+ String resultadoCustoConduta = getResultadoCustoConduta();
+ String resultadoCustoInvestigacao = getResultadoCustoInvestigacao();
+ if (resultadoCustoConduta != null || resultadoCustoInvestigacao != null) {
+ retorno.append("-Quanto a utilização de recursos ");
+ if (resultadoCustoInvestigacao != null && resultadoCustoConduta != null)
+ retorno.append("sua investigação e conduta foram dispendiosas");
+ else if (resultadoCustoInvestigacao != null)
+ retorno.append("sua investigação foi dispendiosa");
+ else if (resultadoCustoConduta != null)
+ retorno.append("sua conduta foi dispendiosa");
+ retorno.append("!\n");
+ }
+
+ // Log de execução
+ List<LogPerguntas> logPerguntas = em.createQuery("From LogPerguntas where sessaoUsuario.id=:pIdSessao and paciente.id=:pIdPaciente")
+ .setParameter("pIdSessao", sessaoUsuario.getId())
+ .setParameter("pIdPaciente", paciente.getId())
+ .getResultList();
+
+ // Mostra os sintomas esperados:
+ retorno.append("\n\nSINAIS / SINTOMAS:\nAS PERGUNTAS QUE PODERIAM FORTALECER O DIAGNÓSTICO SÃO:\n");
+ for(LogPerguntas logPergunta : logPerguntas) {
+ if (logPergunta.getTipoNodo().equals(Nodo.SINAL_SINTOMA) && logPergunta.isAtivo())
+ retorno.append(logPergunta.getPergunta() + "\n");
+ }
+
+ // Mostra os sintomas selecionados:
+ retorno.append("\n\nAS PERGUNTAS SELECIONADAS NO DECORRER DA SUA SIMULAÇÃO FORAM:\n");
+ List<Nodo> nodosInvestigacao = logExecucao.getNodosInvestigacao();
+ for(Nodo nodoInvestigacao : nodosInvestigacao) {
+ if (nodoInvestigacao.getTipo().equals(Nodo.SINAL_SINTOMA)) {
+ for(LogPerguntas logPergunta : logPerguntas) {
+ if (logPergunta.getNodo().getId() == nodoInvestigacao.getId()) {
+ retorno.append(logPergunta.getPergunta() + "\n");
+ break;
+ }
+ }
+ }
+ }
+
+ return retorno.toString();
}
}
git://200.18.67.61 / simdecs2.git / blobdiff