Desenvolvimento App Conforto Térmico

Olá amigo, seja bem-vindo.

Será que não existe uma fórmula matemática para se chegar às classificações da tabela?

Algo como uma equação que lhe retornasse um coeficiente que poderia ser associado a um grau de estresse térmico.

Minha primeira sugestão seria resolver esse problema matematicamente, mas se você me disser que a única fonte de consulta é essa tabela estática, infelizmente sua melhor alternativa é armazenar manualmente esses dados em forma de conjuntos de dados, como arrays, classes ou mesmo banco de dados.

Exemplo: 44,4 graus, umidade de 40%.

Percorremos até o indíce do eixo X (coluna) 4 (começando em 0).

Depois percorremos até o índice Y (linha) referente a 44,4 graus.

Nesse exemplo temos o valor de 94, que seria severo, se não entendi nada errado na tabela.

Daí você podería perguntar: mas a temperatura que eu tenho aqui é 44,3. Como acesso esse índice, se minha tabela contempla apenas 43,9 e 44,4?

Você pode resolver isso no PHP dessa forma. Basta você converter a lógica para a sua linguagem de preferência.

<?php
$temperatura = 44.3;

$a = 43.9;
$b = 44.4;

// abs é o módulo do número, na matemática
// a saída neste exemplo é 44.4, mas se $temperatura fosse 44, por ex, seria 43.9

echo abs( $b - $temperatura ) < abs( $a - $temperatura ) ? $b : $a;

	 

	Não entendo nada do assunto, mas encontrei isso aqui também. Será que não ajuda? [https://www.youtube.com/watch?v=L4Mkd4tMBi4](https://www.youtube.com/watch?v=L4Mkd4tMBi4)

	 

	Boa sorte :)

Boa noite amigo,

Existe sim uma fórmula matemática, peço perdão achei que tinha anexado a mesma, segue abaixo:

ITU = (0,8 x TA + (UR/100) x (TA-14,4) + 46,4).

Onde o ITU é o índice que temos tabelado, UR a umidade do ar e TA a temperatura do ambiente.

Mas a minha dificuldade está na interpretação da tabela, pois acho que os valores estão aproximados, por exemplo, em um momento, temos 90 como estresse térmico moderado (UR = 20 e TA = 46.1) mas em outro momento temos 90 como estresse térmico severo (UR = 30 e TA = 43.3).

Então a dúvida é, como posso filtrar sobre qual estresse é quando o resultado do cálculo da 90, por exemplo.

Humm sim, entendi a questão.

Tinha notado esse ponto, mas imaginei que fosse um problema na formatação da tabela, afinal de contas não via muito sentido de o índice 90, como no seu exemplo, representar simultaneamente moderado e severo.

Vou lhe propor uma solução:

1 - Observe que na tabela não há nenhum índice menor do que 72 (com ausência de estresse). Isso significa que se a formula retorna 71, você não precisa consultar a tabela.

Observe ainda que nenhum 72 se faz presente nos grupos de moderado / severo / crítico, apenas em ameno.

Note ainda que 96 é outro número que está presente somente em um grupo: dessa vez o dos severos.

Existe uma tendência de que os números estejam corretamente agrupados somente em um rótulo. Esses números você ignora. Todos os outros, vamos chamar de ambíguos.

É este segundo grupo de valores que você deve catalogar em um array.

Exemplo, novamente no PHP, que é onde me sinto confortável:

const AMBIGUOUS = [
 // Em 25 graus a 100% de UR temos um moderado:
 250 => [ 100 => Stress::MODERATE ],

 // Já na linha dos 26,1 graus temos 3 ambíguos:
 261 => [ 80 => Stress::SOFT, 90 => Stress::MODERATE, 100 => Stress::MODERATE ],

 // ...
 433 => [ 30 => Stress::SEVERE ],
 461 => [ 20 => Stress::MODERATE ],
];

	 

	No caso, Stress::SOFT, Stress::MODERATE e os demais são constantes que representam índices (0,1,2,3...).

	No PHP o que está dentro de colchetes é um array. O mesmo que **new Array()** em outras linguagens.

	No caso temos um array cujas chaves são as temperaturas em inteiros (representando as linhas na sua tabela) e valores são outros arrays (representando as colunas de umidade relativa, ainda na sua tabela).

	Lembrando que esse array será populado somente com os valores ambíguos, ou seja, que podem surgir em diferentes grupos de classificações.

	 

	Bom... agora temos apenas 2 passos:

	1 - Verificamos se o valor se encontra na tabela, e portanto deve ser recuperado no array (e não calculado).

// Primeiro passo da lógica. Busca por ambiguidade:

private function getAmbiguousStressRatingIndex() {
 $temp = $this->temp;
 $ur = $this->ur;

 if ( isset( self::AMBIGUOUS[ $temp ] ) && isset( self::AMBIGUOUS[ $temp ][ $ur ] ) )
 return self::AMBIGUOUS[ $temp ][ $ur ];// int = índice do rótulo encontrado

 return false;// boolean false = não encontrou. Podia ser Exception, mas vamos facilitar o código
}

	 

	2 - Não foi encontrado? Bom, é hora de calcular, pois esse cara não é ambíguo:

// Utilizado apenas após confirmada a ausência de ambiguidade
// ITU = (0,8 x TA + (UR/100) x (TA-14,4) + 46,4)

private function getGeneralRatingIndex() {
 $temp = $this->temp / 10;// Estávamos trabalhando com valores inteiros para a temperatura. 244 => 24.4
 $ur = $this->ur / 100;
 $ITU = .8 * $temp + $ur * ( $temp - 14.4 ) + 46.4;

 if ( $ITU < 72 ) return Stress::ABSENT;
 if ( $ITU < 79 ) return Stress::SOFT;
 if ( $ITU < 90 ) return Stress::MODERATE;
 if ( $ITU < 98 ) return Stress::SEVERE;

 return Stress::CRITICAL;
}

	 

	Por fim, temos a lógica de exibição baseada nas regras acima:

