Commit 81661b0c authored by Ken Martin's avatar Ken Martin
Browse files

ENH: added range min and max to the output of most data arrays in the XML readers and writers

parent 91c92c83
......@@ -61,6 +61,8 @@ public:
{
assert( numTimeStep > 0);
this->Positions.resize(numTimeStep);
this->RangeMinPositions.resize(numTimeStep);
this->RangeMaxPositions.resize(numTimeStep);
this->OffsetValues.resize(numTimeStep);
}
unsigned long &GetPosition(unsigned int t)
......@@ -68,6 +70,16 @@ public:
assert( t < this->Positions.size());
return this->Positions[t];
}
unsigned long &GetRangeMinPosition(unsigned int t)
{
assert( t < this->RangeMinPositions.size());
return this->RangeMinPositions[t];
}
unsigned long &GetRangeMaxPosition(unsigned int t)
{
assert( t < this->RangeMaxPositions.size());
return this->RangeMaxPositions[t];
}
unsigned long &GetOffsetValue(unsigned int t)
{
assert( t < this->OffsetValues.size());
......@@ -79,7 +91,15 @@ public:
}
private:
unsigned long LastMTime; // Previously written dataarray mtime
vtkstd::vector<unsigned long> Positions; // Position in the stream to write the offset
// at some point these vectors could become a vector of map <string,ul>
// where the string is the name of the offset, but that would be pretty fat
// and slow, but if another couple offsets are added then we should
// consider doing it
// Position in the stream to write the offset
vtkstd::vector<unsigned long> Positions;
vtkstd::vector<unsigned long> RangeMinPositions; // Where is this
vtkstd::vector<unsigned long> RangeMaxPositions; // Whee is this
vtkstd::vector<unsigned long> OffsetValues; // Value of offset
};
......@@ -87,11 +107,12 @@ private:
class OffsetsManagerGroup
{
public:
// This is kind of a hack since we need to consider both the case of Points with
// only one array over time and PointData with possibly multiple array over time
// therefore we need to use a OffsetsManagerGroup for representing offset from
// Points but OffsetsManagerArray for PointData. In both case the toplevel structure
// is a container of Pieces...
// This is kind of a hack since we need to consider both the case of Points
// with only one array over time and PointData with possibly multiple array
// over time therefore we need to use a OffsetsManagerGroup for
// representing offset from Points but OffsetsManagerArray for
// PointData. In both case the toplevel structure is a container of
// Pieces...
OffsetsManager &GetPiece(unsigned int index)
{
assert( index < this->Internals.size());
......@@ -101,10 +122,10 @@ public:
// GetElement should be used when manipulating a OffsetsManagerArray
OffsetsManager &GetElement(unsigned int index)
{
// commenting the following out, this is an heisenbug which only appears on gcc
// when exporting GLIBCPP_NEW=1. If you try to print the value or run through gdb
// it desepears
//assert( index < this->Internals.size());
// commenting the following out, this is an heisenbug which only appears
// on gcc when exporting GLIBCPP_NEW=1. If you try to print the value or
// run through gdb it desepears //assert( index <
// this->Internals.size());
OffsetsManager &e = this->Internals[index];
return e;
}
......
......@@ -23,11 +23,11 @@
#include "vtkXMLDataParser.h"
#include "vtkInformationVector.h"
#include "vtkInformation.h"
#include "vtkExecutive.h"
#include "vtkStreamingDemandDrivenPipeline.h"
#include "assert.h"
vtkCxxRevisionMacro(vtkXMLDataReader, "1.25");
vtkCxxRevisionMacro(vtkXMLDataReader, "1.26");
//----------------------------------------------------------------------------
vtkXMLDataReader::vtkXMLDataReader()
......@@ -114,14 +114,17 @@ void vtkXMLDataReader::SetupOutputInformation(vtkInformation *outInfo)
}
// Initialize DataArraySelections to enable all that are present
this->SetDataArraySelections(this->PointDataElements[0], this->PointDataArraySelection);
this->SetDataArraySelections(this->CellDataElements[0], this->CellDataArraySelection);
this->SetDataArraySelections(this->PointDataElements[0],
this->PointDataArraySelection);
this->SetDataArraySelections(this->CellDataElements[0],
this->CellDataArraySelection);
// Setup the Field Information for PointData. We only need the
// information from one piece because all pieces have the same set of arrays.
vtkInformationVector *infoVector = NULL;
if (!this->SetFieldDataInfo(this->PointDataElements[0],
vtkDataObject::FIELD_ASSOCIATION_POINTS, this->GetNumberOfPoints(), infoVector))
vtkDataObject::FIELD_ASSOCIATION_POINTS,
this->GetNumberOfPoints(), infoVector))
{
return;
}
......@@ -134,7 +137,8 @@ void vtkXMLDataReader::SetupOutputInformation(vtkInformation *outInfo)
// now the Cell data
infoVector = NULL;
if (!this->SetFieldDataInfo(this->CellDataElements[0],
vtkDataObject::FIELD_ASSOCIATION_CELLS, this->GetNumberOfCells(), infoVector))
vtkDataObject::FIELD_ASSOCIATION_CELLS,
this->GetNumberOfCells(), infoVector))
{
return;
}
......@@ -145,11 +149,64 @@ void vtkXMLDataReader::SetupOutputInformation(vtkInformation *outInfo)
}
}
void vtkXMLDataReader::SetupUpdateExtentInformation(vtkInformation *outInfo)
{
// get the current piece being requested
int piece =
outInfo->Get(vtkStreamingDemandDrivenPipeline::UPDATE_PIECE_NUMBER());
// Setup the Field Information for PointData.
vtkInformationVector *infoVector =
outInfo->Get(vtkDataObject::POINT_DATA_VECTOR());
if (!this->SetUpdateExtentInfo(this->PointDataElements[piece],
infoVector))
{
return;
}
// now the Cell data
infoVector = outInfo->Get(vtkDataObject::CELL_DATA_VECTOR());
if (!this->SetUpdateExtentInfo(this->CellDataElements[piece],
infoVector))
{
return;
}
}
//----------------------------------------------------------------------------
int vtkXMLDataReader::SetUpdateExtentInfo(vtkXMLDataElement *eDSA,
vtkInformationVector *infoVector)
{
if (!eDSA)
{
return 1;
}
int i;
vtkInformation *info = NULL;
// Cycle through each data array
for(i = 0; i < eDSA->GetNumberOfNestedElements(); i++)
{
vtkXMLDataElement* eNested = eDSA->GetNestedElement(i);
vtkInformation *info = infoVector->GetInformationObject(i);
double range[2];
if (eNested->GetScalarAttribute("RangeMin", range[0]) &&
eNested->GetScalarAttribute("RangeMax", range[1]))
{
info->Set(vtkDataObject::FIELD_RANGE(), range, 2);
}
}
return 1;
}
//----------------------------------------------------------------------------
void vtkXMLDataReader::CopyOutputInformation(vtkInformation *outInfo, int port)
{
vtkInformation *localInfo = this->GetExecutive()->GetOutputInformation( port );
vtkInformation *localInfo =
this->GetExecutive()->GetOutputInformation( port );
if ( localInfo->Has(vtkDataObject::POINT_DATA_VECTOR()) )
{
outInfo->CopyEntry( localInfo, vtkDataObject::POINT_DATA_VECTOR() );
......
......@@ -48,10 +48,14 @@ protected:
vtkXMLDataReader();
~vtkXMLDataReader();
int SetUpdateExtentInfo(vtkXMLDataElement *eDSA,
vtkInformationVector *infoVector);
// Add functionality to methods from superclass.
virtual void CreateXMLParser();
virtual void DestroyXMLParser();
virtual void SetupOutputInformation(vtkInformation *outInfo);
virtual void SetupUpdateExtentInformation(vtkInformation *outInfo);
int ReadPrimaryElement(vtkXMLDataElement* ePrimary);
void SetupOutputData();
......
......@@ -33,7 +33,7 @@
#undef vtkOffsetsManager_DoNotInclude
vtkCxxRevisionMacro(vtkXMLHyperOctreeWriter, "1.4");
vtkCxxRevisionMacro(vtkXMLHyperOctreeWriter, "1.5");
vtkStandardNewMacro(vtkXMLHyperOctreeWriter);
//----------------------------------------------------------------------------
......@@ -43,6 +43,7 @@ vtkXMLHyperOctreeWriter::vtkXMLHyperOctreeWriter()
this->TopologyOM = new OffsetsManagerGroup;
this->PointDataOM = new OffsetsManagerGroup;
this->CellDataOM = new OffsetsManagerGroup;
this->TopologyOM->Allocate(1,1);
}
//----------------------------------------------------------------------------
......@@ -143,11 +144,19 @@ int vtkXMLHyperOctreeWriter::WriteData()
//write out the data arrays in the appended data block while going back
//and filling in empty offset space in previously written entries
unsigned long dummy;
this->WriteDataArrayAppendedData(this->TopologyArray, this->TopoOffset, dummy);
this->WriteDataArrayAppendedData
(this->TopologyArray,
this->TopologyOM->GetElement(0).GetPosition(0),
this->TopologyOM->GetElement(0).GetOffsetValue(0));
double *range = this->TopologyArray->GetRange(-1);
this->ForwardAppendedDataDouble
(this->TopologyOM->GetElement(0).GetRangeMinPosition(0),
range[0],"RangeMin" );
this->ForwardAppendedDataDouble
(this->TopologyOM->GetElement(0).GetRangeMaxPosition(0),
range[1],"RangeMax" );
this->SetProgressRange(progressRange, 1, fractions);
this->WritePointDataAppendedData(this->GetInput()->GetPointData(), 0, this->PointDataOM);
this->SetProgressRange(progressRange, 2, fractions);
......@@ -239,11 +248,15 @@ int vtkXMLHyperOctreeWriter::WriteTopology(vtkIndent indent)
if (this->GetDataMode() == vtkXMLWriter::Appended)
{
this->TopoOffset = this->WriteDataArrayAppended(this->TopologyArray, indent.GetNextIndent(), "Topology", 1);
this->WriteDataArrayAppended(this->TopologyArray,
indent.GetNextIndent(),
this->TopologyOM->GetElement(0),
"Topology", 1, 0);
}
else
{
this->WriteDataArrayInline(this->TopologyArray, indent.GetNextIndent(), "Topology", 1);
this->WriteDataArrayInline(this->TopologyArray,
indent.GetNextIndent(), "Topology", 1);
}
os << indent << "</" << "Topology" << ">\n";
......
......@@ -33,7 +33,7 @@
#include <sys/stat.h>
#include <assert.h>
vtkCxxRevisionMacro(vtkXMLReader, "1.40");
vtkCxxRevisionMacro(vtkXMLReader, "1.41");
//----------------------------------------------------------------------------
vtkXMLReader::vtkXMLReader()
......@@ -330,19 +330,23 @@ int vtkXMLReader::ReadXMLInformation()
}
//----------------------------------------------------------------------------
int vtkXMLReader::RequestInformation(vtkInformation *request,
vtkInformationVector **vtkNotUsed(inputVector),
vtkInformationVector *outputVector)
int vtkXMLReader
::RequestInformation(vtkInformation *request,
vtkInformationVector **vtkNotUsed(inputVector),
vtkInformationVector *outputVector)
{
if (this->ReadXMLInformation())
{
this->InformationError = 0;
// Let the subclasses read the information they want.
int outputPort = request->Get( vtkDemandDrivenPipeline::FROM_OUTPUT_PORT() );
int outputPort =
request->Get( vtkDemandDrivenPipeline::FROM_OUTPUT_PORT() );
outputPort = outputPort >= 0 ? outputPort : 0;
this->SetupOutputInformation( outputVector->GetInformationObject(outputPort) );
this->SetupOutputInformation
(outputVector->GetInformationObject(outputPort) );
// this->NumberOfTimeSteps has been set during the this->ReadXMLInformation()
// this->NumberOfTimeSteps has been set during the
// this->ReadXMLInformation()
int numTimesteps = this->GetNumberOfTimeSteps();
this->TimeStepRange[0] = 0;
this->TimeStepRange[1] = numTimesteps-1;
......@@ -367,6 +371,22 @@ int vtkXMLReader::RequestInformation(vtkInformation *request,
return !this->InformationError;
}
//----------------------------------------------------------------------------
int vtkXMLReader
::RequestUpdateExtentInformation
(vtkInformation *request,
vtkInformationVector **vtkNotUsed(inputVector),
vtkInformationVector *outputVector)
{
int outputPort =
request->Get( vtkDemandDrivenPipeline::FROM_OUTPUT_PORT() );
outputPort = outputPort >= 0 ? outputPort : 0;
this->SetupUpdateExtentInformation
(outputVector->GetInformationObject(outputPort) );
return 1;
}
//----------------------------------------------------------------------------
int vtkXMLReader::RequestData(vtkInformation *request,
vtkInformationVector **vtkNotUsed(inputVector),
......@@ -547,7 +567,8 @@ int vtkXMLReader::ReadPrimaryElement(vtkXMLDataElement* ePrimary)
// Let check the "TimeValues" here
const int tsMax = 4096;
double timevalues[tsMax];
int numTimeSteps = ePrimary->GetVectorAttribute("TimeValues", tsMax, timevalues);
int numTimeSteps =
ePrimary->GetVectorAttribute("TimeValues", tsMax, timevalues);
assert( numTimeSteps <= tsMax);
this->SetNumberOfTimeSteps( numTimeSteps );
......@@ -598,7 +619,7 @@ vtkDataArray* vtkXMLReader::CreateDataArray(vtkXMLDataElement* da)
{
array->SetNumberOfComponents(components);
}
return array;
}
......@@ -937,6 +958,13 @@ int vtkXMLReader::SetFieldDataInfo(vtkXMLDataElement *eDSA,
info->Set(vtkDataObject::FIELD_NUMBER_OF_COMPONENTS(), 1);
}
double range[2];
if (eNested->GetScalarAttribute("RangeMin", range[0]) &&
eNested->GetScalarAttribute("RangeMax", range[1]))
{
info->Set(vtkDataObject::FIELD_RANGE(), range, 2);
}
info->Set(vtkDataObject::FIELD_ACTIVE_ATTRIBUTE(), activeFlag);
infoVector->Append( info );
info->Delete();
......@@ -1126,6 +1154,14 @@ int vtkXMLReader::ProcessRequest(vtkInformation* request,
return this->RequestInformation(request, inputVector, outputVector);
}
// return UE info
if(request->Has
(vtkStreamingDemandDrivenPipeline::REQUEST_UPDATE_EXTENT_INFORMATION()))
{
return this->RequestUpdateExtentInformation(request,
inputVector, outputVector);
}
return this->Superclass::ProcessRequest(request, inputVector, outputVector);
}
......
......@@ -116,6 +116,10 @@ protected:
// Setup the output's information.
virtual void SetupOutputInformation(vtkInformation *vtkNotUsed(outInfo)) {}
// Setup the output's information for the update extent
virtual void SetupUpdateExtentInformation
(vtkInformation *vtkNotUsed(outInfo)) {}
// Setup the output's data with allocation.
virtual void SetupOutputData();
......@@ -222,6 +226,10 @@ protected:
virtual int RequestInformation(vtkInformation *request,
vtkInformationVector **inputVector,
vtkInformationVector *outputVector);
virtual int RequestUpdateExtentInformation
(vtkInformation *request,
vtkInformationVector **inputVector,
vtkInformationVector *outputVector);
vtkTimeStamp ReadMTime;
......
......@@ -35,7 +35,7 @@
#include <assert.h>
vtkCxxRevisionMacro(vtkXMLUnstructuredDataWriter, "1.19");
vtkCxxRevisionMacro(vtkXMLUnstructuredDataWriter, "1.20");
//----------------------------------------------------------------------------
vtkXMLUnstructuredDataWriter::vtkXMLUnstructuredDataWriter()
......@@ -626,8 +626,9 @@ void vtkXMLUnstructuredDataWriter::WriteCellsAppended(const char* name,
{
if(allcells[i])
{
cellsManager->GetElement(i).GetPosition(t) =
this->WriteDataArrayAppended(allcells[i], indent.GetNextIndent(),names[i],0,t);
this->WriteDataArrayAppended(allcells[i], indent.GetNextIndent(),
cellsManager->GetElement(i),
names[i],0,t);
if (this->ErrorCode == vtkErrorCode::OutOfDiskSpaceError)
{
return;
......
......@@ -42,7 +42,7 @@
# include <io.h> /* unlink */
#endif
vtkCxxRevisionMacro(vtkXMLWriter, "1.58");
vtkCxxRevisionMacro(vtkXMLWriter, "1.59");
vtkCxxSetObjectMacro(vtkXMLWriter, Compressor, vtkDataCompressor);
//----------------------------------------------------------------------------
......@@ -666,6 +666,7 @@ unsigned long vtkXMLWriter::WriteAppendedDataOffset(unsigned long streamPos,
return endPos;
}
//----------------------------------------------------------------------------
unsigned long vtkXMLWriter::ForwardAppendedDataOffset(unsigned long streamPos,
unsigned long offset,
......@@ -691,6 +692,31 @@ unsigned long vtkXMLWriter::ForwardAppendedDataOffset(unsigned long streamPos,
return endPos;
}
//----------------------------------------------------------------------------
unsigned long vtkXMLWriter::ForwardAppendedDataDouble(unsigned long streamPos,
double value,
const char* attr)
{
ostream& os = *(this->Stream);
unsigned long returnPos = os.tellp();
os.seekp(streamPos);
if(attr)
{
os << " " << attr << "=";
}
os << "\"" << value << "\"";
unsigned long endPos = os.tellp();
os.seekp(returnPos);
os.flush();
if (os.fail())
{
this->SetErrorCode(vtkErrorCode::GetLastSystemError());
}
return endPos;
}
//----------------------------------------------------------------------------
int vtkXMLWriter::WriteBinaryData(void* data, int numWords, int wordType)
{
......@@ -1223,6 +1249,12 @@ int vtkXMLWriter::WriteScalarAttribute(const char* name, float data)
return this->WriteVectorAttribute(name, 1, &data);
}
//----------------------------------------------------------------------------
int vtkXMLWriter::WriteScalarAttribute(const char* name, double data)
{
return this->WriteVectorAttribute(name, 1, &data);
}
//----------------------------------------------------------------------------
#ifdef VTK_USE_64BIT_IDS
int vtkXMLWriter::WriteScalarAttribute(const char* name, vtkIdType data)
......@@ -1494,21 +1526,28 @@ int vtkXMLWriter::WriteAsciiData(void* data, int numWords, int wordType,
}
//----------------------------------------------------------------------------
unsigned long vtkXMLWriter::WriteDataArrayAppended(vtkDataArray* a,
vtkIndent indent,
const char* alternateName,
int writeNumTuples,
int timestep)
void vtkXMLWriter::WriteDataArrayAppended(vtkDataArray* a,
vtkIndent indent,
OffsetsManager &offs,
const char* alternateName,
int writeNumTuples,
int timestep)
{
ostream& os = *(this->Stream);
// Write the header <DataArray:
this->WriteDataArrayHeader(a,indent,alternateName, writeNumTuples, timestep);
unsigned long pos = this->ReserveAttributeSpace("offset");
// write the scalar range of this data array, we reserver space because we
// don't actually have the data at this point
offs.GetRangeMinPosition(timestep)
= this->ReserveAttributeSpace("RangeMin");
offs.GetRangeMaxPosition(timestep)
= this->ReserveAttributeSpace("RangeMax");
offs.GetPosition(timestep) = this->ReserveAttributeSpace("offset");
// Close the header
os << "/>\n";
this->WriteDataArrayFooter(os, indent);
return pos;
}
//----------------------------------------------------------------------------
......@@ -1565,6 +1604,7 @@ void vtkXMLWriter::WriteDataArrayHeader(vtkDataArray* a, vtkIndent indent,
this->WriteScalarAttribute("NumberOfTuples",
a->GetNumberOfTuples());
}
this->WriteDataModeAttribute("format");
}
......@@ -1584,7 +1624,12 @@ void vtkXMLWriter::WriteDataArrayInline(vtkDataArray* a, vtkIndent indent,
{
ostream& os = *(this->Stream);
// Write the header <DataArray:
this->WriteDataArrayHeader(a, indent, alternateName, writeNumTuples, -1);
this->WriteDataArrayHeader(a, indent, alternateName, writeNumTuples, 0);
// write the range
this->WriteScalarAttribute("RangeMin",a->GetRange(-1)[0]);
this->WriteScalarAttribute("RangeMax",a->GetRange(-1)[1]);
// Close the header
os << ">\n";
// Write the data
......@@ -1774,10 +1819,10 @@ void vtkXMLWriter::WriteFieldDataAppended(vtkFieldData* fd,
for(i=0; i < fd->GetNumberOfArrays(); ++i)
{
fdManager->GetElement(i).Allocate(1);
fdManager->GetElement(i).GetPosition(0) =
this->WriteDataArrayAppended(fd->GetArray(i),
indent.GetNextIndent(),
names[i], 1 , -1);
this->WriteDataArrayAppended(fd->GetArray(i),
indent.GetNextIndent(),
fdManager->GetElement(i),
names[i], 1 , 0);
if (this->ErrorCode != vtkErrorCode::NoError)
{
this->DestroyStringArray(fd->GetNumberOfArrays(), names);
......@@ -1811,6 +1856,13 @@ void vtkXMLWriter::WriteFieldDataAppendedData(vtkFieldData* fd, int timestep,
this->WriteDataArrayAppendedData(fd->GetArray(i),
fdManager->GetElement(i).GetPosition(timestep),
fdManager->GetElement(i).GetOffsetValue(timestep));
double *range = fd->GetArray(i)->GetRange(-1);
this->ForwardAppendedDataDouble
(fdManager->GetElement(i).GetRangeMinPosition(timestep),
range[0],"RangeMin" );
this->ForwardAppendedDataDouble
(fdManager->GetElement(i).GetRangeMaxPosition(timestep),
range[1],"RangeMax" );
if (this->ErrorCode != vtkErrorCode::NoError)
{
return;
......@@ -1843,10 +1895,10 @@ void vtkXMLWriter::WritePointDataAppended(vtkPointData* pd, vtkIndent indent,
pdManager->GetElement(i).Allocate(this->NumberOfTimeSteps);
for(int t=0; t< this->NumberOfTimeSteps; ++t)
{
pdManager->GetElement(i).GetPosition(t) =
this->WriteDataArrayAppended(pd->GetArray(i),
indent.GetNextIndent(),
names[i],0,t);
this->WriteDataArrayAppended(pd->GetArray(i),
indent.GetNextIndent(),
pdManager->GetElement(i),
names[i],0,t);
if (this->ErrorCode != vtkErrorCode::NoError)
{
this->DestroyStringArray(pd->GetNumberOfArrays(), names);
......@@ -1878,13 +1930,14 @@ void vtkXMLWriter::WritePointDataAppendedData(vtkPointData* pd, int timestep,
unsigned long mtime = pd->GetMTime();
// Only write pd if MTime has changed
unsigned long &pdMTime = pdManager->GetElement(i).GetLastMTime();
vtkDataArray* a = this->CreateArrayForPoints(pd->GetArray(i));
if( pdMTime != mtime )
{
pdMTime = mtime;
vtkDataArray* a = this->CreateArrayForPoints(pd->GetArray(i));
this->WriteDataArrayAppendedData(a, pdManager->GetElement(i).GetPosition(timestep),
pdManager->GetElement(i).GetOffsetValue(timestep));
a->Delete();
this->WriteDataArrayAppendedData
(a,
pdManager->GetElement(i).GetPosition(timestep),
pdManager->GetElement(i).GetOffsetValue(timestep));
if (this->ErrorCode != vtkErrorCode::NoError)
{
return;
......@@ -1895,10 +1948,18 @@ void vtkXMLWriter::WritePointDataAppendedData(vtkPointData* pd, int timestep,
assert( timestep > 0 );
pdManager->GetElement(i).GetOffsetValue(timestep) =
pdManager->GetElement(i).GetOffsetValue(timestep-1);
this->ForwardAppendedDataOffset(pdManager->GetElement(i).GetPosition(timestep),
pdManager->GetElement(i).GetOffsetValue(timestep),
"offset" );
}
this->ForwardAppendedDataOffset
(pdManager->GetElement(i).GetPosition(timestep),
pdManager->GetElement(i).GetOffsetValue(timestep),"offset" );
}
double *range = a->GetRange(-1);
this->ForwardAppendedDataDouble
(pdManager->GetElement(i).GetRangeMinPosition(timestep),
range[0],"RangeMin" );
this->ForwardAppendedDataDouble
(pdManager->GetElement(i).GetRangeMaxPosition(timestep),
range[1],"RangeMax" );
a->Delete();
}
}
......@@ -1926,10 +1987,10 @@ void vtkXMLWriter::WriteCellDataAppended(vtkCellData* cd, vtkIndent indent,
cdManager->GetElement(i).Allocate(this->NumberOfTimeSteps);
for(int t=0; t< this->NumberOfTimeSteps; ++t)
{
cdManager->GetElement(i).GetPosition(t) =
this->WriteDataArrayAppended(cd->GetArray(i),