escript/src/DataAbstract.h

// $Id$
/* 
 ************************************************************
 *          Copyright 2006 by ACcESS MNRF                   *
 *                                                          *
 *              http://www.access.edu.au                    *
 *       Primary Business: Queensland, Australia            *
 *  Licensed under the Open Software License version 3.0    *
 *     http://www.opensource.org/licenses/osl-3.0.php       *
 *                                                          *
 ************************************************************

*/

#if !defined escript_DataAbstract_20040315_H
#define escript_DataAbstract_20040315_H
#include "system_dep.h"

#include "DataArrayView.h"
#include "DataArray.h"
#include "FunctionSpace.h"

#include <boost/scoped_ptr.hpp>
#include <boost/python/numeric.hpp>

#include <string>
#include <fstream>

namespace escript {

/**
   \brief
   DataAbstract provides an abstract interface for the class of containers
   which hold ESyS data. 

   Description:
   DataAbstract provides an abstract interface for the class of containers
   which hold ESyS data. The container may be thought of as a 2 dimensional
   array of data points where one dimension corresponds to the number of samples
   and the other to the number of data points per sample as defined by the function
   space associated with each Data object. The data points themselves are arrays of
   doubles of rank 0-4.
*/

class DataAbstract {

 public:

  typedef DataArrayView::ValueType ValueType;
  typedef DataArrayView::ShapeType ShapeType;

  /**
     \brief
     Constructor for DataAbstract.

     Description:
     Constructor for DataAbstract.

     \param what - Input - A description of what this data represents.
  */
  ESCRIPT_DLL_API
  DataAbstract(const FunctionSpace& what);

  /**
    \brief
    Destructor for DataAbstract.
  */
  ESCRIPT_DLL_API
  virtual
  ~DataAbstract();

  /**
     \brief
     Write the data as a string.
  */
  ESCRIPT_DLL_API
  virtual
  std::string
  toString() const = 0;

  /**
     \brief
     Return the number of data points per sample.
  */
  ESCRIPT_DLL_API
  int
  getNumDPPSample() const;

  /**
     \brief
     Return the number of samples.
  */
  ESCRIPT_DLL_API
  int
  getNumSamples() const;

  /**
     \brief
     Return the DataArrayView of the point data. This essentially contains 
     the shape information for each data point although it also may be used
     to manipulate the point data.
  */
  ESCRIPT_DLL_API
  DataArrayView&
  getPointDataView();

  ESCRIPT_DLL_API
  const DataArrayView&
  getPointDataView() const;

  /**
     \brief
     Return the offset for the given sample. This returns the offset for the given
     point into the container holding the point data. Only really necessary to
     avoid creating many DataArrayView objects.

     \param sampleNo - Input - sample number.
     \param dataPointNo - Input - data point number.
   */
  ESCRIPT_DLL_API
  virtual
  ValueType::size_type
  getPointOffset(int sampleNo,
                 int dataPointNo) const = 0;

  /**
     \brief
     Return the sample data for the given sample number.
  */
  ESCRIPT_DLL_API
  double*
  getSampleData(ValueType::size_type sampleNo);

  /**
     \brief
     Return the number of doubles stored for this Data object.
  */
  ESCRIPT_DLL_API
  virtual
  ValueType::size_type
  getLength() const = 0;

  /**
     \brief
     Return the sample data for the given tag key.
     NB: If the data isn't tagged an exception will be thrown.
  */
  ESCRIPT_DLL_API
  virtual
  double*
  getSampleDataByTag(int tag);

  /**
     \brief
     Assign the given value to the data-points(s) referenced by the given
     reference number.

     If this Data object cannot be accessed by reference numbers an
     exception will be thrown.

     \param ref - Input - reference number.
     \param value - Input - value to assign to data-points associated with
                            the given reference number.
  */
  ESCRIPT_DLL_API
  virtual
  void
  setRefValue(int ref,
              const DataArray& value);

  /**
     \brief
     Return the values associated with the data-point(s) referenced by the given
     reference number.

     If this Data object cannot be accessed by reference numbers an
     exception will be thrown.

     \param ref - Input - reference number.
     \param value - Output - object to receive data-points associated with
                             the given reference number.
  */
  ESCRIPT_DLL_API
  virtual
  void
  getRefValue(int ref,
              DataArray& value);

  /**
     \brief
     Check this and the given RHS operands are compatible. Throws
     an exception if they aren't.

     \param right - Input - The right hand side.
  */
  ESCRIPT_DLL_API
  void
  operandCheck(const DataAbstract& right) const;

  /**
     \brief
     Return true if a valid sample point number.
  */
  ESCRIPT_DLL_API
  bool
  validSamplePointNo(int samplePointNo) const;

  /**
     \brief
     Return true if a valid sample number.
  */
  ESCRIPT_DLL_API
  bool
  validSampleNo(int sampleNo) const;
 
  /**
     \brief
     Return a view into the data for the data point specified.
     NOTE: Construction of the DataArrayView is a relatively expensive 
     operation.

     \param sampleNo - Input - the sample number.
     \param dataPointNo - Input - the data point number.
  */
  ESCRIPT_DLL_API
  virtual
  DataArrayView
  getDataPoint(int sampleNo,
               int dataPointNo) = 0;

  /**
     \brief
     Return the function space associated with this Data object.
  */
  ESCRIPT_DLL_API
  const
  FunctionSpace&
  getFunctionSpace() const;

  /**
     \brief
     Return the given slice from this object.

     NB: The caller is responsible for managing the object created.
  */
  ESCRIPT_DLL_API
  virtual
  DataAbstract*
  getSlice(const DataArrayView::RegionType& region) const = 0;

  /**
     \brief
     Copy the specified region from the given object.

     \param value - Input - Data to copy from
     \param region - Input - Region to copy.
  */
  ESCRIPT_DLL_API
  virtual
  void
  setSlice(const DataAbstract* value,
           const DataArrayView::RegionType& region) = 0;

  /**
     \brief
     Reshape the data points if they are currently rank 0.
     Will throw an exception if the data points are not rank 0.
     The original data point value is used for all values of the new
     data point.
  */
  ESCRIPT_DLL_API
  virtual
  void
  reshapeDataPoint(const ShapeType& shape) = 0;

  /**
     \brief
     setTaggedValue
                                                                                                                                   
     Description:
     Assign the given value to the given tag.

     NB: If the data isn't tagged an exception will be thrown.

     \param tagKey - Input - Integer key.
     \param value - Input - Single DataArrayView value to be assigned to the tag.
  */
  ESCRIPT_DLL_API
  virtual
  void
  setTaggedValue(int tagKey,
                 const DataArrayView& value);

  /**
    \brief
    Archive the underlying data values to the file referenced
    by ofstream. A count of the number of values expected to be written
    is provided as a cross-check.

    The return value indicates success (0) or otherwise (1).
  */
  ESCRIPT_DLL_API
  virtual
  int
  archiveData(std::ofstream& archiveFile,
              const ValueType::size_type noValues) const;

  /**
    \brief
    Extract the number of values specified by noValues from the file
    referenced by ifstream to the underlying data structure.

    The return value indicates success (0) or otherwise (1).
  */
  ESCRIPT_DLL_API
  virtual
  int
  extractData(std::ifstream& archiveFile,
              const ValueType::size_type noValues);

  /**
     \brief
     Copy the numarray object to the data points in this object.

     Description:
     Copy the numarray object to the data points in this object.

     \param value Input - new values for the data points
  */
  ESCRIPT_DLL_API
  virtual void
  copyAll(const boost::python::numeric::array& value);

  /**
     \brief
     Return the tag number associated with the given data-point number.

     If the object cannot be referenced by tag numbers, an exception
     will be thrown.
  */
  ESCRIPT_DLL_API
  virtual
  int
  getTagNumber(int dpno);

  /**
     \brief
     Computes a symmetric matrix (A + AT) / 2

     \param ev - Output - a symmetric matrix

  */
  ESCRIPT_DLL_API
  virtual void
  symmetric(DataAbstract* ev);

  /**
     \brief
     Computes a nonsymmetric matrix (A - AT) / 2

     \param ev - Output - a nonsymmetric matrix

  */
  ESCRIPT_DLL_API
  virtual void
  nonsymmetric(DataAbstract* ev);

  /**
     \brief
     Computes the trace of a matrix

     \param ev - Output - the trace of a matrix

  */
  ESCRIPT_DLL_API
  virtual void
  trace(DataAbstract* ev, int axis_offset);

  /**
     \brief
     Transpose each data point of this Data object around the given axis.

     \param ev - Output - the transpose of a matrix

  */
  ESCRIPT_DLL_API
  virtual void
  transpose(DataAbstract* ev, int axis_offset);

  /**
     \brief
     swaps components axis0 and axis1

     \param ev - Output - swapped components

  */
  ESCRIPT_DLL_API
  virtual void
  swapaxes(DataAbstract* ev, int axis0, int axis1);
  /**
     \brief
     solves the eigenvalue problem this*V=ev*V for the eigenvalues ev

     \param ev - Output - eigenvalues in increasing order at each data point

  */
  ESCRIPT_DLL_API
  virtual void
  eigenvalues(DataAbstract* ev);

  /**
     \brief
     solves the eigenvalue problem this*V=ev*V for the eigenvalues ev and eigenvectors V

     \param ev - Output - eigenvalues in increasing order at each data point
     \param V - Output - corresponding eigenvectors. They are normalized such that their length is one
                         and the first nonzero component is positive.
     \param tol - Input - eigenvalue with relative distance tol are treated as equal.

  */

  ESCRIPT_DLL_API
  virtual void
  eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);

 protected:

  /**
     \brief
     Set the pointDataView DataArrayView associated with this object.

     \param input - Input - The point data view. DataAbstract takes ownership
     of the DataArrayView provided. It will delete it when it is destructed.
  */
  ESCRIPT_DLL_API
  void
  setPointDataView(const DataArrayView& input);

  ESCRIPT_DLL_API
  void
  resetPointDataView();

 private:

  //
  // The number of samples in this Data object.
  // This is derived directly from the FunctionSpace.
  int m_noSamples;

  //
  // The number of data points per sample in this Data object.
  // This is derived directly from the FunctionSpace.
  int m_noDataPointsPerSample;

  //
  // The DataArrayView of the data array associated with this object.
  // The data array is defined only in child classes of this class, it
  // is not defined in this abstract parent class.
  boost::scoped_ptr<DataArrayView> m_pointDataView;

  //
  // A FunctionSpace which provides a description of the data associated
  // with this Data object.
  FunctionSpace m_functionSpace;

};

inline
bool
DataAbstract::validSamplePointNo(int samplePointNo) const 
{
  return ((0 <= samplePointNo) && (samplePointNo < m_noDataPointsPerSample));
}

inline
bool
DataAbstract::validSampleNo(int sampleNo) const
{
  return ((0 <= sampleNo) && (sampleNo < m_noSamples));
}

inline
DataAbstract::ValueType::value_type*
DataAbstract::getSampleData(ValueType::size_type sampleNo)
{
  return &(m_pointDataView->getData(getPointOffset(sampleNo,0)));
}

inline
int
DataAbstract::getNumDPPSample() const 
{
  return m_noDataPointsPerSample;
}

inline
int
DataAbstract::getNumSamples() const
{
  return m_noSamples;
}

inline
const
FunctionSpace&
DataAbstract::getFunctionSpace() const
{
  return m_functionSpace;
}

inline
const
DataArrayView&
DataAbstract::getPointDataView() const
{
  return *(m_pointDataView.get());
}

inline
DataArrayView&
DataAbstract::getPointDataView()
{
  return *(m_pointDataView.get());
}
} // end of namespace

#endif
1	// $Id$
2	/*
3	************************************************************
4	* Copyright 2006 by ACcESS MNRF *
5	* *
6	* http://www.access.edu.au *
7	* Primary Business: Queensland, Australia *
8	* Licensed under the Open Software License version 3.0 *
9	* http://www.opensource.org/licenses/osl-3.0.php *
10	* *
11	************************************************************
12
13	*/
14
15	#if !defined escript_DataAbstract_20040315_H
16	#define escript_DataAbstract_20040315_H
17	#include "system_dep.h"
18
19	#include "DataArrayView.h"
20	#include "DataArray.h"
21	#include "FunctionSpace.h"
22
23	#include <boost/scoped_ptr.hpp>
24	#include <boost/python/numeric.hpp>
25
26	#include <string>
27	#include <fstream>
28
29	namespace escript {
30
31	/**
32	\brief
33	DataAbstract provides an abstract interface for the class of containers
34	which hold ESyS data.
35
36	Description:
37	DataAbstract provides an abstract interface for the class of containers
38	which hold ESyS data. The container may be thought of as a 2 dimensional
39	array of data points where one dimension corresponds to the number of samples
40	and the other to the number of data points per sample as defined by the function
41	space associated with each Data object. The data points themselves are arrays of
42	doubles of rank 0-4.
43	*/
44
45	class DataAbstract {
46
47	public:
48
49	typedef DataArrayView::ValueType ValueType;
50	typedef DataArrayView::ShapeType ShapeType;
51
52	/**
53	\brief
54	Constructor for DataAbstract.
55
56	Description:
57	Constructor for DataAbstract.
58
59	\param what - Input - A description of what this data represents.
60	*/
61	ESCRIPT_DLL_API
62	DataAbstract(const FunctionSpace& what);
63
64	/**
65	\brief
66	Destructor for DataAbstract.
67	*/
68	ESCRIPT_DLL_API
69	virtual
70	~DataAbstract();
71
72	/**
73	\brief
74	Write the data as a string.
75	*/
76	ESCRIPT_DLL_API
77	virtual
78	std::string
79	toString() const = 0;
80
81	/**
82	\brief
83	Return the number of data points per sample.
84	*/
85	ESCRIPT_DLL_API
86	int
87	getNumDPPSample() const;
88
89	/**
90	\brief
91	Return the number of samples.
92	*/
93	ESCRIPT_DLL_API
94	int
95	getNumSamples() const;
96
97	/**
98	\brief
99	Return the DataArrayView of the point data. This essentially contains
100	the shape information for each data point although it also may be used
101	to manipulate the point data.
102	*/
103	ESCRIPT_DLL_API
104	DataArrayView&
105	getPointDataView();
106
107	ESCRIPT_DLL_API
108	const DataArrayView&
109	getPointDataView() const;
110
111	/**
112	\brief
113	Return the offset for the given sample. This returns the offset for the given
114	point into the container holding the point data. Only really necessary to
115	avoid creating many DataArrayView objects.
116
117	\param sampleNo - Input - sample number.
118	\param dataPointNo - Input - data point number.
119	*/
120	ESCRIPT_DLL_API
121	virtual
122	ValueType::size_type
123	getPointOffset(int sampleNo,
124	int dataPointNo) const = 0;
125
126	/**
127	\brief
128	Return the sample data for the given sample number.
129	*/
130	ESCRIPT_DLL_API
131	double*
132	getSampleData(ValueType::size_type sampleNo);
133
134	/**
135	\brief
136	Return the number of doubles stored for this Data object.
137	*/
138	ESCRIPT_DLL_API
139	virtual
140	ValueType::size_type
141	getLength() const = 0;
142
143	/**
144	\brief
145	Return the sample data for the given tag key.
146	NB: If the data isn't tagged an exception will be thrown.
147	*/
148	ESCRIPT_DLL_API
149	virtual
150	double*
151	getSampleDataByTag(int tag);
152
153	/**
154	\brief
155	Assign the given value to the data-points(s) referenced by the given
156	reference number.
157
158	If this Data object cannot be accessed by reference numbers an
159	exception will be thrown.
160
161	\param ref - Input - reference number.
162	\param value - Input - value to assign to data-points associated with
163	the given reference number.
164	*/
165	ESCRIPT_DLL_API
166	virtual
167	void
168	setRefValue(int ref,
169	const DataArray& value);
170
171	/**
172	\brief
173	Return the values associated with the data-point(s) referenced by the given
174	reference number.
175
176	If this Data object cannot be accessed by reference numbers an
177	exception will be thrown.
178
179	\param ref - Input - reference number.
180	\param value - Output - object to receive data-points associated with
181	the given reference number.
182	*/
183	ESCRIPT_DLL_API
184	virtual
185	void
186	getRefValue(int ref,
187	DataArray& value);
188
189	/**
190	\brief
191	Check this and the given RHS operands are compatible. Throws
192	an exception if they aren't.
193
194	\param right - Input - The right hand side.
195	*/
196	ESCRIPT_DLL_API
197	void
198	operandCheck(const DataAbstract& right) const;
199
200	/**
201	\brief
202	Return true if a valid sample point number.
203	*/
204	ESCRIPT_DLL_API
205	bool
206	validSamplePointNo(int samplePointNo) const;
207
208	/**
209	\brief
210	Return true if a valid sample number.
211	*/
212	ESCRIPT_DLL_API
213	bool
214	validSampleNo(int sampleNo) const;
215
216	/**
217	\brief
218	Return a view into the data for the data point specified.
219	NOTE: Construction of the DataArrayView is a relatively expensive
220	operation.
221
222	\param sampleNo - Input - the sample number.
223	\param dataPointNo - Input - the data point number.
224	*/
225	ESCRIPT_DLL_API
226	virtual
227	DataArrayView
228	getDataPoint(int sampleNo,
229	int dataPointNo) = 0;
230
231	/**
232	\brief
233	Return the function space associated with this Data object.
234	*/
235	ESCRIPT_DLL_API
236	const
237	FunctionSpace&
238	getFunctionSpace() const;
239
240	/**
241	\brief
242	Return the given slice from this object.
243
244	NB: The caller is responsible for managing the object created.
245	*/
246	ESCRIPT_DLL_API
247	virtual
248	DataAbstract*
249	getSlice(const DataArrayView::RegionType& region) const = 0;
250
251	/**
252	\brief
253	Copy the specified region from the given object.
254
255	\param value - Input - Data to copy from
256	\param region - Input - Region to copy.
257	*/
258	ESCRIPT_DLL_API
259	virtual
260	void
261	setSlice(const DataAbstract* value,
262	const DataArrayView::RegionType& region) = 0;
263
264	/**
265	\brief
266	Reshape the data points if they are currently rank 0.
267	Will throw an exception if the data points are not rank 0.
268	The original data point value is used for all values of the new
269	data point.
270	*/
271	ESCRIPT_DLL_API
272	virtual
273	void
274	reshapeDataPoint(const ShapeType& shape) = 0;
275
276	/**
277	\brief
278	setTaggedValue
279
280	Description:
281	Assign the given value to the given tag.
282
283	NB: If the data isn't tagged an exception will be thrown.
284
285	\param tagKey - Input - Integer key.
286	\param value - Input - Single DataArrayView value to be assigned to the tag.
287	*/
288	ESCRIPT_DLL_API
289	virtual
290	void
291	setTaggedValue(int tagKey,
292	const DataArrayView& value);
293
294	/**
295	\brief
296	Archive the underlying data values to the file referenced
297	by ofstream. A count of the number of values expected to be written
298	is provided as a cross-check.
299
300	The return value indicates success (0) or otherwise (1).
301	*/
302	ESCRIPT_DLL_API
303	virtual
304	int
305	archiveData(std::ofstream& archiveFile,
306	const ValueType::size_type noValues) const;
307
308	/**
309	\brief
310	Extract the number of values specified by noValues from the file
311	referenced by ifstream to the underlying data structure.
312
313	The return value indicates success (0) or otherwise (1).
314	*/
315	ESCRIPT_DLL_API
316	virtual
317	int
318	extractData(std::ifstream& archiveFile,
319	const ValueType::size_type noValues);
320
321	/**
322	\brief
323	Copy the numarray object to the data points in this object.
324
325	Description:
326	Copy the numarray object to the data points in this object.
327
328	\param value Input - new values for the data points
329	*/
330	ESCRIPT_DLL_API
331	virtual void
332	copyAll(const boost::python::numeric::array& value);
333
334	/**
335	\brief
336	Return the tag number associated with the given data-point number.
337
338	If the object cannot be referenced by tag numbers, an exception
339	will be thrown.
340	*/
341	ESCRIPT_DLL_API
342	virtual
343	int
344	getTagNumber(int dpno);
345
346	/**
347	\brief
348	Computes a symmetric matrix (A + AT) / 2
349
350	\param ev - Output - a symmetric matrix
351
352	*/
353	ESCRIPT_DLL_API
354	virtual void
355	symmetric(DataAbstract* ev);
356
357	/**
358	\brief
359	Computes a nonsymmetric matrix (A - AT) / 2
360
361	\param ev - Output - a nonsymmetric matrix
362
363	*/
364	ESCRIPT_DLL_API
365	virtual void
366	nonsymmetric(DataAbstract* ev);
367
368	/**
369	\brief
370	Computes the trace of a matrix
371
372	\param ev - Output - the trace of a matrix
373
374	*/
375	ESCRIPT_DLL_API
376	virtual void
377	trace(DataAbstract* ev, int axis_offset);
378
379	/**
380	\brief
381	Transpose each data point of this Data object around the given axis.
382
383	\param ev - Output - the transpose of a matrix
384
385	*/
386	ESCRIPT_DLL_API
387	virtual void
388	transpose(DataAbstract* ev, int axis_offset);
389
390	/**
391	\brief
392	swaps components axis0 and axis1
393
394	\param ev - Output - swapped components
395
396	*/
397	ESCRIPT_DLL_API
398	virtual void
399	swapaxes(DataAbstract* ev, int axis0, int axis1);
400	/**
401	\brief
402	solves the eigenvalue problem thisV=evV for the eigenvalues ev
403
404	\param ev - Output - eigenvalues in increasing order at each data point
405
406	*/
407	ESCRIPT_DLL_API
408	virtual void
409	eigenvalues(DataAbstract* ev);
410
411	/**
412	\brief
413	solves the eigenvalue problem thisV=evV for the eigenvalues ev and eigenvectors V
414
415	\param ev - Output - eigenvalues in increasing order at each data point
416	\param V - Output - corresponding eigenvectors. They are normalized such that their length is one
417	and the first nonzero component is positive.
418	\param tol - Input - eigenvalue with relative distance tol are treated as equal.
419
420	*/
421
422	ESCRIPT_DLL_API
423	virtual void
424	eigenvalues_and_eigenvectors(DataAbstract* ev,DataAbstract* V,const double tol=1.e-13);
425
426	protected:
427
428	/**
429	\brief
430	Set the pointDataView DataArrayView associated with this object.
431
432	\param input - Input - The point data view. DataAbstract takes ownership
433	of the DataArrayView provided. It will delete it when it is destructed.
434	*/
435	ESCRIPT_DLL_API
436	void
437	setPointDataView(const DataArrayView& input);
438
439	ESCRIPT_DLL_API
440	void
441	resetPointDataView();
442
443	private:
444
445	//
446	// The number of samples in this Data object.
447	// This is derived directly from the FunctionSpace.
448	int m_noSamples;
449
450	//
451	// The number of data points per sample in this Data object.
452	// This is derived directly from the FunctionSpace.
453	int m_noDataPointsPerSample;
454
455	//
456	// The DataArrayView of the data array associated with this object.
457	// The data array is defined only in child classes of this class, it
458	// is not defined in this abstract parent class.
459	boost::scoped_ptr<DataArrayView> m_pointDataView;
460
461	//
462	// A FunctionSpace which provides a description of the data associated
463	// with this Data object.
464	FunctionSpace m_functionSpace;
465
466	};
467
468	inline
469	bool
470	DataAbstract::validSamplePointNo(int samplePointNo) const
471	{
472	return ((0 <= samplePointNo) && (samplePointNo < m_noDataPointsPerSample));
473	}
474
475	inline
476	bool
477	DataAbstract::validSampleNo(int sampleNo) const
478	{
479	return ((0 <= sampleNo) && (sampleNo < m_noSamples));
480	}
481
482	inline
483	DataAbstract::ValueType::value_type*
484	DataAbstract::getSampleData(ValueType::size_type sampleNo)
485	{
486	return &(m_pointDataView->getData(getPointOffset(sampleNo,0)));
487	}
488
489	inline
490	int
491	DataAbstract::getNumDPPSample() const
492	{
493	return m_noDataPointsPerSample;
494	}
495
496	inline
497	int
498	DataAbstract::getNumSamples() const
499	{
500	return m_noSamples;
501	}
502
503	inline
504	const
505	FunctionSpace&
506	DataAbstract::getFunctionSpace() const
507	{
508	return m_functionSpace;
509	}
510
511	inline
512	const
513	DataArrayView&
514	DataAbstract::getPointDataView() const
515	{
516	return *(m_pointDataView.get());
517	}
518
519	inline
520	DataArrayView&
521	DataAbstract::getPointDataView()
522	{
523	return *(m_pointDataView.get());
524	}
525	} // end of namespace
526
527	#endif
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision