applications/utilities/postProcessing/graphics/PV3FoamReader/PV3FoamReader/vtkPV3FoamReader.cxx

   1 /*=========================================================================
   2
   3   Program:   Visualization Toolkit
   4   Module:    $RCSfile: vtkPV3FoamReader.cxx,v $
   5
   6   Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
   7   All rights reserved.
   8   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
   9
  10      This software is distributed WITHOUT ANY WARRANTY; without even
  11      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  12      PURPOSE.  See the above copyright notice for more information.
  13
  14 =========================================================================*/
  15
  16 #include "vtkPV3FoamReader.h"
  17
  18 #include "pqApplicationCore.h"
  19 #include "pqRenderView.h"
  20 #include "pqServerManagerModel.h"
  21
  22 // VTK includes
  23 #include "vtkCallbackCommand.h"
  24 #include "vtkDataArraySelection.h"
  25 #include "vtkInformation.h"
  26 #include "vtkInformationVector.h"
  27 #include "vtkMultiBlockDataSet.h"
  28 #include "vtkObjectFactory.h"
  29 #include "vtkSMRenderViewProxy.h"
  30 #include "vtkStreamingDemandDrivenPipeline.h"
  31 #include "vtkStringArray.h"
  32
  33 // Foam includes
  34 #include "vtkPV3Foam.H"
  35
  36 vtkCxxRevisionMacro(vtkPV3FoamReader, "$Revision: 1.5$");
  37 vtkStandardNewMacro(vtkPV3FoamReader);
  38
  39 #undef EXPERIMENTAL_TIME_CACHING
  40
  41 vtkPV3FoamReader::vtkPV3FoamReader()
  42 {
  43     Debug = 0;
  44     vtkDebugMacro(<<"Constructor");
  45
  46     SetNumberOfInputPorts(0);
  47
  48     FileName  = NULL;
  49     foamData_ = NULL;
  50
  51     output0_  = NULL;
  52
  53 #ifdef VTKPV3FOAM_DUALPORT
  54     // Add second output for the Lagrangian
  55     this->SetNumberOfOutputPorts(2);
  56     vtkMultiBlockDataSet *lagrangian = vtkMultiBlockDataSet::New();
  57     lagrangian->ReleaseData();
  58
  59     this->GetExecutive()->SetOutputData(1, lagrangian);
  60     lagrangian->Delete();
  61 #endif
  62
  63     TimeStepRange[0] = 0;
  64     TimeStepRange[1] = 0;
  65
  66     CacheMesh = 1;
  67
  68     ExtrapolatePatches = 0;
  69     IncludeSets = 0;
  70     IncludeZones = 0;
  71     ShowPatchNames = 0;
  72
  73     UpdateGUI = 0;
  74
  75     PartSelection = vtkDataArraySelection::New();
  76     VolFieldSelection = vtkDataArraySelection::New();
  77     PointFieldSelection = vtkDataArraySelection::New();
  78     LagrangianFieldSelection = vtkDataArraySelection::New();
  79
  80     // Setup the selection callback to modify this object when an array
  81     // selection is changed.
  82     SelectionObserver = vtkCallbackCommand::New();
  83     SelectionObserver->SetCallback
  84     (
  85         &vtkPV3FoamReader::SelectionModifiedCallback
  86     );
  87     SelectionObserver->SetClientData(this);
  88
  89     PartSelection->AddObserver
  90     (
  91         vtkCommand::ModifiedEvent,
  92         this->SelectionObserver
  93     );
  94     VolFieldSelection->AddObserver
  95     (
  96         vtkCommand::ModifiedEvent,
  97         this->SelectionObserver
  98     );
  99     PointFieldSelection->AddObserver
 100     (
 101         vtkCommand::ModifiedEvent,
 102         this->SelectionObserver
 103     );
 104     LagrangianFieldSelection->AddObserver
 105     (
 106         vtkCommand::ModifiedEvent,
 107         this->SelectionObserver
 108     );
 109 }
 110
 111
 112 vtkPV3FoamReader::~vtkPV3FoamReader()
 113 {
 114     vtkDebugMacro(<<"Deconstructor");
 115
 116     delete foamData_;
 117
 118     if (FileName)
 119     {
 120         delete [] FileName;
 121     }
 122
 123     if (output0_)
 124     {
 125         output0_->Delete();
 126     }
 127
 128
 129     PartSelection->RemoveObserver(this->SelectionObserver);
 130     VolFieldSelection->RemoveObserver(this->SelectionObserver);
 131     PointFieldSelection->RemoveObserver(this->SelectionObserver);
 132     LagrangianFieldSelection->RemoveObserver(this->SelectionObserver);
 133
 134     SelectionObserver->Delete();
 135
 136     PartSelection->Delete();
 137     VolFieldSelection->Delete();
 138     PointFieldSelection->Delete();
 139     LagrangianFieldSelection->Delete();
 140 }
 141
 142
 143 // Do everything except set the output info
 144 int vtkPV3FoamReader::RequestInformation
 145 (
 146     vtkInformation* vtkNotUsed(request),
 147     vtkInformationVector** vtkNotUsed(inputVector),
 148     vtkInformationVector* outputVector
 149 )
 150 {
 151     vtkDebugMacro(<<"RequestInformation");
 152
 153     if (Foam::vtkPV3Foam::debug)
 154     {
 155         cout<<"REQUEST_INFORMATION\n";
 156     }
 157
 158     if (!FileName)
 159     {
 160         vtkErrorMacro("FileName has to be specified!");
 161         return 0;
 162     }
 163
 164     int nInfo = outputVector->GetNumberOfInformationObjects();
 165
 166     if (Foam::vtkPV3Foam::debug)
 167     {
 168         cout<<"RequestInformation with " << nInfo << " item(s)\n";
 169         for (int infoI = 0; infoI < nInfo; ++infoI)
 170         {
 171             outputVector->GetInformationObject(infoI)->Print(cout);
 172         }
 173     }
 174
 175     if (!foamData_)
 176     {
 177         foamData_ = new Foam::vtkPV3Foam(FileName, this);
 178     }
 179     else
 180     {
 181         foamData_->updateInfo();
 182     }
 183
 184     int nTimeSteps = 0;
 185     double* timeSteps = foamData_->findTimes(nTimeSteps);
 186
 187     if (!nTimeSteps)
 188     {
 189         vtkErrorMacro("could not find valid OpenFOAM mesh");
 190
 191         // delete foamData and flag it as fatal error
 192         delete foamData_;
 193         foamData_ = NULL;
 194         return 0;
 195     }
 196
 197     // set identical time steps for all ports
 198     for (int infoI = 0; infoI < nInfo; ++infoI)
 199     {
 200         outputVector->GetInformationObject(infoI)->Set
 201         (
 202             vtkStreamingDemandDrivenPipeline::TIME_STEPS(),
 203             timeSteps,
 204             nTimeSteps
 205         );
 206     }
 207
 208     if (nTimeSteps)
 209     {
 210         double timeRange[2];
 211         timeRange[0] = timeSteps[0];
 212         timeRange[1] = timeSteps[nTimeSteps-1];
 213
 214         if (Foam::vtkPV3Foam::debug > 1)
 215         {
 216             cout<<"nTimeSteps " << nTimeSteps << "\n"
 217                 <<"timeRange " << timeRange[0] << " to " << timeRange[1]
 218                 << "\n";
 219
 220             for (int timeI = 0; timeI < nTimeSteps; ++timeI)
 221             {
 222                 cout<< "step[" << timeI << "] = " << timeSteps[timeI] << "\n";
 223             }
 224         }
 225
 226         for (int infoI = 0; infoI < nInfo; ++infoI)
 227         {
 228             outputVector->GetInformationObject(infoI)->Set
 229             (
 230                 vtkStreamingDemandDrivenPipeline::TIME_RANGE(),
 231                 timeRange,
 232                 2
 233             );
 234         }
 235     }
 236
 237     delete timeSteps;
 238
 239     return 1;
 240 }
 241
 242
 243 // Set the output info
 244 int vtkPV3FoamReader::RequestData
 245 (
 246     vtkInformation* vtkNotUsed(request),
 247     vtkInformationVector** vtkNotUsed(inputVector),
 248     vtkInformationVector* outputVector
 249 )
 250 {
 251     vtkDebugMacro(<<"RequestData");
 252
 253     if (!FileName)
 254     {
 255         vtkErrorMacro("FileName has to be specified!");
 256         return 0;
 257     }
 258
 259     // catch previous error
 260     if (!foamData_)
 261     {
 262         vtkErrorMacro("Reader failed - perhaps no mesh?");
 263         return 0;
 264     }
 265
 266     int nInfo = outputVector->GetNumberOfInformationObjects();
 267
 268     if (Foam::vtkPV3Foam::debug)
 269     {
 270         cout<<"RequestData with " << nInfo << " item(s)\n";
 271         for (int infoI = 0; infoI < nInfo; ++infoI)
 272         {
 273             outputVector->GetInformationObject(infoI)->Print(cout);
 274         }
 275     }
 276
 277     // Get the requested time step.
 278     // We only support requests for a single time step
 279
 280     int nRequestTime = 0;
 281     double requestTime[nInfo];
 282
 283     // taking port0 as the lead for other outputs would be nice, but fails when
 284     // a filter is added - we need to check everything
 285     // but since PREVIOUS_UPDATE_TIME_STEPS() is protected, relay the logic
 286     // to the vtkPV3Foam::setTime() method
 287     for (int infoI = 0; infoI < nInfo; ++infoI)
 288     {
 289         vtkInformation *outInfo = outputVector->GetInformationObject(infoI);
 290
 291         if
 292         (
 293             outInfo->Has
 294             (
 295                 vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS()
 296             )
 297          && outInfo->Length
 298             (
 299                 vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS()
 300             ) >= 1
 301         )
 302         {
 303             requestTime[nRequestTime++] = outInfo->Get
 304             (
 305                 vtkStreamingDemandDrivenPipeline::UPDATE_TIME_STEPS()
 306             )[0];
 307         }
 308     }
 309
 310     if (nRequestTime)
 311     {
 312         foamData_->setTime(nRequestTime, requestTime);
 313     }
 314
 315
 316     vtkMultiBlockDataSet* output = vtkMultiBlockDataSet::SafeDownCast
 317     (
 318         outputVector->GetInformationObject(0)->Get
 319         (
 320             vtkMultiBlockDataSet::DATA_OBJECT()
 321         )
 322     );
 323
 324     if (Foam::vtkPV3Foam::debug)
 325     {
 326         cout<< "update output with "
 327             << output->GetNumberOfBlocks() << " blocks\n";
 328     }
 329
 330
 331 #ifdef EXPERIMENTAL_TIME_CACHING
 332     bool needsUpdate = false;
 333
 334     if (!output0_)
 335     {
 336         output0_ = vtkMultiBlockDataSet::New();
 337         needsUpdate = true;
 338     }
 339
 340     // This experimental bit of code seems to work for the geometry,
 341     // but trashes the fields and still triggers the GeometryFilter
 342     if (needsUpdate)
 343     {
 344         foamData_->Update(output);
 345         output0_->ShallowCopy(output);
 346     }
 347     else
 348     {
 349         output->ShallowCopy(output0_);
 350     }
 351
 352     if (Foam::vtkPV3Foam::debug)
 353     {
 354         if (needsUpdate)
 355         {
 356             cout<< "full UPDATE ---------\n";
 357         }
 358         else
 359         {
 360             cout<< "cached UPDATE ---------\n";
 361         }
 362
 363         cout<< "UPDATED output: ";
 364         output->Print(cout);
 365
 366         cout<< "UPDATED output0_: ";
 367         output0_->Print(cout);
 368     }
 369
 370 #else
 371
 372 #ifdef VTKPV3FOAM_DUALPORT
 373     foamData_->Update
 374     (
 375         output,
 376         vtkMultiBlockDataSet::SafeDownCast
 377         (
 378             outputVector->GetInformationObject(1)->Get
 379             (
 380                 vtkMultiBlockDataSet::DATA_OBJECT()
 381             )
 382         );
 383     );
 384 #else
 385     foamData_->Update(output, output);
 386 #endif
 387
 388     if (ShowPatchNames)
 389     {
 390         addPatchNamesToView();
 391     }
 392     else
 393     {
 394         removePatchNamesFromView();
 395     }
 396
 397 #endif
 398
 399     // Do any cleanup on the Foam side
 400     foamData_->CleanUp();
 401
 402     return 1;
 403 }
 404
 405
 406 void vtkPV3FoamReader::addPatchNamesToView()
 407 {
 408     pqApplicationCore* appCore = pqApplicationCore::instance();
 409
 410     // Server manager model for querying items in the server manager
 411     pqServerManagerModel* smModel = appCore->getServerManagerModel();
 412
 413     // Get all the pqRenderView instances
 414     QList<pqRenderView*> renderViews = smModel->findItems<pqRenderView*>();
 415
 416     for (int viewI=0; viewI<renderViews.size(); viewI++)
 417     {
 418         foamData_->addPatchNames
 419         (
 420             renderViews[viewI]->getRenderViewProxy()->GetRenderer()
 421         );
 422     }
 423 }
 424
 425
 426 void vtkPV3FoamReader::removePatchNamesFromView()
 427 {
 428     pqApplicationCore* appCore = pqApplicationCore::instance();
 429
 430     // Server manager model for querying items in the server manager
 431     pqServerManagerModel* smModel = appCore->getServerManagerModel();
 432
 433     // Get all the pqRenderView instances
 434     QList<pqRenderView*> renderViews = smModel->findItems<pqRenderView*>();
 435
 436     for (int viewI=0; viewI<renderViews.size(); viewI++)
 437     {
 438         foamData_->removePatchNames
 439         (
 440             renderViews[viewI]->getRenderViewProxy()->GetRenderer()
 441         );
 442     }
 443 }
 444
 445
 446 void vtkPV3FoamReader::PrintSelf(ostream& os, vtkIndent indent)
 447 {
 448     vtkDebugMacro(<<"PrintSelf");
 449
 450     this->Superclass::PrintSelf(os,indent);
 451     os<< indent << "File name: "
 452       << (this->FileName ? this->FileName : "(none)") << "\n";
 453
 454     foamData_->PrintSelf(os, indent);
 455
 456     os<< indent << "Time step range: "
 457       << this->TimeStepRange[0] << " - " << this->TimeStepRange[1]
 458       << "\n";
 459     os<< indent << "Time step: " << this->GetTimeStep() << endl;
 460 }
 461
 462
 463 int vtkPV3FoamReader::GetTimeStep()
 464 {
 465     return foamData_ ? foamData_->timeIndex() : -1;
 466 }
 467
 468
 469 // ----------------------------------------------------------------------
 470 // Parts selection list control
 471
 472 vtkDataArraySelection* vtkPV3FoamReader::GetPartSelection()
 473 {
 474     vtkDebugMacro(<<"GetPartSelection");
 475     return PartSelection;
 476 }
 477
 478
 479 int vtkPV3FoamReader::GetNumberOfPartArrays()
 480 {
 481     vtkDebugMacro(<<"GetNumberOfPartArrays");
 482     return PartSelection->GetNumberOfArrays();
 483 }
 484
 485
 486 const char* vtkPV3FoamReader::GetPartArrayName(int index)
 487 {
 488     vtkDebugMacro(<<"GetPartArrayName");
 489     return PartSelection->GetArrayName(index);
 490 }
 491
 492
 493 int vtkPV3FoamReader::GetPartArrayStatus(const char* name)
 494 {
 495     vtkDebugMacro(<<"GetPartArrayStatus");
 496     return PartSelection->ArrayIsEnabled(name);
 497 }
 498
 499
 500 void vtkPV3FoamReader::SetPartArrayStatus(const char* name, int status)
 501 {
 502     vtkDebugMacro(<<"SetPartArrayStatus");
 503     if (status)
 504     {
 505         PartSelection->EnableArray(name);
 506     }
 507     else
 508     {
 509         PartSelection->DisableArray(name);
 510     }
 511 }
 512
 513
 514 // ----------------------------------------------------------------------
 515 // volField selection list control
 516
 517 vtkDataArraySelection* vtkPV3FoamReader::GetVolFieldSelection()
 518 {
 519     vtkDebugMacro(<<"GetVolFieldSelection");
 520     return VolFieldSelection;
 521 }
 522
 523
 524 int vtkPV3FoamReader::GetNumberOfVolFieldArrays()
 525 {
 526     vtkDebugMacro(<<"GetNumberOfVolFieldArrays");
 527     return VolFieldSelection->GetNumberOfArrays();
 528 }
 529
 530
 531 const char* vtkPV3FoamReader::GetVolFieldArrayName(int index)
 532 {
 533     vtkDebugMacro(<<"GetVolFieldArrayName");
 534     return VolFieldSelection->GetArrayName(index);
 535 }
 536
 537
 538 int vtkPV3FoamReader::GetVolFieldArrayStatus(const char* name)
 539 {
 540     vtkDebugMacro(<<"GetVolFieldArrayStatus");
 541     return VolFieldSelection->ArrayIsEnabled(name);
 542 }
 543
 544
 545 void vtkPV3FoamReader::SetVolFieldArrayStatus(const char* name, int status)
 546 {
 547     vtkDebugMacro(<<"SetVolFieldArrayStatus");
 548     if (status)
 549     {
 550         VolFieldSelection->EnableArray(name);
 551     }
 552     else
 553     {
 554         VolFieldSelection->DisableArray(name);
 555     }
 556 }
 557
 558
 559 // ----------------------------------------------------------------------
 560 // pointField selection list control
 561
 562 vtkDataArraySelection* vtkPV3FoamReader::GetPointFieldSelection()
 563 {
 564     vtkDebugMacro(<<"GetPointFieldSelection");
 565     return PointFieldSelection;
 566 }
 567
 568
 569 int vtkPV3FoamReader::GetNumberOfPointFieldArrays()
 570 {
 571     vtkDebugMacro(<<"GetNumberOfPointFieldArrays");
 572     return PointFieldSelection->GetNumberOfArrays();
 573 }
 574
 575
 576 const char* vtkPV3FoamReader::GetPointFieldArrayName(int index)
 577 {
 578     vtkDebugMacro(<<"GetPointFieldArrayName");
 579     return PointFieldSelection->GetArrayName(index);
 580 }
 581
 582
 583 int vtkPV3FoamReader::GetPointFieldArrayStatus(const char* name)
 584 {
 585     vtkDebugMacro(<<"GetPointFieldArrayStatus");
 586     return PointFieldSelection->ArrayIsEnabled(name);
 587 }
 588
 589
 590 void vtkPV3FoamReader::SetPointFieldArrayStatus(const char* name, int status)
 591 {
 592     vtkDebugMacro(<<"SetPointFieldArrayStatus");
 593     if (status)
 594     {
 595         PointFieldSelection->EnableArray(name);
 596     }
 597     else
 598     {
 599         PointFieldSelection->DisableArray(name);
 600     }
 601 }
 602
 603
 604 // ----------------------------------------------------------------------
 605 // lagrangianField selection list control
 606
 607 vtkDataArraySelection* vtkPV3FoamReader::GetLagrangianFieldSelection()
 608 {
 609     vtkDebugMacro(<<"GetLagrangianFieldSelection");
 610     return LagrangianFieldSelection;
 611 }
 612
 613
 614 int vtkPV3FoamReader::GetNumberOfLagrangianFieldArrays()
 615 {
 616     vtkDebugMacro(<<"GetNumberOfLagrangianFieldArrays");
 617     return LagrangianFieldSelection->GetNumberOfArrays();
 618 }
 619
 620
 621 const char* vtkPV3FoamReader::GetLagrangianFieldArrayName(int index)
 622 {
 623     vtkDebugMacro(<<"GetLagrangianFieldArrayName");
 624     return LagrangianFieldSelection->GetArrayName(index);
 625 }
 626
 627
 628 int vtkPV3FoamReader::GetLagrangianFieldArrayStatus(const char* name)
 629 {
 630     vtkDebugMacro(<<"GetLagrangianFieldArrayStatus");
 631     return LagrangianFieldSelection->ArrayIsEnabled(name);
 632 }
 633
 634
 635 void vtkPV3FoamReader::SetLagrangianFieldArrayStatus
 636 (
 637     const char* name,
 638     int status
 639 )
 640 {
 641     vtkDebugMacro(<<"SetLagrangianFieldArrayStatus");
 642     if (status)
 643     {
 644         LagrangianFieldSelection->EnableArray(name);
 645     }
 646     else
 647     {
 648         LagrangianFieldSelection->DisableArray(name);
 649     }
 650 }
 651
 652
 653 // ----------------------------------------------------------------------
 654
 655 void vtkPV3FoamReader::SelectionModifiedCallback
 656 (
 657     vtkObject*,
 658     unsigned long,
 659     void* clientdata,
 660     void*
 661 )
 662 {
 663     static_cast<vtkPV3FoamReader*>(clientdata)->SelectionModified();
 664 }
 665
 666
 667 void vtkPV3FoamReader::SelectionModified()
 668 {
 669     vtkDebugMacro(<<"SelectionModified");
 670     Modified();
 671 }
 672
 673
 674 int vtkPV3FoamReader::FillOutputPortInformation
 675 (
 676     int port,
 677     vtkInformation* info
 678 )
 679 {
 680     if (port == 0)
 681     {
 682         return this->Superclass::FillOutputPortInformation(port, info);
 683     }
 684     info->Set(vtkDataObject::DATA_TYPE_NAME(), "vtkMultiBlockDataSet");
 685     return 1;
 686 }
 687
 688
 689 // ************************************************************************* //