applications/utilities/postProcessing/graphics/PVFoamReader/PVFoamReader/vtkFoamReader.cxx

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Description
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include <ctype.h>
  30
  31 #include "vtkFoamReader.h"
  32
  33 #include "vtkCallbackCommand.h"
  34 #include "vtkDataArraySelection.h"
  35 #include "vtkDataArrayCollection.h"
  36 #include "vtkObjectFactory.h"
  37 #include "vtkDataSet.h"
  38 #include "vtkErrorCode.h"
  39 #include "vtkUnstructuredGrid.h"
  40
  41 #include "vtkFoam.H"
  42
  43 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
  44
  45 vtkCxxRevisionMacro(vtkFoamReader, "$Revision: 1.20 $");
  46 vtkStandardNewMacro(vtkFoamReader);
  47
  48 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  49
  50 vtkFoamReader::vtkFoamReader()
  51 {
  52     StoredOutputs = NULL;
  53
  54     FileName  = NULL;
  55     foamData_ = NULL;
  56
  57     CacheMesh = 0;
  58
  59     UpdateGUI = 1;
  60     UpdateGUIOld = 1;
  61     TimeStep = 0;
  62     TimeStepRange[0] = 0;
  63     TimeStepRange[1] = 0;
  64
  65     TimeStepLimits[0] = 2;
  66     TimeStepLimits[1] = 5;
  67
  68     TimeSelection = vtkDataArraySelection::New();
  69     RegionSelection = vtkDataArraySelection::New();
  70     VolFieldSelection = vtkDataArraySelection::New();
  71     PointFieldSelection = vtkDataArraySelection::New();
  72
  73     // Setup the selection callback to modify this object when an array
  74     // selection is changed.
  75     SelectionObserver = vtkCallbackCommand::New();
  76     SelectionObserver->SetCallback(&vtkFoamReader::SelectionModifiedCallback);
  77     SelectionObserver->SetClientData(this);
  78
  79     TimeSelection->AddObserver
  80     (
  81         vtkCommand::ModifiedEvent,
  82         this->SelectionObserver
  83     );
  84     RegionSelection->AddObserver
  85     (
  86         vtkCommand::ModifiedEvent,
  87         this->SelectionObserver
  88     );
  89     VolFieldSelection->AddObserver
  90     (
  91         vtkCommand::ModifiedEvent,
  92         this->SelectionObserver
  93     );
  94     PointFieldSelection->AddObserver
  95     (
  96         vtkCommand::ModifiedEvent,
  97         this->SelectionObserver
  98     );
  99
 100     // This is needed by ParaView 2.?.?
 101     this->SetNumberOfOutputPorts(0);
 102 }
 103
 104
 105 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 106
 107 vtkFoamReader::~vtkFoamReader()
 108 {
 109     if (foamData_)
 110     {
 111         delete foamData_;
 112     }
 113
 114     if (StoredOutputs)
 115     {
 116         StoredOutputs->Delete();
 117     }
 118
 119     if (FileName)
 120     {
 121         delete [] FileName;
 122     }
 123
 124     TimeSelection->RemoveObserver(this->SelectionObserver);
 125     RegionSelection->RemoveObserver(this->SelectionObserver);
 126     VolFieldSelection->RemoveObserver(this->SelectionObserver);
 127     PointFieldSelection->RemoveObserver(this->SelectionObserver);
 128     SelectionObserver->Delete();
 129
 130     TimeSelection->Delete();
 131     RegionSelection->Delete();
 132     VolFieldSelection->Delete();
 133     PointFieldSelection->Delete();
 134 }
 135
 136
 137 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 138
 139 void vtkFoamReader::ExecuteInformation()
 140 {
 141     if (!foamData_)
 142     {
 143         vtkDebugMacro( << "Reading Foam case" << FileName);
 144         foamData_ = new Foam::vtkFoam(FileName, this);
 145     }
 146     else
 147     {
 148         foamData_->UpdateInformation();
 149     }
 150
 151     vtkDebugMacro( << "end of ExecuteInformation\n");
 152 }
 153
 154
 155 void vtkFoamReader::Execute()
 156 {
 157     if (!StoredOutputs)
 158     {
 159         foamData_->Update();
 160
 161         StoredOutputs = vtkFoamData::New();
 162
 163         for (int i = 0; i < GetNumberOfOutputs(); i++)
 164         {
 165             vtkDataObject* tmp = GetOutput(i);
 166             vtkDataObject* output = tmp->NewInstance();
 167             output->ShallowCopy(tmp);
 168             StoredOutputs->SetNthOutput(i, output);
 169             output->Delete();
 170         }
 171     }
 172     else
 173     {
 174         for (int i = 0; i < GetNumberOfOutputs(); i++)
 175         {
 176             vtkDataObject* output = GetOutput(i);
 177             int tempExtent[6];
 178             output->GetUpdateExtent(tempExtent);
 179             output->ShallowCopy(StoredOutputs->GetOutput(i));
 180             output->SetUpdateExtent(tempExtent);
 181         }
 182
 183         if (UpdateGUIOld == GetUpdateGUI())
 184         {
 185             foamData_->Update();
 186
 187             for (int i = 0; i < GetNumberOfOutputs(); i++)
 188             {
 189                 vtkDataObject* tmp = GetOutput(i);
 190                 vtkDataObject* output = tmp->NewInstance();
 191                 output->ShallowCopy(tmp);
 192                 StoredOutputs->SetNthOutput(i, output);
 193                 output->Delete();
 194             }
 195         }
 196     }
 197
 198     UpdateGUIOld = GetUpdateGUI();
 199 }
 200
 201
 202 void vtkFoamReader::SetFileName(const char *name)
 203 {
 204     if (name && !FileName || (FileName && !strcmp(FileName,name)))
 205     {
 206         if (!FileName)
 207         {
 208             FileName = new char[strlen(name) + 1];
 209             strcpy(FileName, name);
 210         }
 211     }
 212     else
 213     {
 214         vtkErrorMacro("Changing case is not currently supported.\nPlease delete reader and create a new one for the new case.");
 215         return;
 216     }
 217
 218     /*
 219     if ( FileName && name && (!strcmp(FileName,name)))
 220     {
 221         return;
 222     }
 223
 224     if (!name && !FileName)
 225     {
 226         return;
 227     }
 228
 229     if (FileName)
 230     {
 231         delete [] FileName;
 232     }
 233
 234     FileName = new char[strlen(name) + 1];
 235     strcpy(FileName, name);
 236
 237     if (foamData_)
 238     {
 239         delete foamData_;
 240         foamData_ = NULL;
 241
 242         if (StoredOutputs)
 243         {
 244             StoredOutputs->Delete();
 245             StoredOutputs = NULL;
 246         }
 247     }
 248
 249     Modified();
 250     */
 251 }
 252
 253
 254 void vtkFoamReader::PrintSelf(ostream& os, vtkIndent indent)
 255 {
 256     Superclass::PrintSelf(os,indent);
 257
 258     os  << indent << "File Name: "
 259         << (FileName ? FileName : "(none)") << "\n";
 260 }
 261
 262
 263 vtkDataArraySelection* vtkFoamReader::GetTimeSelection()
 264 {
 265     return TimeSelection;
 266 }
 267
 268 int vtkFoamReader::GetNumberOfTimeArrays()
 269 {
 270     return TimeSelection->GetNumberOfArrays();
 271 }
 272
 273 const char* vtkFoamReader::GetTimeArrayName(int index)
 274 {
 275     return TimeSelection->GetArrayName(index);
 276 }
 277
 278 int vtkFoamReader::GetTimeArrayStatus(const char* name)
 279 {
 280     return TimeSelection->ArrayIsEnabled(name);
 281 }
 282
 283 void vtkFoamReader::SetTimeArrayStatus(const char* name, int status)
 284 {
 285     if(status)
 286     {
 287         TimeSelection->EnableArray(name);
 288     }
 289     else
 290     {
 291         TimeSelection->DisableArray(name);
 292     }
 293 }
 294
 295 vtkDataArraySelection* vtkFoamReader::GetRegionSelection()
 296 {
 297     return RegionSelection;
 298 }
 299
 300 int vtkFoamReader::GetNumberOfRegionArrays()
 301 {
 302     return RegionSelection->GetNumberOfArrays();
 303 }
 304
 305 const char* vtkFoamReader::GetRegionArrayName(int index)
 306 {
 307     return RegionSelection->GetArrayName(index);
 308 }
 309
 310 int vtkFoamReader::GetRegionArrayStatus(const char* name)
 311 {
 312     return RegionSelection->ArrayIsEnabled(name);
 313 }
 314
 315 void vtkFoamReader::SetRegionArrayStatus(const char* name, int status)
 316 {
 317     if(status)
 318     {
 319         RegionSelection->EnableArray(name);
 320     }
 321     else
 322     {
 323         RegionSelection->DisableArray(name);
 324     }
 325 }
 326
 327
 328 vtkDataArraySelection* vtkFoamReader::GetVolFieldSelection()
 329 {
 330     return VolFieldSelection;
 331 }
 332
 333 int vtkFoamReader::GetNumberOfVolFieldArrays()
 334 {
 335     return VolFieldSelection->GetNumberOfArrays();
 336 }
 337
 338 const char* vtkFoamReader::GetVolFieldArrayName(int index)
 339 {
 340     return VolFieldSelection->GetArrayName(index);
 341 }
 342
 343 int vtkFoamReader::GetVolFieldArrayStatus(const char* name)
 344 {
 345     return VolFieldSelection->ArrayIsEnabled(name);
 346 }
 347
 348 void vtkFoamReader::SetVolFieldArrayStatus(const char* name, int status)
 349 {
 350     if(status)
 351     {
 352         VolFieldSelection->EnableArray(name);
 353     }
 354     else
 355     {
 356         VolFieldSelection->DisableArray(name);
 357     }
 358 }
 359
 360
 361 vtkDataArraySelection* vtkFoamReader::GetPointFieldSelection()
 362 {
 363     return PointFieldSelection;
 364 }
 365
 366 int vtkFoamReader::GetNumberOfPointFieldArrays()
 367 {
 368     return PointFieldSelection->GetNumberOfArrays();
 369 }
 370
 371 const char* vtkFoamReader::GetPointFieldArrayName(int index)
 372 {
 373     return PointFieldSelection->GetArrayName(index);
 374 }
 375
 376 int vtkFoamReader::GetPointFieldArrayStatus(const char* name)
 377 {
 378     return PointFieldSelection->ArrayIsEnabled(name);
 379 }
 380
 381 void vtkFoamReader::SetPointFieldArrayStatus(const char* name, int status)
 382 {
 383     if(status)
 384     {
 385         PointFieldSelection->EnableArray(name);
 386     }
 387     else
 388     {
 389         PointFieldSelection->DisableArray(name);
 390     }
 391 }
 392
 393
 394 void vtkFoamReader::SelectionModifiedCallback
 395 (
 396     vtkObject*,
 397     unsigned long,
 398     void* clientdata,
 399     void*
 400 )
 401 {
 402     static_cast<vtkFoamReader*>(clientdata)->SelectionModified();
 403 }
 404
 405 void vtkFoamReader::SelectionModified()
 406 {
 407     Modified();
 408 }
 409
 410
 411 // ************************************************************************* //