Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
ExpList3D.cpp
Go to the documentation of this file.
1 ///////////////////////////////////////////////////////////////////////////////
2 //
3 // File ExpList3D.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: Expansion list 3D definition
33 //
34 ///////////////////////////////////////////////////////////////////////////////
35 
36 #include <iomanip>
37 #include <MultiRegions/ExpList3D.h>
38 
39 #include <LocalRegions/HexExp.h>
40 #include <LocalRegions/PrismExp.h>
41 #include <LocalRegions/PyrExp.h>
42 #include <LocalRegions/TetExp.h>
43 
44 #include <LibUtilities/Foundations/Interp.h>
45 #include <LibUtilities/Foundations/PhysGalerkinProject.h>
46 
47 using namespace std;
48 
49 namespace Nektar
50 {
51  namespace MultiRegions
52  {
53 
54  ExpList3D::ExpList3D(): ExpList()
55  {
56  SetExpType(e3D);
57  }
58 
59  ExpList3D::ExpList3D(const ExpList3D &In): ExpList(In)
60  {
61  SetExpType(e3D);
62  }
63 
64  ExpList3D::ExpList3D(const ExpList3D &In,
65  const std::vector<unsigned int> &eIDs,
66  const bool DeclareCoeffPhysArrays,
67  const Collections::ImplementationType ImpType):
68  ExpList(In, eIDs, DeclareCoeffPhysArrays)
69  {
70  SetExpType(e3D);
71 
72  // Setup Default optimisation information.
73  int nel = GetExpSize();
74  m_globalOptParam = MemoryManager<NekOptimize::GlobalOptParam>
75  ::AllocateSharedPtr(nel);
76 
77  SetCoeffPhysOffsets();
78 
79  if (DeclareCoeffPhysArrays)
80  {
81  // Set up m_coeffs, m_phys.
82  m_coeffs = Array<OneD, NekDouble>(m_ncoeffs);
83  m_phys = Array<OneD, NekDouble>(m_npoints);
84  }
85 
86  ReadGlobalOptimizationParameters();
87  CreateCollections(ImpType);
88  }
89 
90  ExpList3D::~ExpList3D()
91  {
92  }
93 
94 
95  ExpList3D::ExpList3D(const LibUtilities::SessionReaderSharedPtr &pSession,
96  const LibUtilities::BasisKey &TBa,
97  const LibUtilities::BasisKey &TBb,
98  const LibUtilities::BasisKey &TBc,
99  const LibUtilities::BasisKey &HBa,
100  const LibUtilities::BasisKey &HBb,
101  const LibUtilities::BasisKey &HBc,
102  const SpatialDomains::MeshGraphSharedPtr &graph3D,
103  const LibUtilities::PointsType TetNb,
104  const Collections::ImplementationType ImpType):
105  ExpList(pSession,graph3D)
106  {
107  SetExpType(e3D);
108 
109  LocalRegions::TetExpSharedPtr tet;
110  LocalRegions::HexExpSharedPtr hex;
111  LocalRegions::PrismExpSharedPtr prism;
112  LocalRegions::PyrExpSharedPtr pyramid;
113 
114  const SpatialDomains::ExpansionMap &expansions = graph3D->GetExpansions();
115 
116  SpatialDomains::ExpansionMap::const_iterator expIt;
117  for (expIt = expansions.begin(); expIt != expansions.end(); ++expIt)
118  {
119  SpatialDomains::TetGeomSharedPtr TetGeom;
120  SpatialDomains::HexGeomSharedPtr HexGeom;
121  SpatialDomains::PrismGeomSharedPtr PrismGeom;
122  SpatialDomains::PyrGeomSharedPtr PyrGeom;
123 
124  if((TetGeom = boost::dynamic_pointer_cast<SpatialDomains::TetGeom>(expIt->second->m_geomShPtr)))
125  {
126  if(TetNb < LibUtilities::SIZE_PointsType)
127  {
128 // Ntet = MemoryManager<LocalRegions::NodalTetExp>::AllocateSharedPtr(TetBa,TetBb,TetBc,TetNb,TetGeom);
129 // (*m_exp).push_back(Ntet);
130  }
131  else
132  {
133  tet = MemoryManager<LocalRegions::TetExp>::AllocateSharedPtr(TBa,TBb,TBc,TetGeom);
134  (*m_exp).push_back(tet);
135  }
136 
137  m_ncoeffs += LibUtilities::StdTetData::getNumberOfCoefficients(TBa.GetNumModes(), TBb.GetNumModes(), TBc.GetNumModes());
138 
139  m_npoints += TBa.GetNumPoints()*TBb.GetNumPoints()*TBc.GetNumPoints();
140  }
141 /*
142  else if((PrismGeom = boost::dynamic_pointer_cast<SpatialDomains::PrismGeom>(expansions[i]->m_geomShPtr)))
143  {
144  prism = MemoryManager<LocalRegions::PrismExp>::AllocateSharedPtr(Ba,Bb,Bc,PrismGeom);
145  (*m_exp).push_back(prism);
146 
147  m_ncoeffs += StdRegions::StdPrismData::getNumberOfCoefficients(Ba.GetNumModes(), Bb.GetNumModes(), Bc.GetNumModes());
148  m_npoints += Ba.GetNumPoints()*Bb.GetNumPoints()*Bc.GetNumPoints();
149 
150  }
151  else if((PyrGeom = boost::dynamic_pointer_cast<SpatialDomains::PyrGeom>(expansions[i]->m_geomShPtr)))
152  {
153  pyramid = MemoryManager<LocalRegions::PyrExp>::AllocateSharedPtr(Ba,Bb,Bc,PyrGeom);
154  (*m_exp).push_back(pyramid);
155 
156  m_ncoeffs += StdRegions::StdPyrData::getNumberOfCoefficients(Ba.GetNumModes(), Bb.GetNumModes(), Bc.GetNumModes());
157  m_npoints += Ba.GetNumPoints()*Bb.GetNumPoints()*Bc.GetNumPoints();
158 
159  }
160 */
161  else if((HexGeom = boost::dynamic_pointer_cast<SpatialDomains::HexGeom>(expIt->second->m_geomShPtr)))
162  {
163  hex = MemoryManager<LocalRegions::HexExp>::AllocateSharedPtr(HBa,HBb,HBc, HexGeom);
164  (*m_exp).push_back(hex);
165 
166  m_ncoeffs += HBa.GetNumModes()*HBb.GetNumModes()*HBc.GetNumModes();
167  m_npoints += HBa.GetNumPoints()*HBb.GetNumPoints()*HBc.GetNumPoints();
168  }
169  else
170  {
171  ASSERTL0(false,"dynamic cast to a proper Geometry3D failed");
172  }
173 
174  }
175 
176  // Setup Default optimisation information.
177  int nel = GetExpSize();
178  m_globalOptParam = MemoryManager<NekOptimize::GlobalOptParam>
179  ::AllocateSharedPtr(nel);
180 
181  SetCoeffPhysOffsets();
182 
183  // Set up m_coeffs, m_phys.
184  m_coeffs = Array<OneD, NekDouble>(m_ncoeffs);
185  m_phys = Array<OneD, NekDouble>(m_npoints);
186 
187  ReadGlobalOptimizationParameters();
188  CreateCollections(ImpType);
189  }
190 
191  /**
192  * Given a mesh \a graph3D, containing information about the domain and
193  * the spectral/hp element expansion, this constructor fills the list
194  * of local expansions \texttt{m_exp} with the proper expansions,
195  * calculates the total number of quadrature points
196  * \f$\boldsymbol{x}_i\f$ and the local expansion coefficients
197  * \f$\hat{u}^e_n\f$ and allocates memory for the arrays #m_coeffs and
198  * #m_phys.
199  *
200  * @param graph3D A mesh, containing information about the domain
201  * and the spectral/hp element expansion.
202  */
203  ExpList3D::ExpList3D(const LibUtilities::SessionReaderSharedPtr &pSession,
204  const SpatialDomains::MeshGraphSharedPtr &graph3D,
205  const std::string &variable,
206  const Collections::ImplementationType ImpType):
207  ExpList(pSession,graph3D)
208  {
209  SetExpType(e3D);
210 
211  int elmtid = 0;
212  LocalRegions::TetExpSharedPtr tet;
213  LocalRegions::HexExpSharedPtr hex;
214  LocalRegions::PrismExpSharedPtr prism;
215  LocalRegions::PyrExpSharedPtr pyramid;
216 
217  const SpatialDomains::ExpansionMap &expansions
218  = graph3D->GetExpansions(variable);
219 
220  SpatialDomains::ExpansionMap::const_iterator expIt;
221  for (expIt = expansions.begin(); expIt != expansions.end(); ++expIt)
222  {
223  SpatialDomains::TetGeomSharedPtr TetGeom;
224  SpatialDomains::HexGeomSharedPtr HexGeom;
225  SpatialDomains::PrismGeomSharedPtr PrismGeom;
226  SpatialDomains::PyrGeomSharedPtr PyrGeom;
227 
228  if((TetGeom = boost::dynamic_pointer_cast<
229  SpatialDomains::TetGeom>(expIt->second->m_geomShPtr)))
230  {
231  LibUtilities::BasisKey TetBa
232  = expIt->second->m_basisKeyVector[0];
233  LibUtilities::BasisKey TetBb
234  = expIt->second->m_basisKeyVector[1];
235  LibUtilities::BasisKey TetBc
236  = expIt->second->m_basisKeyVector[2];
237 
238  if(TetBa.GetBasisType() == LibUtilities::eGLL_Lagrange ||
239  TetBa.GetBasisType() == LibUtilities::eGauss_Lagrange)
240  {
241  ASSERTL0(false,"LocalRegions::NodalTetExp is not "
242  "implemented yet");
243  }
244  else
245  {
246  tet = MemoryManager<LocalRegions::TetExp>
247  ::AllocateSharedPtr(TetBa,TetBb,TetBc,
248  TetGeom);
249  tet->SetElmtId(elmtid++);
250  (*m_exp).push_back(tet);
251  }
252  }
253  else if((PrismGeom = boost::dynamic_pointer_cast<SpatialDomains
254  ::PrismGeom>(expIt->second->m_geomShPtr)))
255  {
256  LibUtilities::BasisKey PrismBa
257  = expIt->second->m_basisKeyVector[0];
258  LibUtilities::BasisKey PrismBb
259  = expIt->second->m_basisKeyVector[1];
260  LibUtilities::BasisKey PrismBc
261  = expIt->second->m_basisKeyVector[2];
262 
263  prism = MemoryManager<LocalRegions::PrismExp>
264  ::AllocateSharedPtr(PrismBa,PrismBb,
265  PrismBc,PrismGeom);
266  prism->SetElmtId(elmtid++);
267  (*m_exp).push_back(prism);
268  }
269  else if((PyrGeom = boost::dynamic_pointer_cast<
270  SpatialDomains::PyrGeom>(expIt->second->m_geomShPtr)))
271  {
272  LibUtilities::BasisKey PyrBa
273  = expIt->second->m_basisKeyVector[0];
274  LibUtilities::BasisKey PyrBb
275  = expIt->second->m_basisKeyVector[1];
276  LibUtilities::BasisKey PyrBc
277  = expIt->second->m_basisKeyVector[2];
278 
279  pyramid = MemoryManager<LocalRegions::PyrExp>
280  ::AllocateSharedPtr(PyrBa,PyrBb,PyrBc,
281  PyrGeom);
282  pyramid->SetElmtId(elmtid++);
283  (*m_exp).push_back(pyramid);
284  }
285  else if((HexGeom = boost::dynamic_pointer_cast<
286  SpatialDomains::HexGeom>(expIt->second->m_geomShPtr)))
287  {
288  LibUtilities::BasisKey HexBa
289  = expIt->second->m_basisKeyVector[0];
290  LibUtilities::BasisKey HexBb
291  = expIt->second->m_basisKeyVector[1];
292  LibUtilities::BasisKey HexBc
293  = expIt->second->m_basisKeyVector[2];
294 
295  hex = MemoryManager<LocalRegions::HexExp>
296  ::AllocateSharedPtr(HexBa,HexBb,HexBc,
297  HexGeom);
298  hex->SetElmtId(elmtid++);
299  (*m_exp).push_back(hex);
300  }
301  else
302  {
303  ASSERTL0(false,"dynamic cast to a proper Geometry3D "
304  "failed");
305  }
306 
307  }
308 
309  // Setup Default optimisation information.
310  int nel = GetExpSize();
311  m_globalOptParam = MemoryManager<NekOptimize::GlobalOptParam>
312  ::AllocateSharedPtr(nel);
313 
314  SetCoeffPhysOffsets();
315 
316  // Set up m_coeffs, m_phys.
317  m_coeffs = Array<OneD, NekDouble>(m_ncoeffs);
318  m_phys = Array<OneD, NekDouble>(m_npoints);
319 
320  ReadGlobalOptimizationParameters();
321  CreateCollections(ImpType);
322  }
323 
324  /**
325  * Given an expansion vector \a expansions, containing
326  * information about the domain and the spectral/hp element
327  * expansion, this constructor fills the list of local
328  * expansions \texttt{m_exp} with the proper expansions,
329  * calculates the total number of quadrature points
330  * \f$\boldsymbol{x}_i\f$ and the local expansion coefficients
331  * \f$\hat{u}^e_n\f$ and allocates memory for the arrays
332  * #m_coeffs and #m_phys.
333  *
334  * @param expansions An expansion vector, containing
335  * information about the domain and the
336  * spectral/hp element expansion.
337  */
338  ExpList3D::ExpList3D(const SpatialDomains::ExpansionMap &expansions,
339  const Collections::ImplementationType ImpType):
340  ExpList()
341  {
342  SetExpType(e3D);
343 
344  int elmtid = 0;
345  LocalRegions::TetExpSharedPtr tet;
346  LocalRegions::HexExpSharedPtr hex;
347  LocalRegions::PrismExpSharedPtr prism;
348  LocalRegions::PyrExpSharedPtr pyramid;
349 
350 
351  for(int i = 0; i < expansions.size(); ++i)
352  {
353  SpatialDomains::TetGeomSharedPtr TetGeom;
354  SpatialDomains::HexGeomSharedPtr HexGeom;
355  SpatialDomains::PrismGeomSharedPtr PrismGeom;
356  SpatialDomains::PyrGeomSharedPtr PyrGeom;
357 
358  SpatialDomains::ExpansionMap::const_iterator expmap = expansions.find(i);
359  ASSERTL1(expmap != expansions.end(), "Unable to find expansion.");
360  const SpatialDomains::ExpansionShPtr exp = expmap->second;
361 
362  if((TetGeom = boost::dynamic_pointer_cast<
363  SpatialDomains::TetGeom>(exp->m_geomShPtr)))
364  {
365  LibUtilities::BasisKey TetBa
366  = exp->m_basisKeyVector[0];
367  LibUtilities::BasisKey TetBb
368  = exp->m_basisKeyVector[1];
369  LibUtilities::BasisKey TetBc
370  = exp->m_basisKeyVector[2];
371 
372  if(TetBa.GetBasisType() == LibUtilities::eGLL_Lagrange ||
373  TetBa.GetBasisType() == LibUtilities::eGauss_Lagrange)
374  {
375  ASSERTL0(false,"LocalRegions::NodalTetExp is not "
376  "implemented yet");
377  }
378  else
379  {
380  tet = MemoryManager<LocalRegions::TetExp>
381  ::AllocateSharedPtr(TetBa,TetBb,TetBc,
382  TetGeom);
383  tet->SetElmtId(elmtid++);
384  (*m_exp).push_back(tet);
385  }
386  }
387  else if((PrismGeom = boost::dynamic_pointer_cast<
388  SpatialDomains::PrismGeom>(exp->m_geomShPtr)))
389  {
390  LibUtilities::BasisKey PrismBa
391  = exp->m_basisKeyVector[0];
392  LibUtilities::BasisKey PrismBb
393  = exp->m_basisKeyVector[1];
394  LibUtilities::BasisKey PrismBc
395  = exp->m_basisKeyVector[2];
396 
397  prism = MemoryManager<LocalRegions::PrismExp>
398  ::AllocateSharedPtr(PrismBa,PrismBb,
399  PrismBc,PrismGeom);
400  prism->SetElmtId(elmtid++);
401  (*m_exp).push_back(prism);
402  }
403  else if((PyrGeom = boost::dynamic_pointer_cast<
404  SpatialDomains::PyrGeom>(exp->m_geomShPtr)))
405  {
406  LibUtilities::BasisKey PyrBa
407  = exp->m_basisKeyVector[0];
408  LibUtilities::BasisKey PyrBb
409  = exp->m_basisKeyVector[1];
410  LibUtilities::BasisKey PyrBc
411  = exp->m_basisKeyVector[2];
412 
413  pyramid = MemoryManager<LocalRegions::PyrExp>
414  ::AllocateSharedPtr(PyrBa,PyrBb,PyrBc,
415  PyrGeom);
416  pyramid->SetElmtId(elmtid++);
417  (*m_exp).push_back(pyramid);
418  }
419  else if((HexGeom = boost::dynamic_pointer_cast<
420  SpatialDomains::HexGeom>(exp->m_geomShPtr)))
421  {
422  LibUtilities::BasisKey HexBa
423  = exp->m_basisKeyVector[0];
424  LibUtilities::BasisKey HexBb
425  = exp->m_basisKeyVector[1];
426  LibUtilities::BasisKey HexBc
427  = exp->m_basisKeyVector[2];
428 
429  hex = MemoryManager<LocalRegions::HexExp>
430  ::AllocateSharedPtr(HexBa,HexBb,HexBc,
431  HexGeom);
432  hex->SetElmtId(elmtid++);
433  (*m_exp).push_back(hex);
434  }
435  else
436  {
437  ASSERTL0(false,"dynamic cast to a proper Geometry3D "
438  "failed");
439  }
440 
441  }
442 
443  // Setup Default optimisation information.
444  int nel = GetExpSize();
445  m_globalOptParam = MemoryManager<NekOptimize::GlobalOptParam>
446  ::AllocateSharedPtr(nel);
447 
448  SetCoeffPhysOffsets();
449 
450  // Set up m_coeffs, m_phys.
451  m_coeffs = Array<OneD, NekDouble>(m_ncoeffs);
452  m_phys = Array<OneD, NekDouble>(m_npoints);
453 
454  CreateCollections(ImpType);
455  }
456 
457  void ExpList3D::v_ReadGlobalOptimizationParameters()
458  {
459  Array<OneD, int> NumShape(4,0);
460 
461  for(int i = 0; i < GetExpSize(); ++i)
462  {
463  switch ((*m_exp)[i]->DetShapeType())
464  {
465  case LibUtilities::eTetrahedron: NumShape[0]++; break;
466  case LibUtilities::ePyramid: NumShape[1]++; break;
467  case LibUtilities::ePrism: NumShape[2]++; break;
468  case LibUtilities::eHexahedron: NumShape[3]++; break;
469  default:
470  ASSERTL0(false, "Unknown expansion type.");
471  break;
472  }
473  }
474 
475  int three = 3;
476  m_globalOptParam = MemoryManager<NekOptimize::GlobalOptParam>
477  ::AllocateSharedPtr(m_session,three,NumShape);
478  }
479 
480  void ExpList3D::v_WriteVtkPieceHeader(std::ostream &outfile, int expansion, int istrip)
481  {
482  int i,j,k;
483  int nquad0 = (*m_exp)[expansion]->GetNumPoints(0);
484  int nquad1 = (*m_exp)[expansion]->GetNumPoints(1);
485  int nquad2 = (*m_exp)[expansion]->GetNumPoints(2);
486  int ntot = nquad0*nquad1*nquad2;
487  int ntotminus = (nquad0-1)*(nquad1-1)*(nquad2-1);
488 
489  Array<OneD,NekDouble> coords[3];
490  coords[0] = Array<OneD,NekDouble>(ntot);
491  coords[1] = Array<OneD,NekDouble>(ntot);
492  coords[2] = Array<OneD,NekDouble>(ntot);
493  (*m_exp)[expansion]->GetCoords(coords[0],coords[1],coords[2]);
494 
495  outfile << " <Piece NumberOfPoints=\""
496  << ntot << "\" NumberOfCells=\""
497  << ntotminus << "\">" << endl;
498  outfile << " <Points>" << endl;
499  outfile << " <DataArray type=\"Float64\" "
500  << "NumberOfComponents=\"3\" format=\"ascii\">" << endl;
501  outfile << " ";
502  for (i = 0; i < ntot; ++i)
503  {
504  for (j = 0; j < 3; ++j)
505  {
506  outfile << setprecision(8) << scientific
507  << (float)coords[j][i] << " ";
508  }
509  outfile << endl;
510  }
511 
512  outfile << endl;
513  outfile << " </DataArray>" << endl;
514  outfile << " </Points>" << endl;
515  outfile << " <Cells>" << endl;
516  outfile << " <DataArray type=\"Int32\" "
517  << "Name=\"connectivity\" format=\"ascii\">" << endl;
518  for (i = 0; i < nquad0-1; ++i)
519  {
520  for (j = 0; j < nquad1-1; ++j)
521  {
522  for (k = 0; k < nquad2-1; ++k)
523  {
524  outfile << k*nquad0*nquad1 + j*nquad0 + i << " "
525  << k*nquad0*nquad1 + j*nquad0 + i + 1 << " "
526  << k*nquad0*nquad1 + (j+1)*nquad0 + i + 1 << " "
527  << k*nquad0*nquad1 + (j+1)*nquad0 + i << " "
528  << (k+1)*nquad0*nquad1 + j*nquad0 + i << " "
529  << (k+1)*nquad0*nquad1 + j*nquad0 + i + 1 << " "
530  << (k+1)*nquad0*nquad1 + (j+1)*nquad0 + i + 1 << " "
531  << (k+1)*nquad0*nquad1 + (j+1)*nquad0 + i << " " << endl;
532  }
533  }
534  }
535  outfile << endl;
536  outfile << " </DataArray>" << endl;
537  outfile << " <DataArray type=\"Int32\" "
538  << "Name=\"offsets\" format=\"ascii\">" << endl;
539  for (i = 0; i < ntotminus; ++i)
540  {
541  outfile << i*8+8 << " ";
542  }
543  outfile << endl;
544  outfile << " </DataArray>" << endl;
545  outfile << " <DataArray type=\"UInt8\" "
546  << "Name=\"types\" format=\"ascii\">" << endl;
547  for (i = 0; i < ntotminus; ++i)
548  {
549  outfile << "12 ";
550  }
551  outfile << endl;
552  outfile << " </DataArray>" << endl;
553  outfile << " </Cells>" << endl;
554  outfile << " <PointData>" << endl;
555  }
556 
557  void ExpList3D::v_SetUpPhysNormals()
558  {
559  int i, j;
560  for (i = 0; i < m_exp->size(); ++i)
561  {
562  for (j = 0; j < (*m_exp)[i]->GetNfaces(); ++j)
563  {
564  (*m_exp)[i]->ComputeFaceNormal(j);
565  }
566  }
567  }
568 
569  void ExpList3D::v_PhysInterp1DScaled(const NekDouble scale,
570  const Array<OneD, NekDouble> &inarray,
571  Array<OneD, NekDouble> &outarray)
572  {
573  int cnt,cnt1;
574 
575  cnt = cnt1 = 0;
576  for(int i = 0; i < GetExpSize(); ++i)
577  {
578  // get new points key
579  int pt0 = (*m_exp)[i]->GetNumPoints(0);
580  int pt1 = (*m_exp)[i]->GetNumPoints(1);
581  int pt2 = (*m_exp)[i]->GetNumPoints(2);
582  int npt0 = (int) pt0*scale;
583  int npt1 = (int) pt1*scale;
584  int npt2 = (int) pt2*scale;
585 
586  LibUtilities::PointsKey newPointsKey0(npt0,(*m_exp)[i]->GetPointsType(0));
587  LibUtilities::PointsKey newPointsKey1(npt1,(*m_exp)[i]->GetPointsType(1));
588  LibUtilities::PointsKey newPointsKey2(npt2,(*m_exp)[i]->GetPointsType(2));
589 
590  // Interpolate points;
591  LibUtilities::Interp3D((*m_exp)[i]->GetBasis(0)->GetPointsKey(),
592  (*m_exp)[i]->GetBasis(1)->GetPointsKey(),
593  (*m_exp)[i]->GetBasis(2)->GetPointsKey(),
594  &inarray[cnt], newPointsKey0,
595  newPointsKey1, newPointsKey2,
596  &outarray[cnt1]);
597 
598  cnt += pt0*pt1*pt2;
599  cnt1 += npt0*npt1*npt2;
600  }
601  }
602 
603  void ExpList3D::v_PhysGalerkinProjection1DScaled(const NekDouble scale,
604  const Array<OneD, NekDouble> &inarray,
605  Array<OneD, NekDouble> &outarray)
606  {
607  int cnt,cnt1;
608 
609  cnt = cnt1 = 0;
610  for(int i = 0; i < GetExpSize(); ++i)
611  {
612  // get new points key
613  int pt0 = (*m_exp)[i]->GetNumPoints(0);
614  int pt1 = (*m_exp)[i]->GetNumPoints(1);
615  int pt2 = (*m_exp)[i]->GetNumPoints(2);
616  int npt0 = (int) pt0*scale;
617  int npt1 = (int) pt1*scale;
618  int npt2 = (int) pt2*scale;
619 
620  LibUtilities::PointsKey newPointsKey0(npt0,(*m_exp)[i]->GetPointsType(0));
621  LibUtilities::PointsKey newPointsKey1(npt1,(*m_exp)[i]->GetPointsType(1));
622  LibUtilities::PointsKey newPointsKey2(npt2,(*m_exp)[i]->GetPointsType(2));
623 
624  // Project points;
625  LibUtilities::PhysGalerkinProject3D(newPointsKey0,
626  newPointsKey1,
627  newPointsKey2,
628  &inarray[cnt],
629  (*m_exp)[i]->GetBasis(0)->GetPointsKey(),
630  (*m_exp)[i]->GetBasis(1)->GetPointsKey(),
631  (*m_exp)[i]->GetBasis(2)->GetPointsKey(),
632  &outarray[cnt1]);
633 
634  cnt += npt0*npt1*npt2;
635  cnt1 += pt0*pt1*pt2;
636  }
637 
638  }
639  } //end of namespace
640 } //end of namespace
641 
Nektar::SpatialDomains::PyrGeomSharedPtr
boost::shared_ptr< PyrGeom > PyrGeomSharedPtr
Definition: PyrGeom.h:84
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:198
Nektar::MemoryManager::AllocateSharedPtr
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:235
Nektar::MultiRegions::ExpList3D::v_SetUpPhysNormals
virtual void v_SetUpPhysNormals()
Set up the normals on each expansion.
Definition: ExpList3D.cpp:557
Nektar::MultiRegions::ExpList::m_globalOptParam
NekOptimize::GlobalOptParamSharedPtr m_globalOptParam
Definition: ExpList.h:1052
PhysGalerkinProject.h
PyrExp.h
Nektar::LibUtilities::BasisKey::GetBasisType
BasisType GetBasisType() const
Return type of expansion basis.
Definition: Basis.h:139
Nektar::LibUtilities::eGauss_Lagrange
Lagrange Polynomials using the Gauss points .
Definition: BasisType.h:54
std
STL namespace.
Nektar::LocalRegions::HexExpSharedPtr
boost::shared_ptr< HexExp > HexExpSharedPtr
Definition: HexExp.h:57
Nektar::MultiRegions::ExpList::m_phys
Array< OneD, NekDouble > m_phys
The global expansion evaluated at the quadrature points.
Definition: ExpList.h:1015
Nektar::SpatialDomains::HexGeomSharedPtr
boost::shared_ptr< HexGeom > HexGeomSharedPtr
Definition: HexGeom.h:110
Nektar::LibUtilities::StdTetData::getNumberOfCoefficients
int getNumberOfCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:186
Nektar::MultiRegions::ExpList::m_coeffs
Array< OneD, NekDouble > m_coeffs
Concatenation of all local expansion coefficients.
Definition: ExpList.h:998
Nektar::MultiRegions::ExpList::GetExpSize
int GetExpSize(void)
This function returns the number of elements in the expansion.
Definition: ExpList.h:2046
Nektar::LocalRegions::TetExpSharedPtr
boost::shared_ptr< TetExp > TetExpSharedPtr
Definition: TetExp.h:228
Nektar::LibUtilities::SessionReaderSharedPtr
boost::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: MeshPartition.h:51
Nektar::MultiRegions::ExpList3D::v_PhysGalerkinProjection1DScaled
virtual void v_PhysGalerkinProjection1DScaled(const NekDouble scale, const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: ExpList3D.cpp:603
Nektar::MultiRegions::ExpList
Base class for all multi-elemental spectral/hp expansions.
Definition: ExpList.h:101
Nektar::MultiRegions::ExpList::m_exp
boost::shared_ptr< LocalRegions::ExpansionVector > m_exp
The list of local expansions.
Definition: ExpList.h:1036
PrismExp.h
HexExp.h
Nektar::LocalRegions::PyrExpSharedPtr
boost::shared_ptr< PyrExp > PyrExpSharedPtr
Definition: PyrExp.h:164
Nektar::MultiRegions::ExpList::m_ncoeffs
int m_ncoeffs
The total number of local degrees of freedom. m_ncoeffs .
Definition: ExpList.h:976
Nektar::LibUtilities::BasisKey::GetNumPoints
int GetNumPoints() const
Return points order at which basis is defined.
Definition: Basis.h:128
Nektar::MultiRegions::ExpList::SetCoeffPhysOffsets
void SetCoeffPhysOffsets()
Definition of the total number of degrees of freedom and quadrature points and offsets to access data...
Definition: ExpList.cpp:247
Nektar::MultiRegions::ExpList::m_session
LibUtilities::SessionReaderSharedPtr m_session
Session.
Definition: ExpList.h:969
Nektar::LibUtilities::PhysGalerkinProject3D
void PhysGalerkinProject3D(const BasisKey &fbasis0, const BasisKey &fbasis1, const BasisKey &fbasis2, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, const BasisKey &tbasis2, Array< OneD, NekDouble > &to)
Definition: PhysGalerkinProject.cpp:178
Nektar::LibUtilities::PointsKey
Defines a specification for a set of points.
Definition: Points.h:58
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44
Nektar::LocalRegions::PrismExpSharedPtr
boost::shared_ptr< PrismExp > PrismExpSharedPtr
Definition: PrismExp.h:222
Interp.h
Nektar::MultiRegions::ExpList3D::v_ReadGlobalOptimizationParameters
virtual void v_ReadGlobalOptimizationParameters()
Definition: ExpList3D.cpp:457
ExpList3D.h
Nektar::MultiRegions::ExpList3D::~ExpList3D
virtual ~ExpList3D()
Destructor.
Definition: ExpList3D.cpp:90
Nektar::LibUtilities::Interp3D
void Interp3D(const BasisKey &fbasis0, const BasisKey &fbasis1, const BasisKey &fbasis2, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, const BasisKey &tbasis2, Array< OneD, NekDouble > &to)
this function interpolates a 3D function evaluated at the quadrature points of the 3D basis...
Definition: Interp.cpp:186
Nektar::SpatialDomains::ExpansionShPtr
boost::shared_ptr< Expansion > ExpansionShPtr
Definition: MeshGraph.h:173
Nektar::SpatialDomains::PrismGeomSharedPtr
boost::shared_ptr< PrismGeom > PrismGeomSharedPtr
Definition: PrismGeom.h:109
Nektar::SpatialDomains::TetGeomSharedPtr
boost::shared_ptr< TetGeom > TetGeomSharedPtr
Definition: TetGeom.h:106
Nektar::MultiRegions::ExpList3D
Abstraction of a three-dimensional multi-elemental expansion which is merely a collection of local ex...
Definition: ExpList3D.h:49
Nektar::MultiRegions::ExpList3D::ExpList3D
ExpList3D()
Default constructor.
Definition: ExpList3D.cpp:54
TetExp.h
Nektar::MultiRegions::ExpList::CreateCollections
void CreateCollections(Collections::ImplementationType ImpType=Collections::eNoImpType)
Construct collections of elements containing a single element type and polynomial order from the list...
Definition: ExpList.cpp:3151
Nektar::LibUtilities::BasisKey::GetNumModes
int GetNumModes() const
Returns the order of the basis.
Definition: Basis.h:84
Nektar::LibUtilities::eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:53
Nektar::MultiRegions::ExpList::SetExpType
void SetExpType(ExpansionType Type)
Returns the type of the expansion.
Definition: ExpList.cpp:277
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:228
Nektar::SpatialDomains::MeshGraphSharedPtr
boost::shared_ptr< MeshGraph > MeshGraphSharedPtr
Definition: MeshGraph.h:442
Nektar::LibUtilities::BasisKey
Describes the specification for a Basis.
Definition: Basis.h:50
Nektar::MultiRegions::ExpList3D::v_WriteVtkPieceHeader
virtual void v_WriteVtkPieceHeader(std::ostream &outfile, int expansion, int istrip)
Definition: ExpList3D.cpp:480
Nektar::SpatialDomains::ExpansionMap
std::map< int, ExpansionShPtr > ExpansionMap
Definition: MeshGraph.h:174
Nektar::MultiRegions::ExpList3D::v_PhysInterp1DScaled
virtual void v_PhysInterp1DScaled(const NekDouble scale, const Array< OneD, NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: ExpList3D.cpp:569
Generated on Sat Nov 25 2017 16:18:11 for Nektar++ by   doxygen 1.8.8