Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
ExpList1DHomogeneous2D.cpp
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // File ExpList1DHomogeneous2D.cpp
4 //
5 // For more information, please see: http://www.nektar.info
6 //
7 // The MIT License
8 //
9 // Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10 // Department of Aeronautics, Imperial College London (UK), and Scientific
11 // Computing and Imaging Institute, University of Utah (USA).
12 //
13 // License for the specific language governing rights and limitations under
14 // Permission is hereby granted, free of charge, to any person obtaining a
15 // copy of this software and associated documentation files (the "Software"),
16 // to deal in the Software without restriction, including without limitation
17 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
18 // and/or sell copies of the Software, and to permit persons to whom the
19 // Software is furnished to do so, subject to the following conditions:
20 //
21 // The above copyright notice and this permission notice shall be included
22 // in all copies or substantial portions of the Software.
23 //
24 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
25 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
29 // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
30 // DEALINGS IN THE SOFTWARE.
31 //
32 // Description: An ExpList1D which is homogeneous in 2 directions and so
33 // uses much of the functionality from a ExpList2D and its daughters
34 //
35 ///////////////////////////////////////////////////////////////////////////////
36 
38 
39 using namespace std;
40 
41 namespace Nektar
42 {
43  namespace MultiRegions
44  {
45  // Forward declaration for typedefs
46  ExpList1DHomogeneous2D::ExpList1DHomogeneous2D():
48  {
49  }
50 
51  // Constructor for ExpList1DHomogeneous2D to act as a Explist1D field
53  const LibUtilities::BasisKey &HomoBasis_y,
54  const LibUtilities::BasisKey &HomoBasis_z,
55  const NekDouble lhom_y,
56  const NekDouble lhom_z,
57  const bool useFFT,
58  const bool dealiasing,
59  const Array<OneD, ExpListSharedPtr> &points):
60  ExpListHomogeneous2D(pSession,HomoBasis_y,HomoBasis_z,lhom_y,lhom_z,useFFT,dealiasing)
61  {
62  int n,nel;
63 
64  ASSERTL1(m_ny*m_nz == points.num_elements(),
65  "Size of basis number of points and number of lines are "
66  "not the same");
67 
68  for(n = 0; n < points.num_elements(); ++n)
69  {
70  m_lines[n] = points[n];
71  (*m_exp).push_back(points[n]->GetExp(0));
72  }
73 
74  // Setup Default optimisation information.
75  nel = 1;
78 
79  SetCoeffPhys();
80  }
81 
82  /**
83  * @param In ExpList1DHomogeneous2D object to copy.
84  */
87  {
88  for(int n = 0; n < m_lines.num_elements(); ++n)
89  {
90  m_lines[n] = In.m_lines[n];
91  }
92 
93  SetCoeffPhys();
94  }
95 
96  /**
97  * Destructor
98  */
100  {
101  }
102 
104  {
105  int i,n,cnt;
106  int ncoeffs_per_line = m_lines[0]->GetNcoeffs();
107  int npoints_per_line = m_lines[0]->GetTotPoints();
108 
109  int nyzlines = m_lines.num_elements();
110 
111  // Set total coefficients and points
112  m_ncoeffs = ncoeffs_per_line*nyzlines;
113  m_npoints = npoints_per_line*nyzlines;
114 
117 
118  int nel = m_lines[0]->GetExpSize();
119  m_coeff_offset = Array<OneD,int>(nel*nyzlines);
120  m_phys_offset = Array<OneD,int>(nel*nyzlines);
121  Array<OneD, NekDouble> tmparray;
122 
123  for(cnt = n = 0; n < nyzlines; ++n)
124  {
125  m_lines[n]->SetCoeffsArray(tmparray= m_coeffs + ncoeffs_per_line*n);
126  m_lines[n]->SetPhysArray(tmparray = m_phys + npoints_per_line*n);
127 
128  for(i = 0; i < nel; ++i)
129  {
130  m_coeff_offset[cnt] = m_lines[n]->GetCoeff_Offset(i) + n*ncoeffs_per_line;
131  m_phys_offset[cnt++] = m_lines[n]->GetPhys_Offset(i) + n*npoints_per_line;
132  }
133  }
134  }
135 
140  {
141  int n,m,j;
142  Array<OneD, NekDouble> tmp_xc;
143  int nylines = m_homogeneousBasis_y->GetNumPoints();
144  int nzlines = m_homogeneousBasis_z->GetNumPoints();
145  int npoints = 1;
146 
147  // Fill x-y-z-direction
150 
151  Array<OneD, NekDouble> x(npoints);
152  Array<OneD, NekDouble> y(nylines);
153  Array<OneD, NekDouble> z(nzlines);
154 
155  Vmath::Smul(nylines,m_lhom_y/2.0,pts_y,1,y,1);
156  Vmath::Sadd(nylines,m_lhom_y/2.0,y,1,y,1);
157 
158  Vmath::Smul(nzlines,m_lhom_z/2.0,pts_z,1,z,1);
159  Vmath::Sadd(nzlines,m_lhom_z/2.0,z,1,z,1);
160 
161  m_lines[0]->GetCoords(x);
162 
163 
164  for(m = 0; m < nzlines; ++m)
165  {
166  for(j = 0; j < nylines; ++j)
167  {
168  for(n = 0; n < npoints; ++n)
169  {
170  Vmath::Fill(1,x[n],tmp_xc = xc0 + n +(j*npoints) + (m*npoints*nylines), 1);
171  Vmath::Fill(1,y[j],tmp_xc = xc1 + n +(j*npoints) + (m*npoints*nylines), 1);
172  Vmath::Fill(1,z[m],tmp_xc = xc2 + n +(j*npoints) + (m*npoints*nylines), 1);
173  }
174  }
175  }
176  }
177 
178  /**
179  * The operation calls the 2D plane coordinates through the
180  * function ExpList#GetCoords and then evaluated the third
181  * coordinate using the member \a m_lhom
182  *
183  * @param coord_0 After calculation, the \f$x_1\f$ coordinate
184  * will be stored in this array.
185  *
186  * @param coord_1 After calculation, the \f$x_2\f$ coordinate
187  * will be stored in this array. This
188  * coordinate might be evaluated using the
189  * predefined value \a m_lhom
190  *
191  * @param coord_2 After calculation, the \f$x_3\f$ coordinate
192  * will be stored in this array. This
193  * coordinate is evaluated using the
194  * predefined value \a m_lhom
195  */
199  {
200  int n,m,j;
201  Array<OneD, NekDouble> tmp_xc;
202  int npoints = 1;
203 
204  int nylines = m_homogeneousBasis_y->GetNumPoints();
205  int nzlines = m_homogeneousBasis_z->GetNumPoints();
206 
207  // Fill z-direction
210 
211  Array<OneD, NekDouble> x(npoints);
212  Array<OneD, NekDouble> y(nylines);
213  Array<OneD, NekDouble> z(nzlines);
214 
215  m_lines[0]->GetCoords(x);
216 
217  Vmath::Smul(nylines,m_lhom_y/2.0,pts_y,1,y,1);
218  Vmath::Sadd(nylines,m_lhom_y/2.0,y,1,y,1);
219 
220  Vmath::Smul(nzlines,m_lhom_z/2.0,pts_z,1,z,1);
221  Vmath::Sadd(nzlines,m_lhom_z/2.0,z,1,z,1);
222 
223  for(m = 0; m < nzlines; ++m)
224  {
225  for(j = 0; j < nylines; ++j)
226  {
227  for(n = 0; n < npoints; ++n)
228  {
229  Vmath::Fill(1,x[n],tmp_xc = xc0 + n +(j*npoints) + (m*npoints*nylines), 1);
230  Vmath::Fill(1,y[j],tmp_xc = xc1 + n +(j*npoints) + (m*npoints*nylines), 1);
231  Vmath::Fill(1,z[m],tmp_xc = xc2 + n +(j*npoints) + (m*npoints*nylines), 1);
232  }
233  }
234  }
235  }
236 
237 
238  /**
239  * Perform the 2D Forward transform of a set of points representing a plane of
240  * boundary conditions which are merely the collection of the boundary conditions
241  * coming from each 1D expansion.
242  * @param inarray The value of the BC on each point of the y-z homogeneous plane.
243  * @param outarray The value of the the coefficient of the 2D Fourier expansion
244  */
245  //void HomoFwdTrans2D(const Array<OneD, const NekDouble> &inarray, Array<OneD, NekDouble> &outarray)
246  //{
247 
248 
249  //}
250 
251  /**
252  * Write Tecplot Files Zone
253  * @param outfile Output file name.
254  * @param expansion Expansion that is considered
255  */
256  void ExpList1DHomogeneous2D::v_WriteTecplotZone(std::ostream &outfile, int expansion)
257  {
258  int i,j;
259 
260  int nquad0 = 1;
261  int nquad1 = m_homogeneousBasis_y->GetNumPoints();
262  int nquad2 = m_homogeneousBasis_z->GetNumPoints();
263 
264  Array<OneD,NekDouble> coords[3];
265 
266  coords[0] = Array<OneD,NekDouble>(3*nquad0*nquad1*nquad2);
267  coords[1] = coords[0] + nquad0*nquad1*nquad2;
268  coords[2] = coords[1] + nquad0*nquad1*nquad2;
269 
270  GetCoords(expansion,coords[0],coords[1],coords[2]);
271 
272  outfile << "Zone, I=" << nquad1 << ", J=" << nquad0*nquad2
273  << ", F=Block" << std::endl;
274 
275  for(j = 0; j < nquad1; ++j)
276  {
277  for(i = 0; i < nquad2*GetCoordim(0)+1; ++i)
278  {
279  outfile << coords[j][i] << " ";
280  }
281  outfile << std::endl;
282  }
283  }
284 
285 
286  void ExpList1DHomogeneous2D::v_WriteVtkPieceHeader(std::ostream &outfile, int expansion, int istrip)
287  {
288  int i,j;
289 
290  int nquad0 = 1;
291  int nquad1 = m_homogeneousBasis_y->GetNumPoints();
292  int nquad2 = m_homogeneousBasis_z->GetNumPoints();
293 
294  int ntot = nquad0*nquad1*nquad2;
295  int ntotminus = (nquad0)*(nquad1-1)*(nquad2-1);
296 
297  Array<OneD,NekDouble> coords[3];
298  coords[0] = Array<OneD,NekDouble>(ntot);
299  coords[1] = Array<OneD,NekDouble>(ntot);
300  coords[2] = Array<OneD,NekDouble>(ntot);
301  GetCoords(expansion,coords[0],coords[1],coords[2]);
302 
303  outfile << " <Piece NumberOfPoints=\""
304  << ntot << "\" NumberOfCells=\""
305  << ntotminus << "\">" << endl;
306  outfile << " <Points>" << endl;
307  outfile << " <DataArray type=\"Float32\" "
308  << "NumberOfComponents=\"3\" format=\"ascii\">" << endl;
309  outfile << " ";
310  for (i = 0; i < ntot; ++i)
311  {
312  for (j = 0; j < 3; ++j)
313  {
314  outfile << coords[j][i] << " ";
315  }
316  outfile << endl;
317  }
318  outfile << endl;
319  outfile << " </DataArray>" << endl;
320  outfile << " </Points>" << endl;
321  outfile << " <Cells>" << endl;
322  outfile << " <DataArray type=\"Int32\" "
323  << "Name=\"connectivity\" format=\"ascii\">" << endl;
324  for (i = 0; i < nquad0; ++i)
325  {
326  for (j = 0; j < nquad1-1; ++j)
327  {
328  outfile << j*nquad0 + i << " "
329  << j*nquad0 + i + 1 << " "
330  << (j+1)*nquad0 + i + 1 << " "
331  << (j+1)*nquad0 + i << endl;
332  }
333  }
334  outfile << endl;
335  outfile << " </DataArray>" << endl;
336  outfile << " <DataArray type=\"Int32\" "
337  << "Name=\"offsets\" format=\"ascii\">" << endl;
338  for (i = 0; i < ntotminus; ++i)
339  {
340  outfile << i*4+4 << " ";
341  }
342  outfile << endl;
343  outfile << " </DataArray>" << endl;
344  outfile << " <DataArray type=\"UInt8\" "
345  << "Name=\"types\" format=\"ascii\">" << endl;
346  for (i = 0; i < ntotminus; ++i)
347  {
348  outfile << "9 ";
349  }
350  outfile << endl;
351  outfile << " </DataArray>" << endl;
352  outfile << " </Cells>" << endl;
353  outfile << " <PointData>" << endl;
354  }
355 
356 
357  } //end of namespace
358 } //end of namespace
359 
360 
361 /**
362 * $Log: v $
363 *
364 **/
365 
Abstraction of a two-dimensional multi-elemental expansion which is merely a collection of local expa...
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
NekOptimize::GlobalOptParamSharedPtr m_globalOptParam
Definition: ExpList.h:1052
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.cpp:46
void SetCoeffPhys(void)
Definition of the total number of degrees of freedom and quadrature points. Sets up the storage for m...
const boost::shared_ptr< LocalRegions::ExpansionVector > GetExp() const
This function returns the vector of elements in the expansion.
Definition: ExpList.h:2067
void GetCoords(Array< OneD, NekDouble > &coord_0, Array< OneD, NekDouble > &coord_1=NullNekDouble1DArray, Array< OneD, NekDouble > &coord_2=NullNekDouble1DArray)
This function calculates the coordinates of all the elemental quadrature points . ...
STL namespace.
Array< OneD, NekDouble > m_phys
The global expansion evaluated at the quadrature points.
Definition: ExpList.h:1015
NekDouble m_lhom_z
Width of homogeneous direction z.
Array< OneD, NekDouble > m_coeffs
Concatenation of all local expansion coefficients.
Definition: ExpList.h:998
boost::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: MeshPartition.h:51
Array< OneD, ExpListSharedPtr > m_lines
Vector of ExpList, will be filled with ExpList1D.
Array< OneD, int > m_coeff_offset
Offset of elemental data into the array m_coeffs.
Definition: ExpList.h:1047
Abstraction of a one-dimensional multi-elemental expansion which is merely a collection of local expa...
LibUtilities::BasisSharedPtr m_homogeneousBasis_z
Base expansion in z direction.
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:213
virtual void v_WriteVtkPieceHeader(std::ostream &outfile, int expansion, int istrip)
Array< OneD, int > m_phys_offset
Offset of elemental data into the array m_phys.
Definition: ExpList.h:1050
int m_ncoeffs
The total number of local degrees of freedom. m_ncoeffs .
Definition: ExpList.h:976
NekDouble m_lhom_y
Width of homogeneous direction y.
double NekDouble
virtual void v_GetCoords(Array< OneD, NekDouble > &coord_0, Array< OneD, NekDouble > &coord_1, Array< OneD, NekDouble > &coord_2)
void Sadd(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Add vector y = alpha + x.
Definition: Vmath.cpp:315
int m_ny
Number of modes = number of poitns in y direction.
LibUtilities::BasisSharedPtr m_homogeneousBasis_y
Definition of the total number of degrees of freedom and quadrature points. Sets up the storage for m...
int m_nz
Number of modes = number of poitns in z direction.
virtual void v_WriteTecplotZone(std::ostream &outfile, int expansion)
int GetCoordim(int eid)
This function returns the dimension of the coordinates of the element eid.
Definition: ExpList.h:1898
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
Describes the specification for a Basis.
Definition: Basis.h:50