#!/bin/sh
#------------------------------------------------------------------------------
# =========                 |
# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
#  \\    /   O peration     | Website:  https://openfoam.org
#   \\  /    A nd           | Copyright (C) 2011-2024 OpenFOAM Foundation
#    \\/     M anipulation  |
#------------------------------------------------------------------------------
# License
#     This file is part of OpenFOAM.
#
#     OpenFOAM is free software: you can redistribute it and/or modify it
#     under the terms of the GNU General Public License as published by
#     the Free Software Foundation, either version 3 of the License, or
#     (at your option) any later version.
#
#     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
#     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
#     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
#     for more details.
#
#     You should have received a copy of the GNU General Public License
#     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
#
# Script
#     paraFoam
#
# Description
#     start paraview with the OpenFOAM libraries
#
#------------------------------------------------------------------------------
usage() {
    cat<<USAGE

Usage: ${0##*/} [OPTION] [PARAVIEW_OPTION]
options:
  -block            use blockMesh reader  (uses .blockMesh extension)
  -builtin          use VTK builtin OpenFOAM reader  (uses .foam extension)
  -case <dir>       specify alternative case directory, default is the cwd
  -empty            launch ParaView without opening any data files
  -region <name>    specify alternative mesh region
  -touch            only create the file  (eg, .blockMesh, .OpenFOAM, etc)
  -touchAll         create .blockMesh, .OpenFOAM files (and for all regions)
  -help             print the usage

paraview options start with a double dashes

* start paraview $ParaView_VERSION with the OpenFOAM libraries

USAGE
}

error() {
    exec 1>&2
    while [ "$#" -ge 1 ]; do echo "$1"; shift; done
    usage
    exit 1
}

pvExec () {
    # For now filter out any ld.so errors. Caused by non-system compiler?
    paraview "$@" 2>&1 | grep -v -F 'Inconsistency detected by ld.so'
}

noPV() {
    cat<<EOF

For information on packaged versions of OpenFOAM/ParaView and compilation of
OpenFOAM/ParaView, see https://openfoam.org/download

Alternatively, you might be able to view your OpenFOAM data with the reader
module provided with ParaView by running:
    paraFoam -builtin

EOF
}

noPVExe () {
    cat<<EOF
FATAL ERROR: A ParaView executable was not found on your system.  This means
that ParaView is not installed, or that OpenFOAM has been configured to use a
different installation of ParaView from that which is installed.
EOF
noPV
}

noPVReader () {
    cat<<EOF
FATAL ERROR: The reader module for OpenFOAM data was not found on your system.
This means that OpenFOAM was not built with ParaView support, or that ParaView
is not installed, or that OpenFOAM has been configured to use a different
installation of ParaView from that which is installed.
EOF
noPV
}

# We want to do nice exit when running paraview to give paraview opportunity
# to clean up
unset FOAM_ABORT

unset regionName optTouch

# Hack: change all locale to 'C' i.e. using '.' for decimal point. This is
# only needed temporarily until paraview is locale aware. (git version is
# already 2010-07)
export LC_ALL=C

# Reader extension
extension=OpenFOAM

requirePVExe=1
requirePVReader=1

# Parse options
while [ "$#" -gt 0 ]
do
    case "$1" in
    -h | -help)
        usage && exit 0
        ;;
    -block | -blockMesh)
        extension=blockMesh
        shift
        ;;
    -builtin)
        extension=foam
        requirePVExe=1
        requirePVReader=0
        shift
        ;;
    -case)
        [ "$#" -ge 2 ] || error "'$1' option requires an argument"
        cd "$2" 2>/dev/null || error "directory does not exist:  '$2'"
        shift 2
        ;;
    -empty)
        echo "Launching ParaView without opening any files."
        pvExec && exit 0
        ;;
    -region)
        [ "$#" -ge 2 ] || error "'$1' option requires an argument"
        regionName=$2
        shift 2
        ;;
    -touch)
        optTouch=true
        requirePVExe=0
        requirePVReader=0
        shift
        ;;
    -touchAll)
        optTouch=all
        requirePVExe=0
        requirePVReader=0
        shift
        ;;
    --)
        shift
        break    # Stop here, treat balance as paraview options
        ;;
    --*)
        break    # Stop here, treat this and balance as paraview options
        ;;
    *)
        error "unknown option/argument: '$*'"
        ;;
    esac