$ambiguousRatingIndex = $this->getAmbiguousStressRatingIndex();

if ( $ambiguousRatingIndex !== false )
 return sprintf( 'Classificação (por tabela de desambiguação): %s', self::RATING[ $ambiguousRatingIndex ] );

 $rating = $this->getGeneralRatingIndex();
 return sprintf( 'Classificação geral do estresse térmico por ausência de ambiguidade: %s', self::RATING[ $rating ] );
}

	 

	Reunindo e organizando tudo que foi dito:

<?php

 const ABSENT = 0; // Ausente
 const SOFT = 1; // Ameno
 const MODERATE = 2; // Moderado
 const SEVERE = 3; // Severo
 const CRITICAL = 4; // Morte/Crítico

 const RATING = [
 self::ABSENT => 'Ausência de estresse térmico',
 self::SOFT => 'Estresse térmico ameno',
 self::MODERATE => 'Estresse térmico moderado',
 self::SEVERE => 'Estresse térmico severo',
 self::CRITICAL => 'Estresse térmico crítico. Ocorrência de morte.',
 ];

 const AMBIGUOUS = [
 // Em 25 graus a 100% de UR temos um moderado:
 250 => [ 100 => Stress::MODERATE ],

 // Já na linha dos 26,1 graus temos 3 ambíguos:
 261 => [ 80 => Stress::SOFT, 90 => Stress::MODERATE, 100 => Stress::MODERATE ],

 // ...
 433 => [ 30 => Stress::SEVERE ],
 461 => [ 20 => Stress::MODERATE ],
 ];

 public $temp;// int
 public $ur;// int

 public function __construct( $temp, $ur ) {
 $this->temp = $temp;
 $this->ur = $ur;
 }

 public function __toString() {
 $ambiguousRatingIndex = $this->getAmbiguousStressRatingIndex();

 if ( $ambiguousRatingIndex !== false )
 return sprintf( 'Classificação (por tabela de desambiguação): %s', self::RATING[ $ambiguousRatingIndex ] );
 else {
 $rating = $this->getGeneralRatingIndex();
 return sprintf( 'Classificação geral do estresse térmico por ausência de ambiguidade: %s', self::RATING[ $rating ] );
 }
 }

 // Primeiro passo da lógica. Busca por ambiguidade:
 private function getAmbiguousStressRatingIndex() {
 $temp = $this->temp;
 $ur = $this->ur;

 if ( isset( self::AMBIGUOUS[ $temp ] ) && isset( self::AMBIGUOUS[ $temp ][ $ur ] ) )
 return self::AMBIGUOUS[ $temp ][ $ur ];// int = índice do rótulo encontrado

 return false;// boolean false = não encontrou. Podia ser Exception, mas vamos facilitar o código
 }

 // Utilizado apenas após confirmada a ausência de ambiguidade
 // ITU = (0,8 x TA + (UR/100) x (TA-14,4) + 46,4)
 private function getGeneralRatingIndex() {
 $temp = $this->temp / 10;// Estávamos trabalhando com valores inteiros para a temperatura. 244 => 24.4
 $ur = $this->ur / 100;
 $ITU = .8 * $temp + $ur * ( $temp - 14.4 ) + 46.4;

 if ( $ITU < 72 ) return Stress::ABSENT;
 if ( $ITU < 79 ) return Stress::SOFT;
 if ( $ITU < 90 ) return Stress::MODERATE;
 if ( $ITU < 98 ) return Stress::SEVERE;

 return Stress::CRITICAL;
 }

}

echo (string)( new Stress( 250, 100 ) ) . "\n";// 25,0 graus / 100% UR
echo (string)( new Stress( 261, 80 ) ) . "\n";// 26,1 graus / 80% UR
echo (string)( new Stress( 261, 90 ) ) . "\n";// 26,1 graus / 90% UR
echo (string)( new Stress( 461, 20 ) ) . "\n";// 46,1 graus / 20% UR (seu exemplo)
echo (string)( new Stress( 433, 30 ) ) . "\n";// 43,3 graus / 30% UR (seu exemplo)

echo (string)( new Stress( 239, 40 ) ) . "\n";
echo (string)( new Stress( 317, 20 ) ) . "\n";
echo (string)( new Stress( 444, 80 ) ) . "\n";

	 

	Saída:

Classificação (por tabela de desambiguação): Estresse térmico moderado
Classificação (por tabela de desambiguação): Estresse térmico ameno
Classificação (por tabela de desambiguação): Estresse térmico moderado
Classificação (por tabela de desambiguação): Estresse térmico moderado
Classificação (por tabela de desambiguação): Estresse térmico severo
Classificação geral do estresse térmico por ausência de ambiguidade: Ausência de estresse térmico
Classificação geral do estresse térmico por ausência de ambiguidade: Estresse térmico ameno
Classificação geral do estresse térmico por ausência de ambiguidade: Estresse térmico crítico. Ocorrência de morte.

Agora é com você: converter o código para a sua linguagem e popular a tabela (array) dos ambíguos.

Essa é a forma mais performática que consigo imaginar no momento. Só seria interessante fazer alguns ajustes, dividir em mais classes com uma hierarquia mais inteligente, mas a ideia é essa aí.

Se quiser testar em tempo real e fazer ajustes (testei bem pouco, pode ser que você encontre algum bug se testar mais): https://3v4l.org/vt7eP

Muitíssimo obrigado amigo, deu uma clareada na minha mente. Vou seguir fazendo testes assim que converter pra java, obrigado mesmo.