This repository has been archived on 2023-11-20. You can view files and clone it, but cannot push or open issues or pull requests.
foam-extend4.1-coherent-io/applications/utilities/postProcessing/graphics/PVFoamReader/PVFoamReader/vtkFoamReader.cxx
2016-06-21 15:04:12 +02:00

410 lines
9.2 KiB
C++

/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | foam-extend: Open Source CFD
\\ / O peration | Version: 4.0
\\ / A nd | Web: http://www.foam-extend.org
\\/ M anipulation | For copyright notice see file Copyright
-------------------------------------------------------------------------------
License
This file is part of foam-extend.
foam-extend 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.
foam-extend 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 foam-extend. If not, see <http://www.gnu.org/licenses/>.
Description
\*---------------------------------------------------------------------------*/
#include <ctype.h>
#include "vtkFoamReader.h"
#include "vtkCallbackCommand.h"
#include "vtkDataArraySelection.h"
#include "vtkDataArrayCollection.h"
#include "vtkObjectFactory.h"
#include "vtkDataSet.h"
#include "vtkErrorCode.h"
#include "vtkUnstructuredGrid.h"
#include "vtkFoam.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
vtkCxxRevisionMacro(vtkFoamReader, "$Revision: 1.20 $");
vtkStandardNewMacro(vtkFoamReader);
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
vtkFoamReader::vtkFoamReader()
{
StoredOutputs = NULL;
FileName = NULL;
foamData_ = NULL;
CacheMesh = 0;
UpdateGUI = 1;
UpdateGUIOld = 1;
TimeStep = 0;
TimeStepRange[0] = 0;
TimeStepRange[1] = 0;
TimeStepLimits[0] = 2;
TimeStepLimits[1] = 5;
TimeSelection = vtkDataArraySelection::New();
RegionSelection = vtkDataArraySelection::New();
VolFieldSelection = vtkDataArraySelection::New();
PointFieldSelection = vtkDataArraySelection::New();
// Setup the selection callback to modify this object when an array
// selection is changed.
SelectionObserver = vtkCallbackCommand::New();
SelectionObserver->SetCallback(&vtkFoamReader::SelectionModifiedCallback);
SelectionObserver->SetClientData(this);
TimeSelection->AddObserver
(
vtkCommand::ModifiedEvent,
this->SelectionObserver
);
RegionSelection->AddObserver
(
vtkCommand::ModifiedEvent,
this->SelectionObserver
);
VolFieldSelection->AddObserver
(
vtkCommand::ModifiedEvent,
this->SelectionObserver
);
PointFieldSelection->AddObserver
(
vtkCommand::ModifiedEvent,
this->SelectionObserver
);
// This is needed by ParaView 2.?.?
this->SetNumberOfOutputPorts(0);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
vtkFoamReader::~vtkFoamReader()
{
if (foamData_)
{
delete foamData_;
}
if (StoredOutputs)
{
StoredOutputs->Delete();
}
if (FileName)
{
delete [] FileName;
}
TimeSelection->RemoveObserver(this->SelectionObserver);
RegionSelection->RemoveObserver(this->SelectionObserver);
VolFieldSelection->RemoveObserver(this->SelectionObserver);
PointFieldSelection->RemoveObserver(this->SelectionObserver);
SelectionObserver->Delete();
TimeSelection->Delete();
RegionSelection->Delete();
VolFieldSelection->Delete();
PointFieldSelection->Delete();
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void vtkFoamReader::ExecuteInformation()
{
if (!foamData_)
{
vtkDebugMacro( << "Reading Foam case" << FileName);
foamData_ = new Foam::vtkFoam(FileName, this);
}
else
{
foamData_->UpdateInformation();
}
vtkDebugMacro( << "end of ExecuteInformation\n");
}
void vtkFoamReader::Execute()
{
if (!StoredOutputs)
{
foamData_->Update();
StoredOutputs = vtkFoamData::New();
for (int i = 0; i < GetNumberOfOutputs(); i++)
{
vtkDataObject* tmp = GetOutput(i);
vtkDataObject* output = tmp->NewInstance();
output->ShallowCopy(tmp);
StoredOutputs->SetNthOutput(i, output);
output->Delete();
}
}
else
{
for (int i = 0; i < GetNumberOfOutputs(); i++)
{
vtkDataObject* output = GetOutput(i);
int tempExtent[6];
output->GetUpdateExtent(tempExtent);
output->ShallowCopy(StoredOutputs->GetOutput(i));
output->SetUpdateExtent(tempExtent);
}
if (UpdateGUIOld == GetUpdateGUI())
{
foamData_->Update();
for (int i = 0; i < GetNumberOfOutputs(); i++)
{
vtkDataObject* tmp = GetOutput(i);
vtkDataObject* output = tmp->NewInstance();
output->ShallowCopy(tmp);
StoredOutputs->SetNthOutput(i, output);
output->Delete();
}
}
}
UpdateGUIOld = GetUpdateGUI();
}
void vtkFoamReader::SetFileName(const char *name)
{
if (name && !FileName || (FileName && !strcmp(FileName,name)))
{
if (!FileName)
{
FileName = new char[strlen(name) + 1];
strcpy(FileName, name);
}
}
else
{
vtkErrorMacro("Changing case is not currently supported.\nPlease delete reader and create a new one for the new case.");
return;
}
/*
if ( FileName && name && (!strcmp(FileName,name)))
{
return;
}
if (!name && !FileName)
{
return;
}
if (FileName)
{
delete [] FileName;
}
FileName = new char[strlen(name) + 1];
strcpy(FileName, name);
if (foamData_)
{
delete foamData_;
foamData_ = NULL;
if (StoredOutputs)
{
StoredOutputs->Delete();
StoredOutputs = NULL;
}
}
Modified();
*/
}
void vtkFoamReader::PrintSelf(ostream& os, vtkIndent indent)
{
Superclass::PrintSelf(os,indent);
os << indent << "File Name: "
<< (FileName ? FileName : "(none)") << "\n";
}
vtkDataArraySelection* vtkFoamReader::GetTimeSelection()
{
return TimeSelection;
}
int vtkFoamReader::GetNumberOfTimeArrays()
{
return TimeSelection->GetNumberOfArrays();
}
const char* vtkFoamReader::GetTimeArrayName(int index)
{
return TimeSelection->GetArrayName(index);
}
int vtkFoamReader::GetTimeArrayStatus(const char* name)
{
return TimeSelection->ArrayIsEnabled(name);
}
void vtkFoamReader::SetTimeArrayStatus(const char* name, int status)
{
if(status)
{
TimeSelection->EnableArray(name);
}
else
{
TimeSelection->DisableArray(name);
}
}
vtkDataArraySelection* vtkFoamReader::GetRegionSelection()
{
return RegionSelection;
}
int vtkFoamReader::GetNumberOfRegionArrays()
{
return RegionSelection->GetNumberOfArrays();
}
const char* vtkFoamReader::GetRegionArrayName(int index)
{
return RegionSelection->GetArrayName(index);
}
int vtkFoamReader::GetRegionArrayStatus(const char* name)
{
return RegionSelection->ArrayIsEnabled(name);
}
void vtkFoamReader::SetRegionArrayStatus(const char* name, int status)
{
if(status)
{
RegionSelection->EnableArray(name);
}
else
{
RegionSelection->DisableArray(name);
}
}
vtkDataArraySelection* vtkFoamReader::GetVolFieldSelection()
{
return VolFieldSelection;
}
int vtkFoamReader::GetNumberOfVolFieldArrays()
{
return VolFieldSelection->GetNumberOfArrays();
}
const char* vtkFoamReader::GetVolFieldArrayName(int index)
{
return VolFieldSelection->GetArrayName(index);
}
int vtkFoamReader::GetVolFieldArrayStatus(const char* name)
{
return VolFieldSelection->ArrayIsEnabled(name);
}
void vtkFoamReader::SetVolFieldArrayStatus(const char* name, int status)
{
if(status)
{
VolFieldSelection->EnableArray(name);
}
else
{
VolFieldSelection->DisableArray(name);
}
}
vtkDataArraySelection* vtkFoamReader::GetPointFieldSelection()
{
return PointFieldSelection;
}
int vtkFoamReader::GetNumberOfPointFieldArrays()
{
return PointFieldSelection->GetNumberOfArrays();
}
const char* vtkFoamReader::GetPointFieldArrayName(int index)
{
return PointFieldSelection->GetArrayName(index);
}
int vtkFoamReader::GetPointFieldArrayStatus(const char* name)
{
return PointFieldSelection->ArrayIsEnabled(name);
}
void vtkFoamReader::SetPointFieldArrayStatus(const char* name, int status)
{
if(status)
{
PointFieldSelection->EnableArray(name);
}
else
{
PointFieldSelection->DisableArray(name);
}
}
void vtkFoamReader::SelectionModifiedCallback
(
vtkObject*,
unsigned long,
void* clientdata,
void*
)
{
static_cast<vtkFoamReader*>(clientdata)->SelectionModified();
}
void vtkFoamReader::SelectionModified()
{
Modified();
}
// ************************************************************************* //