done

# Check for incompatibility of options
if [ -n "$regionName" ]
then
    case $extension in
    blockMesh)
        echo "FATAL ERROR: The blockMesh reader does not support regions"
        exit 1
        ;;
    foam)
        echo "FATAL ERROR: The builtin reader does not support regions"
        exit 1
        ;;
    esac
fi

# Check that the executable and/or the reader module are available
[ $requirePVExe -eq 1 ] && \
    ! which paraview > /dev/null 2>&1 && \
    noPVExe && exit 1
[ $requirePVReader -eq 1 ] && \
    ! [ -f "$PV_PLUGIN_PATH/libPVFoamReader_SM.so" ] && \
    noPVReader && exit 1

# Check for --data=... argument
hasDataArg()
{
    hasData=false
    while [ "$#" -gt 0 ]
    do
        case "$1" in
        (--data=*)
            hasData=true
            break
            ;;
        esac
        shift
    done
}
hasDataArg "$@"

# Construct a case name from the directory name
caseName=${PWD##*/}
caseFile="$caseName.$extension"
if [ -n "$regionName" ]
then
    if [ ! -d constant/"$regionName" ]
    then
        echo "FATAL ERROR: Region $regionName does not exist"
        exit 1
    else
        caseFile="$caseName{$regionName}.$extension"
    fi
fi

# If the touch option is set, then create files and exit
case "${optTouch:-false}" in
all)
    # Block mesh
    if [ -f system/blockMeshDict ] || [ -f constant/polyMesh/blockMeshDict ]
    then
        touch "$caseName.blockMesh"
        echo "Created '$caseName.blockMesh'"
    fi

    # Default region
    touch "$caseName.OpenFOAM"
    echo "Created '$caseName.OpenFOAM'"

    # Find other probable regions
    for region in constant/*
    do
        [ -d "$region/polyMesh" ] && \
            regionName=${region##*/} && \
            touch "$caseName{$regionName}.OpenFOAM" && \
            echo "Created '$caseName{$regionName}.OpenFOAM'"
    done
    exit 0
    ;;

true)
    # Default region
    touch "$caseFile"
    echo "Created '$caseFile'"
    exit 0
    ;;
esac

# Parent directory for normal or parallel results
case "$caseName" in
    processor*) parentDir=".." ;;
    *)          parentDir="."  ;;
esac

# If we have a --data=... argument, then send this directly to paraview
if [ "${hasData:-false}" = true ]
then
    pvExec "$@"
    exit 0
fi

# Check existence of essential files
warn="WARN file does not exist:"
case $extension in
    blockMesh)
        blockMeshDictDir=system/blockMeshDict
        if [ -f constant/polyMesh/blockMeshDict ]
        then
            blockMeshDictDir=constant/polyMesh/blockMeshDict
        fi

        for check in system/controlDict $blockMeshDictDir
        do
            [ -s "$parentDir/$check" ] || [ -s "$parentDir/$check.orig" ] ||
            {
                [ -n "$warn" ] && echo "$warn" 1>&2
                echo "    $parentDir/$check" 1>&2
                unset warn
            }
        done
        ;;

    OpenFOAM | foam)
        for check in system/controlDict
        do
            [ -s "$parentDir/$check" ] || [ -s "$parentDir/$check.orig" ] ||
            {
                [ -n "$warn" ] && echo "$warn" 1>&2
                echo "    $parentDir/$check" 1>&2
                unset warn
            }
        done
        ;;
esac

# Warn if essential files do not exist
[ -n "$warn" ] || {
    echo "Cannot locate OpenFOAM-format case files"
    printf "Would you like to open ParaView anyway <Y|n>:"
    read open
    [ "$open" = "" ] || echo "$open" | grep -iqE "^y" && pvExec
    exit
}

# Only create/remove the caseFile if it didn't already exist
[ -e "$caseFile" ] || {
    trap "rm -f $caseFile 2>/dev/null; exit 0" EXIT TERM INT
    touch "$caseFile"
    echo "Created temporary '$caseFile'"
}

# Run paraview
pvExec --data="$caseFile" "$@"

#------------------------------------------------------------------------------