Commit de57d2da authored by Mark Olesen's avatar Mark Olesen
Browse files

DEFEATURE: remove paraview reader modules (migrate to submodule)

parent 858f0f2c
#!/bin/sh
cd "${0%/*}" || exit # Run from this directory
. ${WM_PROJECT_DIR:?}/wmake/scripts/wmakeFunctions # Require wmake functions
. ${WM_PROJECT_DIR:?}/wmake/scripts/paraviewFunctions # For API info
# -----------------------------------------------------------------------------
get_pvplugin_api || echo "No ParaView plugin information found" 1>&2
# Cleanup libraries
wclean libso common
wclean libso blockMeshReader/library
wclean libso foamReader/library
# Cleanup client-server and/or combined plugins
rm -f $FOAM_LIBBIN/libPVblockMeshReader* 2>/dev/null
rm -f $FOAM_LIBBIN/libPVFoamReader* 2>/dev/null
# Cleanup generated files - remove entire top-level
removeObjectDir $PWD
#------------------------------------------------------------------------------
#!/bin/sh
cd "${0%/*}" || exit # Run from this directory
export WM_CONTINUE_ON_ERROR=true # Optional unit
. ${WM_PROJECT_DIR:?}/wmake/scripts/AllwmakeParseArguments
. ${WM_PROJECT_DIR:?}/wmake/scripts/paraviewFunctions # CMake, PV functions
# -----------------------------------------------------------------------------
warnIncomplete()
{
echo
echo " WARNING: incomplete build of ParaView plugin: $@"
echo
}
if have_pvplugin_support
then
(
wmakeLibPv common
wmakeLibPv blockMeshReader/library
wmakeLibPv foamReader/library
unset cmakeOpts cmakeType
if [ "$targetType" != objects ]
then
case "$PARAVIEW_API" in
(5.[0-6])
cmakeType="cmakePv"
;;
(*)
# cmakeType="cmakePvInstall"
warnIncomplete "(unknown/unsupported version: $PARAVIEW_API)"
;;
esac
fi
if [ -n "$cmakeType" ]
then
"$cmakeType" $PWD/blockMeshReader "$cmakeOpts" || warnIncomplete "blockMesh"
"$cmakeType" $PWD/foamReader "$cmakeOpts" || warnIncomplete "OpenFOAM"
fi
)
fi
#------------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# Standard definitions when using OpenFOAM
if (NOT EXISTS "$ENV{WM_PROJECT_DIR}")
message(FATAL_ERROR "WM_PROJECT_DIR not set - no OpenFOAM??")
endif()
# WM_OSTYPE env variable is optional (only POSIX anyhow)
if (EXISTS "$ENV{WM_OSTYPE}")
set(WM_OSTYPE "$ENV{WM_OSTYPE}")
else()
set(WM_OSTYPE "POSIX")
endif()
# Convenience name, as per wmake internals
set(LIB_SRC "$ENV{WM_PROJECT_DIR}/src")
# Needed for internal label-size, scalar-size, templates
add_definitions(
-DWM_$ENV{WM_PRECISION_OPTION}
-DWM_LABEL_SIZE=$ENV{WM_LABEL_SIZE}
-DNoRepository
-std=c++11
)
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# OpenFOAM blockMeshDict reader plugin for ParaView GUI (pre-5.7)
link_directories(
$ENV{FOAM_LIBBIN}
)
include_directories(
${LIB_SRC}/OpenFOAM/include
${LIB_SRC}/OpenFOAM/lnInclude
${LIB_SRC}/OSspecific/${WM_OSTYPE}/lnInclude
${LIB_SRC}/meshing/blockMesh/lnInclude
${PROJECT_SOURCE_DIR}/../common
${PROJECT_SOURCE_DIR}/library
${PROJECT_SOURCE_DIR}/plugin
${PROJECT_SOURCE_DIR}/plugin/reader
)
set(OPENFOAM_LIBNAMES
OpenFOAM
blockMesh
)
# Set output library destination to plugin directory
set(
LIBRARY_OUTPUT_PATH $ENV{FOAM_PV_PLUGIN_LIBBIN}
CACHE INTERNAL
"Single output directory for building all libraries."
)
qt5_wrap_cpp(MOC_SRCS plugin/pqFoamBlockMeshControls.h)
add_paraview_property_group_widget(IFACES0 IFACES0_SRCS
TYPE "openfoam_blockMesh_general_controls"
CLASS_NAME pqFoamBlockMeshControls
)
add_paraview_plugin(
PVblockMeshReader_SM "${foam_api}"
SERVER_MANAGER_XML
plugin/PVblockMeshReader_SM.xml
SERVER_MANAGER_SOURCES
plugin/reader/vtkPVblockMeshReader.cxx
GUI_INTERFACES
${IFACES0}
SOURCES
${IFACES0_SRCS}
${MOC_SRCS}
plugin/pqFoamBlockMeshControls.cxx
)
target_link_libraries(
PVblockMeshReader_SM
LINK_PUBLIC
vtkPVFoamCommon${foamPvLibQualifier}
vtkPVblockMesh${foamPvLibQualifier}
${OPENFOAM_LIBNAMES}
)
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# OpenFOAM blockMeshDict reader plugin for ParaView GUI (5.7+)
message(FATAL_ERROR "paraview-${pv_api} not yet supported")
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
cmake_minimum_required(VERSION 2.8)
cmake_policy(SET CMP0002 NEW) # Policy CMP0002 required for for cmake >= 3
# Fail if not building out-of-source
if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
message(FATAL_ERROR
"In-source builds disallowed. Use a separate build directory")
endif()
#-----------------------------------------------------------------------------
# Simple discovery and sanity checks
find_package(ParaView REQUIRED)
# Qualify OpenFOAM/ParaView libraries with -pvMAJ.MIN
# The pv_api can also be used for paraview-MAJ.MIN
if (DEFINED ENV{PARAVIEW_API})
set(pv_api "$ENV{PARAVIEW_API}")
else()
if (${ParaView_VERSION} GREATER_EQUAL 5.7)
string(REGEX MATCH [0-9]+[.][0-9]+ pv_api ${ParaView_VERSION})
message("The PARAVIEW_API env was unset, "
"extracted value from version="
"${ParaView_VERSION} is ${pv_api}")
else()
set(pv_api "${PARAVIEW_VERSION_MAJOR}.${ParaView_VERSION_MINOR}")
message("The PARAVIEW_API env was unset, "
"assembled from maj/min="
"${ParaView_VERSION_MAJOR}/${ParaView_VERSION_MINOR} is ${pv_api}")
endif()
endif()
# Pass through the OpenFOAM API value to the reader
set(foam_api "$ENV{FOAM_API}")
if (NOT "${foam_api}")
set(foam_api "2.0")
endif()
set(foamPvLibQualifier "-pv${pv_api}")
#-----------------------------------------------------------------------------
message("================")
message("Using ParaView = $ENV{ParaView_DIR}")
message("OpenFOAM api = ${foam_api}, libs = ${foamPvLibQualifier}")
#-----------------------------------------------------------------------------
include(CMakeLists-OpenFOAM.txt)
if (${ParaView_VERSION} GREATER_EQUAL 5.7)
message("================")
include(CMakeLists-Project57.txt)
else()
message("================")
include(${PARAVIEW_USE_FILE})
include(CMakeLists-Project.txt)
endif()
#-----------------------------------------------------------------------------
vtkPVblockMesh.C
vtkPVblockMeshConvert.C
LIB = $(FOAM_LIBBIN)/libvtkPVblockMesh-pv${PARAVIEW_API}
EXE_INC = \
${c++LESSWARN} \
-I$(LIB_SRC)/fileFormats/lnInclude \
-I$(LIB_SRC)/conversion/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/mesh/blockMesh/lnInclude \
-I$(PARAVIEW_INC_DIR) \
-I$(PARAVIEW_INC_DIR)/vtkkwiml \
-I../../common \
-I../plugin/reader
LIB_LIBS = \
-lmeshTools \
-lblockMesh \
-L$(FOAM_LIBBIN) -lvtkPVFoamCommon-pv${PARAVIEW_API} \
$(GLIBS)
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2017-2019 OpenCFD Ltd.
-------------------------------------------------------------------------------
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/>.
\*---------------------------------------------------------------------------*/
#include "vtkPVblockMesh.H"
#include "vtkPVblockMeshReader.h"
// OpenFOAM includes
#include "blockMesh.H"
#include "blockMeshTools.H"
#include "foamVersion.H"
#include "Time.H"
#include "patchZones.H"
#include "StringStream.H"
// VTK includes
#include "vtkDataArraySelection.h"
#include "vtkMultiBlockDataSet.h"
#include "vtkRenderer.h"
#include "vtkTextActor.h"
#include "vtkTextProperty.h"
#include "vtkSmartPointer.h"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(vtkPVblockMesh, 0);
}
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
namespace Foam
{
// file-scope
//- Create a text actor
static vtkSmartPointer<vtkTextActor> createTextActor
(
const std::string& s,
const Foam::point& pt
)
{
auto txt = vtkSmartPointer<vtkTextActor>::New();
txt->SetInput(s.c_str());
// Set text properties
vtkTextProperty* tprop = txt->GetTextProperty();
tprop->SetFontFamilyToArial();
tprop->BoldOn();
tprop->ShadowOff();
tprop->SetLineSpacing(1.0);
tprop->SetFontSize(14);
tprop->SetColor(1.0, 0.0, 1.0);
tprop->SetJustificationToCentered();
txt->GetPositionCoordinate()->SetCoordinateSystemToWorld();
txt->GetPositionCoordinate()->SetValue(pt.x(), pt.y(), pt.z());
return txt;
}
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
void Foam::vtkPVblockMesh::resetCounters()
{
// Reset mesh part ids and sizes
rangeBlocks_.reset();
rangeEdges_.reset();
rangeCorners_.reset();
}
void Foam::vtkPVblockMesh::updateInfoBlocks
(
vtkDataArraySelection* select
)
{
DebugInfo
<< "<beg> updateInfoBlocks"
<< " [meshPtr=" << (meshPtr_ ? "set" : "null") << "]" << endl;
rangeBlocks_.reset(select->GetNumberOfArrays());
const blockMesh& blkMesh = *meshPtr_;
const int nBlocks = blkMesh.size();
for (int blockI = 0; blockI < nBlocks; ++blockI)
{
const blockDescriptor& blockDef = blkMesh[blockI];
// Display either blockI as a number or with its name
// (looked up from blockMeshDict)
OStringStream ostr;
blockDescriptor::write(ostr, blockI, blkMesh.meshDict());
// append the (optional) zone name
if (!blockDef.zoneName().empty())
{
ostr << " - " << blockDef.zoneName();
}
// Add "blockId" or "blockId - zoneName" to GUI list
select->AddArray(ostr.str().c_str());
++rangeBlocks_;
}
DebugInfo << "<end> updateInfoBlocks" << endl;
}
void Foam::vtkPVblockMesh::updateInfoEdges
(
vtkDataArraySelection* select
)
{
DebugInfo
<< "<beg> updateInfoEdges"
<< " [meshPtr=" << (meshPtr_ ? "set" : "null") << "]" << endl;
rangeEdges_.reset(select->GetNumberOfArrays());
const blockMesh& blkMesh = *meshPtr_;
const blockEdgeList& edges = blkMesh.edges();
forAll(edges, edgeI)
{
OStringStream ostr;
blockVertex::write(ostr, edges[edgeI].start(), blkMesh.meshDict());
ostr<< ":";
blockVertex::write(ostr, edges[edgeI].end(), blkMesh.meshDict());
ostr << " - " << edges[edgeI].type();
// Add "beg:end - type" to GUI list
select->AddArray(ostr.str().c_str());
++rangeEdges_;
}
DebugInfo << "<end> updateInfoEdges" << endl;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::vtkPVblockMesh::vtkPVblockMesh
(
const char* const FileName,
vtkPVblockMeshReader* reader
)
:
reader_(reader),
dbPtr_(nullptr),
meshPtr_(nullptr),
meshRegion_(polyMesh::defaultRegion),
meshDir_(polyMesh::meshSubDir),
rangeBlocks_("block"),
rangeEdges_("edges"),
rangeCorners_("corners")
{
DebugInfo << "vtkPVblockMesh - " << FileName << endl;
// avoid argList and get rootPath/caseName directly from the file
fileName fullCasePath(fileName(FileName).path());
if (!isDir(fullCasePath))
{
return;
}
if (fullCasePath == ".")
{
fullCasePath = cwd();
}
// OPENFOAM API
setEnv("FOAM_API", std::to_string(foamVersion::api), true);
// The name of the executable, unless already present in the environment
setEnv("FOAM_EXECUTABLE", "paraview", false);
// Set the case as an environment variable - some BCs might use this
if (fullCasePath.name().find("processor", 0) == 0)
{
const fileName globalCase = fullCasePath.path();
setEnv("FOAM_CASE", globalCase, true);
setEnv("FOAM_CASENAME", globalCase.name(), true);
}
else
{
setEnv("FOAM_CASE", fullCasePath, true);
setEnv("FOAM_CASENAME", fullCasePath.name(), true);
}
// look for 'case{region}.OpenFOAM'
// could be stringent and insist the prefix match the directory name...
// Note: cannot use fileName::name() due to the embedded '{}'
string caseName(fileName(FileName).lessExt());
string::size_type beg = caseName.find_last_of("/{");
string::size_type end = caseName.find('}', beg);
if
(
beg != string::npos && caseName[beg] == '{'
&& end != string::npos && end == caseName.size()-1
)
{
meshRegion_ = caseName.substr(beg+1, end-beg-1);
// some safety
if (meshRegion_.empty())
{
meshRegion_ = polyMesh::defaultRegion;
}
if (meshRegion_ != polyMesh::defaultRegion)
{
meshDir_ = meshRegion_/polyMesh::meshSubDir;
}
}
DebugInfo
<< "fullCasePath=" << fullCasePath << nl
<< "FOAM_CASE=" << getEnv("FOAM_CASE") << nl
<< "FOAM_CASENAME=" << getEnv("FOAM_CASENAME") << endl;
// Create time object
dbPtr_.reset
(
new Time
(
Time::controlDictName,
fileName(fullCasePath.path()),
fileName(fullCasePath.name())
)
);
dbPtr_().functionObjects().off();
updateInfo();
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::vtkPVblockMesh::~vtkPVblockMesh()
{
DebugInfo << "~vtkPVblockMesh" << endl;
delete meshPtr_;
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::vtkPVblockMesh::updateInfo()
{
DebugInfo
<< "<beg> updateInfo"
<< " [meshPtr=" << (meshPtr_ ? "set" : "null") << "] " << endl;
resetCounters();
vtkDataArraySelection* blockSelection = reader_->GetBlockSelection();
vtkDataArraySelection* edgeSelection = reader_->GetCurvedEdgesSelection();
const bool firstTime = (!blockSelection->GetNumberOfArrays() && !meshPtr_);
// Preserve the enabled selections if possible
HashSet<string> enabledParts;
HashSet<string> enabledEdges;
if (!firstTime)
{
enabledParts = getSelectedArraySet(blockSelection);
enabledEdges = getSelectedArraySet(edgeSelection);
}
// Clear current mesh parts list
blockSelection->RemoveAllArrays();
edgeSelection->RemoveAllArrays();
// need a blockMesh
updateFoamMesh();
// Update mesh parts list
updateInfoBlocks(blockSelection);
// Update curved edges list
updateInfoEdges(edgeSelection);
// Restore the enabled selections
if (!firstTime)
{
setSelectedArrayEntries(blockSelection, enabledParts);
setSelectedArrayEntries(edgeSelection, enabledEdges);
}
DebugInfo << "<end> updateInfo" << endl;
}
void Foam::vtkPVblockMesh::updateFoamMesh()
{
DebugInfo << "<beg> updateFoamMesh" << endl;