#include "vtkCellArray.h"
#include "vtkDoubleArray.h"
#include "vtkObjectFactory.h"
+#ifdef MEDREADER_USE_MPI
+#include "vtkMultiProcessController.h"
+#endif
#include "MEDFileFieldRepresentationTree.hxx"
#include <sstream>
#include <algorithm>
+/*!
+ * This class stores properties in loading state mode (pvsm) when the MED file has not been read yet.
+ * The file is not read beacause FileName has not been informed yet ! So this class stores properties of vtkMEDReader instance that
+ * owns it and wait the vtkMEDReader::SetFileName to apply properties afterwards.
+ */
+class PropertyKeeper
+{
+public:
+ PropertyKeeper(vtkMEDReader *master):_master(master),IsGVActivated(false),GVValue(0),IsCMActivated(false),CMValue(0) { }
+ void assignPropertiesIfNeeded();
+ bool arePropertiesOnTreeToSetAfter() const;
+ //
+ void pushFieldStatusEntry(const char* name, int status);
+ void pushGenerateVectorsValue(int value);
+ void pushChangeModeValue(int value);
+ void pushTimesFlagsStatusEntry(const char* name, int status);
+protected:
+ // pool of pairs to assign in SetFieldsStatus if needed. The use case is the load using pvsm.
+ std::vector< std::pair<std::string,int> > SetFieldsStatusPairs;
+ // generate vector
+ bool IsGVActivated;
+ int GVValue;
+ // change mode
+ bool IsCMActivated;
+ int CMValue;
+ //
+ std::vector< std::pair<std::string,int> > TimesFlagsStatusPairs;
+ vtkMEDReader *_master;
+};
+
+void PropertyKeeper::assignPropertiesIfNeeded()
+{
+ if(!this->SetFieldsStatusPairs.empty())
+ {
+ for(std::vector< std::pair<std::string,int> >::const_iterator it=this->SetFieldsStatusPairs.begin();it!=this->SetFieldsStatusPairs.end();it++)
+ _master->SetFieldsStatus((*it).first.c_str(),(*it).second);
+ this->SetFieldsStatusPairs.clear();
+ }
+ if(!this->TimesFlagsStatusPairs.empty())
+ {
+ for(std::vector< std::pair<std::string,int> >::const_iterator it=this->TimesFlagsStatusPairs.begin();it!=this->TimesFlagsStatusPairs.end();it++)
+ _master->SetTimesFlagsStatus((*it).first.c_str(),(*it).second);
+ this->TimesFlagsStatusPairs.clear();
+ }
+ if(this->IsGVActivated)
+ {
+ _master->GenerateVectors(this->GVValue);
+ this->IsGVActivated=false;
+ }
+ if(this->IsCMActivated)
+ {
+ _master->ChangeMode(this->CMValue);
+ this->IsCMActivated=false;
+ }
+}
+
+void PropertyKeeper::pushFieldStatusEntry(const char* name, int status)
+{
+ bool found(false);
+ for(std::vector< std::pair<std::string,int> >::const_iterator it=this->SetFieldsStatusPairs.begin();it!=this->SetFieldsStatusPairs.end() && !found;it++)
+ found=(*it).first==name;
+ if(!found)
+ this->SetFieldsStatusPairs.push_back(std::pair<std::string,int>(name,status));
+}
+
+void PropertyKeeper::pushTimesFlagsStatusEntry(const char* name, int status)
+{
+ bool found(false);
+ for(std::vector< std::pair<std::string,int> >::const_iterator it=this->TimesFlagsStatusPairs.begin();it!=this->TimesFlagsStatusPairs.end() && !found;it++)
+ found=(*it).first==name;
+ if(!found)
+ this->TimesFlagsStatusPairs.push_back(std::pair<std::string,int>(name,status));
+}
+
+void PropertyKeeper::pushGenerateVectorsValue(int value)
+{
+ this->IsGVActivated=true;
+ this->GVValue=value;
+}
+
+void PropertyKeeper::pushChangeModeValue(int value)
+{
+ this->IsCMActivated=true;
+ this->CMValue=value;
+}
+
+bool PropertyKeeper::arePropertiesOnTreeToSetAfter() const
+{
+ return !SetFieldsStatusPairs.empty();
+}
+
class vtkMEDReader::vtkMEDReaderInternal
{
public:
- vtkMEDReaderInternal():TK(0),IsMEDOrSauv(true),IsStdOrMode(false),GenerateVect(false),SIL(0),LastLev0(-1),FirstCall0(2)
+ vtkMEDReaderInternal(vtkMEDReader *master):TK(0),IsMEDOrSauv(true),IsStdOrMode(false),GenerateVect(false),SIL(0),LastLev0(-1),FirstCall0(2),PK(master)
{
}
vtkMutableDirectedGraph* SIL;
// store the lev0 id in Tree corresponding to the TIME_STEPS in the pipeline.
int LastLev0;
+ // The property keeper is usable only in pvsm mode.
+ PropertyKeeper PK;
private:
unsigned char FirstCall0;
};
vtkStandardNewMacro(vtkMEDReader);
-vtkMEDReader::vtkMEDReader():Internal(new vtkMEDReaderInternal)
+vtkMEDReader::vtkMEDReader():Internal(new vtkMEDReaderInternal(this))
{
this->SetNumberOfInputPorts(0);
this->SetNumberOfOutputPorts(1);
std::cerr << "vtkMEDReader::Reload" << a << std::endl;
std::string fName((const char *)this->GetFileName());
delete this->Internal;
- this->Internal=new vtkMEDReaderInternal;
+ this->Internal=new vtkMEDReaderInternal(this);
this->SetFileName(fName.c_str());
}
void vtkMEDReader::GenerateVectors(int val)
{
+ if(this->Internal->FileName.empty())
+ {//pvsm mode
+ this->Internal->PK.pushGenerateVectorsValue(val);
+ return ;
+ }
+ //not pvsm mode (general case)
bool val2((bool)val);
if(val2!=this->Internal->GenerateVect)
{
void vtkMEDReader::ChangeMode(int newMode)
{
+ if(this->Internal->FileName.empty())
+ {//pvsm mode
+ this->Internal->PK.pushChangeModeValue(newMode);
+ return ;
+ }
+ //not pvsm mode (general case)
this->Internal->IsStdOrMode=newMode!=0;
//std::cerr << "vtkMEDReader::ChangeMode : " << this->Internal->IsStdOrMode << std::endl;
this->Modified();
void vtkMEDReader::SetFileName(const char *fname)
{
- this->Internal->FileName=fname;
- std::size_t pos(this->Internal->FileName.find_last_of('.'));
- if(pos!=std::string::npos)
+ try
{
- std::string ext(this->Internal->FileName.substr(pos));
- if(ext.find("sauv")!=std::string::npos)
- this->Internal->IsMEDOrSauv=false;
+ this->Internal->FileName=fname;
+ std::size_t pos(this->Internal->FileName.find_last_of('.'));
+ if(pos!=std::string::npos)
+ {
+ std::string ext(this->Internal->FileName.substr(pos));
+ if(ext.find("sauv")!=std::string::npos)
+ this->Internal->IsMEDOrSauv=false;
+ }
+ if(this->Internal->Tree.getNumberOfLeavesArrays()==0)
+ {
+ int iPart(-1),nbOfParts(-1);
+#ifdef MEDREADER_USE_MPI
+ vtkMultiProcessController *vmpc(vtkMultiProcessController::GetGlobalController());
+ if(vmpc)
+ {
+ iPart=vmpc->GetLocalProcessId();
+ nbOfParts=vmpc->GetNumberOfProcesses();
+ }
+#endif
+ this->Internal->Tree.loadMainStructureOfFile(this->Internal->FileName.c_str(),this->Internal->IsMEDOrSauv,iPart,nbOfParts);
+ if(!this->Internal->PK.arePropertiesOnTreeToSetAfter())
+ this->Internal->Tree.activateTheFirst();//This line manually initialize the status of server (this) with the remote client.
+ this->Internal->TK.setMaxNumberOfTimeSteps(this->Internal->Tree.getMaxNumberOfTimeSteps());
+ }
+ this->Modified();
+ this->Internal->PK.assignPropertiesIfNeeded();
}
- if(this->Internal->Tree.getNumberOfLeavesArrays()==0)
+ catch(INTERP_KERNEL::Exception& e)
{
- this->Internal->Tree.loadMainStructureOfFile(this->Internal->FileName.c_str(),this->Internal->IsMEDOrSauv);
- this->Internal->Tree.activateTheFirst();//This line manually initialize the status of server (this) with the remote client.
- this->Internal->TK.setMaxNumberOfTimeSteps(this->Internal->Tree.getMaxNumberOfTimeSteps());
+ delete this->Internal;
+ this->Internal=0;
+ std::ostringstream oss;
+ oss << "Exception has been thrown in vtkMEDReader::SetFileName : " << e.what() << std::endl;
+ if(this->HasObserver("ErrorEvent") )
+ this->InvokeEvent("ErrorEvent",const_cast<char *>(oss.str().c_str()));
+ else
+ vtkOutputWindowDisplayErrorText(const_cast<char *>(oss.str().c_str()));
+ vtkObject::BreakOnError();
}
- this->Modified();
}
char *vtkMEDReader::GetFileName()
int vtkMEDReader::RequestInformation(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector)
{
//std::cerr << "########################################## RequestInformation ##########################################" << std::endl;
+ if(!this->Internal)
+ return 0;
try
{
vtkInformation *outInfo(outputVector->GetInformationObject(0));
- outInfo->Set(vtkStreamingDemandDrivenPipeline::MAXIMUM_NUMBER_OF_PIECES(),-1);
outInfo->Set(vtkDataObject::DATA_TYPE_NAME(),"vtkMultiBlockDataSet");
this->UpdateSIL(outInfo);
//
}
catch(INTERP_KERNEL::Exception& e)
{
- std::cerr << "Exception has been thrown in vtkMEDReader::RequestInformation : " << e.what() << std::endl;
+ std::ostringstream oss;
+ oss << "Exception has been thrown in vtkMEDReader::RequestInformation : " << e.what() << std::endl;
+ if(this->HasObserver("ErrorEvent") )
+ this->InvokeEvent("ErrorEvent",const_cast<char *>(oss.str().c_str()));
+ else
+ vtkOutputWindowDisplayErrorText(const_cast<char *>(oss.str().c_str()));
+ vtkObject::BreakOnError();
return 0;
}
return 1;
int vtkMEDReader::RequestData(vtkInformation *request, vtkInformationVector **inputVector, vtkInformationVector *outputVector)
{
//std::cerr << "########################################## RequestData ##########################################";
+ if(!this->Internal)
+ return 0;
try
{
vtkInformation *outInfo(outputVector->GetInformationObject(0));
}
catch(INTERP_KERNEL::Exception& e)
{
- std::cerr << "Exception has been thrown in vtkMEDReader::RequestInformation : " << e.what() << std::endl;
+ std::cerr << "Exception has been thrown in vtkMEDReader::RequestData : " << e.what() << std::endl;
return 0;
}
return 1;
void vtkMEDReader::SetFieldsStatus(const char* name, int status)
{
//std::cerr << "vtkMEDReader::SetFieldsStatus(" << name << "," << status << ") called !" << std::endl;
- this->Internal->Tree.changeStatusOfAndUpdateToHaveCoherentVTKDataSet(this->Internal->Tree.getIdHavingZeName(name),status);
- if(std::string(name)==GetFieldsTreeArrayName(GetNumberOfFieldsTreeArrays()-1))
- if(!this->Internal->PluginStart0())
- this->Modified();
+ if(this->Internal->FileName.empty())
+ {//pvsm mode
+ this->Internal->PK.pushFieldStatusEntry(name,status);
+ return ;
+ }
+ //not pvsm mode (general case)
+ try
+ {
+ this->Internal->Tree.changeStatusOfAndUpdateToHaveCoherentVTKDataSet(this->Internal->Tree.getIdHavingZeName(name),status);
+ if(std::string(name)==GetFieldsTreeArrayName(GetNumberOfFieldsTreeArrays()-1))
+ if(!this->Internal->PluginStart0())
+ this->Modified();
+ }
+ catch(INTERP_KERNEL::Exception& e)
+ {
+ if(!this->Internal->FileName.empty())
+ {
+ std::cerr << "vtkMEDReader::SetFieldsStatus error : " << e.what() << " *** WITH STATUS=" << status << endl;
+ return ;
+ }
+ }
}
int vtkMEDReader::GetNumberOfFieldsTreeArrays()
{
+ if(!this->Internal)
+ return 0;
int ret(this->Internal->Tree.getNumberOfLeavesArrays());
//std::cerr << "vtkMEDReader::GetNumberOfFieldsTreeArrays called ! " << ret << std::endl;
return ret;
const char *vtkMEDReader::GetFieldsTreeArrayName(int index)
{
- std::string ret(this->Internal->Tree.getNameOf(index));
+ return this->Internal->Tree.getNameOfC(index);
//std::cerr << "vtkMEDReader::GetFieldsTreeArrayName(" << index << ") called ! " << ret << std::endl;
- return ret.c_str();
}
int vtkMEDReader::GetFieldsTreeArrayStatus(const char *name)
void vtkMEDReader::SetTimesFlagsStatus(const char *name, int status)
{
+ if(this->Internal->FileName.empty())
+ {//pvsm mode
+ this->Internal->PK.pushTimesFlagsStatusEntry(name,status);
+ return ;
+ }
+ //not pvsm mode (general case)
int pos(0);
std::istringstream iss(name); iss >> pos;
this->Internal->TK.getTimesFlagArray()[pos].first=(bool)status;
int vtkMEDReader::GetNumberOfTimesFlagsArrays()
{
+ if(!this->Internal)
+ return 0;
return (int)this->Internal->TK.getTimesFlagArray().size();
}
void vtkMEDReader::UpdateSIL(vtkInformation *info)
{
+ if(!this->Internal)
+ return ;
vtkMutableDirectedGraph *sil(vtkMutableDirectedGraph::New());
std::string meshName(this->BuildSIL(sil));
if(meshName!=this->Internal->DftMeshName)
