From 6acd16c222abebd19df62094e4759f203370fedd Mon Sep 17 00:00:00 2001 From: Simone Poncioni Date: Fri, 23 Aug 2024 11:07:49 +0200 Subject: [PATCH 1/8] issues with ubelix tbd --- .gitignore | 1 + 02_CODE/cfg/hfe-tibia.yaml | 6 ++-- 02_CODE/cfg/paths-tibia.yaml | 4 +-- 02_CODE/src/hfe_abq/simulation.py | 37 +++++++++++++++++------- 02_CODE/src/hfe_accurate/hfe_accurate.py | 20 ++++++++++++- 5 files changed, 52 insertions(+), 16 deletions(-) diff --git a/.gitignore b/.gitignore index 2faf01a..5826f2e 100644 --- a/.gitignore +++ b/.gitignore @@ -21,6 +21,7 @@ outputs/ !04_SIMULATIONS/simulations_directory.text 99_TEMP/ QMSKI/DSC_PAPER/ +out/ multirun/ diff --git a/02_CODE/cfg/hfe-tibia.yaml b/02_CODE/cfg/hfe-tibia.yaml index 182b678..82c5828 100644 --- a/02_CODE/cfg/hfe-tibia.yaml +++ b/02_CODE/cfg/hfe-tibia.yaml @@ -21,7 +21,7 @@ mesher: air_elements: False # True #if you want keep the elements to have a fullbock mesh in x-y direction image_processing: - origaim_separate: False # For Hosseini Dataset, Image parameters are read from original aim, not from processed BMD file, as there they were deleted by medtool pre-processing + origaim_separate: False # For Hosseini Dataset, Image parameters are read from original aim, not from processed BMD file, there they were deleted by medtool pre-processing mask_separate: True # Standard evaluation gives two separate mask file (CORTMASK and TRABMASK), False if one maskfile with two different labels imtype: NATIVE # NATIVE or BMD bvtv_scaling: 1 # 0: no scaling, 1: Scaling of BVTV 61um to BVTV 11.4um [Hosseini2017] @@ -51,11 +51,11 @@ loadcase: time_for_displacement: 1 min_step_size: 0.0000000001 max_step_size: 0.3 - load_displacement: -1.0 # (mm) + load_displacement: -0.10 # (mm) abaqus: nlgeom: on # affects NLGEOM parameter in abaqus simulation (on/off) - abaqus_nprocs: 8 # (-) + abaqus_nprocs: 4 # (-) abaqus_memory: 6000 # (MB) delete_odb: False # delete odb after retrieving data max_increments: 1000 # int number [1-1000] diff --git a/02_CODE/cfg/paths-tibia.yaml b/02_CODE/cfg/paths-tibia.yaml index 423b09d..2a81854 100644 --- a/02_CODE/cfg/paths-tibia.yaml +++ b/02_CODE/cfg/paths-tibia.yaml @@ -1,7 +1,7 @@ paths: origaimdir: 00_ORIGAIM/TIBIA aimdir: 01_DATA/TIBIA/ - feadir: 04_SIMULATIONS/TIBIA + feadir: 04_SIMULATIONS/TIBIA_P sumdir: 05_SUMMARIES/TIBIA commondir: 01_DATA/BATCH/FEA_noReg/IMAGES/ # if registration is true -> path to registration files folder_bc_psl_loadcases: 02_CODE/abq/BC_PSL/ @@ -20,6 +20,6 @@ filenames: version: verification_files: 1 - current_version: 04_strain + current_version: 03_sener site_bone: Tibia # Radius / Tibia diff --git a/02_CODE/src/hfe_abq/simulation.py b/02_CODE/src/hfe_abq/simulation.py index 63afe00..b3aa3ec 100644 --- a/02_CODE/src/hfe_abq/simulation.py +++ b/02_CODE/src/hfe_abq/simulation.py @@ -1,8 +1,10 @@ import logging import os +import subprocess import sys import traceback from pathlib import Path +import time LOGGING_NAME = "HFE-ACCURATE" logger = logging.getLogger(LOGGING_NAME) @@ -40,19 +42,34 @@ def simulate_loadcase(cfg, sample: str, inputfile: str, umat: str, loadcase: str basepath = os.getcwd() os.chdir(simdir) - command = str( - "%s job=%s inp=%s cpus=%d memory=%d user=%s scratch=%s ask_delete=OFF -interactive" - % (ABAQUS, job, inputfile, NPROCS, RAM, umat, SCRATCH) - ) - logger.info(command) + command = [ + ABAQUS, + f"job={job}", + f"inp={inputfile}", + f"cpus={NPROCS}", + f"memory={RAM}", + f"user={umat}", + f"scratch={SCRATCH}", + "ask_delete=OFF", + "verbose=3", + "-interactive" + ] + logger.info(" ".join(command)) try: - os.system(command) + result = subprocess.run(command, capture_output=True, text=True) + logger.info(result.stdout) + if result.returncode == 0: + logger.info("Abaqus simulation completed successfully") + else: + logger.error("Abaqus simulation failed with return code %d", result.returncode) + logger.error(result.stderr) except Exception as e: logger.error("Simulation of FZ_MAX loadcase resulted in error") logger.error(e) logger.error(traceback.format_exc()) - logger.error(sys.stderr) - pass - os.chdir(basepath) + finally: + os.chdir(basepath) + time.sleep(600) # TODO: remove this as soon as ubelix issue is solved (POS, 23.08.2024) + odb_path = simdir / (job + ".odb") - return odb_path + return odb_path \ No newline at end of file diff --git a/02_CODE/src/hfe_accurate/hfe_accurate.py b/02_CODE/src/hfe_accurate/hfe_accurate.py index 1afc66e..727cefd 100644 --- a/02_CODE/src/hfe_accurate/hfe_accurate.py +++ b/02_CODE/src/hfe_accurate/hfe_accurate.py @@ -120,8 +120,10 @@ def pipeline_hfe(cfg, folder_id, grayscale_filename): end_simulation = time() time_record["simulation"] = end_simulation - start_simulation + logger.info("Running postprocessing.datfilereader_psl") optim = {} optim = postprocessing.datfilereader_psl(cfg, grayscale_filename, optim, "FZ_MAX") + logger.info("Execution completed: postprocessing.datfilereader_psl") # timing end_sample = time() @@ -131,10 +133,18 @@ def pipeline_hfe(cfg, folder_id, grayscale_filename): path2dat = Path(inputfile).parent / ( grayscale_filename + "_" + cfg.version.current_version[0:2] + ".dat" ) + + logger.info(f"path2dat: {path2dat}") + logger.info(f"absolute path2dat: {path2dat.absolute}") + thickness = max(val[2] for val in bone["nodes"].values()) - min( val[2] for val in bone["nodes"].values() ) + logger.info(f"Thickness: {thickness}") + + logger.info("Running compute_optim_report_variables") optim = por.compute_optim_report_variables(optim, path2dat, thickness) + logger.info("Execution completed: compute_optim_report_variables") bone = por.compute_bone_report_variables_no_psl(bone) # only for sensitivity analysis @@ -144,6 +154,8 @@ def pipeline_hfe(cfg, folder_id, grayscale_filename): "n_elms_transverse_cort": cfg.meshing_settings.n_elms_transverse_cort, "n_elms_radial": cfg.meshing_settings.n_elms_radial, } + + logger.info("Executing postprocessing.write_data_summary") postprocessing.write_data_summary( cfg, optim, @@ -153,11 +165,17 @@ def pipeline_hfe(cfg, folder_id, grayscale_filename): DOFs=bone["degrees_of_freedom"], time_sim=time_record[grayscale_filename], ) - + logger.info("Executed: postprocessing.write_data_summary") + if cfg.strain_localisation.strain_analysis is True: + logger.info("Running strain analysis evaluation") odb2vtkpath = cfg.socket_paths.odb2vtk odb_path = odb_path abq_path = cfg.solver.abaqus + logger.info(f"odb2vtkpath: {odb2vtkpath}") + logger.info(f"odb_path: {odb_path}") + logger.info(f"abq_path: {abq_path}") + odb2vtk_wrapper = Odb2VtkWrapper( odb2vtkpath, odb_path, abq_path, only_last_frame=True ) From 517dd910f62358b942617eed9bec2c972f7f131f Mon Sep 17 00:00:00 2001 From: SimonePoncioni <57197609+simoneponcioni@users.noreply.github.com> Date: Tue, 27 Aug 2024 15:06:40 +0200 Subject: [PATCH 2/8] Create LICENSE --- LICENSE | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 LICENSE diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..eacf03c --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2024 University of Bern - ARTORG Center + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. From e233d0d2ba82faec7bdb9c518657aec84f46bd3a Mon Sep 17 00:00:00 2001 From: Simone Poncioni Date: Tue, 27 Aug 2024 15:23:47 +0200 Subject: [PATCH 3/8] solved ubelix issue with MPI --- .../Dockerfile.ubuntu24.04.ifort.thrusections | 68 --- 02_CODE/cfg/hfe-repro.yaml | 4 +- 02_CODE/cfg/hfe-tibia.yaml | 4 +- 02_CODE/cfg/mesh.yaml | 9 +- 02_CODE/cfg/paths-repro.yaml | 4 +- 02_CODE/cfg/paths-tibia.yaml | 2 +- .../Dockerfile.ubuntu24.04.gcc | 0 .../Dockerfile.ubuntu24.04.ifort | 0 .../docker_apptainer_hpc/build_container.sh | 24 + 02_CODE/docker_apptainer_hpc/submit_hfe.sh | 43 ++ 02_CODE/hpc/slurm_submit_hfe.sh | 31 -- 02_CODE/src/hfe_abq/simulation.py | 33 +- 02_CODE/src/hfe_abq/write_abaqus.py | 3 +- 02_CODE/src/hfe_accurate/hfe_accurate.py | 2 +- 02_CODE/src/hfe_utils/f_decomposition.py | 10 +- 02_CODE/src/hfe_utils/imutils.py | 2 +- 02_CODE/src/hfe_utils/odb2vtk_wrapper.py | 22 +- 02_CODE/src/hfe_utils/pos_monitor.mplstyle | 30 + 02_CODE/src/pipeline_runner.py | 2 +- QMSKI/DiceSimilarityCoefficient/Dice.ipynb | 226 -------- QMSKI/SSAM/test_mesh_sum.ipynb | 100 ---- QMSKI/SSAM/tests_pyssam.ipynb | 526 ------------------ .../sensitivity_analysis.ipynb | 224 +------- .../gluer_reproducibility.ipynb | 18 +- QMSKI/validation/linreg.ipynb | 111 ---- 25 files changed, 169 insertions(+), 1329 deletions(-) delete mode 100644 02_CODE/Dockerfile.ubuntu24.04.ifort.thrusections rename 02_CODE/{ => docker_apptainer_hpc}/Dockerfile.ubuntu24.04.gcc (100%) rename 02_CODE/{ => docker_apptainer_hpc}/Dockerfile.ubuntu24.04.ifort (100%) create mode 100644 02_CODE/docker_apptainer_hpc/build_container.sh create mode 100644 02_CODE/docker_apptainer_hpc/submit_hfe.sh delete mode 100644 02_CODE/hpc/slurm_submit_hfe.sh create mode 100644 02_CODE/src/hfe_utils/pos_monitor.mplstyle delete mode 100644 QMSKI/DiceSimilarityCoefficient/Dice.ipynb delete mode 100644 QMSKI/SSAM/test_mesh_sum.ipynb delete mode 100644 QMSKI/SSAM/tests_pyssam.ipynb delete mode 100644 QMSKI/validation/linreg.ipynb diff --git a/02_CODE/Dockerfile.ubuntu24.04.ifort.thrusections b/02_CODE/Dockerfile.ubuntu24.04.ifort.thrusections deleted file mode 100644 index 8de6a85..0000000 --- a/02_CODE/Dockerfile.ubuntu24.04.ifort.thrusections +++ /dev/null @@ -1,68 +0,0 @@ -FROM ubuntu:24.04 - -ENV DEBIAN_FRONTEND noninteractive -ENV LC_ALL=en_US.UTF-8 -ENV LANG=en_US.UTF-8 - -RUN apt-get update && apt-get install -y \ -apt-utils cargo clang clang-tidy cmake \ -fonts-cmu ftp gcc gcovr \ -git g++ gfortran libboost-dev libcgns-dev \ -libfltk1.3-dev libfreetype6-dev libgl1-mesa-dev libgl1-mesa-dri libhdf5-dev \ -libocct-data-exchange-dev libocct-foundation-dev libocct-ocaf-dev libopenblas-dev libopenmpi-dev \ -libpetsc-complex-dev libxfixes-dev libxcursor-dev libxft-dev libxi-dev \ -libxinerama-dev libxmu-dev libslepc-complex3.19-dev mesa-common-dev python3-pip \ -swig tcl-dev tk-dev valgrind vim wget \ -sudo locales \ -&& apt-get clean - -RUN locale-gen en_US.UTF-8 - -# install ifort compiler -RUN wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB | gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null -RUN echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" | sudo tee /etc/apt/sources.list.d/oneAPI.list -RUN sudo apt update && sudo apt upgrade -y -RUN sudo apt-get install -y intel-basekit intel-hpckit -RUN /bin/bash -c "source /opt/intel/oneapi/setvars.sh" -RUN unset PYTHONPATH - -# Install miniconda -RUN wget https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda.sh && \ -bash ~/miniconda.sh -b -p /opt/miniconda && rm ~/miniconda.sh -ENV PATH="/opt/miniconda/bin:$PATH" - -# Create a conda environment -RUN conda create -n hfe-essentials python=3.12 -SHELL ["conda", "run", "-n", "hfe-essentials", "/bin/bash", "-c"] -# Copy hfe requirements.txt and install requirements -COPY ./requirements.txt . -RUN pip install --no-cache-dir -r requirements.txt -RUN pip install -U scikit-image -RUN pip install imutils - -# Set GitHub username and personal access token -ARG GITHUB_USERNAME -ARG GITHUB_TOKEN -ARG USER_UID=1000 -ARG USER_GID=1000 - -# Install the meshing package -RUN git clone -b ThruSections --single-branch https://${GITHUB_USERNAME}:${GITHUB_TOKEN}@github.com/artorg-unibe-ch/spline_mesher.git ./pyhexspline/spline_mesher -WORKDIR ./pyhexspline/spline_mesher -RUN pip install -e . - -# Change ownership of the conda environment to the hfe user -RUN useradd -ms /bin/bash hfe -RUN chown -R hfe:hfe /opt/miniconda/envs/hfe-essentials - -USER hfe -WORKDIR /home/hfe -RUN mkdir -p ~/.ssh -RUN chmod 700 ~/.ssh -ENV PATH="/opt/cargo/bin:${PATH}" - -# conda init, source .bashrc, conda activate -RUN conda init bash -RUN echo "conda activate hfe-essentials" >> ~/.bashrc - -# https://pythonspeed.com/articles/activate-conda-dockerfile/ diff --git a/02_CODE/cfg/hfe-repro.yaml b/02_CODE/cfg/hfe-repro.yaml index 1159397..0324c3c 100644 --- a/02_CODE/cfg/hfe-repro.yaml +++ b/02_CODE/cfg/hfe-repro.yaml @@ -51,11 +51,11 @@ loadcase: time_for_displacement: 1 min_step_size: 0.0000000001 max_step_size: 0.3 - load_displacement: -0.35 # (mm) + load_displacement: -0.35 # (mm) abaqus: nlgeom: on # affects NLGEOM parameter in abaqus simulation (on/off) - abaqus_nprocs: 8 # (-) + abaqus_nprocs: 4 # (-) abaqus_memory: 6000 # (MB) delete_odb: False # delete odb after retrieving data max_increments: 1000 # int number [1-1000] diff --git a/02_CODE/cfg/hfe-tibia.yaml b/02_CODE/cfg/hfe-tibia.yaml index 82c5828..6b25c4c 100644 --- a/02_CODE/cfg/hfe-tibia.yaml +++ b/02_CODE/cfg/hfe-tibia.yaml @@ -51,11 +51,11 @@ loadcase: time_for_displacement: 1 min_step_size: 0.0000000001 max_step_size: 0.3 - load_displacement: -0.10 # (mm) + load_displacement: -0.35 # (mm) abaqus: nlgeom: on # affects NLGEOM parameter in abaqus simulation (on/off) - abaqus_nprocs: 4 # (-) + abaqus_nprocs: 8 # (-) abaqus_memory: 6000 # (MB) delete_odb: False # delete odb after retrieving data max_increments: 1000 # int number [1-1000] diff --git a/02_CODE/cfg/mesh.yaml b/02_CODE/cfg/mesh.yaml index 2d28e5a..4088d51 100644 --- a/02_CODE/cfg/mesh.yaml +++ b/02_CODE/cfg/mesh.yaml @@ -12,7 +12,7 @@ meshing_settings: outside_val: 1 # threshold value for the outside of the mask lower_thresh: 0 # lower threshold for the mask upper_thresh: 0.9 # upper threshold for the mask - s: 500 # smoothing factor of the spline + s: 400 # smoothing factor of the spline k: 3 # degree of the spline interp_points: 200 # number of points to interpolate the spline dp_simplification_outer: 3 # Ramer-Douglas-Peucker simplification factor for the periosteal contour @@ -23,11 +23,12 @@ meshing_settings: center_square_length_factor: 0.4 # size ratio of the refinement square: 0 < l_f < 1 mesh_order: 1 # set order of the mesh (1: linear, 2: quadratic) sweep_factor: 1 # factor for the sweep used in hydra for the sensitivity analysis - n_elms_longitudinal: 3 - n_elms_transverse_trab: 15 - n_elms_transverse_cort: 3 + n_elms_longitudinal: 3 + n_elms_transverse_trab: 15 + n_elms_transverse_cort: 3 n_elms_radial: 20 # ! Should be 10 if trab_refinement is True ellipsoid_fitting: True + show_plots: False # show plots during construction show_gmsh: False # show gmsh GUI write_mesh: True # write mesh to file diff --git a/02_CODE/cfg/paths-repro.yaml b/02_CODE/cfg/paths-repro.yaml index 49c33a9..c7a3e17 100644 --- a/02_CODE/cfg/paths-repro.yaml +++ b/02_CODE/cfg/paths-repro.yaml @@ -1,8 +1,8 @@ paths: origaimdir: 00_ORIGAIM/REPRO/ aimdir: 01_DATA/REPRO/ - feadir: 04_SIMULATIONS/REPRO - sumdir: 05_SUMMARIES/REPRO + feadir: 04_SIMULATIONS/REPRO_PAPER + sumdir: 05_SUMMARIES/REPRO_PAPER commondir: 01_DATA/BATCH/FEA_noReg/IMAGES/ # if registration is true -> path to registration files folder_bc_psl_loadcases: 02_CODE/abq/BC_PSL/ boundary_conditions: 02_CODE/abq/BC_PSL/boundary_conditions.inp diff --git a/02_CODE/cfg/paths-tibia.yaml b/02_CODE/cfg/paths-tibia.yaml index 2a81854..9458346 100644 --- a/02_CODE/cfg/paths-tibia.yaml +++ b/02_CODE/cfg/paths-tibia.yaml @@ -20,6 +20,6 @@ filenames: version: verification_files: 1 - current_version: 03_sener + current_version: 03_testmpi site_bone: Tibia # Radius / Tibia diff --git a/02_CODE/Dockerfile.ubuntu24.04.gcc b/02_CODE/docker_apptainer_hpc/Dockerfile.ubuntu24.04.gcc similarity index 100% rename from 02_CODE/Dockerfile.ubuntu24.04.gcc rename to 02_CODE/docker_apptainer_hpc/Dockerfile.ubuntu24.04.gcc diff --git a/02_CODE/Dockerfile.ubuntu24.04.ifort b/02_CODE/docker_apptainer_hpc/Dockerfile.ubuntu24.04.ifort similarity index 100% rename from 02_CODE/Dockerfile.ubuntu24.04.ifort rename to 02_CODE/docker_apptainer_hpc/Dockerfile.ubuntu24.04.ifort diff --git a/02_CODE/docker_apptainer_hpc/build_container.sh b/02_CODE/docker_apptainer_hpc/build_container.sh new file mode 100644 index 0000000..ef95d27 --- /dev/null +++ b/02_CODE/docker_apptainer_hpc/build_container.sh @@ -0,0 +1,24 @@ +#!/bin/bash + +# User info +#SBATCH --mail-user=simone.poncioni@unibe.ch +#SBATCH --mail-type=begin,end,fail + +# Job name +#SBATCH --job-name="build_container" + +# Runtime and memory +#SBATCH --time=01:00:00 +#SBATCH --cpus-per-task=10 +#SBATCH --mem-per-cpu=4G +#SBATCH --tmp=64G + +# Workdir +#SBATCH --chdir=/storage/workspaces/artorg_msb/hpc_abaqus/poncioni/apptainer +#SBATCH --out=%x.out +#SBATCH --err=%x.err + + +# Run command +srun apptainer build --force hfe_development_ifort.sif docker://simoneponcioni/hfe_development:latest + diff --git a/02_CODE/docker_apptainer_hpc/submit_hfe.sh b/02_CODE/docker_apptainer_hpc/submit_hfe.sh new file mode 100644 index 0000000..66e6f53 --- /dev/null +++ b/02_CODE/docker_apptainer_hpc/submit_hfe.sh @@ -0,0 +1,43 @@ +#!/bin/bash + +# User info +#SBATCH --mail-user=simone.poncioni@unibe.ch +#SBATCH --mail-type=begin,end,fail + +# Job name +#SBATCH --job-name="hfe_pipeline" + +# Runtime and memory +#SBATCH --time=03:00:00 +#SBATCH --cpus-per-task=16 +#SBATCH --ntasks-per-node=1 +#SBATCH --mem-per-cpu=8G +#SBATCH --tmp=100G +#SBATCH --array=1-5%5 + +# Workdir +#SBATCH --chdir=/storage/workspaces/artorg_msb/hpc_abaqus/poncioni/HFE +#SBATCH --output=out/hfe_%A_%a.out +#SBATCH --error=out/hfe_%A_%a.err + +############################################################################################################## +### Load modules +HPC_WORKSPACE=hpc_abaqus module load Workspace + +unset SLURM_GTIDS + +### greyscale_filenames.txt contains lines with 1 greyscale_filename per line. +greyscale_filenames=/storage/workspaces/artorg_msb/hpc_abaqus/poncioni/HFE/00_ORIGAIM/filenames.txt + +### Line contains greyscale_filename for run +# Get greyscale_filename +greyscale_filename=$(cat $greyscale_filenames | awk -v var=$SLURM_ARRAY_TASK_ID 'NR==var {print $1}') + + +### Zero pad the task ID to match the numbering of the input files +n=$(printf "%04d" $SLURM_ARRAY_TASK_ID) + +# Run command +srun apptainer exec /storage/workspaces/artorg_msb/hpc_abaqus/poncioni/apptainer/hfe_development_ifort.sif \ +/bin/bash -c "source /opt/intel/oneapi/setvars.sh && source /opt/miniconda/etc/profile.d/conda.sh && conda activate hfe-essentials && python 02_CODE/src/pipeline_runner.py simulations.grayscale_filenames=$greyscale_filename" + diff --git a/02_CODE/hpc/slurm_submit_hfe.sh b/02_CODE/hpc/slurm_submit_hfe.sh deleted file mode 100644 index b19a6fb..0000000 --- a/02_CODE/hpc/slurm_submit_hfe.sh +++ /dev/null @@ -1,31 +0,0 @@ -#!/bin/bash - -# User info -#SBATCH --mail-user=simone.poncioni@unibe.ch -#SBATCH --mail-type=begin,end,fail - -# Job name -#SBATCH --job-name="hfe_pipeline_test" - -# Runtime and memory -#SBATCH --partition=epyc2,bdw -#SBATCH --time=00:30:00 -#SBATCH --cpus-per-task=16 -#SBATCH --mem-per-cpu=4G -#SBATCH --tmp=64G - -#SBATCH --output=%x.out -#SBATCH --error=%x.err -#SBATCH --chdir=/storage/workspaces/artorg_msb/hpc_abaqus/poncioni/HFE - -# Load modules -HPC_WORKSPACE=hpc_abaqus module load Workspace -module load GCCcore/12.3.0 -unset SLURM_GTIDS - -# Run command -srun apptainer exec \ -/storage/workspaces/artorg_msb/hpc_abaqus/poncioni/apptainer/hfe_development.sif \ -/bin/bash -c "source /opt/miniconda/etc/profile.d/conda.sh && \ -conda activate hfe-essentials && \ -python 02_CODE/src/pipeline_runner.py" \ No newline at end of file diff --git a/02_CODE/src/hfe_abq/simulation.py b/02_CODE/src/hfe_abq/simulation.py index b3aa3ec..4f9f4a3 100644 --- a/02_CODE/src/hfe_abq/simulation.py +++ b/02_CODE/src/hfe_abq/simulation.py @@ -13,7 +13,7 @@ def simulate_loadcase(cfg, sample: str, inputfile: str, umat: str, loadcase: str): """ - Run abaqus simulation from os subprocess. + Run Abaqus simulation from os subprocess. Args: config: configuration dictionary @@ -25,6 +25,9 @@ def simulate_loadcase(cfg, sample: str, inputfile: str, umat: str, loadcase: str Returns: None """ + + setup_env_cmd = 'module load intel-compilers/2021.2.0' + ABAQUS = cfg.solver.abaqus NPROCS = cfg.abaqus.abaqus_nprocs RAM = cfg.abaqus.abaqus_memory @@ -42,21 +45,18 @@ def simulate_loadcase(cfg, sample: str, inputfile: str, umat: str, loadcase: str basepath = os.getcwd() os.chdir(simdir) - command = [ - ABAQUS, - f"job={job}", - f"inp={inputfile}", - f"cpus={NPROCS}", - f"memory={RAM}", - f"user={umat}", - f"scratch={SCRATCH}", - "ask_delete=OFF", - "verbose=3", - "-interactive" - ] - logger.info(" ".join(command)) + # command = ( + # f"{setup_env_cmd} && " + # f"{ABAQUS} job={job} inp={inputfile} cpus={NPROCS} memory={RAM} " + # f"user={umat} scratch={SCRATCH} ask_delete=OFF verbose=3 -interactive" + # ) + command = ( + f"{ABAQUS} job={job} inp={inputfile} cpus={NPROCS} memory={RAM} " + f"user={umat} scratch={SCRATCH} ask_delete=OFF verbose=3 -interactive" + ) + logger.info(command) try: - result = subprocess.run(command, capture_output=True, text=True) + result = subprocess.run(command, capture_output=True, text=True, shell=True) logger.info(result.stdout) if result.returncode == 0: logger.info("Abaqus simulation completed successfully") @@ -69,7 +69,6 @@ def simulate_loadcase(cfg, sample: str, inputfile: str, umat: str, loadcase: str logger.error(traceback.format_exc()) finally: os.chdir(basepath) - time.sleep(600) # TODO: remove this as soon as ubelix issue is solved (POS, 23.08.2024) odb_path = simdir / (job + ".odb") - return odb_path \ No newline at end of file + return odb_path diff --git a/02_CODE/src/hfe_abq/write_abaqus.py b/02_CODE/src/hfe_abq/write_abaqus.py index 4fdd9d5..c248271 100644 --- a/02_CODE/src/hfe_abq/write_abaqus.py +++ b/02_CODE/src/hfe_abq/write_abaqus.py @@ -557,7 +557,8 @@ def _write_output_history(self, REF_NODE: str): RF *NODE PRINT, NSET=REF_NODE, FREQUENCY=1, SUMMARY=NO U, - RF + RF, + CF, *End Step """ return textwrap.dedent(out_hist) diff --git a/02_CODE/src/hfe_accurate/hfe_accurate.py b/02_CODE/src/hfe_accurate/hfe_accurate.py index 727cefd..6635c27 100644 --- a/02_CODE/src/hfe_accurate/hfe_accurate.py +++ b/02_CODE/src/hfe_accurate/hfe_accurate.py @@ -180,7 +180,7 @@ def pipeline_hfe(cfg, folder_id, grayscale_filename): odb2vtkpath, odb_path, abq_path, only_last_frame=True ) vtk_path = odb2vtk_wrapper.convert() - print(f"ODB to VTK file written to {vtk_path}") + logger.info(f"ODB to VTK file written to {vtk_path}") decomposition_to_vtu(vtk_path) if cfg.abaqus.delete_odb is True: diff --git a/02_CODE/src/hfe_utils/f_decomposition.py b/02_CODE/src/hfe_utils/f_decomposition.py index a643eb3..b56d4e6 100644 --- a/02_CODE/src/hfe_utils/f_decomposition.py +++ b/02_CODE/src/hfe_utils/f_decomposition.py @@ -132,23 +132,23 @@ def add_data_to_vtu( def decomposition_to_vtu(input_filepath): - print(f"Reading {input_filepath} ...") + logger.info(f"Reading {input_filepath} ...") output_compression = read_vtu(input_filepath) centroid_arrays = get_centroid_arrays(output_compression) - print(f"Extracted {len(centroid_arrays)} arrays from the vtu file") + logger.info(f"Extracted {len(centroid_arrays)} arrays from the vtu file") F = get_F_matrix(centroid_arrays) - print(f"Extracted F matrix with shape {F.shape}") + logger.info(f"Extracted F matrix with shape {F.shape}") spherical_compression, isovolumic_deformation = decomposition(F) output_filepath = input_filepath.with_stem(input_filepath.stem + "_with_data") - print(f"Saving output to {output_filepath} ...") + logger.info(f"Saving output to {output_filepath} ...") add_data_to_vtu( output_compression, spherical_compression, isovolumic_deformation, output_filepath, ) - print("Done!") + logger.info("Done!") def main(): diff --git a/02_CODE/src/hfe_utils/imutils.py b/02_CODE/src/hfe_utils/imutils.py index dbcd90f..30107dd 100644 --- a/02_CODE/src/hfe_utils/imutils.py +++ b/02_CODE/src/hfe_utils/imutils.py @@ -329,7 +329,7 @@ def read_aim(name, filenames, bone, lock): #IMG_pad = IMG_pad[10:-10, :, :] # pass # ! Updated for the REPRO dataset, check robustness - IMG_pad = IMG_pad[:-50, :, :] + IMG_pad = IMG_pad[10:-40, :, :] IMG_array = sitk.GetArrayFromImage(IMG_pad) diff --git a/02_CODE/src/hfe_utils/odb2vtk_wrapper.py b/02_CODE/src/hfe_utils/odb2vtk_wrapper.py index a68c4a6..5b17890 100644 --- a/02_CODE/src/hfe_utils/odb2vtk_wrapper.py +++ b/02_CODE/src/hfe_utils/odb2vtk_wrapper.py @@ -1,12 +1,18 @@ import os from pathlib import Path import json +import logging + +LOGGING_NAME = "HFE-ACCURATE" +logger = logging.getLogger(LOGGING_NAME) +logger.propagate = False + # flake8: noqa: E501 class Odb2VtkWrapper: - def __init__(self, odb2vtk_path, odb_path, abq_path, only_last_frame=False): + def __init__(self, odb2vtk_path: Path, odb_path: Path, abq_path: Path, only_last_frame=False): self.odb2vtk_path = odb2vtk_path self.odb_path = Path(odb_path) self.vtu_path = self.odb_path.with_suffix(".vtu") @@ -37,16 +43,22 @@ def convert(self): frames = [frames[-1]] step_cli = f"{stepname}:{','.join(map(str, frames))}" - print(stepname) - print(step_cli) + logger.info(stepname) + logger.info(step_cli) os.system( f"{self.abq_path} python {self.odb2vtk_path} --header 0 --instance {instance_str} --step {step_cli} --odbFile {self.odb_path}" ) + + vtu_conv_path = self.odb_path.parent / self.odb_path.stem / f"{stepname}_{frames[0]}.vtu" vtu_out_path = ( self.odb_path.parent / self.odb_path.stem / f"{self.odb_path.stem}_{frames[0]}.vtu" ) + + logger.debug(f'vtu_conv_path: {vtu_conv_path}') + logger.debug(f'vtu_out_path: {vtu_out_path}') + vtu_conv_path.rename(vtu_out_path) return vtu_out_path.resolve() @@ -55,11 +67,11 @@ def test(): abq_path = "/storage/workspaces/artorg_msb/hpc_abaqus/Software/DassaultSystemes/SIMULIA/Commands/abq2024" # odb2vtkpath = "/home/simoneponcioni/Documents/04_TOOLS/ODB2VTK/python/odb2vtk.py" odb2vtkpath = "/storage/workspaces/artorg_msb/hpc_abaqus/poncioni/TOOLS/ODB2VTK/python/odb2vtk.py" - odb_path = "/storage/workspaces/artorg_msb/hpc_abaqus/poncioni/HFE/04_SIMULATIONS/REPRO/IMAGES/00000148/C1/T/C0001406_02.odb" + odb_path = "/storage/workspaces/artorg_msb/hpc_abaqus/poncioni/HFE/04_SIMULATIONS/REPRO_PAPER/IMAGES/00000148/C2/T/C0001407_06.odb" wrapper = Odb2VtkWrapper(odb2vtkpath, odb_path, abq_path, only_last_frame=True) vtk_path = wrapper.convert() - print(vtk_path) + logger.info(vtk_path) if __name__ == "__main__": diff --git a/02_CODE/src/hfe_utils/pos_monitor.mplstyle b/02_CODE/src/hfe_utils/pos_monitor.mplstyle new file mode 100644 index 0000000..69512e2 --- /dev/null +++ b/02_CODE/src/hfe_utils/pos_monitor.mplstyle @@ -0,0 +1,30 @@ +# Font Properties +font.family: STIXGeneral +mathtext.fontset: stix +font.size: 16 +# Axes properties +axes.linewidth: 2 +axes.labelpad: 10 +# Tick properties +# x-axis +xtick.top: True +xtick.direction: in# y-axis +ytick.right: True +ytick.direction: in + +# x-axis +xtick.major.size: 7 +xtick.major.width: 2 +xtick.minor.size: 5 +xtick.minor.width: 2# y-axis +ytick.major.size: 7 +ytick.major.width: 2 +ytick.minor.size: 5 +ytick.minor.width: 2 + +# Lines properties +lines.linewidth: 2 + +# Legend properties +legend.framealpha: 1 +legend.frameon: False diff --git a/02_CODE/src/pipeline_runner.py b/02_CODE/src/pipeline_runner.py index 4d0ae71..ef95627 100644 --- a/02_CODE/src/pipeline_runner.py +++ b/02_CODE/src/pipeline_runner.py @@ -95,7 +95,7 @@ def standalone_execution_sequential(cfg: HFEConfig): -@hydra.main(config_path="../cfg/", config_name="hfe-tibia", version_base=None) +@hydra.main(config_path="../cfg/", config_name="hfe-repro", version_base=None) def main(cfg: HFEConfig): EXECUTION_TYPE = ExecutionType.PYTHON diff --git a/QMSKI/DiceSimilarityCoefficient/Dice.ipynb b/QMSKI/DiceSimilarityCoefficient/Dice.ipynb deleted file mode 100644 index ac130d3..0000000 --- a/QMSKI/DiceSimilarityCoefficient/Dice.ipynb +++ /dev/null @@ -1,226 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import pyvista as pv\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import vtk\n", - "from vtk.util.numpy_support import numpy_to_vtk, vtk_to_numpy\n", - "import SimpleITK as sitk\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "def polydata_to_imagedata(polydata, dimensions=(100, 100, 100), padding=1):\n", - " '''\n", - " https://github.com/tfmoraes/polydata_to_imagedata/blob/main/polydata_to_imagedata.py\n", - " '''\n", - " xi, xf, yi, yf, zi, zf = polydata.GetBounds()\n", - " dx, dy, dz = dimensions\n", - "\n", - " # Calculating spacing\n", - " sx = (xf - xi) / dx\n", - " sy = (yf - yi) / dy\n", - " sz = (zf - zi) / dz\n", - "\n", - " # Calculating Origin\n", - " ox = xi + sx / 2.0\n", - " oy = yi + sy / 2.0\n", - " oz = zi + sz / 2.0\n", - "\n", - " if padding:\n", - " ox -= sx\n", - " oy -= sy\n", - " oz -= sz\n", - "\n", - " dx += 2 * padding\n", - " dy += 2 * padding\n", - " dz += 2 * padding\n", - "\n", - " image = vtk.vtkImageData()\n", - " image.SetSpacing((sx, sy, sz))\n", - " image.SetDimensions((dx, dy, dz))\n", - " image.SetExtent(0, dx - 1, 0, dy - 1, 0, dz - 1)\n", - " image.SetOrigin((ox, oy, oz))\n", - " image.AllocateScalars(vtk.VTK_UNSIGNED_CHAR, 1)\n", - "\n", - " inval = 1\n", - " outval = 0\n", - "\n", - " for i in range(image.GetNumberOfPoints()):\n", - " image.GetPointData().GetScalars().SetTuple1(i, inval)\n", - "\n", - " pol2stenc = vtk.vtkPolyDataToImageStencil()\n", - " pol2stenc.SetInputData(polydata)\n", - " pol2stenc.SetOutputOrigin((ox, oy, oz))\n", - " pol2stenc.SetOutputSpacing((sx, sy, sz))\n", - " pol2stenc.SetOutputWholeExtent(image.GetExtent())\n", - " pol2stenc.Update()\n", - "\n", - " imgstenc = vtk.vtkImageStencil()\n", - " imgstenc.SetInputData(image)\n", - " imgstenc.SetStencilConnection(pol2stenc.GetOutputPort())\n", - " imgstenc.ReverseStencilOff()\n", - " imgstenc.SetBackgroundValue(outval)\n", - " imgstenc.Update()\n", - "\n", - " return imgstenc.GetOutput()\n", - "\n", - "def vtk2numpy(imvtk):\n", - " \"\"\"turns a vtk image data into a numpy array\"\"\"\n", - " dim = imvtk.GetDimensions()\n", - " data = imvtk.GetPointData().GetScalars()\n", - " imnp = vtk_to_numpy(data)\n", - " # vtk and numpy have different array conventions\n", - " imnp = imnp.reshape(dim[2], dim[1], dim[0])\n", - " imnp = imnp.transpose(2, 1, 0)\n", - " return imnp\n", - "\n", - "def dice_coefficient(truth, prediction):\n", - " intersection = np.logical_and(truth, prediction)\n", - " return 1 - 2. * intersection.sum() / (truth.sum() + prediction.sum())" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# read masks and sum them together\n", - "cort_mask = sitk.ReadImage('/home/simoneponcioni/Documents/01_PHD/03_Methods/HFE/01_DATA/446_R_75_F/C0003091_CORTMASK.mhd')\n", - "trab_mask = sitk.ReadImage('/home/simoneponcioni/Documents/01_PHD/03_Methods/HFE/01_DATA/446_R_75_F/C0003091_TRABMASK.mhd')\n", - "mask_sitk = cort_mask + trab_mask\n", - "mask_np = sitk.GetArrayFromImage(mask_sitk)\n", - "mask_np = np.flip(mask_np, axis=1)\n", - "\n", - "plt.figure()\n", - "plt.imshow(mask_np[:,:,250])\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "mesh_p = '/home/simoneponcioni/Documents/01_PHD/03_Methods/HFE/03_MESH/C0003091sweep_1/C0003091sweep_1.vtk'\n", - "mesh = pv.read(mesh_p)\n", - "mesh['density'] = np.full(mesh.n_cells, 1)\n", - "mesh_grid = pv.create_grid(mesh, dimensions=(mask_np.shape[2], mask_np.shape[1], mask_np.shape[0]))\n", - "mesh_res = mesh_grid.sample(mesh)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "density_data = mesh_res.get_array(name=\"density\")\n", - "density_data_3d = density_data.reshape([mask_np.shape[0], mask_np.shape[1], mask_np.shape[2]])" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "mask_np = np.where(mask_np > 0, 1, 0)\n", - "density_data_3d = np.where(density_data_3d > 0, 1, 0)\n", - "\n", - "plt.figure()\n", - "plt.imshow(mask_np[:,:,mask_np.shape[2] // 2], cmap='gray')\n", - "plt.imshow(density_data_3d[:,:,mask_np.shape[2] // 2], cmap='gray', alpha=0.5)\n", - "plt.colorbar()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.9458073817413738\n" - ] - } - ], - "source": [ - "mask_sitk = sitk.GetImageFromArray(mask_np)\n", - "mesh_sitk = sitk.GetImageFromArray(density_data_3d)\n", - "mask_sitk.CopyInformation(mask_sitk)\n", - "mesh_sitk.CopyInformation(mask_sitk)\n", - "\n", - "meas = sitk.LabelOverlapMeasuresImageFilter()\n", - "meas.Execute(mask_sitk, mesh_sitk)\n", - "dice = meas.GetDiceCoefficient()\n", - "print(dice)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "hfe-accurate", - "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.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/QMSKI/SSAM/test_mesh_sum.ipynb b/QMSKI/SSAM/test_mesh_sum.ipynb deleted file mode 100644 index d8ee495..0000000 --- a/QMSKI/SSAM/test_mesh_sum.ipynb +++ /dev/null @@ -1,100 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import pyvista as pv\n", - "from pathlib import Path" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# 1. load all the meshes\n", - "base_path = Path('/home/simoneponcioni/Documents/01_PHD/04_Output-Reports-Presentations-Publications/HFE-RESULTS/strain-distribution/20240722')\n", - "mesh_paths = [mesh for mesh in base_path.rglob('*.vtu')]" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# create a loop and extract the cell data LE_Centroid for each mesh\n", - "LE_centroids = []\n", - "for mesh_path in mesh_paths:\n", - " mesh = pv.read(mesh_path)\n", - " # LE_centroids.append(mesh.cell_data['LE_Centroid'])\n", - " LE_centroids.append(mesh.cell_data['SDV_DMG_Centroid'])" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# now we have a list of LE_centroids, we can create a new mesh with the average LE_centroid\n", - "average_LE_centroid = sum(LE_centroids) / len(LE_centroids)\n", - "# we can apply the average LE_centroid to the mesh\n", - "ssm_path = Path('/home/simoneponcioni/Documents/01_PHD/03_Methods/Meshing/Meshing/03_MESH/tibia-ssm/tibia-ssm.vtk')\n", - "mesh = pv.read(ssm_path)\n", - "mesh.cell_data['LE_Centroid_avg'] = average_LE_centroid\n", - "mesh.save('/home/simoneponcioni/Documents/01_PHD/03_Methods/HFE/QMSKI/SSAM/tibia_ssm_DMG_centroid.vtu')" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['COORD_Centroid', 'COORD_IntegrationPoints', 'LE_Centroid', 'LE_IntegrationPoints', 'S_Centroid', 'S_IntegrationPoints', 'SDV_BVTVC_Centroid', 'SDV_BVTVC_IntegrationPoints', 'SDV_BVTVT_Centroid', 'SDV_BVTVT_IntegrationPoints', 'SDV_DMG_Centroid', 'SDV_DMG_IntegrationPoints', 'SDV_F11_Centroid', 'SDV_F11_IntegrationPoints', 'SDV_F12_Centroid', 'SDV_F12_IntegrationPoints', 'SDV_F13_Centroid', 'SDV_F13_IntegrationPoints', 'SDV_F21_Centroid', 'SDV_F21_IntegrationPoints', 'SDV_F22_Centroid', 'SDV_F22_IntegrationPoints', 'SDV_F23_Centroid', 'SDV_F23_IntegrationPoints', 'SDV_F31_Centroid', 'SDV_F31_IntegrationPoints', 'SDV_F32_Centroid', 'SDV_F32_IntegrationPoints', 'SDV_F33_Centroid', 'SDV_F33_IntegrationPoints', 'SDV_OFVALUE_Centroid', 'SDV_OFVALUE_IntegrationPoints', 'SDV_PBVC_Centroid', 'SDV_PBVC_IntegrationPoints', 'SDV_PBVT_Centroid', 'SDV_PBVT_IntegrationPoints', 'SENER_Centroid', 'SENER_IntegrationPoints', 'Material_Orientation']\n", - "[1.4458955e+01 1.3278940e+01 1.0874437e+01 ... 2.8786664e-03 2.4832610e-02\n", - " 2.4870580e-02]\n" - ] - } - ], - "source": [ - "# TESTING\n", - "import pyvista as pv\n", - "mesh = pv.read('/home/simoneponcioni/Desktop/energy_density/Step-Compression_23.vtu')\n", - "# print all cell data\n", - "print(mesh.cell_data.keys())\n", - "\n", - "print(mesh.cell_data['SENER_Centroid'])" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "hfe-accurate", - "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.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/QMSKI/SSAM/tests_pyssam.ipynb b/QMSKI/SSAM/tests_pyssam.ipynb deleted file mode 100644 index dc32176..0000000 --- a/QMSKI/SSAM/tests_pyssam.ipynb +++ /dev/null @@ -1,526 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### SSM For tibia and raadius periosteal and endosteal surfaces\n", - "\n", - "Still has some issues:\n", - "- L / R images are not correctly landmarked\n", - "- Images have to be all the same size in z-dir (my dataset is already partially filtered for joint surfaces, need to adapt)\n", - "- Should be ran on the repro dataset, not on the validation one (which is smaller)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import pyssam\n", - "from pathlib import Path\n", - "import SimpleITK as sitk\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import pyvista as pv\n", - "import point_cloud_utils as pcu\n", - "from copy import copy\n", - "from skimage.measure import find_contours\n", - "from scipy.interpolate import interp1d" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "basepath = Path('/home/simoneponcioni/Documents/01_PHD/03_Methods/HFE/01_DATA/TIBIA')\n", - "landmarkpath = Path('/home/simoneponcioni/Documents/01_PHD/03_Methods/HFE/QMSKI/SSAM/') / 'landmarks_ext'\n", - "landmarkpath = Path('/home/simoneponcioni/Documents/01_PHD/03_Methods/HFE/QMSKI/SSAM/') / 'landmarks_int'\n", - "# for all subdirs, get all '_CORTMASK' files\n", - "cort_list = []\n", - "trab_list = []\n", - "for file in basepath.iterdir():\n", - " if file.is_file() and '_CORTMASK' in file.name and 'mhd' in file.suffix:\n", - " cort_list.append(file)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "def classify_and_store_contours(mask, slice_idx):\n", - " contours = find_contours(mask[:, :, slice_idx]) # , level=0.5)\n", - " if contours:\n", - " outer_contours = contours[0] # First contour as outer\n", - " if len(contours) > 1:\n", - " inner_contours = contours[1] # Second contour as inner\n", - " return outer_contours, inner_contours\n", - "\n", - "def interpolate_contour(contour, num_points=100):\n", - " distances = np.sqrt(np.sum(np.diff(contour, axis=0)**2, axis=1))\n", - " cumulative_distances = np.insert(np.cumsum(distances), 0, 0)\n", - "\n", - " interp_func = interp1d(cumulative_distances, contour, axis=0, kind='linear')\n", - " new_distances = np.linspace(0, cumulative_distances[-1], num_points)\n", - "\n", - " interpolated_contour = interp_func(new_distances)\n", - " return interpolated_contour\n", - "\n", - "def process_image(imnp):\n", - " # get contour for each slice\n", - " out_list = []\n", - " inn_list = []\n", - " for slice_idx in range(imnp.shape[2]):\n", - " out, inn = classify_and_store_contours(imnp, slice_idx)\n", - " # add slice_idx to array\n", - " out = np.column_stack((out, np.ones(out.shape[0]) * slice_idx))\n", - " inn = np.column_stack((inn, np.ones(inn.shape[0]) * slice_idx))\n", - "\n", - " # interpolate contours\n", - " out = interpolate_contour(out, num_points=100)\n", - " inn = interpolate_contour(inn, num_points=100)\n", - "\n", - " out_list.append(out)\n", - " inn_list.append(inn)\n", - " return out_list, inn_list" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting contours from C0003096_CORTMASK.mhd\n", - "Extracting contours from C0003109_CORTMASK.mhd\n", - "Extracting contours from C0003098_CORTMASK.mhd\n", - "Extracting contours from C0003111_CORTMASK.mhd\n", - "Extracting contours from C0003095_CORTMASK.mhd\n", - "Extracting contours from C0003105_CORTMASK.mhd\n", - "Extracting contours from C0003106_CORTMASK.mhd\n", - "Extracting contours from C0003104_CORTMASK.mhd\n", - "Extracting contours from C0003108_CORTMASK.mhd\n", - "Extracting contours from C0003110_CORTMASK.mhd\n", - "Extracting contours from C0003101_CORTMASK.mhd\n", - "Extracting contours from C0003103_CORTMASK.mhd\n", - "Extracting contours from C0003115_CORTMASK.mhd\n", - "Extracting contours from C0003116_CORTMASK.mhd\n", - "Extracting contours from C0003112_CORTMASK.mhd\n", - "Extracting contours from C0003118_CORTMASK.mhd\n", - "Extracting contours from C0003114_CORTMASK.mhd\n", - "Extracting contours from C0003091_CORTMASK.mhd\n", - "Extracting contours from C0003097_CORTMASK.mhd\n", - "Extracting contours from C0003094_CORTMASK.mhd\n", - "Extracting contours from C0003099_CORTMASK.mhd\n", - "Extracting contours from C0003113_CORTMASK.mhd\n", - "Extracting contours from C0003117_CORTMASK.mhd\n" - ] - } - ], - "source": [ - "# Extract endosteal and periosteal surfaces\n", - "all_points_endo = []\n", - "all_points_peri = []\n", - "for file in cort_list:\n", - " print(f'Extracting contours from {file.name}')\n", - " sitk_image = sitk.ReadImage(str(file))\n", - " np_image = sitk.GetArrayFromImage(sitk_image)\n", - " np_image = np.transpose(np_image, (2, 1, 0))\n", - " np_image = np.flip(np_image, axis=0)\n", - " np_image = np_image[:, :, 5:450]\n", - " out_list, inn_list = process_image(np_image)\n", - " out_list = np.array(out_list).reshape(-1, 3)\n", - " inn_list = np.array(inn_list).reshape(-1, 3)\n", - "\n", - " all_points_endo.append(inn_list)\n", - " all_points_peri.append(out_list)\n", - "landmarks = np.array(all_points_endo)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "ssm_obj = pyssam.SSM(landmarks)\n", - "ssm_obj.create_pca_model(ssm_obj.landmarks_columns_scale)\n", - "mean_shape_columnvector = ssm_obj.compute_dataset_mean()\n", - "mean_shape = mean_shape_columnvector.reshape(-1, 3)\n", - "shape_model_components = ssm_obj.pca_model_components" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# Define some plotting functions\n", - "def plot_cumulative_variance(explained_variance, target_variance=-1):\n", - " number_of_components = np.arange(0, len(explained_variance))+1\n", - " fig, ax = plt.subplots(1,1)\n", - " color = \"blue\"\n", - " ax.plot(number_of_components, explained_variance*100.0, marker=\"o\", ms=2, color=color, mec=color, mfc=color)\n", - " if target_variance > 0.0:\n", - " ax.axhline(target_variance*100.0)\n", - " \n", - " ax.set_ylabel(\"Variance [%]\")\n", - " ax.set_xlabel(\"Number of components\")\n", - " ax.grid(axis=\"x\")\n", - " plt.show()\n", - " \n", - "def plot_shape_modes(\n", - " mean_shape_columnvector, \n", - " mean_shape, \n", - " original_shape_parameter_vector,\n", - " shape_model_components,\n", - " mode_to_plot,\n", - "):\n", - " weights = [-2, 0, 2]\n", - " fig, ax = plt.subplots(1, 3)\n", - " for j, weights_i in enumerate(weights):\n", - " shape_parameter_vector = copy(original_shape_parameter_vector)\n", - " shape_parameter_vector[mode_to_plot] = weights_i\n", - " mode_i_coords = ssm_obj.morph_model(\n", - " mean_shape_columnvector, \n", - " shape_model_components, \n", - " shape_parameter_vector\n", - " ).reshape(-1, 3)\n", - "\n", - " offset_dist = pyssam.utils.euclidean_distance(\n", - " mean_shape, \n", - " mode_i_coords\n", - " )\n", - " # colour points blue if closer to point cloud centre than mean shape\n", - " mean_shape_dist_from_centre = pyssam.utils.euclidean_distance(\n", - " mean_shape,\n", - " np.zeros(3),\n", - " )\n", - " mode_i_dist_from_centre = pyssam.utils.euclidean_distance(\n", - " mode_i_coords,\n", - " np.zeros(3),\n", - " )\n", - " offset_dist = np.where(\n", - " mode_i_dist_from_centre" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "print(f\"To obtain {ssm_obj.desired_variance*100}% variance, {ssm_obj.required_mode_number} modes are required\")\n", - "plot_cumulative_variance(np.cumsum(ssm_obj.pca_object.explained_variance_ratio_), 0.9)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "explained variance is 0.0807170243072318\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "mode_to_plot = 1\n", - "print(f\"explained variance is {ssm_obj.pca_object.explained_variance_ratio_[mode_to_plot]}\")\n", - "\n", - "plot_shape_modes(\n", - " mean_shape_columnvector, \n", - " mean_shape, \n", - " ssm_obj.model_parameters,\n", - " ssm_obj.pca_model_components,\n", - " mode_to_plot,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "# convert mean shape to pyvista mesh\n", - "mean_shape_mesh = pv.PolyData(mean_shape)\n", - "mean_shape_mesh.plot(notebook=False)\n", - "# save mean shape to file\n", - "mean_shape_mesh.save('ssm.vtk')" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[0m\u001b[33m2024-08-08 16:08:04.463 (6896.178s) [ 7F793BC4F740] vtkDelaunay3D.cxx:513 WARN| vtkDelaunay3D (0x558336edc220): 2 degenerate triangles encountered, mesh quality suspect\u001b[0m\n" - ] - } - ], - "source": [ - "import tetgen\n", - "\n", - "# Read the VTK files\n", - "peri = pv.read('/home/simoneponcioni/Documents/01_PHD/03_Methods/HFE/ssm_periosteum.vtk')\n", - "endo = pv.read('/home/simoneponcioni/Documents/01_PHD/03_Methods/HFE/ssm_endosteum.vtk')\n", - "\n", - "# Process periosteum\n", - "surf_peri = peri.delaunay_3d()\n", - "tet_peri = tetgen.TetGen(surf_peri.extract_surface())\n", - "tet_peri.tetrahedralize(order=1, mindihedral=20)\n", - "grid_peri = tet_peri.grid.extract_surface()\n", - "\n", - "# Process endosteum\n", - "surf_endo = endo.delaunay_3d()\n", - "tet_endo = tetgen.TetGen(surf_endo.extract_surface())\n", - "tet_endo.tetrahedralize(order=1, mindihedral=20)\n", - "grid_endo = tet_endo.grid.extract_surface()\n", - "\n", - "# Perform boolean difference operation\n", - "cut = grid_peri.boolean_difference(grid_endo)\n", - "\n", - "# Plotting\n", - "pl = pv.Plotter(notebook=False, shape=(1, 2))\n", - "pl.add_mesh(grid_peri, show_edges=True, opacity=0.5, color='grey')\n", - "pl.add_mesh(grid_endo, color=\"orange\", show_edges=False, opacity=0.5)\n", - "pl.add_mesh(cut, color=\"red\")\n", - "pl.subplot(0, 1)\n", - "pl.add_mesh(cut, color=\"red\")\n", - "pl.link_views()\n", - "pl.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 58, - "metadata": {}, - "outputs": [], - "source": [ - "import pyvista as pv\n", - "import tetgen\n", - "import numpy as np\n", - "\n", - "# Load or create your PLC\n", - "sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)\n", - "\n", - "# Generate a background mesh with desired resolution\n", - "def generate_background_mesh(bounds, resolution=20, eps=1e-6):\n", - " x_min, x_max, y_min, y_max, z_min, z_max = bounds\n", - " grid_x, grid_y, grid_z = np.meshgrid(\n", - " np.linspace(x_min - eps, x_max + eps, resolution),\n", - " np.linspace(y_min - eps, y_max + eps, resolution),\n", - " np.linspace(z_min - eps, z_max + eps, resolution),\n", - " indexing=\"ij\",\n", - " )\n", - " return pv.StructuredGrid(grid_x, grid_y, grid_z).triangulate()\n", - "\n", - "bg_mesh = generate_background_mesh(sphere.bounds)\n", - "\n", - "# Define sizing function based on radial distance from a focus point\n", - "def radial_sizing_function(points, focus_point=np.array([0, 0, 0]), max_size=1.0, min_size=0.1):\n", - " distances = np.linalg.norm(points - focus_point, axis=1)\n", - " # Invert the distances to make the center coarser and the outer thinner\n", - " sizes = min_size + (max_size - min_size) * (1 - distances / np.max(distances))\n", - " return np.clip(sizes, min_size, max_size)\n", - "\n", - "# Apply the sizing function to the mesh\n", - "bg_mesh.point_data['target_size'] = radial_sizing_function(bg_mesh.points, focus_point=np.array([0, 1, 0]), max_size=2.0, min_size=0.01)\n", - "\n", - "tet_kwargs = dict(order=1, mindihedral=20, minratio=1.5)\n", - "tet = tetgen.TetGen(sphere)\n", - "tet.tetrahedralize(bgmesh=bg_mesh, **tet_kwargs)\n", - "refined_mesh = tet.grid\n", - "\n", - "# Plotting\n", - "pl = pv.Plotter(notebook=False, shape=(1, 2))\n", - "# clip sphere to show the interior in plane 0, 1, 0\n", - "sphere_clipped = sphere.clip(normal=[1,0,0], invert=True)\n", - "pl.add_mesh(sphere_clipped, show_edges=True, opacity=0.5, color='grey')\n", - "# pl.add_mesh(sphere, show_edges=True, opacity=1.0, color='grey')\n", - "pl.subplot(0, 1)\n", - "pl.add_mesh(refined_mesh, color=\"orange\", show_edges=True, opacity=1)\n", - "pl.link_views()\n", - "pl.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 74, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/simoneponcioni/anaconda3/envs/hfe-accurate/lib/python3.9/site-packages/pyvista/plotting/_plotting.py:282: PyVistaDeprecationWarning: \n", - "\"stitle\" is a deprecated keyword argument and will be removed in a future\n", - "release.\n", - "\n", - "Use ``scalar_bar_args`` instead. For example:\n", - "\n", - "scalar_bar_args={'title': 'Scalar Bar Title'}\n", - "\n", - " warnings.warn(USE_SCALAR_BAR_ARGS, PyVistaDeprecationWarning)\n" - ] - } - ], - "source": [ - "# based on https://tetgen.pyvista.org/\n", - "\n", - "import pyvista as pv\n", - "import tetgen\n", - "import numpy as np\n", - "\n", - "pv.set_plot_theme('document')\n", - "\n", - "# Load or create your PLC\n", - "sphere = pv.Sphere(theta_resolution=10, phi_resolution=10)\n", - "\n", - "# Generate a background mesh with desired resolution\n", - "def generate_background_mesh(bounds, resolution=20, eps=1e-6):\n", - " x_min, x_max, y_min, y_max, z_min, z_max = bounds\n", - " grid_x, grid_y, grid_z = np.meshgrid(\n", - " np.linspace(x_min - eps, x_max + eps, resolution),\n", - " np.linspace(y_min - eps, y_max + eps, resolution),\n", - " np.linspace(z_min - eps, z_max + eps, resolution),\n", - " indexing=\"ij\",\n", - " )\n", - " return pv.StructuredGrid(grid_x, grid_y, grid_z).triangulate()\n", - "\n", - "bg_mesh = generate_background_mesh(sphere.bounds)\n", - "\n", - "# Define sizing function based on radial distance from a focus point\n", - "def radial_sizing_function(points, focus_point=np.array([0, 0, 0]), max_size=1.0, min_size=0.1):\n", - " distances = np.linalg.norm(points - focus_point, axis=1)\n", - " # Scale the sizes to make the center finer and the outer coarser\n", - " sizes = min_size + (max_size - min_size) * (distances / np.max(distances))\n", - " return np.clip(sizes, min_size, max_size)\n", - "\n", - "# Apply the sizing function to the mesh\n", - "bg_mesh.point_data['target_size'] = radial_sizing_function(bg_mesh.points, focus_point=np.array([0, 0, 0]), max_size=0.2, min_size=0.001)\n", - "\n", - "# Tetrahedralize with background mesh\n", - "tet_kwargs = dict(order=1, mindihedral=20, minratio=1.5)\n", - "tet = tetgen.TetGen(sphere)\n", - "tet.tetrahedralize(bgmesh=bg_mesh, **tet_kwargs)\n", - "grid = tet.grid\n", - "\n", - "# Get cell centroids\n", - "cells = grid.cells.reshape(-1, 5)[:, 1:]\n", - "cell_center = grid.points[cells].mean(1)\n", - "\n", - "# Extract cells below the 0 xy plane\n", - "mask = cell_center[:, 2] < 0\n", - "cell_ind = mask.nonzero()[0]\n", - "subgrid = grid.extract_cells(cell_ind)\n", - "\n", - "# Compute cell quality\n", - "cell_qual = subgrid.compute_cell_quality()['CellQuality']\n", - "\n", - "# Plotting\n", - "pl = pv.Plotter(notebook=False, shape=(1, 2))\n", - "# Clip sphere to show the interior in plane 0, 1, 0\n", - "pl.add_mesh(sphere, show_edges=True, opacity=1.0, color='grey')\n", - "pl.subplot(0, 1)\n", - "pl.add_mesh(subgrid, scalars=cell_qual, stitle='Quality', cmap='bwr', clim=[0, 1], flip_scalars=True, show_edges=True)\n", - "pl.link_views()\n", - "pl.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "testing", - "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.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/QMSKI/convergence_study/sensitivity_analysis.ipynb b/QMSKI/convergence_study/sensitivity_analysis.ipynb index 8322f16..dc303aa 100644 --- a/QMSKI/convergence_study/sensitivity_analysis.ipynb +++ b/QMSKI/convergence_study/sensitivity_analysis.ipynb @@ -54,26 +54,7 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(0.6, 0.0, 0.2)\n" - ] - } - ], - "source": [ - "rgb_color = (153, 0, 51)\n", - "rgb_color_base1 = tuple([round(x/255, 2) for x in rgb_color])\n", - "print(rgb_color_base1)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { "metadata": {} }, @@ -87,7 +68,7 @@ "import statistics\n", "\n", "\n", - "matplotlib.style.use('/home/simoneponcioni/Documents/01_PHD/03_Methods/Meshing/Meshing/02_CODE/src/pyhexspline/cfgdir/pos_monitor.mplstyle')" + "matplotlib.style.use('../../02_CODE/src/hfe_utils/pos_monitor.mplstyle')" ] }, { @@ -98,9 +79,8 @@ }, "outputs": [], "source": [ - "df_tibia = pd.read_csv('convergence_study/convergence_tibia.csv')\n", - "df_radius = pd.read_csv('convergence_study/convergence_radius.csv')\n", - "# img = mpimg.imread('C0003091.png')\n", + "df_tibia = pd.read_csv('convergence_tibia.csv')\n", + "df_radius = pd.read_csv('convergence_radius.csv')\n", "df_list = [df_tibia, df_radius]\n", "df_names = ['Tibia', 'Radius']\n", "props = ['stiffness', 'yield']" @@ -196,9 +176,7 @@ " else:\n", " yield_force_dfs.append((dofs, mean_errors, std_errors, df_name))\n", "\n", - "# Create a figure with 2 horizontal subplots\n", "fig, axs = plt.subplots(nrows=1, ncols=2, figsize=(12, 6))\n", - "\n", "# Plot stiffness\n", "for dofs, mean_errors, std_errors, df_name in stiffness_dfs:\n", " if df_name == 'Radius':\n", @@ -207,7 +185,6 @@ " _color = 'tab:blue'\n", " axs[0].errorbar(dofs, mean_errors, yerr=std_errors, fmt='o', label=f'{df_name}', color=_color)\n", " axs[0].plot(dofs, mean_errors, linestyle='--', color=_color)\n", - " print(f'{df_name} - {dofs} - {mean_errors} - {std_errors}')\n", "axs[0].axhline(0, color='tab:grey', linestyle='--')\n", "axs[0].axhline(2, color='tab:green', linestyle='--')\n", "axs[0].set_xscale('log')\n", @@ -234,17 +211,10 @@ "\n", "# Adjust layout\n", "plt.tight_layout()\n", - "# plt.savefig('mesh-sensitivity-analysis.png', dpi=300, bbox_inches='tight')\n", + "plt.savefig('mesh-sensitivity-analysis.png', dpi=300, bbox_inches='tight')\n", "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": 22, @@ -345,9 +315,6 @@ " dofs = grouped_df.index\n", " mean_simulation_time = grouped_df['mean'] / 60\n", " std_simulation_time = grouped_df['std'].fillna(0) / 60 # Handle NaN values\n", - " print(f\"Mean simulation time (minutes) for {df_name}:\\n\", mean_simulation_time)\n", - " print(f\"Standard deviation of simulation time (minutes) for {df_name}:\\n\", std_simulation_time)\n", - "\n", " simulation_time_dfs.append((dofs, mean_simulation_time, std_simulation_time, df_name))\n", "\n", "plt.figure(figsize=(6, 6))\n", @@ -356,13 +323,9 @@ " _color = 'tab:red'\n", " else:\n", " _color = 'tab:blue'\n", - " print(len(dofs))\n", - " print(dofs)\n", - " print(len(mean_times))\n", - " print(len(std_times))\n", - "\n", " plt.errorbar(dofs, mean_times, yerr=std_times, fmt='o', label=f'{df_name}', color=_color)\n", " plt.plot(dofs, mean_times, linestyle='--', color=_color)\n", + "\n", "plt.xscale('log')\n", "plt.yscale('log')\n", "plt.xlim(1e3)\n", @@ -374,13 +337,6 @@ "plt.savefig('simulation-time.png', dpi=300, bbox_inches='tight')" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "code", "execution_count": null, @@ -412,174 +368,6 @@ " simulation_time_dfs.append((dofs, mean_simulation_times, std_simulation_times, df_name))" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(12, 12), sharex='col', sharey='row')\n", - "fig, axs = plt.subplot_mosaic([['stiffness', 'yield'], ['simulation_time', 'simulation_time']], figsize=(12, 12))\n", - "\n", - "# Plot stiffness\n", - "for dofs, mean_errors, std_errors, df_name in stiffness_dfs:\n", - " if df_name == 'Radius':\n", - " _color = 'tab:red'\n", - " else:\n", - " _color = 'tab:blue'\n", - " axs['stiffness'].errorbar(dofs, mean_errors, yerr=std_errors, fmt='o', label=f'{df_name}', color=_color)\n", - " axs['stiffness'].plot(dofs, mean_errors, linestyle='--', color=_color)\n", - "axs['stiffness'].set_xscale('log')\n", - "axs['stiffness'].set_xlabel('Degrees of Freedom (-)')\n", - "axs['stiffness'].set_ylabel('Relative error (%)')\n", - "axs['stiffness'].set_title('Relative error in stiffness estimation', weight='bold')\n", - "axs['stiffness'].legend()\n", - "\n", - "# Plot yield force\n", - "for dofs, mean_errors, std_errors, df_name in yield_force_dfs:\n", - " if df_name == 'Radius':\n", - " _color = 'tab:red'\n", - " else:\n", - " _color = 'tab:blue'\n", - " axs['yield'].errorbar(dofs, mean_errors, yerr=std_errors, fmt='o', label=f'{df_name}', color=_color)\n", - " axs['yield'].plot(dofs, mean_errors, linestyle='--', color=_color)\n", - "axs['yield'].set_xscale('log')\n", - "axs['yield'].set_xlabel('Degrees of Freedom (-)')\n", - "axs['yield'].set_ylabel('Relative error (%)')\n", - "axs['yield'].set_title('Relative error in yield force estimation', weight='bold')\n", - "axs['yield'].legend()\n", - "\n", - "# Plot simulation_time\n", - "for dofs, mean_times, std_times, df_name in simulation_time_dfs:\n", - " if df_name == 'Radius':\n", - " _color = 'tab:red'\n", - " else:\n", - " _color = 'tab:blue'\n", - " axs['simulation_time'].errorbar(dofs, mean_times, yerr=std_times, fmt='o', label=f'{df_name}', color=_color)\n", - " axs['simulation_time'].plot(dofs, mean_times, linestyle='--', color=_color)\n", - "axs['simulation_time'].set_xscale('log')\n", - "axs['simulation_time'].set_yscale('log')\n", - "axs['simulation_time'].set_xlim(1e3)\n", - "axs['simulation_time'].set_ylim(1e-0)\n", - "axs['simulation_time'].set_xlabel('Degrees of Freedom (-)')\n", - "axs['simulation_time'].set_ylabel('Simulation Time (min)')\n", - "axs['simulation_time'].set_title('Wall Clock Time', weight='bold')\n", - "axs['simulation_time'].legend()\n", - "\n", - "# Remove unused subplot\n", - "# fig.delaxes(axs['simulation_time'])\n", - "\n", - "# Adjust layout\n", - "plt.tight_layout()\n", - "plt.savefig('combined-plots.png', dpi=300, bbox_inches='tight')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(12, 12), sharex='col', sharey='row')\n", - "\n", - "# ... your other plots ...\n", - "\n", - "# Plot simulation_time\n", - "for dofs, mean_times, std_times, df_name in simulation_time_dfs:\n", - " if df_name == 'Radius':\n", - " _color = 'tab:red'\n", - " else:\n", - " _color = 'tab:blue'\n", - " axs[1, 0].errorbar(dofs, mean_times, yerr=std_times, fmt='o', label=f'{df_name}', color=_color)\n", - " axs[1, 0].plot(dofs, mean_times, linestyle='--', color=_color)\n", - "axs[1, 0].set_xscale('log')\n", - "axs[1, 0].set_yscale('log')\n", - "axs[1, 0].set_xlim(1e3)\n", - "axs[1, 0].set_ylim(1e-0)\n", - "axs[1, 0].set_xlabel('Degrees of Freedom (-)')\n", - "axs[1, 0].set_ylabel('Simulation Time (min)')\n", - "axs[1, 0].set_title('Wall Clock Time', weight='bold')\n", - "axs[1, 0].legend()\n", - "\n", - "# Remove unused subplot\n", - "fig.delaxes(axs[1,1])\n", - "\n", - "# Adjust layout\n", - "plt.tight_layout()\n", - "plt.savefig('combined-plots.png', dpi=300, bbox_inches='tight')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, axs = plt.subplots(nrows=2, ncols=2, figsize=(12, 12), sharex='col', sharey='row')\n", - "\n", - "# ... your other plots ...\n", - "\n", - "# Plot simulation_time\n", - "for dofs, mean_times, std_times, df_name in simulation_time_dfs:\n", - " if df_name == 'Radius':\n", - " _color = 'tab:red'\n", - " else:\n", - " _color = 'tab:blue'\n", - " axs[1, 0].errorbar(dofs, mean_times, yerr=std_times, fmt='o', label=f'{df_name}', color=_color)\n", - " axs[1, 0].plot(dofs, mean_times, linestyle='--', color=_color)\n", - "axs[1, 0].set_xscale('log')\n", - "axs[1, 0].set_yscale('log')\n", - "axs[1, 0].set_xlim(1e3)\n", - "axs[1, 0].set_ylim(1e-0)\n", - "axs[1, 0].set_xlabel('Degrees of Freedom (-)')\n", - "axs[1, 0].set_ylabel('Simulation Time (min)')\n", - "axs[1, 0].set_title('Wall Clock Time', weight='bold')\n", - "axs[1, 0].legend()\n", - "\n", - "# Remove unused subplot\n", - "fig.delaxes(axs[1,1])\n", - "\n", - "# Adjust layout\n", - "plt.tight_layout()\n", - "plt.savefig('combined-plots.png', dpi=300, bbox_inches='tight')\n", - "plt.show()" - ] - }, { "cell_type": "markdown", "metadata": {}, diff --git a/QMSKI/gluer_repeatability/gluer_reproducibility.ipynb b/QMSKI/gluer_repeatability/gluer_reproducibility.ipynb index 76fb883..9547076 100644 --- a/QMSKI/gluer_repeatability/gluer_reproducibility.ipynb +++ b/QMSKI/gluer_repeatability/gluer_reproducibility.ipynb @@ -1,5 +1,16 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculate coefficient of variation as per Glüer et al. (1995)\n", + "\n", + "Author: Simone Poncioni, MSB, ARTORG Center for Biomedical Engineering Research, University of Bern, Switzerland\n", + "\n", + "Date: 07.2024" + ] + }, { "cell_type": "code", "execution_count": null, @@ -376,13 +387,6 @@ "plt.tight_layout()\n", "plt.show()\n" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/QMSKI/validation/linreg.ipynb b/QMSKI/validation/linreg.ipynb deleted file mode 100644 index 3da3286..0000000 --- a/QMSKI/validation/linreg.ipynb +++ /dev/null @@ -1,111 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/simoneponcioni/anaconda3/envs/testing/lib/python3.9/site-packages/pandas/core/arrays/masked.py:60: UserWarning: Pandas requires version '1.3.6' or newer of 'bottleneck' (version '1.3.2' currently installed).\n", - " from pandas.core import (\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "import statsmodels.api as sm" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Slope: 0.6000000000000004\n", - "Slope Standard Error: 0.282842712474619\n", - "T-Statistic: 2.121320343559644\n", - "P-Value: 0.12402706265755435\n", - " OLS Regression Results \n", - "==============================================================================\n", - "Dep. Variable: y R-squared: 0.600\n", - "Model: OLS Adj. R-squared: 0.467\n", - "Method: Least Squares F-statistic: 4.500\n", - "Date: Fri, 26 Jul 2024 Prob (F-statistic): 0.124\n", - "Time: 09:13:45 Log-Likelihood: -5.2598\n", - "No. Observations: 5 AIC: 14.52\n", - "Df Residuals: 3 BIC: 13.74\n", - "Df Model: 1 \n", - "Covariance Type: nonrobust \n", - "==============================================================================\n", - " coef std err t P>|t| [0.025 0.975]\n", - "------------------------------------------------------------------------------\n", - "const 2.2000 0.938 2.345 0.101 -0.785 5.185\n", - "x1 0.6000 0.283 2.121 0.124 -0.300 1.500\n", - "==============================================================================\n", - "Omnibus: nan Durbin-Watson: 2.017\n", - "Prob(Omnibus): nan Jarque-Bera (JB): 0.570\n", - "Skew: 0.289 Prob(JB): 0.752\n", - "Kurtosis: 1.450 Cond. No. 8.37\n", - "==============================================================================\n", - "\n", - "Notes:\n", - "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/simoneponcioni/anaconda3/envs/testing/lib/python3.9/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 5 samples were given.\n", - " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" - ] - } - ], - "source": [ - "x = sm.add_constant(x)\n", - "\n", - "model = sm.OLS(y, x).fit()\n", - "slope = model.params[1]\n", - "slope_se = model.bse[1]\n", - "\n", - "t_stat = slope / slope_se\n", - "\n", - "p_value = model.pvalues[1]\n", - "\n", - "print(f\"Slope: {slope}\")\n", - "print(f\"Slope Standard Error: {slope_se}\")\n", - "print(f\"T-Statistic: {t_stat}\")\n", - "print(f\"P-Value: {p_value}\")\n", - "print(model.summary())\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "testing", - "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.9.17" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 3f03ec04111ff7f6a866541866fa784d3693d67e Mon Sep 17 00:00:00 2001 From: SimonePoncioni <57197609+simoneponcioni@users.noreply.github.com> Date: Mon, 2 Sep 2024 11:30:37 +0200 Subject: [PATCH 4/8] Update issue templates --- .github/ISSUE_TEMPLATE/bug_report.md | 38 ++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 .github/ISSUE_TEMPLATE/bug_report.md diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md new file mode 100644 index 0000000..dd84ea7 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug_report.md @@ -0,0 +1,38 @@ +--- +name: Bug report +about: Create a report to help us improve +title: '' +labels: '' +assignees: '' + +--- + +**Describe the bug** +A clear and concise description of what the bug is. + +**To Reproduce** +Steps to reproduce the behavior: +1. Go to '...' +2. Click on '....' +3. Scroll down to '....' +4. See error + +**Expected behavior** +A clear and concise description of what you expected to happen. + +**Screenshots** +If applicable, add screenshots to help explain your problem. + +**Desktop (please complete the following information):** + - OS: [e.g. iOS] + - Browser [e.g. chrome, safari] + - Version [e.g. 22] + +**Smartphone (please complete the following information):** + - Device: [e.g. iPhone6] + - OS: [e.g. iOS8.1] + - Browser [e.g. stock browser, safari] + - Version [e.g. 22] + +**Additional context** +Add any other context about the problem here. From 54be01dde51b30a351d9aff7faea48b29b103c44 Mon Sep 17 00:00:00 2001 From: Simone Poncioni Date: Mon, 2 Sep 2024 11:32:06 +0200 Subject: [PATCH 5/8] added BVTVT and BVTVC eval for repro --- 02_CODE/src/hfe_utils/imutils.py | 5 ---- QMSKI/gluer_repeatability/rho.py | 40 ++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 5 deletions(-) create mode 100644 QMSKI/gluer_repeatability/rho.py diff --git a/02_CODE/src/hfe_utils/imutils.py b/02_CODE/src/hfe_utils/imutils.py index 30107dd..2a40b65 100644 --- a/02_CODE/src/hfe_utils/imutils.py +++ b/02_CODE/src/hfe_utils/imutils.py @@ -325,11 +325,6 @@ def read_aim(name, filenames, bone, lock): print("Removing 10 slices") IMG_pad = IMG_pad[5:-10, :, :] print(IMG_pad.GetSize()) - else: - #IMG_pad = IMG_pad[10:-10, :, :] - # pass - # ! Updated for the REPRO dataset, check robustness - IMG_pad = IMG_pad[10:-40, :, :] IMG_array = sitk.GetArrayFromImage(IMG_pad) diff --git a/QMSKI/gluer_repeatability/rho.py b/QMSKI/gluer_repeatability/rho.py new file mode 100644 index 0000000..bb72abe --- /dev/null +++ b/QMSKI/gluer_repeatability/rho.py @@ -0,0 +1,40 @@ +import numpy as np +import pyvista as pv +from pathlib import Path + + +def list_vtus(basepath: Path): + vtu_list = basepath.rglob("*_with_data.vtu") + return list(vtu_list) + + +def read_rho_vtu(vtu_path: Path): + vtu = pv.read(str(vtu_path)) + bvtvt = vtu.cell_data["SDV_BVTVT_Centroid"] + avg_bvtvt = np.mean(bvtvt) + bvtvc = vtu.cell_data["SDV_BVTVC_Centroid"] + avg_bvtvc = np.mean(bvtvc) + return avg_bvtvt, avg_bvtvc + + +def append_csv(csv_path: Path, vtu_path: Path, bvtvt: float, bvtvc: float): + vtu_name = vtu_path.stem.split('_')[0] + with open(csv_path, "a") as f: + f.write(f"{vtu_name},{bvtvt},{bvtvc}\n") + + +def main(): + basepath = Path("/storage/workspaces/artorg_msb/hpc_abaqus/poncioni/HFE/04_SIMULATIONS/REPRO_PAPER/IMAGES") + csv_path = Path.cwd() / "rho.csv" + + vtu_l = list_vtus(basepath) + + for vtu_path in vtu_l: + bvtvt, bvtvc = read_rho_vtu(vtu_path) + append_csv(csv_path, vtu_path, bvtvt, bvtvc) + + return None + + +if __name__ == "__main__": + main() From 1cfc4fd9e66efb1c9a737335888493c653be5549 Mon Sep 17 00:00:00 2001 From: Simone Poncioni Date: Mon, 2 Sep 2024 11:35:23 +0200 Subject: [PATCH 6/8] updated hfe_accurate.py --- 02_CODE/src/hfe_accurate/hfe_accurate.py | 46 ++++++++++++------------ 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/02_CODE/src/hfe_accurate/hfe_accurate.py b/02_CODE/src/hfe_accurate/hfe_accurate.py index 6635c27..0f9916e 100644 --- a/02_CODE/src/hfe_accurate/hfe_accurate.py +++ b/02_CODE/src/hfe_accurate/hfe_accurate.py @@ -36,31 +36,31 @@ # flake8: noqa: E402, W503 +''' +# TODO: reactivate this for mesh sensitivity analysis +# n_sim = int(15) # has to match sweep in config +# min = 5, 5, 2, 7 +# max = 20, 50, 10, 50 did not work, reducing to 20, 40, 10, 40 +n_elms_longitudinal = np.linspace(1, 20, n_sim, dtype=int) +n_elms_transverse_trab = np.linspace(3, 50, n_sim, dtype=int) +n_elms_transverse_cort = np.linspace(1, 10, n_sim, dtype=int) +n_radial = np.linspace(3, 50, n_sim, dtype=int) + +# update meshing settings with sweep factor for sensitivity analysis +sweep = cfg.meshing_settings.sweep_factor +cfg.meshing_settings.n_elms_longitudinal = int( + n_elms_longitudinal[sweep - 1].item() +) +cfg.meshing_settings.n_elms_transverse_trab = int( + n_elms_transverse_trab[sweep - 1].item() +) +cfg.meshing_settings.n_elms_transverse_cort = int( + n_elms_transverse_cort[sweep - 1].item() +) +cfg.meshing_settings.n_elms_radial = int(n_radial[sweep - 1].item()) +''' def pipeline_hfe(cfg, folder_id, grayscale_filename): - ''' - # TODO: reactivate this for mesh sensitivity analysis - # n_sim = int(15) # has to match sweep in config - # min = 5, 5, 2, 7 - # max = 20, 50, 10, 50 did not work, reducing to 20, 40, 10, 40 - n_elms_longitudinal = np.linspace(1, 20, n_sim, dtype=int) - n_elms_transverse_trab = np.linspace(3, 50, n_sim, dtype=int) - n_elms_transverse_cort = np.linspace(1, 10, n_sim, dtype=int) - n_radial = np.linspace(3, 50, n_sim, dtype=int) - - # update meshing settings with sweep factor for sensitivity analysis - sweep = cfg.meshing_settings.sweep_factor - cfg.meshing_settings.n_elms_longitudinal = int( - n_elms_longitudinal[sweep - 1].item() - ) - cfg.meshing_settings.n_elms_transverse_trab = int( - n_elms_transverse_trab[sweep - 1].item() - ) - cfg.meshing_settings.n_elms_transverse_cort = int( - n_elms_transverse_cort[sweep - 1].item() - ) - cfg.meshing_settings.n_elms_radial = int(n_radial[sweep - 1].item()) - ''' # timing time_record = {} From 2b6e0eab8eacdf7b2e5a6cedb2fbf0d4c82391c4 Mon Sep 17 00:00:00 2001 From: Simone Poncioni Date: Mon, 2 Sep 2024 11:41:29 +0200 Subject: [PATCH 7/8] renamed file pt2 --- .../hfe_accurate/{hfe_accurate.py => hfe_accurate_pipeline.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename 02_CODE/src/hfe_accurate/{hfe_accurate.py => hfe_accurate_pipeline.py} (100%) diff --git a/02_CODE/src/hfe_accurate/hfe_accurate.py b/02_CODE/src/hfe_accurate/hfe_accurate_pipeline.py similarity index 100% rename from 02_CODE/src/hfe_accurate/hfe_accurate.py rename to 02_CODE/src/hfe_accurate/hfe_accurate_pipeline.py From 22307bd33a6b08944d771f0db2eeb08141ac63da Mon Sep 17 00:00:00 2001 From: Simone Poncioni Date: Mon, 2 Sep 2024 11:42:29 +0200 Subject: [PATCH 8/8] added docs --- .../src/hfe_accurate/hfe_accurate_pipeline.py | 40 ++++++++----------- 1 file changed, 17 insertions(+), 23 deletions(-) diff --git a/02_CODE/src/hfe_accurate/hfe_accurate_pipeline.py b/02_CODE/src/hfe_accurate/hfe_accurate_pipeline.py index 0f9916e..e957a9b 100644 --- a/02_CODE/src/hfe_accurate/hfe_accurate_pipeline.py +++ b/02_CODE/src/hfe_accurate/hfe_accurate_pipeline.py @@ -24,9 +24,9 @@ import hfe_utils.print_optim_report as por import numpy as np import yaml +from hfe_utils.f_decomposition import decomposition_to_vtu from hfe_utils.io_utils import print_mem_usage, write_timing_summary from hfe_utils.odb2vtk_wrapper import Odb2VtkWrapper -from hfe_utils.f_decomposition import decomposition_to_vtu os.environ["NUMEXPR_MAX_THREADS"] = "16" @@ -36,7 +36,7 @@ # flake8: noqa: E402, W503 -''' +""" # TODO: reactivate this for mesh sensitivity analysis # n_sim = int(15) # has to match sweep in config # min = 5, 5, 2, 7 @@ -58,9 +58,21 @@ n_elms_transverse_cort[sweep - 1].item() ) cfg.meshing_settings.n_elms_radial = int(n_radial[sweep - 1].item()) -''' +""" + def pipeline_hfe(cfg, folder_id, grayscale_filename): + """ + Executes the homogenized finite elements (HFE) pipeline for a given sample. + + Args: + cfg: Configuration object containing all necessary settings. + folder_id (str): Identifier for the folder containing the sample data. + grayscale_filename (str): Filename of the grayscale image to be processed. + + Returns: + tuple: A tuple containing the time record dictionary and the summary path. + """ # timing time_record = {} @@ -120,10 +132,8 @@ def pipeline_hfe(cfg, folder_id, grayscale_filename): end_simulation = time() time_record["simulation"] = end_simulation - start_simulation - logger.info("Running postprocessing.datfilereader_psl") optim = {} optim = postprocessing.datfilereader_psl(cfg, grayscale_filename, optim, "FZ_MAX") - logger.info("Execution completed: postprocessing.datfilereader_psl") # timing end_sample = time() @@ -133,18 +143,10 @@ def pipeline_hfe(cfg, folder_id, grayscale_filename): path2dat = Path(inputfile).parent / ( grayscale_filename + "_" + cfg.version.current_version[0:2] + ".dat" ) - - logger.info(f"path2dat: {path2dat}") - logger.info(f"absolute path2dat: {path2dat.absolute}") - thickness = max(val[2] for val in bone["nodes"].values()) - min( val[2] for val in bone["nodes"].values() ) - logger.info(f"Thickness: {thickness}") - - logger.info("Running compute_optim_report_variables") optim = por.compute_optim_report_variables(optim, path2dat, thickness) - logger.info("Execution completed: compute_optim_report_variables") bone = por.compute_bone_report_variables_no_psl(bone) # only for sensitivity analysis @@ -154,8 +156,6 @@ def pipeline_hfe(cfg, folder_id, grayscale_filename): "n_elms_transverse_cort": cfg.meshing_settings.n_elms_transverse_cort, "n_elms_radial": cfg.meshing_settings.n_elms_radial, } - - logger.info("Executing postprocessing.write_data_summary") postprocessing.write_data_summary( cfg, optim, @@ -165,22 +165,16 @@ def pipeline_hfe(cfg, folder_id, grayscale_filename): DOFs=bone["degrees_of_freedom"], time_sim=time_record[grayscale_filename], ) - logger.info("Executed: postprocessing.write_data_summary") - + if cfg.strain_localisation.strain_analysis is True: - logger.info("Running strain analysis evaluation") odb2vtkpath = cfg.socket_paths.odb2vtk odb_path = odb_path abq_path = cfg.solver.abaqus - logger.info(f"odb2vtkpath: {odb2vtkpath}") - logger.info(f"odb_path: {odb_path}") - logger.info(f"abq_path: {abq_path}") - odb2vtk_wrapper = Odb2VtkWrapper( odb2vtkpath, odb_path, abq_path, only_last_frame=True ) vtk_path = odb2vtk_wrapper.convert() - logger.info(f"ODB to VTK file written to {vtk_path}") + print(f"ODB to VTK file written to {vtk_path}") decomposition_to_vtu(vtk_path) if cfg.abaqus.delete_odb is True: