#!/bin/sh
#------------------------------------------------------------------------------
# =========                 |
# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
#  \\    /   O peration     | Website:  https://openfoam.org
#   \\  /    A nd           | Copyright (C) 2011-2019 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
#
# Note
#     combining -block or -builtin options with the -region option yields
#     undefined behaviour
#------------------------------------------------------------------------------
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 () {
    _opt=""
    [ "$ParaView_GL" = mesa ] && _opt="--mesa"

    paraview $_opt "$@"
}

noPVReader () {
    cat<<EOF
FATAL ERROR: The official reader module for OpenFOAM data does not exist on
your system.  This means that the version of ParaView you are using was not
compiled with OpenFOAM, or distributed with a packaged version of OpenFOAM.

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
}

# 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

requirePV=1

# Parse options
while [ "$#" -gt 0 ]
do
    case "$1" in
    -h | -help)
        usage && exit 0
        ;;
    -block | -blockMesh)
        extension=blockMesh
        shift
        ;;
    -builtin)
        extension=foam
        requirePV=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
        requirePV=0
        shift
        ;;
    -touchAll)
        optTouch=all
        requirePV=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 that reader module has been built
[ $requirePV -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 "$@"

# Get a sensible caseName from the directory name
caseName=${PWD##*/}
caseFile="$caseName.$extension"
fvControls="system"

if [ -n "$regionName" ]
then
    if [ ! -d constant/"$regionName" ]
    then
        echo "FATAL ERROR: Region $regionName does not exist"
        exit 1
    else
        caseFile="$caseName{$regionName}.$extension"
        fvControls="$fvControls/$regionName"
    fi
fi

case "${optTouch:-false}" in
all)
    extension=OpenFOAM
    if [ -f system/blockMeshDict ] || [ -f constant/polyMesh/blockMeshDict ]
    then
        touch "$caseName.blockMesh"
        echo "Created '$caseName.blockMesh'"
    fi
    touch "$caseName.$extension"
    echo "Created '$caseName.$extension'"
    # Discover probable regions
    for region in constant/*
    do
        [ -d "$region" ] && [ -d "${region}/polyMesh" ] && \
            regionName=${region##*/} && \
            touch "$caseName{$regionName}.$extension" && \
            echo "Created '$caseName{$regionName}.$extension'"
    done
    exit 0
    ;;
true)
    touch "$caseFile"
    echo "Created '$caseFile'"
    exit 0
    ;;
esac


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


if [ "${hasData:-false}" = true ]
then

    # Has --data=.., send directly to paraview
    pvExec "$@"

else

    # 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
            ;;

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

    [ -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 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'"
    }

    # For now filter out any ld.so errors. Caused by non-system compiler?
    pvExec --data="$caseFile" "$@" 2>&1 \
        | grep -v -F 'Inconsistency detected by ld.so'
fi


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