escript/src/DataTagged.cpp

// $Id$

/*
 ******************************************************************************
 *                                                                            *
 *       COPYRIGHT  ACcESS 2004 -  All Rights Reserved                        *
 *                                                                            *
 * This software is the property of ACcESS. No part of this code              *
 * may be copied in any form or by any means without the expressed written    *
 * consent of ACcESS.  Copying, use or modification of this software          *
 * by any unauthorised person is illegal unless that person has a software    *
 * license agreement with ACcESS.                                             *
 *                                                                            *
 ******************************************************************************
*/

#include "escript/Data/DataTagged.h"
#include "escript/Data/DataConstant.h"
#include "escript/Data/DataExpanded.h"
#include "escript/Data/DataException.h"

#include <sstream>

using namespace std;

namespace escript {

DataTagged::DataTagged()
  : DataAbstract(FunctionSpace())
{
  // create a scalar default value
  m_data.resize(1,0.,1);
  DataArrayView temp(m_data,DataArrayView::ShapeType());
  setPointDataView(temp);
}

DataTagged::DataTagged(const TagListType& tagKeys, 
               const ValueListType& values,
               const DataArrayView& defaultValue,
               const FunctionSpace& what)
  : DataAbstract(what)
{
  // initialise the array of data values
  // the default value is always the first item in the values list
  int len = defaultValue.noValues();
  m_data.resize(len,0.,len);
  for (int i=0; i<defaultValue.noValues(); i++) {
    m_data[i]=defaultValue.getData(i);
  }

  // create the data view
  DataArrayView temp(m_data,defaultValue.getShape());
  setPointDataView(temp);

  // add remaining tags and values
  addTaggedValues(tagKeys,values);
}

DataTagged::DataTagged(const FunctionSpace& what,
                       const DataArrayView::ShapeType &shape,
                       const int tags[],
                       const ValueType &data)
  : DataAbstract(what)
{
  // copy the data
  m_data=data;

  // create the view of the data
  DataArrayView tempView(m_data,shape);
  setPointDataView(tempView);

  // create the tag lookup map
  for (int sampleNo=0; sampleNo<getNumSamples(); sampleNo++) {
    m_offsetLookup.insert(DataMapType::value_type(sampleNo,tags[sampleNo]));
  }
}

DataTagged::DataTagged(const DataTagged& other)
  : DataAbstract(other.getFunctionSpace()),
  m_data(other.m_data),
  m_offsetLookup(other.m_offsetLookup)
{
  // create the data view
  DataArrayView temp(m_data,other.getPointDataView().getShape());
  setPointDataView(temp);
}

DataTagged::DataTagged(const DataConstant& other)
  : DataAbstract(other.getFunctionSpace())
{
  // fill the default value with the constant value item from "other"
  const DataArrayView& value=other.getPointDataView();
  int len = value.noValues();
  m_data.resize(len,0.,len);
  for (int i=0; i<value.noValues(); i++) {
    m_data[i]=value.getData(i);
  }

  // create the data view
  DataArrayView temp(m_data,value.getShape());
  setPointDataView(temp);
}

DataTagged::DataTagged(const DataTagged& other, 
               const DataArrayView::RegionType& region)
  : DataAbstract(other.getFunctionSpace())
{
  // get the shape of the slice to copy from other
  DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
  DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);

  // allocate enough space for all values
  int len = DataArrayView::noValues(shape)*(other.m_offsetLookup.size()+1);
  m_data.resize(len,0.,len);

  // create the data view
  DataArrayView temp(m_data,shape);
  setPointDataView(temp);

  // copy the default value
  getDefaultValue().copySlice(other.getDefaultValue(),region_loop_range);

  // loop through the tag values copying these
  DataMapType::const_iterator pos;
  DataArrayView::ValueType::size_type tagOffset=getPointDataView().noValues();
  for (pos=other.m_offsetLookup.begin();pos!=other.m_offsetLookup.end();pos++){
    getPointDataView().copySlice(tagOffset,other.getPointDataView(),pos->second,region_loop_range);
    m_offsetLookup.insert(DataMapType::value_type(pos->first,tagOffset));
    tagOffset+=getPointDataView().noValues();
  }
}

void
DataTagged::reshapeDataPoint(const DataArrayView::ShapeType& shape) 
{
  // can only reshape a rank zero data point
  if (getPointDataView().getRank()!=0) {
    stringstream temp;
    temp << "Error - Can only reshape Data with data points of rank 0. "
     << "This Data has data points with rank: " 
     << getPointDataView().getRank();
    throw DataException(temp.str());
  }

  // allocate enough space for all values
  DataArrayView::ValueType newData(DataArrayView::noValues(shape)*(m_offsetLookup.size()+1));
  DataArrayView newView(newData,shape);
  newView.copy(0,getDefaultValue()());

  // loop through the tag values
  DataMapType::iterator pos;
  DataArrayView::ValueType::size_type tagOffset=DataArrayView::noValues(shape);
  for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();pos++){
    newView.copy(tagOffset,m_data[pos->second]);
    pos->second=tagOffset;
    tagOffset+=DataArrayView::noValues(shape);
  }
  m_data=newData;
  DataArrayView temp(m_data,shape);
  setPointDataView(temp);
}

DataAbstract*
DataTagged::getSlice(const DataArrayView::RegionType& region) const 
{
  return new DataTagged(*this,region);
}

void
DataTagged::setSlice(const DataAbstract* value,
                     const DataArrayView::RegionType& region) 
{
  const DataTagged* tempDataTag=dynamic_cast<const DataTagged*>(value);
  if (tempDataTag==0) {
    throw DataException("Programming error - casting to DataTagged.");
  }

  DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
  DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
  if (getPointDataView().getRank()!=region.size()) {
    throw DataException("Error - Invalid slice region.");
  }
  if (tempDataTag->getPointDataView().getRank()>0 && !value->getPointDataView().checkShape(shape)) {
    throw DataException (value->getPointDataView().createShapeErrorMessage(
                "Error - Couldn't copy slice due to shape mismatch.",shape));
  }

  getDefaultValue().copySliceFrom(tempDataTag->getDefaultValue(),region_loop_range);

  // loop through the tag values
  DataMapType::const_iterator pos;
  for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();pos++) {
    getDataPointByTag(pos->first).copySliceFrom(tempDataTag->getDataPointByTag(pos->first),region_loop_range);
  }
}

int
DataTagged::getTagNumber(int dpno)
{
  //
  // Get the number of samples and data-points per sample
  int numSamples = getNumSamples();
  int numDataPointsPerSample = getNumDPPSample();
  int numDataPoints = numSamples * numDataPointsPerSample;

  if (numDataPointsPerSample==0) {
    throw DataException("DataTagged::getTagNumber error: no data-points associated with this object.");
  }

  if (dpno<0 || dpno>numDataPoints) {
    throw DataException("DataTagged::getTagNumber error: invalid data-point number supplied.");
  }

  //
  // Determine the sample number which corresponds to this data-point number
  int sampleNo = dpno / numDataPointsPerSample;

  //
  // Determine the tag number which corresponds to this sample number
  int tagNo = getFunctionSpace().getTagFromSampleNo(sampleNo);

  //
  // return the tag number
  return(tagNo);
}

void
DataTagged::setTaggedValue(int tagKey,
                           const DataArrayView& value)
{
  if (!getPointDataView().checkShape(value.getShape())) {
      throw DataException(getPointDataView().createShapeErrorMessage(
                          "Error - Cannot setTaggedValue due to shape mismatch.", value.getShape()));
  }
  DataMapType::iterator pos(m_offsetLookup.find(tagKey));
  if (pos==m_offsetLookup.end()) {
    // tag couldn't be found so use addTaggedValue
    addTaggedValue(tagKey,value);
  } else {
    // copy the values into the data array at the offset determined by m_offsetLookup
    int offset=pos->second;
    for (int i=0; i<getPointDataView().noValues(); i++) {
      m_data[offset+i]=value.getData(i);
    }
  }
}

void
DataTagged::addTaggedValue(int tagKey,
                           const DataArrayView& value)
{
  if (!getPointDataView().checkShape(value.getShape())) {
    throw DataException(getPointDataView().createShapeErrorMessage(
                        "Error - Cannot addTaggedValue due to shape mismatch.", value.getShape()));
  }
  DataMapType::iterator pos(m_offsetLookup.find(tagKey));
  if (pos!=m_offsetLookup.end()) {
    // tag already exists so use setTaggedValue
    setTaggedValue(tagKey,value);
  } else {
    // save the key and the location of its data in the lookup tab
    m_offsetLookup.insert(DataMapType::value_type(tagKey,m_data.size()));
    // add the data given in "value" at the end of m_data
    // need to make a temp copy of m_data, resize m_data, then copy
    // all the old values plus the value to be added back into m_data
    ValueType m_data_temp(m_data);
    int oldSize=m_data.size();
    int newSize=m_data.size()+value.noValues();
    m_data.resize(newSize,0.,newSize);
    for (int i=0;i<oldSize;i++) {
      m_data[i]=m_data_temp[i];
    }
    for (int i=0;i<value.noValues();i++) {
      m_data[oldSize+i]=value.getData(i);
    }
  }
}

void
DataTagged::setTaggedValues(const TagListType& tagKeys,
                            const ValueListType& values)
{
  addTaggedValues(tagKeys,values);
}

void
DataTagged::addTaggedValues(const TagListType& tagKeys,
                            const ValueListType& values)
{
  if (values.size()==0) {
    // copy the default value for each of the tags
    TagListType::const_iterator iT;
    for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
      // the point data view for DataTagged points at the default value
      addTaggedValue(*iT,getPointDataView());
    }
  } else if (values.size()==1 && tagKeys.size()>1) {
    // assume the one value will be used for all tag values
    TagListType::const_iterator iT;
    for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
      addTaggedValue(*iT,values[0]);
    }
  } else {
    if (tagKeys.size()!=values.size()) {
      stringstream temp;
      temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()
       << " doesn't match the number of values: " << values.size();
      throw DataException(temp.str());
    } else {
      for (int i=0;i<tagKeys.size();i++) {
        addTaggedValue(tagKeys[i],values[i]);
      }
    }
  }
}

double*
DataTagged::getSampleDataByTag(int tag)
{
  DataMapType::iterator pos(m_offsetLookup.find(tag));
  if (pos==m_offsetLookup.end()) {
    // tag couldn't be found so return the default value
    return &(m_data[0]);
  } else {
    // return the data-point corresponding to the given tag
    return &(m_data[pos->second]);
  }
}

string
DataTagged::toString() const
{
  stringstream temp;
  DataMapType::const_iterator i;
  temp << "Tag(Default)" << endl;
  temp << getDefaultValue().toString() << endl;
  // create a temporary view as the offset will be changed
  DataArrayView tempView(getPointDataView().getData(), getPointDataView().getShape());
  for (i=m_offsetLookup.begin();i!=m_offsetLookup.end();++i) {
    temp << "Tag(" << i->first << ")" << endl;
    tempView.setOffset(i->second);
    temp << tempView.toString() << endl;
  }
  return temp.str();
}

DataArrayView
DataTagged::getDataPointByTag(int tag) const
{
  DataMapType::const_iterator pos(m_offsetLookup.find(tag));
  DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
  if (pos!=m_offsetLookup.end()) {
    offset=pos->second;
  }
  DataArrayView temp(getPointDataView());
  temp.setOffset(offset);
  return temp;
}

DataArrayView::ValueType::size_type 
DataTagged::getPointOffset(int sampleNo,
                           int dataPointNo) const
{
  int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
  DataMapType::const_iterator pos(m_offsetLookup.find(tagKey));
  DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
  if (pos!=m_offsetLookup.end()) {
    offset=pos->second;
  }
  return offset;
}

DataArrayView
DataTagged::getDataPoint(int sampleNo,
                         int dataPointNo)
{
  EsysAssert(validSampleNo(sampleNo),"(getDataPoint) Invalid sampleNo: " << sampleNo);
  int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
  return getDataPointByTag(tagKey);
}

const DataTagged::DataMapType&
DataTagged::getTagLookup() const
{
  return m_offsetLookup;
}

DataArrayView::ValueType::size_type
DataTagged::getLength() const
{
  return m_data.size();
}

int
DataTagged::archiveData(ofstream& archiveFile,
                        const DataArrayView::ValueType::size_type noValues) const
{
  return(m_data.archiveData(archiveFile, noValues));
}

int
DataTagged::extractData(ifstream& archiveFile,
                        const DataArrayView::ValueType::size_type noValues)
{
  return(m_data.extractData(archiveFile, noValues));
}

}  // end of namespace
1	// $Id$
2
3	/*
4	******************************************************************************
5	* *
6	* COPYRIGHT ACcESS 2004 - All Rights Reserved *
7	* *
8	* This software is the property of ACcESS. No part of this code *
9	* may be copied in any form or by any means without the expressed written *
10	* consent of ACcESS. Copying, use or modification of this software *
11	* by any unauthorised person is illegal unless that person has a software *
12	* license agreement with ACcESS. *
13	* *
14	******************************************************************************
15	*/
16
17	#include "escript/Data/DataTagged.h"
18	#include "escript/Data/DataConstant.h"
19	#include "escript/Data/DataExpanded.h"
20	#include "escript/Data/DataException.h"
21
22	#include <sstream>
23
24	using namespace std;
25
26	namespace escript {
27
28	DataTagged::DataTagged()
29	: DataAbstract(FunctionSpace())
30	{
31	// create a scalar default value
32	m_data.resize(1,0.,1);
33	DataArrayView temp(m_data,DataArrayView::ShapeType());
34	setPointDataView(temp);
35	}
36
37	DataTagged::DataTagged(const TagListType& tagKeys,
38	const ValueListType& values,
39	const DataArrayView& defaultValue,
40	const FunctionSpace& what)
41	: DataAbstract(what)
42	{
43	// initialise the array of data values
44	// the default value is always the first item in the values list
45	int len = defaultValue.noValues();
46	m_data.resize(len,0.,len);
47	for (int i=0; i<defaultValue.noValues(); i++) {
48	m_data[i]=defaultValue.getData(i);
49	}
50
51	// create the data view
52	DataArrayView temp(m_data,defaultValue.getShape());
53	setPointDataView(temp);
54
55	// add remaining tags and values
56	addTaggedValues(tagKeys,values);
57	}
58
59	DataTagged::DataTagged(const FunctionSpace& what,
60	const DataArrayView::ShapeType &shape,
61	const int tags[],
62	const ValueType &data)
63	: DataAbstract(what)
64	{
65	// copy the data
66	m_data=data;
67
68	// create the view of the data
69	DataArrayView tempView(m_data,shape);
70	setPointDataView(tempView);
71
72	// create the tag lookup map
73	for (int sampleNo=0; sampleNo<getNumSamples(); sampleNo++) {
74	m_offsetLookup.insert(DataMapType::value_type(sampleNo,tags[sampleNo]));
75	}
76	}
77
78	DataTagged::DataTagged(const DataTagged& other)
79	: DataAbstract(other.getFunctionSpace()),
80	m_data(other.m_data),
81	m_offsetLookup(other.m_offsetLookup)
82	{
83	// create the data view
84	DataArrayView temp(m_data,other.getPointDataView().getShape());
85	setPointDataView(temp);
86	}
87
88	DataTagged::DataTagged(const DataConstant& other)
89	: DataAbstract(other.getFunctionSpace())
90	{
91	// fill the default value with the constant value item from "other"
92	const DataArrayView& value=other.getPointDataView();
93	int len = value.noValues();
94	m_data.resize(len,0.,len);
95	for (int i=0; i<value.noValues(); i++) {
96	m_data[i]=value.getData(i);
97	}
98
99	// create the data view
100	DataArrayView temp(m_data,value.getShape());
101	setPointDataView(temp);
102	}
103
104	DataTagged::DataTagged(const DataTagged& other,
105	const DataArrayView::RegionType& region)
106	: DataAbstract(other.getFunctionSpace())
107	{
108	// get the shape of the slice to copy from other
109	DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
110	DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
111
112	// allocate enough space for all values
113	int len = DataArrayView::noValues(shape)*(other.m_offsetLookup.size()+1);
114	m_data.resize(len,0.,len);
115
116	// create the data view
117	DataArrayView temp(m_data,shape);
118	setPointDataView(temp);
119
120	// copy the default value
121	getDefaultValue().copySlice(other.getDefaultValue(),region_loop_range);
122
123	// loop through the tag values copying these
124	DataMapType::const_iterator pos;
125	DataArrayView::ValueType::size_type tagOffset=getPointDataView().noValues();
126	for (pos=other.m_offsetLookup.begin();pos!=other.m_offsetLookup.end();pos++){
127	getPointDataView().copySlice(tagOffset,other.getPointDataView(),pos->second,region_loop_range);
128	m_offsetLookup.insert(DataMapType::value_type(pos->first,tagOffset));
129	tagOffset+=getPointDataView().noValues();
130	}
131	}
132
133	void
134	DataTagged::reshapeDataPoint(const DataArrayView::ShapeType& shape)
135	{
136	// can only reshape a rank zero data point
137	if (getPointDataView().getRank()!=0) {
138	stringstream temp;
139	temp << "Error - Can only reshape Data with data points of rank 0. "
140	<< "This Data has data points with rank: "
141	<< getPointDataView().getRank();
142	throw DataException(temp.str());
143	}
144
145	// allocate enough space for all values
146	DataArrayView::ValueType newData(DataArrayView::noValues(shape)*(m_offsetLookup.size()+1));
147	DataArrayView newView(newData,shape);
148	newView.copy(0,getDefaultValue()());
149
150	// loop through the tag values
151	DataMapType::iterator pos;
152	DataArrayView::ValueType::size_type tagOffset=DataArrayView::noValues(shape);
153	for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();pos++){
154	newView.copy(tagOffset,m_data[pos->second]);
155	pos->second=tagOffset;
156	tagOffset+=DataArrayView::noValues(shape);
157	}
158	m_data=newData;
159	DataArrayView temp(m_data,shape);
160	setPointDataView(temp);
161	}
162
163	DataAbstract*
164	DataTagged::getSlice(const DataArrayView::RegionType& region) const
165	{
166	return new DataTagged(*this,region);
167	}
168
169	void
170	DataTagged::setSlice(const DataAbstract* value,
171	const DataArrayView::RegionType& region)
172	{
173	const DataTagged* tempDataTag=dynamic_cast<const DataTagged*>(value);
174	if (tempDataTag==0) {
175	throw DataException("Programming error - casting to DataTagged.");
176	}
177
178	DataArrayView::ShapeType shape(DataArrayView::getResultSliceShape(region));
179	DataArrayView::RegionLoopRangeType region_loop_range=getSliceRegionLoopRange(region);
180	if (getPointDataView().getRank()!=region.size()) {
181	throw DataException("Error - Invalid slice region.");
182	}
183	if (tempDataTag->getPointDataView().getRank()>0 && !value->getPointDataView().checkShape(shape)) {
184	throw DataException (value->getPointDataView().createShapeErrorMessage(
185	"Error - Couldn't copy slice due to shape mismatch.",shape));
186	}
187
188	getDefaultValue().copySliceFrom(tempDataTag->getDefaultValue(),region_loop_range);
189
190	// loop through the tag values
191	DataMapType::const_iterator pos;
192	for (pos=m_offsetLookup.begin();pos!=m_offsetLookup.end();pos++) {
193	getDataPointByTag(pos->first).copySliceFrom(tempDataTag->getDataPointByTag(pos->first),region_loop_range);
194	}
195	}
196
197	int
198	DataTagged::getTagNumber(int dpno)
199	{
200	//
201	// Get the number of samples and data-points per sample
202	int numSamples = getNumSamples();
203	int numDataPointsPerSample = getNumDPPSample();
204	int numDataPoints = numSamples * numDataPointsPerSample;
205
206	if (numDataPointsPerSample==0) {
207	throw DataException("DataTagged::getTagNumber error: no data-points associated with this object.");
208	}
209
210	if (dpno<0 \|\| dpno>numDataPoints) {
211	throw DataException("DataTagged::getTagNumber error: invalid data-point number supplied.");
212	}
213
214	//
215	// Determine the sample number which corresponds to this data-point number
216	int sampleNo = dpno / numDataPointsPerSample;
217
218	//
219	// Determine the tag number which corresponds to this sample number
220	int tagNo = getFunctionSpace().getTagFromSampleNo(sampleNo);
221
222	//
223	// return the tag number
224	return(tagNo);
225	}
226
227	void
228	DataTagged::setTaggedValue(int tagKey,
229	const DataArrayView& value)
230	{
231	if (!getPointDataView().checkShape(value.getShape())) {
232	throw DataException(getPointDataView().createShapeErrorMessage(
233	"Error - Cannot setTaggedValue due to shape mismatch.", value.getShape()));
234	}
235	DataMapType::iterator pos(m_offsetLookup.find(tagKey));
236	if (pos==m_offsetLookup.end()) {
237	// tag couldn't be found so use addTaggedValue
238	addTaggedValue(tagKey,value);
239	} else {
240	// copy the values into the data array at the offset determined by m_offsetLookup
241	int offset=pos->second;
242	for (int i=0; i<getPointDataView().noValues(); i++) {
243	m_data[offset+i]=value.getData(i);
244	}
245	}
246	}
247
248	void
249	DataTagged::addTaggedValue(int tagKey,
250	const DataArrayView& value)
251	{
252	if (!getPointDataView().checkShape(value.getShape())) {
253	throw DataException(getPointDataView().createShapeErrorMessage(
254	"Error - Cannot addTaggedValue due to shape mismatch.", value.getShape()));
255	}
256	DataMapType::iterator pos(m_offsetLookup.find(tagKey));
257	if (pos!=m_offsetLookup.end()) {
258	// tag already exists so use setTaggedValue
259	setTaggedValue(tagKey,value);
260	} else {
261	// save the key and the location of its data in the lookup tab
262	m_offsetLookup.insert(DataMapType::value_type(tagKey,m_data.size()));
263	// add the data given in "value" at the end of m_data
264	// need to make a temp copy of m_data, resize m_data, then copy
265	// all the old values plus the value to be added back into m_data
266	ValueType m_data_temp(m_data);
267	int oldSize=m_data.size();
268	int newSize=m_data.size()+value.noValues();
269	m_data.resize(newSize,0.,newSize);
270	for (int i=0;i<oldSize;i++) {
271	m_data[i]=m_data_temp[i];
272	}
273	for (int i=0;i<value.noValues();i++) {
274	m_data[oldSize+i]=value.getData(i);
275	}
276	}
277	}
278
279	void
280	DataTagged::setTaggedValues(const TagListType& tagKeys,
281	const ValueListType& values)
282	{
283	addTaggedValues(tagKeys,values);
284	}
285
286	void
287	DataTagged::addTaggedValues(const TagListType& tagKeys,
288	const ValueListType& values)
289	{
290	if (values.size()==0) {
291	// copy the default value for each of the tags
292	TagListType::const_iterator iT;
293	for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
294	// the point data view for DataTagged points at the default value
295	addTaggedValue(*iT,getPointDataView());
296	}
297	} else if (values.size()==1 && tagKeys.size()>1) {
298	// assume the one value will be used for all tag values
299	TagListType::const_iterator iT;
300	for (iT=tagKeys.begin();iT!=tagKeys.end();iT++) {
301	addTaggedValue(*iT,values[0]);
302	}
303	} else {
304	if (tagKeys.size()!=values.size()) {
305	stringstream temp;
306	temp << "Error - (addTaggedValue) Number of tags: " << tagKeys.size()
307	<< " doesn't match the number of values: " << values.size();
308	throw DataException(temp.str());
309	} else {
310	for (int i=0;i<tagKeys.size();i++) {
311	addTaggedValue(tagKeys[i],values[i]);
312	}
313	}
314	}
315	}
316
317	double*
318	DataTagged::getSampleDataByTag(int tag)
319	{
320	DataMapType::iterator pos(m_offsetLookup.find(tag));
321	if (pos==m_offsetLookup.end()) {
322	// tag couldn't be found so return the default value
323	return &(m_data[0]);
324	} else {
325	// return the data-point corresponding to the given tag
326	return &(m_data[pos->second]);
327	}
328	}
329
330	string
331	DataTagged::toString() const
332	{
333	stringstream temp;
334	DataMapType::const_iterator i;
335	temp << "Tag(Default)" << endl;
336	temp << getDefaultValue().toString() << endl;
337	// create a temporary view as the offset will be changed
338	DataArrayView tempView(getPointDataView().getData(), getPointDataView().getShape());
339	for (i=m_offsetLookup.begin();i!=m_offsetLookup.end();++i) {
340	temp << "Tag(" << i->first << ")" << endl;
341	tempView.setOffset(i->second);
342	temp << tempView.toString() << endl;
343	}
344	return temp.str();
345	}
346
347	DataArrayView
348	DataTagged::getDataPointByTag(int tag) const
349	{
350	DataMapType::const_iterator pos(m_offsetLookup.find(tag));
351	DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
352	if (pos!=m_offsetLookup.end()) {
353	offset=pos->second;
354	}
355	DataArrayView temp(getPointDataView());
356	temp.setOffset(offset);
357	return temp;
358	}
359
360	DataArrayView::ValueType::size_type
361	DataTagged::getPointOffset(int sampleNo,
362	int dataPointNo) const
363	{
364	int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
365	DataMapType::const_iterator pos(m_offsetLookup.find(tagKey));
366	DataArrayView::ValueType::size_type offset=m_defaultValueOffset;
367	if (pos!=m_offsetLookup.end()) {
368	offset=pos->second;
369	}
370	return offset;
371	}
372
373	DataArrayView
374	DataTagged::getDataPoint(int sampleNo,
375	int dataPointNo)
376	{
377	EsysAssert(validSampleNo(sampleNo),"(getDataPoint) Invalid sampleNo: " << sampleNo);
378	int tagKey=getFunctionSpace().getTagFromSampleNo(sampleNo);
379	return getDataPointByTag(tagKey);
380	}
381
382	const DataTagged::DataMapType&
383	DataTagged::getTagLookup() const
384	{
385	return m_offsetLookup;
386	}
387
388	DataArrayView::ValueType::size_type
389	DataTagged::getLength() const
390	{
391	return m_data.size();
392	}
393
394	int
395	DataTagged::archiveData(ofstream& archiveFile,
396	const DataArrayView::ValueType::size_type noValues) const
397	{
398	return(m_data.archiveData(archiveFile, noValues));
399	}
400
401	int
402	DataTagged::extractData(ifstream& archiveFile,
403	const DataArrayView::ValueType::size_type noValues)
404	{
405	return(m_data.extractData(archiveFile, noValues));
406	}
407
408	} // end of namespace
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision