Index

• prepar
  • 1) Compilar o metis no linux
  • 2) Compilar o prepar
  • 3) Rodando o prepar
  • 4) Exemplo
  • 5) Pre-compilados
  • 6) Docker
  • 7) Usando no WSL

Para compilar o metis basta seguir os seguintes passos:

cd metisLib
tar -xvzf metis-5.1.0.tar.gz
cd metis-5.1.0
make config
make
mkdir -p ./../../lib/
cp -v build/Linux-x86_64/libmetis/libmetis.a ../../lib/
cd ../../

Estes comandos irão descompactar e compilar o metis5, configurar o make, excetar a compilação e copiar automaticamente a libmetis.a para a pasta lib. A libmetis.a será utilizada depois para a compilação do prepar

⚠️⚠️ OBS: Você precisa ter instalado o cmake por causa do metis.

⚠️⚠️ OBS: As versões novas do metis que estão disponiveis no github precisam dessa lib extra libGKlib. As versões mais antigas do metis podem ser encontrados aqui. As prepar só funciona com as versão antigas do metis.

O primeiro passo é fazer uma copia do Makefile_base

cp contrib/Makefile_base Makefile

Antes de compilar o prepar a estrutura do projeto tem que ser algo similar à:

├── include
│   ├── elementos.fi
│   ├── gauss.fi
│   ├── load.fi
│   ├── parallel.fi
│   ├── readfile.fi
│   ├── string.fi
│   ├── termprop.fi
│   ├── time.fi
│   └── transiente.fi
├── lib
│   └── libmetis.a
├── Makefile
└── src
    ├── Adjacency.f
    ├── Filenames.f
    ├── Main.f
    ├── Malloc.f
    ├── Mpi_comunicate.f
    ├── Parallel_imp.f
    ├── Partdmesh.f
    ├── Pdmetis.f
    ├── Propnode.f
    ├── Rdata.f
    ├── Read_mef.f
    ├── Read_metis.f
    ├── Time.f
    ├── Vtk.f
    ├── Write_mef.f
    ├── Write_par.f
    └── Write_vtk.f

Agora para compilar fazer basta:

make

O executável do prepar estará na pasta bin. Como foi usando a opção -static pode ser que seja necessario instalar lib extras no sistema como a glibc-static. Outra opção é tirar a opção -static do Makefile.

Criar um arquivo pre.dat com o conteudo

input  mesh.dat
output     part
div          12
method non-overllaping
partVtk     yes
partMeshVtk yes
partMeshMef yes
meshLoads    no
vtkBin      yes
memory     1000
end

Exsite um exemplo de aquivo de entrada na pastas contrib/bin/. Para usa-lo primeiro vamos descompacta-lo para a pasta bin/.

mkdir -p bin
tar -xvzf contrib/examples/solo.tar.gz -C bin/

Agora para gerar o particionamento basta executar o prepar na pasta bin/.

./prepar solo/pre.dat

Após rodar o prepar a pasta dever ser

solo/
├── config
│   ├── grav.dat
│   ├── poromec.config
│   ├── poromec.solver
│   └── setprint.dat
├── mesh
│   ├── solo1_boun.dat
│   ├── solo1_coor.dat
│   ├── solo1_elmt.dat
│   ├── solo1_elmtloads.dat
│   └── solo1_initial.dat
├── output
├── part
│   ├── solo1_par_0.dat
│   ├── solo1_par_1.dat
│   ├── solo1_par_2.dat
│   ├── solo1_par_3.dat
│   ├── solo1_par_4.dat
│   ├── solo1_par_5.dat
│   ├── solo1_par_n_0_my_part.vtk
│   ├── solo1_par_n_1_my_part.vtk
│   ├── solo1_par_n_2_my_part.vtk
│   ├── solo1_par_n_3_my_part.vtk
│   ├── solo1_par_n_4_my_part.vtk
│   ├── solo1_par_n_5_my_part.vtk
│   ├── solo1_par_n_6_part.vtk
│   └── solo1_par_pre_t_6.txt
├── pre.dat
├── run
│   ├── nloads.dat
│   ├── node.dat
│   └── run.dat
└── solo1.dat

As pastas run, mesh, config e o arquivo solo1.dat são os arquivos de entrada da simulação do mefpar em sequencial. Na pasta solo/part ficam salvos os arquivos do particionamento *.dat e *.vtk. Os arquivos solo1_par_*.dat são arquivos de entrada para a simulação em paralelo do mefpar.

Exemplo da malha particonada em 6 partições

⚠️⚠️ OBS: A estrura de pastas dos arquivos de input e output podem ser mudadas. Essa estrutura é apenas a que eu gosto, mas você pode ficar a vontade de experimentar outras.

Versões pré compilados para linux pode ser encotradas aqui binarios

Caso você queria rodar utilizando containers temos um Dockerfile configurado.

Para gerar a imagem, este procedimento precisa ser feito apenas uma única vez:

docker build -t prepar:latest .

Para executar o prepar e gerar o parcionamento:

docker run --rm -it -v "$(pwd)/bin/solo/:/usr/build/solo/" prepar solo/pre.dat

⚠️⚠️ OBS: O docker pode ser usado no windows também, mas irá usar bastante recurso da máquina.

Você precisará instalar o make, cmake, g++. Usando o Ubuntu 22.04.06 LTS basta utilizar os comandos:

sudo apt update
sudo apt install make cmake g++ gfortran

Após isso você pode seguir o procedimento normal de instalação no linux.