vkt_final.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Importação de bibliotecas  \n",
                "pandas - Análise de dataframes  \n",
                "numpy - Funções de tipos de variáveis, variável np.nan e funções estatísticas (np.percentile)  \n",
                "math - Funções matemáticas, como exponencial, logarítimica e outras  \n",
                "unidecode - Retirada de acentuação de palavras  \n",
                "get_close_matches - Comparação aproximada entre strings  "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "import pandas as pd\n",
                "import numpy as np\n",
                "import math\n",
                "from unidecode import unidecode\n",
                "from difflib import get_close_matches"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "get_vkt_preliminar  \n",
                "Função para indicar qual modelo será adotado para calcular o VKT Preliminar. Os modelos tiveram por referência CETESB (2013).\n",
                "\n",
                "Como parâmetros, são necessários uma parcela do dataframe df_denatran com as colunas ['Ano', 'Combustivel', 'Tipo'], bem como o ano de referência ao qual o VKT deverá ser calculado.\n",
                "\n",
                "CETESB. Curvas de intensidade de uso por tipo de veículo automotor da frota da cidade de São Paulo. São Paulo, SP, 2013. 67 p. (Série Relatórios). Disponível em: < https://cetesb.sp.gov.br/veicular/wpcontent/uploads/sites/6/2013/12/curvas-intensidade-uso-veiculos-automotorescidade-sao-paulo.pdf >. Acesso em: 18 jun. 2021.\n"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def get_vkt_preliminar (df, ano_base):\n",
                "    if(df['Tipo'] == 'AUTOMOVEL'):\n",
                "        if(df['Combustivel'] == 'FLEX'):\n",
                "            return vkt_flex(df['Ano'], ano_base)\n",
                "        elif(df['Combustivel'] == 'GASOLINA'):\n",
                "            return vkt_gasolina(df['Ano'], ano_base)\n",
                "        elif(df['Combustivel'] == 'ALCOOL'):\n",
                "            return vkt_alcool(df['Ano'], ano_base)\n",
                "        elif(df['Combustivel'] == 'DIESEL'):\n",
                "            return vkt_util_diesel(df['Ano'], ano_base)\n",
                "    elif(df['Tipo'] in ['UTILITARIO', 'CAMIONETA']):\n",
                "        if(df['Combustivel'] == 'GASOLINA'):\n",
                "            return vkt_util_gasolina(df['Ano'], ano_base)\n",
                "        elif(df['Combustivel'] == 'FLEX'):\n",
                "            return vkt_util_flex(df['Ano'], ano_base)\n",
                "        elif(df['Combustivel'] == 'DIESEL'):\n",
                "            return vkt_util_diesel(df['Ano'], ano_base)\n",
                "        elif(df['Combustivel'] == 'ALCOOL'):\n",
                "            return vkt_alcool(df['Ano'], ano_base)\n",
                "    elif(df['Tipo'] == 'CAMINHAO'):\n",
                "        return vkt_caminhao(df['Ano'], ano_base)\n",
                "    elif(df['Tipo'] == 'CAMINHONETE'):\n",
                "        return vkt_caminhonete(df['Ano'], ano_base)\n",
                "    elif(df['Tipo'] == 'ONIBUS'):\n",
                "        return vkt_onibus(df['Ano'], ano_base)\n",
                "    elif(df['Tipo'] == 'MICROONIBUS'):\n",
                "        return vkt_microonibus(df['Ano'], ano_base)\n",
                "    elif(df['Tipo'] == 'CAMINHAO TRATOR'):\n",
                "        return vkt_caminhao_trator(df['Ano'], ano_base)\n",
                "    elif(df['Tipo'] in ['MOTOCICLETA', 'CICLOMOTOR', 'TRICICLO', 'QUADRICICLO']):\n",
                "        return vkt_motociclo(df['Ano'], ano_base)\n",
                "    elif(df['Tipo'] == 'MOTONETA'):\n",
                "        return vkt_motoneta(df['Ano'], ano_base)\n",
                "    else:\n",
                "        return np.nan"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_gasolina  \n",
                "Modelo ajustado para a intensidade de uso dos automóveis e derivados a gasolina (quilometragem média anual segundo a idade)\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_gasolina (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if (idade > 40):\n",
                "        return 6174\n",
                "    else:\n",
                "        return (0.6716*(idade**3) - 49.566*(idade**2) + 779.66*idade + 11266)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_alcool  \n",
                "Modelo ajustado para a intensidade de uso dos automóveis e derivados a etanol (quilometragem média por ano segundo a idade)\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_alcool (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if (idade > 28):\n",
                "        return 8275\n",
                "    else:\n",
                "        return (-3.292*(idade**3) + 174.31*(idade**2) - 3083.6*idade + 31628)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_flex  \n",
                "Modelo ajustado para a intensidade de uso dos automóveis e derivados flex (quilometragem média por ano segundo a idade).\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_flex (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if(idade > 10):\n",
                "        return np.nan\n",
                "    elif(idade > 8):\n",
                "        return 15000\n",
                "    elif(idade == 1):\n",
                "        return 17220\n",
                "    else:\n",
                "        return (-24.288*(idade**3) + 426.19*(idade**2) - 2360.4*idade + 19178)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_util_gasolina  \n",
                "Modelo ajustado para a intensidade de uso dos utilitários Otto a gasolina (quilometragem média por ano segundo a idade).\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_util_gasolina (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if (idade > 36):\n",
                "        return 7862\n",
                "    else:\n",
                "        return (0.3623*(idade**3) - 13.828*(idade**2)- 255.77*idade + 18202)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_util_flex  \n",
                "Modelo ajustado para a intensidade de uso dos utilitários Otto flex (quilometragem média por ano segundo a idade).\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_util_flex (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if (idade == 1):\n",
                "        return 18220\n",
                "    elif (idade > 8):\n",
                "        return 17500\n",
                "    elif (idade > 10):\n",
                "        return np.nan\n",
                "    else:\n",
                "        return (107.39*(idade**3) - 1687.3*(idade**2) + 7200.5*idade + 12599)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_caminhao  \n",
                "Modelo ajustado para a intensidade de uso dos caminhões diesel (quilometragem média por ano segundo a idade).\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_caminhao (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if(idade > 60):\n",
                "        return np.nan\n",
                "    elif(idade > 40):\n",
                "        return 21804\n",
                "    else:\n",
                "        return (0.0774*(idade**4) - 7.3952*(idade**3) + 249.38*(idade**2) - 3664*idade + 44505)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_caminhonete  \n",
                "Modelo ajustado para a intensidade de uso das Caminhonetes diesel (quilometragem média por ano segundo a idade).\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_caminhonete (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if (idade > 10):\n",
                "        return 15950\n",
                "    else:\n",
                "        return (-10.399*(idade**3) + 86.398*(idade**2) - 1271.3*idade + 29638)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_onibus  \n",
                "Modelo ajustado para a intensidade de uso dos ônibus urbanos diesel (quilometragem média por ano segundo a idade).\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_onibus (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if (idade > 15):\n",
                "        return 64108*math.exp(-0.046*idade)\n",
                "    else:\n",
                "        return (-8.8551*(idade**3) + 263.41*(idade**2) - 4219.4*idade + 66435)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_util_diesel  \n",
                "Modelo ajustado para a intensidade de uso dos utilitários leves diesel (quilometragem média por ano segundo a idade).\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_util_diesel (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if(idade > 8):\n",
                "        return 13040\n",
                "    else:\n",
                "        return (-64.592*(idade**3) + 720.31*(idade**2) - 2280.8*idade + 19242)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_microonibus  \n",
                "Modelo ajustado para a intensidade de uso dos micro-ônibus diesel.\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado.\n",
                "\n",
                "Como não existe log(0) foi feito um ajuste para o ano 0, considerando log(0)=0 em observação ao gráfico."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_microonibus (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    #Realizado ajuste para idade == 0\n",
                "    if (idade > 15):\n",
                "        return 18680\n",
                "    elif (idade == 0):\n",
                "        return 35578\n",
                "    else:\n",
                "        return (-5661*(math.log(idade)) + 35578)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_caminhao_trator  \n",
                "Modelo ajustado para a intensidade de uso dos caminhões-trator (quilometragem média por ano segundo a idade).\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_caminhao_trator (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if(idade > 52):\n",
                "        return np.nan\n",
                "    else:\n",
                "        return (-1023.7*idade + 57247)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_motociclo  \n",
                "Modelo ajustado para a intensidade de uso de motociclos (quilometragem média segundo a idade). Para os fins deste trabalho foram considerados como motociclos os veículos de tipo Motocicleta, Ciclomotor, Triciclo e Quadriciclo.\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_motociclo (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if (idade > 17):\n",
                "        return 9050\n",
                "    else:\n",
                "        return (1.3392*(idade**3) - 60.492*(idade**2) + 442.92*idade + 12423)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "vkt_motoneta  \n",
                "Modelo ajustado para a intensidade de uso de motonetas (quilometragem média por ano segundo a idade).\n",
                "\n",
                "Como parâmetros, são necessários o ano de fabricação do veículo e o ano de referência ao qual o VKT deverá ser calculado."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_motoneta (ano_fab, ano_base):\n",
                "    idade = ano_base - ano_fab\n",
                "    if (idade > 10):\n",
                "        return (951491.4958*(idade**(-1.9209)))\n",
                "    else:\n",
                "        return (-35.147*(idade**3) + 620.87*(idade**2) - 2970.3*idade + 11431)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "get_close_model  \n",
                "Função procura, inicialmente, se há um automóvel da base DENATRAN com nome exatamente igual à base iCarros. Se não há, busca, através da função get_close_matches, o modelo cujo nome mais se aproxima. Ressalta-se que é realizado um processo de segmentação do modelo para aumentar a probabilidade de resultado, mas há resultados não muito adequados. Sugere-se aumentar o cutoff e realizar um aprofundamento na análise entre os resultados encontrados e os nomes originais.\n",
                "\n",
                "Exemplo de como o algoritimo trabalha\n",
                "Marca/Modelo 'FIAT/ARGO DRIVE 1.3'\n",
                "\n",
                "Primeiramente, separa marca do modelo\n",
                "Marca 'FIAT'\n",
                "Modelo 'ARGO DRIVE 1.3'\n",
                "\n",
                "Na sequência, subdivide o modelo em no máximo 3 utilizando o espaço como delimitador\n",
                "Modelo_A 'ARGO'\n",
                "Modelo_B 'DRIVE'\n",
                "Modelo_C '1.3'\n",
                "\n",
                "Posteriormente, compara individualmente o Modelo_A, Modelo_B e Modelo_C do df_denatran com o Modelo_A a base do iCarros."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def get_close_model (df_denatran):\n",
                "    model = df_marca_modelo5[df_denatran == df_marca_modelo5['Modelo_A']].head(1)\n",
                "\n",
                "    if(len(model) > 0):\n",
                "        return model['Modelo_A'].item()\n",
                "\n",
                "    model = get_close_matches(df_denatran, df_marca_modelo5['Modelo_A'], n=1, cutoff=0.7)\n",
                "\n",
                "    if(len(model) > 0):\n",
                "        return model[0]\n",
                "    else:\n",
                "        return np.nan"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "get_comb  \n",
                "Função compara os parâmetros de consumo que o algoritmo identificou previamente adotando-se, sempre que existir, na seguinte ordem: Consumo[]_A, Consumo[]_B ou Consumo[]_C"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def get_comb (df_denatran):\n",
                "    gasolina = np.nan\n",
                "    alcool = np.nan\n",
                "    diesel = np.nan\n",
                "\n",
                "    if((np.isnan(df_denatran['Consumo_Cidade_Gasolina_A'])) & (np.isnan(df_denatran['Consumo_Cidade_Gasolina_B'])) & (np.isnan(df_denatran['Consumo_Cidade_Gasolina_C'])) & (np.isnan(df_denatran['Consumo_Cidade_Alcool_A'])) & (np.isnan(df_denatran['Consumo_Cidade_Alcool_B'])) & (np.isnan(df_denatran['Consumo_Cidade_Alcool_C']))):\n",
                "        return [gasolina, alcool, diesel]\n",
                "\n",
                "    if((~np.isnan(df_denatran['Consumo_Cidade_Gasolina_A'])) & (df_denatran['Combustivel_Gasolina_A'] == 'Gasolina')):\n",
                "        gasolina = df_denatran['Consumo_Cidade_Gasolina_A']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Gasolina_B'])) & (df_denatran['Combustivel_Gasolina_B'] == 'Gasolina')):\n",
                "        gasolina = df_denatran['Consumo_Cidade_Gasolina_B']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Gasolina_C'])) & (df_denatran['Combustivel_Gasolina_C'] == 'Gasolina')):\n",
                "        gasolina = df_denatran['Consumo_Cidade_Gasolina_C']\n",
                "\n",
                "    if((~np.isnan(df_denatran['Consumo_Cidade_Alcool_A'])) & (df_denatran['Combustivel_Alcool_A'] == 'Alcool')):\n",
                "        alcool = df_denatran['Consumo_Cidade_Alcool_A']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Alcool_B'])) & (df_denatran['Combustivel_Alcool_B'] == 'Alcool')):\n",
                "        alcool = df_denatran['Consumo_Cidade_Alcool_B']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Alcool_C'])) & (df_denatran['Combustivel_Alcool_C'] == 'Alcool')):\n",
                "        alcool = df_denatran['Consumo_Cidade_Alcool_C']\n",
                "\n",
                "    if((~np.isnan(df_denatran['Consumo_Cidade_Gasolina_A'])) & (df_denatran['Combustivel_Gasolina_A'] == 'Alcool')):\n",
                "        alcool = df_denatran['Consumo_Cidade_Gasolina_A']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Gasolina_B'])) & (df_denatran['Combustivel_Gasolina_B'] == 'Alcool')):\n",
                "        alcool = df_denatran['Consumo_Cidade_Gasolina_B']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Gasolina_C'])) & (df_denatran['Combustivel_Gasolina_C'] == 'Alcool')):\n",
                "        alcool = df_denatran['Consumo_Cidade_Gasolina_C']\n",
                "\n",
                "    if((~np.isnan(df_denatran['Consumo_Cidade_Alcool_A'])) & (df_denatran['Combustivel_Alcool_A'] == 'Gasolina')):\n",
                "        gasolina = df_denatran['Consumo_Cidade_Alcool_A']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Alcool_B'])) & (df_denatran['Combustivel_Alcool_B'] == 'Gasolina')):\n",
                "        gasolina = df_denatran['Consumo_Cidade_Alcool_B']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Alcool_C'])) & (df_denatran['Combustivel_Alcool_C'] == 'Gasolina')):\n",
                "        gasolina = df_denatran['Consumo_Cidade_Alcool_C']\n",
                "\n",
                "    if((~np.isnan(df_denatran['Consumo_Cidade_Gasolina_A'])) & (df_denatran['Combustivel_Gasolina_A'] == 'Diesel')):\n",
                "        diesel = df_denatran['Consumo_Cidade_Gasolina_A']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Gasolina_B'])) & (df_denatran['Combustivel_Gasolina_B'] == 'Diesel')):\n",
                "        diesel = df_denatran['Consumo_Cidade_Gasolina_B']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Gasolina_C'])) & (df_denatran['Combustivel_Gasolina_C'] == 'Diesel')):\n",
                "        diesel = df_denatran['Consumo_Cidade_Gasolina_C']\n",
                "\n",
                "    if((~np.isnan(df_denatran['Consumo_Cidade_Alcool_A'])) & (df_denatran['Combustivel_Alcool_A'] == 'Diesel')):\n",
                "        diesel = df_denatran['Consumo_Cidade_Alcool_A']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Alcool_B'])) & (df_denatran['Combustivel_Alcool_B'] == 'Diesel')):\n",
                "        diesel = df_denatran['Consumo_Cidade_Alcool_B']\n",
                "    elif((~np.isnan(df_denatran['Consumo_Cidade_Alcool_C'])) & (df_denatran['Combustivel_Alcool_C'] == 'Diesel')):\n",
                "        diesel = df_denatran['Consumo_Cidade_Alcool_C']\n",
                "\n",
                "    return [gasolina, alcool, diesel]"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "get_consumo  \n",
                "Função procura, para os que não identificou previamente, seus respectivos fatores de consumo conforme base da CETESB (2019) de acordo com tipo de veículo. Caso encontre mais de um fator, realiza média simples e retorna esse valor. CETESB (2019) utiliza o termo \"autonomia\" para se referir ao aqui utilizado \"fator de consumo\".\n",
                "\n",
                "CETESB. Emissões veiculares no estado de São Paulo 2019. São Paulo, SP, 2019. 140 p. (Série Relatórios). Disponível em: < https://cetesb.sp.gov.br/veicular/wp-content/uploads/sites/6/2020/11/Relatorio-Emissoes-Veiculares-no-Estado-de-Sao-Paulo-2019.pdf >. Acesso em: 18 jun. 2021."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def get_consumo(comb, df):\n",
                "    ano = df['Ano']\n",
                "    consumo = []\n",
                "\n",
                "    if((comb not in df['Combustivel']) & (df['Combustivel'] != 'FLEX')):\n",
                "        return np.nan\n",
                "\n",
                "    elif((df['Tipo'] in ['AUTOMOVEL', 'UTILITARIO', 'CAMINHONETE', 'CAMIONETA']) & (comb in ['FLEX', 'ALCOOL', 'GASOLINA'])):\n",
                "        if(ano < 1982):\n",
                "            ano = 1982\n",
                "\n",
                "        consumo = df_base_consumo[(df_base_consumo['Tipo'] == 'AUTOMOVEL') & (df_base_consumo['Ano'] == ano) & (df_base_consumo['Combustivel'].str.contains(comb))]['Consumo']\n",
                "\n",
                "    elif((df['Tipo'] in ['AUTOMOVEL', 'UTILITARIO', 'CAMINHONETE', 'CAMIONETA']) & (comb == 'DIESEL')):\n",
                "        if(ano < 1999):\n",
                "            ano = 1999\n",
                "\n",
                "        consumo = df_base_consumo[(df_base_consumo['Tipo'] == 'CAMINHAO') & (df_base_consumo['Subtipo'] == 'SEMILEVES') & (df_base_consumo['Ano'] == ano) & (df_base_consumo['Combustivel'].str.contains(comb))]['Consumo']\n",
                "\n",
                "    elif((df['Tipo'] == 'CAMINHAO') | (df['Tipo'] == 'CAMINHAO TRATOR')):\n",
                "        if(ano < 1999):\n",
                "            ano = 1999\n",
                "\n",
                "        consumo = df_base_consumo[(df_base_consumo['Tipo'] == 'CAMINHAO') & (df_base_consumo['Ano'] == ano) & (df_base_consumo['Combustivel'].str.contains(comb))]['Consumo']\n",
                "\n",
                "    elif(df['Tipo'] == 'CICLOMOTOR'):\n",
                "        consumo = df_base_consumo[(df_base_consumo['Tipo'] == 'CICLOMOTOR') & (df_base_consumo['Ano'] == ano) & (df_base_consumo['Combustivel'].str.contains(comb))]['Consumo']        \n",
                "\n",
                "    elif(df['Tipo'] in ['MOTOCICLETA', 'MOTONETA', 'QUADRICICLO', 'TRICICLO']):\n",
                "        consumo = df_base_consumo[(df_base_consumo['Tipo'] == 'MOTOCICLETA') & (df_base_consumo['Ano'] == ano) & (df_base_consumo['Combustivel'].str.contains(comb))]['Consumo']        \n",
                "\n",
                "    elif(df['Tipo'] == 'MICROONIBUS'):\n",
                "        if(ano < 1999):\n",
                "            ano = 1999\n",
                "\n",
                "        consumo = df_base_consumo[(df_base_consumo['Subtipo'] == 'MICROONIBUS') & (df_base_consumo['Ano'] == ano) & (df_base_consumo['Combustivel'].str.contains(comb))]['Consumo']        \n",
                "\n",
                "    elif(df['Tipo'] == 'ONIBUS'):\n",
                "        if(ano < 1999):\n",
                "            ano = 1999\n",
                "            \n",
                "        consumo = df_base_consumo[(df_base_consumo['Tipo'] == 'ONIBUS') & (df_base_consumo['Subtipo'] != 'MICROONIBUS') & (df_base_consumo['Ano'] == ano) & (df_base_consumo['Combustivel'].str.contains(comb))]['Consumo']        \n",
                "\n",
                "    if (len(consumo) == 0):\n",
                "        consumo = np.nan\n",
                "    else:\n",
                "        consumo = consumo.mean()\n",
                "\n",
                "    return consumo"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "get_vkt  \n",
                "Função multiplica o VKT Preliminar pelo fator de ajuste com base na relação entre o volume de combustível teórico e o efetivamente vendido.\n",
                "\n",
                "Como parâmetro, é necessário o df_denatran com as colunas ['VKT_Preliminar', 'Combustivel', 'Fator_Alcool', 'Fator_Gasolina', 'Fator_Diesel', 'Relacao']."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def get_vkt (df):\n",
                "    if(df['Combustivel'] == 'ALCOOL'):\n",
                "        vkt = df['VKT_Preliminar']*df['Fator_Alcool']\n",
                "\n",
                "    elif(df['Combustivel'] == 'GASOLINA'):\n",
                "        vkt = df['VKT_Preliminar']*df['Fator_Gasolina']\n",
                "    \n",
                "    elif(df['Combustivel'] == 'DIESEL'):\n",
                "        vkt = df['VKT_Preliminar']*df['Fator_Diesel']\n",
                "\n",
                "    elif(df['Combustivel'] == 'FLEX'):\n",
                "        vkt = df['VKT_Preliminar']*df['Relacao']*df['Fator_Alcool'] + df['VKT_Preliminar']*(1-df['Relacao'])*df['Fator_Gasolina']\n",
                "\n",
                "    return vkt"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "get_sucat  \n",
                "Função realiza a conversão entre a frota licenciada e a frota circulante, através da aplicação das curvas de sucateamento. Destaque para a curva de sucateamento de motos, que foi adaptada através da leitura do gráfico da publicação por não estar efetivamente descrita.\n",
                "\n",
                "BRASIL. Ministério do Meio Ambiente (MMA). 1º Inventário nacional de emissões atmosféricas por veículos automotores rodoviários: relatório final. Brasília, 2011. Disponível em: <https://antigo.mma.gov.br/images/arquivo/80060/Inventario_de_Emissoes_por_Veiculos_Rodoviarios_2013.pdf>. Acesso em: 18 jun. 2021."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def get_sucat (df, ano_base):\n",
                "    idade = ano_base - df['Ano']\n",
                "\n",
                "    if((df['Tipo'] == 'AUTOMOVEL') & (df['Combustivel'] != 'DIESEL')):\n",
                "        return ((1-math.exp(-math.exp(1.798+(-0.137*idade))))*df['Quantidade'])\n",
                "    \n",
                "    elif((df['Tipo'] in ['UTILITARIO', 'CAMIONETA']) & (df['Combustivel'] != 'DIESEL')):\n",
                "        return ((1-math.exp(-math.exp(1.618+(-0.141*idade))))*df['Quantidade'])\n",
                "\n",
                "    elif((df['Tipo'] in ['AUTOMOVEL', 'UTILITARIO', 'CAMIONETA']) & (df['Combustivel'] == 'DIESEL')):\n",
                "        return (((1/(1+math.exp(0.17*(idade-15.3))))+(1/(1+math.exp(0.17*(idade+15.3)))))*df['Quantidade'])\n",
                "\n",
                "    elif((df['Tipo'] in ['CAMINHAO', 'CAMINHONETE', 'CAMINHAO TRATOR']) & (df['Combustivel'] == 'DIESEL')):\n",
                "        return (((1/(1+math.exp(0.10*(idade-17))))+(1/(1+math.exp(0.10*(idade+17)))))*df['Quantidade'])\n",
                "\n",
                "    elif((df['Tipo'] in ['ONIBUS', 'MICROONIBUS']) & (df['Combustivel'] == 'DIESEL')):\n",
                "        return (((1/(1+math.exp(0.16*(idade-19.1))))+(1/(1+math.exp(0.16*(idade+19.1)))))*df['Quantidade'])\n",
                "\n",
                "    elif(df['Tipo'] in ['MOTOCICLETA', 'CICLOMOTOR', 'TRICICLO', 'QUADRICICLO', 'MOTONETA']):\n",
                "        return (math.exp(-0.085*idade)*df['Quantidade'])\n",
                "\n",
                "    return np.nan"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "*Informações Relevantes*\n",
                "Por questões relacionadas à ausência de infraestrutura em nuvem para armazenamento e simplificação do processo, optou-se por salvar o resultado do algoritmo em um arquivo CSV. Por uma questão capacidade de armazenamento em memória RAM de informações dos computadores disponíveis, foi necessário subdividir o processo em subprocessos, salvando o dataframe a cada etapa. De qualquer maneira, a partir deste ponto inicia-se o efetivo cálculo do VKT.\n",
                "\n",
                "**Fontes das Bases de Dados**\n",
                "\n",
                "*datasets/rms_rev02.csv* - https://www.ibge.gov.br/geociencias/organizacao-do-territorio/divisao-regional/18354-regioes-metropolitanas-aglomeracoes-urbanas-e-regioes-integradas-de-desenvolvimento.html - Tratamento realizado pelos autores\n",
                "\n",
                "*datasets/base_denatran_classificacao.csv* - Arquivo desenvolvido pelos autores do artigo\n",
                "\n",
                "*datasets/{ano}/I_Frota_por_UF_Municipio_Marca_e_Modelo_Ano_Dezembro_{ano}.txt* - https://www.gov.br/infraestrutura/pt-br/assuntos/transito/conteudo-Senatran/estatisticas-frota-de-veiculos-senatran (Quantidade de Veículos por UF Município Marca e Modelo de cada ano pesquisado - Não se encontra no GitHub em razão do tamanho do arquivo)\n",
                "\n",
                "**vkt_fase1**\n",
                "\n",
                "Como parâmetros, são necessários ano de referência ao qual o VKT deverá ser calculado, bem como a versão. A versão apenas implicará no nome do arquivo final a ser gerado, já o ano terá implicações nas curvas de sucateamento e de intensidade de uso."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_fase1 (ano, versao):\n",
                "    #Dataframe de Regiões Metropolitanas (df_rms)\n",
                "    df_rms = pd.read_csv('datasets/rms_rev02.csv')\n",
                "\n",
                "    #Dataframe da base de classificação de veículos do DENATRAN (df_base_class_denatran)\n",
                "    df_base_class_denatran = pd.read_csv('datasets/base_denatran_classificacao.csv')\n",
                "\n",
                "    #Dataframe da base de veículos por UF, Município, Marca/Modelo e Ano do DENATRAN (df_denatran)\n",
                "    df_denatran = pd.read_csv('datasets/{}/I_Frota_por_UF_Municipio_Marca_e_Modelo_Ano_Dezembro_{}.txt'.format(ano, ano), sep=';')\n",
                "    print(df_denatran)\n",
                "\n",
                "    #Renomeia as colunas para retirada de acentuação, espaços e caracteres especiais\n",
                "    df_denatran.rename(columns={'Município': 'Municipio', 'Marca Modelo': 'Marca_Modelo', 'Ano Fabricação Veículo CRV': 'Ano', 'Qtd. Veículos': 'Quantidade'}, inplace = True)\n",
                "\n",
                "    #Aplicação do filtro no df_denatran para apenas os municípios que compõem as regiões metropolitanas, conforme df_rms\n",
                "    #Nota: Para as capitais que não compõem nenhuma RM, foi incluída apenas a capital no df_rms\n",
                "    df_denatran = df_denatran[df_denatran[['UF', 'Municipio']].apply(tuple, axis=1).isin(df_rms[['UF','Municipio']].apply(tuple, axis=1))]\n",
                "\n",
                "    #Realização do merge do df_denatran com o df_rms, incluindo a RM e a capital correspondente a cada linha\n",
                "    df_denatran = pd.merge(df_denatran, df_rms[['Municipio', 'UF', 'RM', 'Capital']], on=['Municipio', 'UF'], how='left')\n",
                "\n",
                "    #Tramento inicial do df_denatran\n",
                "    #Retira as linhas com a coluna df_denatran['Ano'] que não sejam numéricas (ex.: 'Não informado')\n",
                "    df_denatran = df_denatran[df_denatran['Ano'].map(lambda x: x.isnumeric())]\n",
                "    #Converte a coluna df_denatran['Ano'] para números inteiros\n",
                "    df_denatran['Ano'] = df_denatran['Ano'].astype(np.int64)\n",
                "    #Converte a coluna df_denatran['Marca_Modelo'] para string\n",
                "    df_denatran['Marca_Modelo'] = df_denatran['Marca_Modelo'].convert_dtypes()\n",
                "    df_denatran['Marca_Modelo'] = df_denatran['Marca_Modelo'].astype(str)\n",
                "\n",
                "    #Tramento inicial do df_base_class_denatran\n",
                "    #Converte a coluna df_base_class_denatran['Ano'] para números inteiros\n",
                "    df_base_class_denatran['Ano'] = df_base_class_denatran['Ano'].astype(np.int64)\n",
                "    #Converte a coluna df_base_class_denatran['Marca_Modelo'] para string\n",
                "    df_base_class_denatran['Marca_Modelo'] = df_base_class_denatran['Marca_Modelo'].convert_dtypes()\n",
                "    df_base_class_denatran['Marca_Modelo'] = df_base_class_denatran['Marca_Modelo'].astype(str)\n",
                "    #Remove df_base_class_denatran['Marca_Modelo', 'Ano'] duplicados\n",
                "    #Nota: Este dataframe já está organizado em ordem decrescente de quantidade. A função drop_duplicates mantém o primeiro registro (com maior quantidade) e elimina os demais. Pode haver erro na classificação dos veículos, mas sempre é adotado o mais provável (por ter mais veículos) no dataframe. Isso influencia nas curvas de intensidade e no fator de ajuste, em razão do tipo de combustível e o tipo de veículo\n",
                "    df_base_class_denatran = df_base_class_denatran.drop_duplicates(subset=['Marca_Modelo', 'Ano'])\n",
                "\n",
                "    #Realização do merge do df_denatran com o df_base_class_denatran, incluindo ['Tipo', 'Combustivel']\n",
                "    df_denatran = pd.merge(df_denatran, df_base_class_denatran[['Marca_Modelo', 'Ano', 'Tipo', 'Combustivel']], on=['Marca_Modelo', 'Ano'], how='left')\n",
                "    #Converte a coluna df_denatran['Tipo'] para string\n",
                "    df_denatran['Tipo'] = df_denatran['Tipo'].astype(str)\n",
                "\n",
                "    #Retira do df_denatran os veículos que não geram VKT através dos combustíveis utilizados para ajuste. Tipos ['BICICLETA', \t'BONDE', \t'CARRO DE MAO', \t'CARROCA', \t'CHARRETE', \t'CHASSI/PLATAFORMA', \t'MOTOR-CASA', \t'Não Identificado', \t'REBOQUE', \t'SEMI-REBOQUE', \t'SIDE-CAR', \t'Sem Informação', \t'TRATOR DE ESTEIRAS', \t'TRATOR DE RODAS', \t'TRATOR MISTO']\n",
                "    tipos_exc = ['BICICLETA', \t'BONDE', \t'CARRO DE MAO', \t'CARROCA', \t'CHARRETE', \t'CHASSI/PLATAFORMA', \t'MOTOR-CASA', \t'Não Identificado', \t'REBOQUE', \t'SEMI-REBOQUE', \t'SIDE-CAR', \t'Sem Informação', \t'TRATOR DE ESTEIRAS', \t'TRATOR DE RODAS', \t'TRATOR MISTO']\n",
                "    df_denatran = df_denatran[~df_denatran['Tipo'].isin(tipos_exc)]\n",
                "\n",
                "    #Reinicia o index do df_denatran\n",
                "    df_denatran.reset_index(drop=True, inplace=True)\n",
                "    #Subdivide Marca e Modelo do campo df_denatran['Marca_Modelo'] utilizando '/' como separador\n",
                "    df_denatran[['Marca','Modelo']] = df_denatran['Marca_Modelo'].str.split('/', n=1, expand=True)\n",
                "    #Retira do df_denatran os veículos que não geram VKT, ou não geram VKT relevante, através dos combustíveis utilizados para ajuste. Tipos ['SR', 'REB', 'R', 'MO', 'M.A.', 'MA', 'MR', 'M.AGRICOLA', 'SE', 'CASE', 'SRM', 'REBOQUE', 'F.PROPRIA']\n",
                "    marcas_exc = ['SR', 'REB', 'R', 'MO', 'M.A.', 'MA', 'MR', 'M.AGRICOLA', 'SE', 'CASE', 'SRM', 'REBOQUE', 'F.PROPRIA']\n",
                "    df_denatran = df_denatran[~df_denatran['Marca'].isin(marcas_exc)]\n",
                "    #Subdivide o campo df_denatran['Modelo'] em até 3 utilizando ' ' como separador\n",
                "    df_denatran[['Modelo_A','Modelo_B','Modelo_C']] = df_denatran['Modelo'].str.split(' ', n=2, expand=True)\n",
                "    #Retira do df_denatran os veículos sem Modelo_A (veículos que eventualmente só tinha a marca)\n",
                "    df_denatran = df_denatran[df_denatran['Modelo_A'].notnull()]\n",
                "\n",
                "    #Salva dataframe\n",
                "    df_denatran.to_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), index=False)\n",
                "    return"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "**vkt_fase2**\n",
                "\n",
                "Como parâmetros, são necessários ano de referência ao qual o VKT deverá ser calculado, bem como a versão. A versão apenas implicará no nome do arquivo final a ser gerado, já o ano terá implicações nas curvas de sucateamento e de intensidade de uso."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_fase2 (ano, versao):\n",
                "    #Abre o dataframe salvo na etapa anterior\n",
                "    df_denatran = pd.read_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), low_memory=False)\n",
                "\n",
                "    tipos = ['AUTOMOVEL', 'CAMINHONETE', 'CAMIONETA', 'UTILITARIO']\n",
                "\n",
                "    #Realiza filtro dos veículos de tipo ['AUTOMOVEL', 'CAMINHONETE', 'CAMIONETA', 'UTILITARIO'] para o dataframe df_denatran_modelos_[]\n",
                "    #Cria um novo dataframe df_denatran_modelos_[]\n",
                "    df_denatran_modelos_a = df_denatran[df_denatran['Tipo'].isin(tipos)]\n",
                "    #Agrupa em cada dataframe df_denatran_modelos_[] por Modelo_[] e Tipo\n",
                "    df_denatran_modelos_a = df_denatran_modelos_a.groupby(['Modelo_A', 'Tipo'])['Quantidade'].sum().sort_values(ascending=False)\n",
                "    df_denatran_modelos_b = df_denatran[df_denatran['Tipo'].isin(tipos)]\n",
                "    df_denatran_modelos_b = df_denatran_modelos_b.groupby(['Modelo_B', 'Tipo'])['Quantidade'].sum().sort_values(ascending=False)\n",
                "    df_denatran_modelos_c = df_denatran[df_denatran['Tipo'].isin(tipos)]\n",
                "    df_denatran_modelos_c = df_denatran_modelos_c.groupby(['Modelo_C', 'Tipo'])['Quantidade'].sum().sort_values(ascending=False)\n",
                "    #Filtra nos dataframes df_denatran_modelos_[] os modelos com quantidade acima do 95° Percentil\n",
                "    #Nota: O 95° percentil foi escolhido arbitrariamente para selecionar os modelos mais significativos da frota e otimizar computacionalmente o algoritimo\n",
                "    df_denatran_modelos_a = df_denatran_modelos_a[df_denatran_modelos_a > np.percentile(df_denatran_modelos_a,95)]\n",
                "    df_denatran_modelos_b = df_denatran_modelos_b[df_denatran_modelos_b > np.percentile(df_denatran_modelos_b,95)]\n",
                "    df_denatran_modelos_c = df_denatran_modelos_c[df_denatran_modelos_c > np.percentile(df_denatran_modelos_c,95)]\n",
                "\n",
                "    #Reseta index dos dataframes df_denatran_modelos_[]\n",
                "    #Nota: Depois de agrupados, as informações que foram selecionadas para agrupar ficam no index do dataframe. A função reset_index, redivide em colunas.\n",
                "    df_denatran_modelos_a = df_denatran_modelos_a.reset_index()\n",
                "    df_denatran_modelos_b = df_denatran_modelos_b.reset_index()\n",
                "    df_denatran_modelos_c = df_denatran_modelos_c.reset_index()\n",
                "\n",
                "    #Aplicação da função get_close_model em cada um dos dataframes df_denatran_modelos_[] no campo Modelo_iCarros_[]\n",
                "    df_denatran_modelos_a['Modelo_iCarros_A'] = df_denatran_modelos_a['Modelo_A'].map(lambda x: get_close_model(x))\n",
                "    df_denatran_modelos_b['Modelo_iCarros_B'] = df_denatran_modelos_b['Modelo_B'].map(lambda x: get_close_model(x))\n",
                "    df_denatran_modelos_c['Modelo_iCarros_C'] = df_denatran_modelos_c['Modelo_C'].map(lambda x: get_close_model(x))\n",
                "    \n",
                "    #Realiza merge do campo Modelo_iCarros_[] dos dataframes df_denatran_modelos_[] com o df_denatran\n",
                "    df_denatran = pd.merge(df_denatran, df_denatran_modelos_a[['Modelo_A', 'Modelo_iCarros_A']], on='Modelo_A', how='left')\n",
                "    df_denatran = pd.merge(df_denatran, df_denatran_modelos_b[['Modelo_B', 'Modelo_iCarros_B']], on='Modelo_B', how='left')\n",
                "    df_denatran = pd.merge(df_denatran, df_denatran_modelos_c[['Modelo_C', 'Modelo_iCarros_C']], on='Modelo_C', how='left')\n",
                "\n",
                "    #Salva dataframe\n",
                "    df_denatran.to_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), index=False)\n",
                "    return"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "**Fontes das Bases de Dados**\n",
                "\n",
                "*datasets/marca_modelo_lista5_priority.csv* - Dados obtidos através de webscrapping do site https://www.icarros.com.br \n",
                "\n",
                "**vkt_fase3**\n",
                "\n",
                "Como parâmetros, são necessários ano de referência ao qual o VKT deverá ser calculado, bem como a versão. A versão apenas implicará no nome do arquivo final a ser gerado, já o ano terá implicações nas curvas de sucateamento e de intensidade de uso."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_fase3 (ano, versao):\n",
                "    #Abre o dataframe salvo na etapa anterior\n",
                "    df_denatran = pd.read_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), low_memory=False)\n",
                "\n",
                "    #Carrega a base de dados do iCarros\n",
                "    df_marca_modelo5 = pd.read_csv('datasets/marca_modelo_lista5_priority.csv')\n",
                "    #Renomeia a coluna 'Modelo' para 'Modelo_A'\n",
                "    #Nota: a alteração faz-se necessárioa para se utilizar\n",
                "    df_marca_modelo5.rename(columns={'Modelo': 'Modelo_A'}, inplace = True)\n",
                "    #Transforma a coluna 'Ano' do dataframe df_marca_modelo5 em inteiro\n",
                "    df_marca_modelo5['Ano'] = df_marca_modelo5['Ano'].astype(np.int64)\n",
                "    #Transforma os parâmetros 'Consumo_Cidade_Gasolina' e 'Consumo_Cidade_Alcool' do dataframe df_marca_modelo5 em números\n",
                "    df_marca_modelo5[['Consumo_Cidade_Gasolina', 'Consumo_Cidade_Alcool']] = df_marca_modelo5[['Consumo_Cidade_Gasolina', 'Consumo_Cidade_Alcool']].apply(lambda x: pd.to_numeric(x, errors='coerce'))\n",
                "    #Retira a acentuação da coluna 'Combustivel_Gasolina' do dataframe df_marca_modelo5, que é o campo que indica precisamente qual o tipo de combustível o veículo utiliza\n",
                "    df_marca_modelo5['Combustivel_Gasolina'] = df_marca_modelo5['Combustivel_Gasolina'].apply(unidecode)\n",
                "    #Retira a acentuação da coluna 'Combustivel_Alcool' do dataframe df_marca_modelo5, que é o campo que indica precisamente qual o outro tipo de combustível o veículo utiliza\n",
                "    df_marca_modelo5['Combustivel_Alcool'] = df_marca_modelo5['Combustivel_Alcool'].apply(unidecode)\n",
                "\n",
                "    #Renomeia as colunas Modelo_iCarros_[] para Modelo_iCarros_[]_t\n",
                "    #Nota1: ao renomear, transfere-se os dados originais para a coluna auxiliar Modelo_iCarros_[]_t e, onde está vazio, é preenchido com o Modelo_[] original gerando novamente a coluna Modelo_iCarros_[]\n",
                "    #Nota2: utilizar a função fillna pode ser computacionalmente vantajosa\n",
                "    df_denatran = df_denatran.rename(columns={'Modelo_iCarros_A': 'Modelo_iCarros_A_t', 'Modelo_iCarros_B': 'Modelo_iCarros_B_t', 'Modelo_iCarros_C': 'Modelo_iCarros_C_t'})\n",
                "    df_denatran['Modelo_iCarros_A'] = df_denatran['Modelo_iCarros_A_t'].where(df_denatran['Modelo_iCarros_A_t'].isnull(), df_denatran['Modelo_A'])\n",
                "    df_denatran['Modelo_iCarros_B'] = df_denatran['Modelo_iCarros_B_t'].where(df_denatran['Modelo_iCarros_B_t'].isnull(), df_denatran['Modelo_B'])\n",
                "    df_denatran['Modelo_iCarros_C'] = df_denatran['Modelo_iCarros_C_t'].where(df_denatran['Modelo_iCarros_C_t'].isnull(), df_denatran['Modelo_C'])\n",
                "\n",
                "    #Exclui a coluna auxiliar Modelo_iCarros_[]_t\n",
                "    df_denatran = df_denatran.drop(['Modelo_iCarros_A_t','Modelo_iCarros_B_t','Modelo_iCarros_C_t'], axis=1)\n",
                "\n",
                "    #Renomeia a coluna Modelo_A por Modelo_iCarros_[] para ser utilizada como chave na junção da base de dados do iCarros (df_marca_modelo5), inserindo os dados sobre consumo\n",
                "    df_marca_modelo5 = df_marca_modelo5.rename(columns={'Modelo_A': 'Modelo_iCarros_A'})\n",
                "    df_denatran = pd.merge(df_denatran, df_marca_modelo5[['Modelo_iCarros_A', 'Ano', 'Combustivel_Gasolina', 'Combustivel_Alcool', 'Consumo_Cidade_Gasolina', 'Consumo_Cidade_Alcool']], on=['Modelo_iCarros_A', 'Ano'], how='left')\n",
                "    df_marca_modelo5 = df_marca_modelo5.rename(columns={'Modelo_iCarros_A': 'Modelo_iCarros_B'})\n",
                "    df_denatran = pd.merge(df_denatran, df_marca_modelo5[['Modelo_iCarros_B', 'Ano', 'Combustivel_Gasolina', 'Combustivel_Alcool', 'Consumo_Cidade_Gasolina', 'Consumo_Cidade_Alcool']], on=['Modelo_iCarros_B', 'Ano'], how='left', suffixes=['_A', None])\n",
                "    df_marca_modelo5 = df_marca_modelo5.rename(columns={'Modelo_iCarros_B': 'Modelo_iCarros_C'})\n",
                "    df_denatran = pd.merge(df_denatran, df_marca_modelo5[['Modelo_iCarros_C', 'Ano', 'Combustivel_Gasolina', 'Combustivel_Alcool', 'Consumo_Cidade_Gasolina', 'Consumo_Cidade_Alcool']], on=['Modelo_iCarros_C', 'Ano'], how='left', suffixes=['_B', '_C'])\n",
                "\n",
                "    #Salva dataframe\n",
                "    df_denatran.to_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), index=False)\n",
                "    return"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "**Fontes das Bases de Dados**\n",
                "\n",
                "*datasets/base_conv_comb_v1.csv* - Desenvolvido pelos autores para relacionar os tipos de combustíveis da base do DENATRAN com os tipos mais simplificados que serão utilizados no algoritmo\n",
                "\n",
                "**vkt_fase4**\n",
                "\n",
                "Como parâmetros, são necessários ano de referência ao qual o VKT deverá ser calculado, bem como a versão. A versão apenas implicará no nome do arquivo final a ser gerado, já o ano terá implicações nas curvas de sucateamento e de intensidade de uso."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_fase4 (ano, versao):\n",
                "    #Abre o dataframe salvo na etapa anterior\n",
                "    df_denatran = pd.read_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), low_memory=False)\n",
                "\n",
                "    #Abre o dataframe de conversão de nome de combustível (df_base_conv_comb)\n",
                "    #Nota: Essa base converte e padroniza os nomes dos combustíveis\n",
                "    df_base_conv_comb = pd.read_csv('datasets/base_conv_comb_v1.csv')\n",
                "    #Renomeia a coluna 'Comb_Ant' para 'Combustivel' do df_base_conv_comb\n",
                "    df_base_conv_comb.rename(columns={'Comb_Ant': 'Combustivel'}, inplace = True)\n",
                "\n",
                "    #Tratamento da coluna 'Combustivel' e 'Comb_Novo' do df_denatran e do df_base_conv_comb\n",
                "    df_denatran['Combustivel'] = df_denatran['Combustivel'].convert_dtypes()\n",
                "    df_base_conv_comb['Combustivel'] = df_base_conv_comb['Combustivel'].convert_dtypes()\n",
                "    df_base_conv_comb['Comb_Novo'] = df_base_conv_comb['Comb_Novo'].convert_dtypes()\n",
                "\n",
                "    #Junção do df_denatran com o df_base_conv_comb\n",
                "    df_denatran = pd.merge(df_denatran, df_base_conv_comb[['Combustivel', 'Comb_Novo']], on='Combustivel', how='left')\n",
                "    #Renomeia as colunas 'Combustivel' para 'Comb_Ant' e 'Comb_Novo' para 'Combustivel' do df_denatran\n",
                "    df_denatran.rename(columns={'Combustivel': 'Comb_Ant', 'Comb_Novo': 'Combustivel'}, inplace = True)\n",
                "    #Tratamento da coluna 'Combustivel' do df_denatran\n",
                "    df_denatran['Combustivel'] = df_denatran['Combustivel'].astype(str)\n",
                "\n",
                "    comb_exc = ['GNV', 'ELETRICO', 'GAS METANO', 'GASOGENIO', 'Não Identificado', 'Sem Informação', 'VIDE/CAMPO/OBSERVACAO']\n",
                "    #df_denatran_comb_exc = df_denatran[df_denatran['Combustivel'].isin(comb_exc)]\n",
                "    #Exclui os combustíveis do tipo ['GNV', 'ELETRICO', 'GAS METANO', 'GASOGENIO', 'Não Identificado', 'Sem Informação', 'VIDE/CAMPO/OBSERVACAO']\n",
                "    #Nota 1: Por questões de complexidade na coleta das informações e por ser a maioria da frota, optou-se por utilizar apenas GASOLINA, FLEX e ETANOL/ÁLCOOL como combustíveis para fins deste estudo\n",
                "    #Nota 2: Como o tipo de combustível advém do dataframe da base de classificação de veículos do DENATRAN (df_base_class_denatran), sendo este já está organizado em ordem decrescente de quantidade, pode haver erro na classificação dos veículos, mas sempre é adotado o mais provável (por ter mais veículos) no dataframe. Nesse sentido, pelos veículos de combustível GASOLINA, FLEX e ETANOL/ÁLCOOL serem maioria da frota, é natural eles serem classificados assim.\n",
                "    df_denatran = df_denatran[~df_denatran['Combustivel'].isin(comb_exc)]\n",
                "\n",
                "    #Aplica a função get_comb, selecionando o fator de consumo mais adequado (priorizando o A, B e C na sequência)\n",
                "    df_denatran[['Consumo_Gasolina', 'Consumo_Alcool', 'Consumo_Diesel']] = df_denatran[['Consumo_Cidade_Gasolina_A', 'Combustivel_Gasolina_A', 'Consumo_Cidade_Gasolina_B', 'Combustivel_Gasolina_B', 'Consumo_Cidade_Gasolina_C', 'Combustivel_Gasolina_C', 'Consumo_Cidade_Alcool_A', 'Combustivel_Alcool_A', 'Consumo_Cidade_Alcool_B', 'Combustivel_Alcool_B', 'Consumo_Cidade_Alcool_C', 'Combustivel_Alcool_C', 'Combustivel', 'Comb_Ant']].apply(lambda x: get_comb(x), axis=1, result_type='expand')\n",
                "\n",
                "    #Exclui as colunas auxiliares ['Marca', 'Modelo', 'Modelo_A', 'Modelo_B', 'Modelo_C', 'Modelo_iCarros_A', 'Modelo_iCarros_B', 'Modelo_iCarros_C', 'Consumo_Cidade_Gasolina_A', 'Combustivel_Gasolina_A', 'Consumo_Cidade_Gasolina_B', 'Combustivel_Gasolina_B', 'Consumo_Cidade_Gasolina_C', 'Combustivel_Gasolina_C', 'Consumo_Cidade_Alcool_A', 'Combustivel_Alcool_A', 'Consumo_Cidade_Alcool_B', 'Combustivel_Alcool_B', 'Consumo_Cidade_Alcool_C', 'Combustivel_Alcool_C', 'Comb_Ant']\n",
                "    df_denatran = df_denatran.drop(['Marca', 'Modelo', 'Modelo_A', 'Modelo_B', 'Modelo_C', 'Modelo_iCarros_A', 'Modelo_iCarros_B', 'Modelo_iCarros_C', 'Consumo_Cidade_Gasolina_A', 'Combustivel_Gasolina_A', 'Consumo_Cidade_Gasolina_B', 'Combustivel_Gasolina_B', 'Consumo_Cidade_Gasolina_C', 'Combustivel_Gasolina_C', 'Consumo_Cidade_Alcool_A', 'Combustivel_Alcool_A', 'Consumo_Cidade_Alcool_B', 'Combustivel_Alcool_B', 'Consumo_Cidade_Alcool_C', 'Combustivel_Alcool_C', 'Comb_Ant'], axis=1)\n",
                "\n",
                "    #Trata as colunas 'Tipo' e 'RM' do df_denatran\n",
                "    df_denatran['Tipo'] = df_denatran['Tipo'].convert_dtypes()\n",
                "    df_denatran['RM'] = df_denatran['RM'].convert_dtypes()\n",
                "\n",
                "    #Salva dataframe\n",
                "    df_denatran.to_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), index=False)\n",
                "    return"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "**vkt_fase5**\n",
                "\n",
                "Como parâmetros, são necessários ano de referência ao qual o VKT deverá ser calculado, bem como a versão. A versão apenas implicará no nome do arquivo final a ser gerado, já o ano terá implicações nas curvas de sucateamento e de intensidade de uso."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_fase5 (ano, versao):\n",
                "    #Abre o dataframe salvo na etapa anterior\n",
                "    df_denatran = pd.read_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), low_memory=False)\n",
                "\n",
                "    #Tratamento de dados da coluna 'Combustivel'\n",
                "    df_denatran['Combustivel'] = df_denatran['Combustivel'].convert_dtypes()\n",
                "    df_denatran['Combustivel'] = df_denatran['Combustivel'].astype(str)\n",
                "\n",
                "    #Aplicação de fatores de consumo médio para os modelos que não foram previamente identificados nas etapas anteriores a partir da média agrupada pelas colunas ['Combustivel', 'RM', 'Tipo', 'Ano']\n",
                "    df_denatran['Consumo_Gasolina'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'GASOLINA')]['Consumo_Gasolina'].fillna(df_denatran.groupby(['Combustivel', 'RM', 'Tipo', 'Ano'])['Consumo_Gasolina'].transform('mean'))\n",
                "    df_denatran['Consumo_Alcool'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'ALCOOL')]['Consumo_Alcool'].fillna(df_denatran.groupby(['Combustivel', 'RM', 'Tipo', 'Ano'])['Consumo_Alcool'].transform('mean'))\n",
                "    df_denatran['Consumo_Diesel'] = df_denatran[(df_denatran['Combustivel'] == 'DIESEL')]['Consumo_Diesel'].fillna(df_denatran.groupby(['Combustivel', 'RM', 'Tipo', 'Ano'])['Consumo_Diesel'].transform('mean'))\n",
                "\n",
                "    #Aplicação de fatores de consumo médio para os modelos que não foram previamente identificados nas etapas anteriores a partir da média agrupada pelas colunas ['Combustivel', 'Tipo', 'Ano']\n",
                "    df_denatran['Consumo_Gasolina'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'GASOLINA')]['Consumo_Gasolina'].fillna(df_denatran.groupby(['Combustivel', 'Tipo', 'Ano'])['Consumo_Gasolina'].transform('mean'))\n",
                "    df_denatran['Consumo_Alcool'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'ALCOOL')]['Consumo_Alcool'].fillna(df_denatran.groupby(['Combustivel', 'Tipo', 'Ano'])['Consumo_Alcool'].transform('mean'))\n",
                "    df_denatran['Consumo_Diesel'] = df_denatran[(df_denatran['Combustivel'] == 'DIESEL')]['Consumo_Diesel'].fillna(df_denatran.groupby(['Combustivel', 'Tipo', 'Ano'])['Consumo_Diesel'].transform('mean'))\n",
                "\n",
                "    #Aplicação de fatores de consumo médio para os modelos que não foram previamente identificados nas etapas anteriores a partir da média agrupada pelas colunas ['Combustivel', 'Tipo']\n",
                "    df_denatran['Consumo_Gasolina'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'GASOLINA')]['Consumo_Gasolina'].fillna(df_denatran.groupby(['Combustivel', 'Tipo'])['Consumo_Gasolina'].transform('mean'))\n",
                "    df_denatran['Consumo_Alcool'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'ALCOOL')]['Consumo_Alcool'].fillna(df_denatran.groupby(['Combustivel', 'Tipo'])['Consumo_Alcool'].transform('mean'))\n",
                "    df_denatran['Consumo_Diesel'] = df_denatran[(df_denatran['Combustivel'] == 'DIESEL')]['Consumo_Diesel'].fillna(df_denatran.groupby(['Combustivel', 'Tipo'])['Consumo_Diesel'].transform('mean'))\n",
                "\n",
                "    #Aplicação de fatores de consumo para os modelos que não foram previamente identificados nas etapas anteriores a partir da função get_consumo, que utiliza a base da CETESB (2019)\n",
                "    df_denatran['Consumo_Gasolina'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'GASOLINA')]['Consumo_Gasolina'].fillna(df_denatran[['Combustivel', 'Tipo', 'Ano']].apply(lambda x: get_consumo('GASOLINA', x), axis=1))\n",
                "    df_denatran['Consumo_Alcool'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'ALCOOL')]['Consumo_Alcool'].fillna(df_denatran[['Combustivel', 'Tipo', 'Ano']].apply(lambda x: get_consumo('ALCOOL', x), axis=1))\n",
                "    df_denatran['Consumo_Diesel'] = df_denatran[(df_denatran['Combustivel'] == 'DIESEL')]['Consumo_Diesel'].fillna(df_denatran[['Combustivel', 'Tipo', 'Ano']].apply(lambda x: get_consumo('DIESEL', x), axis=1))\n",
                "\n",
                "    #Aplicação de fatores de consumo médio para os modelos que não foram previamente identificados nas etapas anteriores a partir da média agrupada pelas colunas ['Combustivel', 'RM', 'Tipo', 'Ano']\n",
                "    df_denatran['Consumo_Gasolina'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'GASOLINA')]['Consumo_Gasolina'].fillna(df_denatran.groupby(['Combustivel', 'RM', 'Tipo', 'Ano'])['Consumo_Gasolina'].transform('mean'))\n",
                "    df_denatran['Consumo_Alcool'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'ALCOOL')]['Consumo_Alcool'].fillna(df_denatran.groupby(['Combustivel', 'RM', 'Tipo', 'Ano'])['Consumo_Alcool'].transform('mean'))\n",
                "    df_denatran['Consumo_Diesel'] = df_denatran[(df_denatran['Combustivel'] == 'DIESEL')]['Consumo_Diesel'].fillna(df_denatran.groupby(['Combustivel', 'RM', 'Tipo', 'Ano'])['Consumo_Diesel'].transform('mean'))\n",
                "\n",
                "    #Aplicação de fatores de consumo médio para os modelos que não foram previamente identificados nas etapas anteriores a partir da média agrupada pelas colunas ['Combustivel', 'Tipo', 'Ano']\n",
                "    df_denatran['Consumo_Gasolina'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'GASOLINA')]['Consumo_Gasolina'].fillna(df_denatran.groupby(['Combustivel', 'Tipo', 'Ano'])['Consumo_Gasolina'].transform('mean'))\n",
                "    df_denatran['Consumo_Alcool'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'ALCOOL')]['Consumo_Alcool'].fillna(df_denatran.groupby(['Combustivel', 'Tipo', 'Ano'])['Consumo_Alcool'].transform('mean'))\n",
                "    df_denatran['Consumo_Diesel'] = df_denatran[(df_denatran['Combustivel'] == 'DIESEL')]['Consumo_Diesel'].fillna(df_denatran.groupby(['Combustivel', 'Tipo', 'Ano'])['Consumo_Diesel'].transform('mean'))\n",
                "\n",
                "    #Aplicação de fatores de consumo médio para os modelos que não foram previamente identificados nas etapas anteriores a partir da média agrupada pelas colunas ['Combustivel', 'Tipo']\n",
                "    df_denatran['Consumo_Gasolina'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'GASOLINA')]['Consumo_Gasolina'].fillna(df_denatran.groupby(['Combustivel', 'Tipo'])['Consumo_Gasolina'].transform('mean'))\n",
                "    df_denatran['Consumo_Alcool'] = df_denatran[(df_denatran['Combustivel'] == 'FLEX') | (df_denatran['Combustivel'] == 'ALCOOL')]['Consumo_Alcool'].fillna(df_denatran.groupby(['Combustivel', 'Tipo'])['Consumo_Alcool'].transform('mean'))\n",
                "    df_denatran['Consumo_Diesel'] = df_denatran[(df_denatran['Combustivel'] == 'DIESEL')]['Consumo_Diesel'].fillna(df_denatran.groupby(['Combustivel', 'Tipo'])['Consumo_Diesel'].transform('mean'))\n",
                "\n",
                "    #Salva dataframe\n",
                "    df_denatran.to_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), index=False)\n",
                "    return\n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "**vkt_fase6**\n",
                "\n",
                "Como parâmetros, são necessários ano de referência ao qual o VKT deverá ser calculado, bem como a versão. A versão apenas implicará no nome do arquivo final a ser gerado, já o ano terá implicações nas curvas de sucateamento e de intensidade de uso."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_fase6 (ano, versao):\n",
                "    #Abre o dataframe salvo na etapa anterior\n",
                "    df_denatran = pd.read_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), low_memory=False)\n",
                "\n",
                "    #Realiza o cálculo de VKT Preliminar através da aplicação da função get_vkt_preliminar\n",
                "    df_denatran['VKT_Preliminar'] = df_denatran[['Ano', 'Combustivel', 'Tipo']].apply(lambda x: get_vkt_preliminar(x, ano), axis=1)\n",
                "    #Cria dataframe df_denatran_vkt_erro, destacando os erros com cálculo do VKT Preliminar (identificar erros)\n",
                "    #df_denatran_vkt_erro = df_denatran[df_denatran['VKT_Preliminar'].map(lambda x: np.isnan(x))]\n",
                "    #Aplica a função get_sucat, transformando a quantidade licenciada em quantidade circulante\n",
                "    df_denatran['Quantidade'] = df_denatran[['Ano', 'Tipo', 'Combustivel', 'Quantidade']].apply(lambda x: get_sucat(x, ano), axis=1)\n",
                "    #Multiplica o VKT Preliminar pelas respectivas quantidades de frota circulante\n",
                "    df_denatran['VKT_Preliminar'] = df_denatran['VKT_Preliminar']*df_denatran['Quantidade']\n",
                "    #Remove os registos com erro no cálculo no VKT Preliminar\n",
                "    df_denatran = df_denatran[~df_denatran['VKT_Preliminar'].map(lambda x: np.isnan(x))]\n",
                "    #Cria df_denatran_vkt_neg com o VKT Preliminar negativo (identificar erros)\n",
                "    #df_denatran_vkt_neg = df_denatran[df_denatran['VKT_Preliminar'] <= 0]\n",
                "\n",
                "    #Realiza filtro no df_preco_comb_rm, que possui a base de relação de preços médios de ETANOL e GASOLINA e a relação de utilização dos respectivos combustíveis por Região Metropolitana conforme modelo Brasil de Brasil (2013) apenas para o ano em análise, gerando o df_preco_comb_rm_anual\n",
                "    #BRASIL. Empresa de Pesquisa Energética - EPE. Ministério de Minas e Energia. Avaliação do Comportamento dos Usuários de Veículos Flex Fuel no Consumo de Combustíveis no Brasil. Brasília: [s.l.], 2013. 48 p. Disponível em: https://www.epe.gov.br/sites-pt/publicacoes-dados-abertos/publicacoes/PublicacoesArquivos/publicacao-250/topico-296/EPE-DPG-SDB-001-2013-r0[1].pdf. Acesso em: 18 jun. 2021.\n",
                "    df_preco_comb_rm_anual = df_preco_comb_rm[df_preco_comb_rm['Ano'] == ano]\n",
                "    \n",
                "    #Realiza junção do df_denatran e df_preco_comb_rm_anual, inserindo a relação de etanol e gasolina em todos os registros (varia conforme Região Metropolitana)\n",
                "    df_denatran = pd.merge(df_denatran, df_preco_comb_rm_anual[['RM', 'Relacao']], on='RM', how='left')\n",
                "\n",
                "    #Exclui a coluna 'Relacao' dos veículos que possuem combustível diferente de Flex\n",
                "    df_denatran.loc[df_denatran['Combustivel'] != 'FLEX', 'Relacao'] = np.nan\n",
                "\n",
                "    #Estima os volumes teóricos de combustível com base no VKT Preliminar, no tipo de combustível, nos fatores de consumo e na relação de uso dos veículos flex\n",
                "    df_denatran['Volume_Gasolina'] = df_denatran[df_denatran['Combustivel'] == 'GASOLINA'][['VKT_Preliminar', 'Consumo_Gasolina']].apply(lambda x: x['VKT_Preliminar']/x['Consumo_Gasolina'], axis=1)\n",
                "    df_denatran.loc[df_denatran['Combustivel'] == 'FLEX', 'Volume_Gasolina'] = df_denatran[df_denatran['Combustivel'] == 'FLEX'][['VKT_Preliminar', 'Consumo_Gasolina', 'Relacao']].apply(lambda x: (x['VKT_Preliminar']*(1-x['Relacao']))/x['Consumo_Gasolina'], axis=1)\n",
                "    df_denatran['Volume_Alcool'] = df_denatran[df_denatran['Combustivel'] == 'ALCOOL'][['VKT_Preliminar', 'Consumo_Alcool']].apply(lambda x: x['VKT_Preliminar']/x['Consumo_Alcool'], axis=1)\n",
                "    df_denatran.loc[df_denatran['Combustivel'] == 'FLEX', 'Volume_Alcool'] = df_denatran[df_denatran['Combustivel'] == 'FLEX'][['VKT_Preliminar', 'Consumo_Alcool', 'Relacao']].apply(lambda x: (x['VKT_Preliminar']*x['Relacao'])/x['Consumo_Alcool'], axis=1)\n",
                "    df_denatran['Volume_Diesel'] = df_denatran[df_denatran['Combustivel'] == 'DIESEL'][['VKT_Preliminar', 'Consumo_Diesel']].apply(lambda x: x['VKT_Preliminar']/x['Consumo_Diesel'], axis=1)\n",
                "\n",
                "    #Salva dataframe\n",
                "    df_denatran.to_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), index=False)\n",
                "    \n",
                "    return"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "**vkt_fase7**\n",
                "  \n",
                "Como parâmetros, são necessários ano de referência ao qual o VKT deverá ser calculado, bem como a versão. A versão apenas implicará no nome do arquivo final a ser gerado, já o ano terá implicações nas curvas de sucateamento e de intensidade de uso."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "def vkt_fase7 (ano, versao):\n",
                "    #Abre o dataframe salvo na etapa anterior\n",
                "    df_denatran = pd.read_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), low_memory=False)\n",
                "    #Soma, por Região Metropolitana, os volumes de álcool, gasolina e diesel\n",
                "    df_denatran_rm = df_denatran.groupby(['RM'])[['Volume_Alcool', 'Volume_Gasolina', 'Volume_Diesel']].sum()\n",
                "    #Reinicia o index, que é agrupado quando utilizada a função groupby\n",
                "    df_denatran_rm = df_denatran_rm.reset_index()\n",
                "\n",
                "    #Filtra o dataframe df_base_volume_comb_rm, que possui os volumes vendidos de cada Região Metropolitana (ANP), para o ano em vigência\n",
                "    df_base_volume_comb_rm_anual = df_base_volume_comb_rm[df_base_volume_comb_rm['Ano'] == ano]\n",
                "    #Remove a coluna 'Ano'\n",
                "    df_base_volume_comb_rm_anual = df_base_volume_comb_rm_anual.drop(['Ano'], axis=1)\n",
                "    #Filtra o dataframe df_base_diesel_rm, que possui os fatores de ajuste dos volumes vendidos de diesel por Região Metropolitana (ANP), para o ano em vigência\n",
                "    df_base_diesel_rm_anual = df_base_diesel_rm[df_base_diesel_rm['Ano'] == ano]\n",
                "    #Remove a coluna 'Ano'\n",
                "    df_base_diesel_rm_anual = df_base_diesel_rm_anual.drop(['Ano'], axis=1)\n",
                "\n",
                "    #Raliza a pivotação do df_base_volume_comb_rm_anual, transformando os elementos da coluna 'Combustivel' em diferentes colunas\n",
                "    df_base_volume_comb_rm_anual = df_base_volume_comb_rm_anual.pivot(index='RM', columns='Combustivel', values='Quantidade')\n",
                "    #Realiza a junção do df_base_volume_comb_rm_anual com o df_base_diesel_rm_anual\n",
                "    df_base_volume_comb_rm_anual = pd.merge(df_base_volume_comb_rm_anual, df_base_diesel_rm_anual, on='RM', how='left')\n",
                "\n",
                "    #Para os anos que a coluna 'Volume_Venda_Diesel' do df_base_volume_comb_rm_anual não possuir valores, anula a coluna 'Fator'\n",
                "    #Nota: Remover após testar (Não faz mais sentido)\n",
                "    #df_base_volume_comb_rm_anual[df_base_volume_comb_rm_anual['Volume_Venda_Diesel'].map(lambda x: np.isnan(x))]['Fator'] = np.nan\n",
                "\n",
                "    #Realiza a junção da df_denatran_rm com a df_base_volume_comb_rm_anual\n",
                "    df_denatran_rm = pd.merge(df_denatran_rm, df_base_volume_comb_rm_anual, on='RM', how='left')\n",
                "\n",
                "    #Calcula os fatores de expansão de cada um dos combustíveis, por tipo através da comparação entre o volume efetivamente vendido e o teórico previamente calculado\n",
                "    df_denatran_rm['Fator_Alcool'] = df_denatran_rm['Volume_Venda_Alcool']/df_denatran_rm['Volume_Alcool']\n",
                "    df_denatran_rm['Fator_Gasolina'] = df_denatran_rm['Volume_Venda_Gasolina']/df_denatran_rm['Volume_Gasolina']\n",
                "    #No caso do diesel, é aplicado um fator de ajuste considerando o que efetivamente foi consumido pelo transporte rodoviário, conforme informações fornecidas pela ANP\n",
                "    df_denatran_rm['Fator_Diesel'] = (df_denatran_rm['Volume_Venda_Diesel']*df_denatran_rm['Fator_Ajuste_Diesel'])/df_denatran_rm['Volume_Diesel']\n",
                "\n",
                "    #Exclui do df_denatran_rm as colunas 'Volume_Alcool', 'Volume_Gasolina', 'Volume_Diesel', 'Volume_Diesel', 'Volume_Venda_Alcool', 'Volume_Venda_Diesel', 'Volume_Venda_GNV', 'Volume_Venda_Gasolina'\n",
                "    df_denatran_rm = df_denatran_rm.drop(['Volume_Alcool', 'Volume_Gasolina', 'Volume_Diesel', 'Volume_Diesel', 'Volume_Venda_Alcool', 'Volume_Venda_Diesel', 'Volume_Venda_GNV', 'Volume_Venda_Gasolina'], axis=1)\n",
                "\n",
                "    #Realiza a junção do df_denatran com o df_denatran_rm\n",
                "    df_denatran = pd.merge(df_denatran, df_denatran_rm, on='RM', how='left')\n",
                "\n",
                "    #Realiza o cálculo do VKT através da aplicação da função get_vkt\n",
                "    df_denatran['VKT'] = df_denatran[['VKT_Preliminar', 'Combustivel', 'Fator_Alcool', 'Fator_Gasolina', 'Fator_Diesel', 'Relacao']].apply(lambda x: get_vkt(x), axis=1)\n",
                "    \n",
                "    #Salva o dataframe\n",
                "    df_denatran.to_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), index=False)\n",
                "\n",
                "    #Soma o VKT, agrupa por Região Metropolitana e salva\n",
                "    df_denatran_rm = df_denatran.groupby(['RM'])['VKT'].sum()\n",
                "    df_denatran_rm.to_csv('datasets/{}/vkt_v{}_rm.csv'.format(ano, versao))\n",
                "    return"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "*Informações relevantes*\n",
                "\n",
                "Estrutura principal do algoritmo, que irá executar a estrutura de repetição encadeada de todas as fases para diferentes anos\n",
                "\n",
                "**Fontes das Bases de Dados**\n",
                "\n",
                "*datasets/marca_modelo_lista5_priority.csv* - Dados obtidos através de webscrapping do site https://www.icarros.com.br \n",
                "\n",
                "*datasets/base_consumo.csv* - Dados obtidos através de webscrapping do site https://www.icarros.com.br\n",
                "\n",
                "*datasets/base_combustiveis_precos_rel_rm.csv* - https://dados.gov.br/dataset/serie-historica-de-precos-de-combustiveis-por-revenda - Tratamento realizado pelos autores através do algoritmo vkt_trata_base_comb.ipynb para cálculo do valor médio de venda por Região Metropolitana\n",
                "\n",
                "*datasets/base_volume_comb_rm.csv* - https://dados.gov.br/dataset/vendas-de-derivados-de-petroleo-e-biocombustiveis - Tratamento realizado pelos autores através do algoritmo vkt_trata_base_volume_comb.ipynb para cálculo do total de massa ou volume vendido por Região Metropolitana\n",
                "\n",
                "*datasets/base_diesel_rm_rev02.csv* - Tratamento realizado pelos autores através do algoritmo vkt_trata_base_diesel.py para cálculo do Fator_Ajuste_Diesel por Região Metropolitana, considerando apenas o diesel destinado ao transporte rodoviário. O arquivo base utilizado como fonte foi obtido através de pedido à AGÊNCIA NACIONAL DO PETRÓLEO, GÁS NATURAL E BIOCOMBUSTÍVEIS (ANP), que rotineiramente realiza o cruzamento das atividades econômicas das pessoas jurídicas compradoras"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "#Carrega o dataframe da lista de veículos e respectivas informações previamente coletadas no iCarros no df_marca_modelo5\n",
                "df_marca_modelo5 = pd.read_csv('datasets/marca_modelo_lista5_priority.csv')\n",
                "#Renomeia a df_marca_modelo5 coluna 'Modelo' para 'Modelo_A'\n",
                "df_marca_modelo5.rename(columns={'Modelo': 'Modelo_A'}, inplace = True)\n",
                "#Tratamento de dados\n",
                "#Tratamento da coluna 'Ano', alterando o tipo da coluna para inteiro\n",
                "df_marca_modelo5['Ano'] = df_marca_modelo5['Ano'].astype(np.int64)\n",
                "#Tratamento das colunas 'Consumo_Cidade_Gasolina' e 'Consumo_Cidade_Alcool', alterando o tipo da coluna para numérico\n",
                "df_marca_modelo5[['Consumo_Cidade_Gasolina', 'Consumo_Cidade_Alcool']] = df_marca_modelo5[['Consumo_Cidade_Gasolina', 'Consumo_Cidade_Alcool']].apply(lambda x: pd.to_numeric(x, errors='coerce'))\n",
                "#Tratamento da coluna 'Combustivel_Gasolina', retirando acentuação\n",
                "#Nota: a coluna 'Combustivel_Gasolina' não indica, necessariamente, que aquela marca/modelo possui combustível do tipo gasolina, mas indica qual tipo principal que foi apresentado no iCarros (geralmente é gasolina)\n",
                "df_marca_modelo5['Combustivel_Gasolina'] = df_marca_modelo5['Combustivel_Gasolina'].apply(unidecode)\n",
                "#Tratamento da coluna 'Combustivel_Alcool', retirando acentuação\n",
                "#Nota: a coluna 'Combustivel_Alcool' não indica, necessariamente, que aquela marca/modelo possui combustível do tipo álcool, mas indica qual tipo principal que foi apresentado no iCarros (geralmente é álcool)\n",
                "df_marca_modelo5['Combustivel_Alcool'] = df_marca_modelo5['Combustivel_Alcool'].apply(unidecode)\n",
                "\n",
                "#Carrega o dataframe com as informações sobre consumo conforme CETESB (2019)\n",
                "df_base_consumo = pd.read_csv('datasets/base_consumo.csv')\n",
                "#Tratamento de dados\n",
                "#Retira os registros com consumo 'nd'\n",
                "df_base_consumo = df_base_consumo[df_base_consumo['Consumo'] != 'nd']\n",
                "#Transforma a coluna 'Consumo' em float\n",
                "df_base_consumo['Consumo'] = df_base_consumo['Consumo'].astype(np.float64)\n",
                "\n",
                "#Carrega o dataframe df_preco_comb_rm, que possui a base de relação de preços médios de ETANOL e GASOLINA e a relação de utilização dos respectivos combustíveis por Região Metropolitana conforme modelo Brasil de Brasil (2013) apenas para o ano em análise, gerando o df_preco_comb_rm_anual\n",
                "#BRASIL. Empresa de Pesquisa Energética - EPE. Ministério de Minas e Energia. Avaliação do Comportamento dos Usuários de Veículos Flex Fuel no Consumo de Combustíveis no Brasil. Brasília: [s.l.], 2013. 48 p. Disponível em: https://www.epe.gov.br/sites-pt/publicacoes-dados-abertos/publicacoes/PublicacoesArquivos/publicacao-250/topico-296/EPE-DPG-SDB-001-2013-r0[1].pdf. Acesso em: 18 jun. 2021.\n",
                "df_preco_comb_rm = pd.read_csv('datasets/base_combustiveis_precos_rel_rm.csv')\n",
                "\n",
                "#Carrega o dataframe df_base_volume_comb_rm, que possui os volumes vendidos de cada Região Metropolitana (ANP), para o ano em vigência\n",
                "df_base_volume_comb_rm = pd.read_csv('datasets/base_volume_comb_rm.csv')\n",
                "#Carrega o dataframe df_base_diesel_rm, que possui os fatores de ajuste dos volumes vendidos de diesel por Região Metropolitana (ANP), para o ano em vigência\n",
                "df_base_diesel_rm = pd.read_csv('datasets/base_diesel_rm_rev02.csv')\n",
                "\n",
                "#Parametrizações dos anos e versão de referência\n",
                "versao = 7\n",
                "ano_i = 2015\n",
                "ano_f = 2019\n",
                "#Inicia estrutura de repetição\n",
                "for ano in range(ano_i, ano_f+1, 1):\n",
                "    print(f\"Iniciando {ano}...\")\n",
                "    vkt_fase1(ano, versao)\n",
                "    print('Fase 1 concluída')\n",
                "    vkt_fase2(ano, versao)\n",
                "    print('Fase 2 concluída')\n",
                "    vkt_fase3(ano, versao)\n",
                "    print('Fase 3 concluída')\n",
                "    vkt_fase4(ano, versao)\n",
                "    print('Fase 4 concluída')\n",
                "    vkt_fase5(ano, versao)\n",
                "    print('Fase 5 concluída')\n",
                "    vkt_fase6(ano, versao)\n",
                "    print('Fase 6 concluída')\n",
                "    vkt_fase7(ano, versao)\n",
                "    print('Fase 7 concluída')\n",
                "    df_denatran = pd.read_csv('datasets/{}/vkt_v{}.csv'.format(ano, versao), low_memory=False)\n",
                "    print(df_denatran)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Estrutura na sequência para aglutinar todos os anos em um mesmo arquivo. Sugere-se que esse arquivo seja utilizado para carregar os dashboards por ser mais conciso"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "#Cria array vazio\n",
                "df_append = []\n",
                "\n",
                "#Inicia estrutura de repetição, carregando o dataframe do respectivo ano pelo arquivo vkt_v{}_rm.csv\n",
                "for ano in range(ano_i, ano_f+1, 1):\n",
                "    df = pd.read_csv('datasets/{}/vkt_v{}_rm.csv'.format(ano, versao), low_memory=False)\n",
                "    #Cria a coluna 'Ano', com o ano de referência\n",
                "    df['Ano'] = ano\n",
                "    #Realiza junção com o dataframe anterior\n",
                "    df_append.append(df)\n",
                "\n",
                "#Realiza junção de todos os dataframes anterior analisados\n",
                "df_rms = pd.concat(df_append)\n",
                "\n",
                "#Realiza substituição dos nomes das Regiões Metropolitanas pelos respectivos nomes resumidos\n",
                "df_rms = df_rms.replace(\n",
                "    {'Região Integrada de Desenvolvimento da Grande Teresina': 'RIDE-Teresina',\n",
                "    'Região Integrada de Desenvolvimento do Distrito Federal e Entorno': 'RIDE-DF',\n",
                "    'Região Metropolitana da Capital': 'RM Boa Vista',\n",
                "    'Região Metropolitana da Grande São Luís': 'RM São Luís',\n",
                "    'Região Metropolitana da Grande Vitória': 'RM Vitória',\n",
                "    'Região Metropolitana de Aracaju': 'RM Aracaju',\n",
                "    'Região Metropolitana de Belo Horizonte': 'RMBH',\n",
                "    'Região Metropolitana de Belém': 'RM Belém',\n",
                "    'Região Metropolitana de Curitiba': 'RM Curitiba',\n",
                "    'Região Metropolitana de Florianópolis': 'RM Florianópolis',\n",
                "    'Região Metropolitana de Fortaleza': 'RM Fortaleza',\n",
                "    'Região Metropolitana de Goiânia': 'RM Goiânia',\n",
                "    'Região Metropolitana de João Pessoa': 'RM João Pessoa',\n",
                "    'Região Metropolitana de Macapá': 'RM Macapá',\n",
                "    'Região Metropolitana de Maceió': 'RM Maceió',\n",
                "    'Região Metropolitana de Manaus': 'RM Manaus',\n",
                "    'Região Metropolitana de Natal': 'RM Natal',\n",
                "    'Região Metropolitana de Palmas': 'RM Palmas',\n",
                "    'Região Metropolitana de Porto Alegre': 'RM Porto Alegre',\n",
                "    'Região Metropolitana de Porto Velho': 'RM Porto Velho',\n",
                "    'Região Metropolitana de Recife': 'RM Recife',\n",
                "    'Região Metropolitana de Salvador': 'RM Salvador',\n",
                "    'Região Metropolitana de São Paulo': 'RMSP',\n",
                "    'Região Metropolitana do Rio de Janeiro': 'RMRJ',\n",
                "    'Região Metropolitana do Vale do Rio Cuiabá': 'RM Cuiabá'})\n",
                "\n",
                "#Salva o dataframe\n",
                "df_rms.to_csv('datasets/vkt_geral_v{}_rm.csv'.format(versao), index=False)"
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3.8.12 ('ambiente')",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.8.12"
        },
        "orig_nbformat": 4,
        "vscode": {
            "interpreter": {
                "hash": "a7bf7aacfaa9b7d360d0e6e8fec79188b95ff2365a4a105cc01ec092e2022ef7"
            }
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}