Intrepid
example_11.cpp
Go to the documentation of this file.
1// @HEADER
2// ************************************************************************
3//
4// Intrepid Package
5// Copyright (2007) Sandia Corporation
6//
7// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8// license for use of this work by or on behalf of the U.S. Government.
9//
10// Redistribution and use in source and binary forms, with or without
11// modification, are permitted provided that the following conditions are
12// met:
13//
14// 1. Redistributions of source code must retain the above copyright
15// notice, this list of conditions and the following disclaimer.
16//
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// 3. Neither the name of the Corporation nor the names of the
22// contributors may be used to endorse or promote products derived from
23// this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36//
37// Questions? Contact Pavel Bochev (pbboche@sandia.gov)
38// Denis Ridzal (dridzal@sandia.gov), or
39// Kara Peterson (kjpeter@sandia.gov)
40//
41// ************************************************************************
42// @HEADER
43
84// Intrepid includes
88//#include "Intrepid_ArrayTools.hpp"
90//#include "Intrepid_RealSpaceTools.hpp"
92#include "Intrepid_Utils.hpp"
93
94// Epetra includes
95#include "Epetra_Time.h"
96#include "Epetra_Map.h"
97#include "Epetra_FEVector.h"
98#include "Epetra_FECrsMatrix.h"
99#include "Epetra_SerialComm.h"
100
101// Teuchos includes
102#include "Teuchos_oblackholestream.hpp"
103#include "Teuchos_RCP.hpp"
104//#include "Teuchos_BLAS.hpp"
105//#include "Teuchos_BLAS_types.hpp"
106
107// Shards includes
108#include "Shards_CellTopology.hpp"
109
110// EpetraExt includes
111#include "EpetraExt_MultiVectorOut.h"
112
113using namespace std;
114using namespace Intrepid;
115
116int main(int argc, char *argv[]) {
117
118 //Check number of arguments
119 if (argc < 4) {
120 std::cout <<"\n>>> ERROR: Invalid number of arguments.\n\n";
121 std::cout <<"Usage:\n\n";
122 std::cout <<" ./Intrepid_example_Drivers_Example_10.exe deg NX NY NZ verbose\n\n";
123 std::cout <<" where \n";
124 std::cout <<" int deg - polynomial degree to be used (assumed >= 1) \n";
125 std::cout <<" int NX - num intervals in x direction (assumed box domain, 0,1) \n";
126 std::cout <<" int NY - num intervals in y direction (assumed box domain, 0,1) \n";
127 std::cout <<" int NZ - num intervals in y direction (assumed box domain, 0,1) \n";
128 std::cout <<" verbose (optional) - any character, indicates verbose output \n\n";
129 exit(1);
130 }
131
132 // This little trick lets us print to std::cout only if
133 // a (dummy) command-line argument is provided.
134 int iprint = argc - 1;
135 Teuchos::RCP<std::ostream> outStream;
136 Teuchos::oblackholestream bhs; // outputs nothing
137 if (iprint > 2)
138 outStream = Teuchos::rcp(&std::cout, false);
139 else
140 outStream = Teuchos::rcp(&bhs, false);
141
142 // Save the format state of the original std::cout.
143 Teuchos::oblackholestream oldFormatState;
144 oldFormatState.copyfmt(std::cout);
145
146 *outStream \
147 << "===============================================================================\n" \
148 << "| |\n" \
149 << "| Example: Build Stiffness Matrix for |\n" \
150 << "| Poisson Equation on Hexahedral Mesh |\n" \
151 << "| |\n" \
152 << "| Questions? Contact Pavel Bochev (pbboche@sandia.gov), |\n" \
153 << "| Denis Ridzal (dridzal@sandia.gov), |\n" \
154 << "| Kara Peterson (kjpeter@sandia.gov). |\n" \
155 << "| |\n" \
156 << "| Intrepid's website: http://trilinos.sandia.gov/packages/intrepid |\n" \
157 << "| Trilinos website: http://trilinos.sandia.gov |\n" \
158 << "| |\n" \
159 << "===============================================================================\n";
160
161
162 // ************************************ GET INPUTS **************************************
163
164 int deg = atoi(argv[1]); // polynomial degree to use
165 int NX = atoi(argv[2]); // num intervals in x direction (assumed box domain, 0,1)
166 int NY = atoi(argv[3]); // num intervals in y direction (assumed box domain, 0,1)
167 int NZ = atoi(argv[4]); // num intervals in y direction (assumed box domain, 0,1)
168
169
170 // *********************************** CELL TOPOLOGY **********************************
171
172 // Get cell topology for base hexahedron
173 typedef shards::CellTopology CellTopology;
174 CellTopology hex_8(shards::getCellTopologyData<shards::Hexahedron<8> >() );
175
176 // Get dimensions
177 int numNodesPerElem = hex_8.getNodeCount();
178 int spaceDim = hex_8.getDimension();
179
180 // *********************************** GENERATE MESH ************************************
181
182 *outStream << "Generating mesh ... \n\n";
183
184 *outStream << " NX" << " NY" << " NZ\n";
185 *outStream << std::setw(5) << NX <<
186 std::setw(5) << NY << std::setw(5) << NZ << "\n\n";
187
188 // Print mesh information
189 int numElems = NX*NY*NZ;
190 int numNodes = (NX+1)*(NY+1)*(NZ+1);
191 *outStream << " Number of Elements: " << numElems << " \n";
192 *outStream << " Number of Nodes: " << numNodes << " \n\n";
193
194 // Cube
195 double leftX = 0.0, rightX = 1.0;
196 double leftY = 0.0, rightY = 1.0;
197 double leftZ = 0.0, rightZ = 1.0;
198
199 // Mesh spacing
200 double hx = (rightX-leftX)/((double)NX);
201 double hy = (rightY-leftY)/((double)NY);
202 double hz = (rightZ-leftZ)/((double)NZ);
203
204 // Get nodal coordinates
205 FieldContainer<double> nodeCoord(numNodes, spaceDim);
206 FieldContainer<int> nodeOnBoundary(numNodes);
207 int inode = 0;
208 for (int k=0; k<NZ+1; k++)
209 {
210 for (int j=0; j<NY+1; j++)
211 {
212 for (int i=0; i<NX+1; i++)
213 {
214 nodeCoord(inode,0) = leftX + (double)i*hx;
215 nodeCoord(inode,1) = leftY + (double)j*hy;
216 nodeCoord(inode,2) = leftZ + (double)k*hz;
217 if (k==0 || k==NZ || j==0 || i==0 || j==NY || i==NX)
218 {
219 nodeOnBoundary(inode)=1;
220 }
221 else
222 {
223 nodeOnBoundary(inode)=0;
224 }
225 inode++;
226 }
227 }
228 }
229#define DUMP_DATA
230#ifdef DUMP_DATA
231 // Print nodal coords
232 ofstream fcoordout("coords.dat");
233 for (int i=0; i<numNodes; i++) {
234 fcoordout << nodeCoord(i,0) <<" ";
235 fcoordout << nodeCoord(i,1) <<" ";
236 fcoordout << nodeCoord(i,2) <<"\n";
237 }
238 fcoordout.close();
239#endif
240
241
242 // Element to Node map
243 // We'll keep it around, but this is only the DOFMap if you are in the lowest order case.
244 FieldContainer<int> elemToNode(numElems, numNodesPerElem);
245 int ielem=0;
246 for (int k=0; k<NZ; k++)
247 {
248 for (int j=0; j<NY; j++)
249 {
250 for (int i=0; i<NX; i++)
251 {
252 elemToNode(ielem,0) = k * ( NX + 1 ) * ( NY + 1 ) + j * ( NX + 1 ) + i;
253 elemToNode(ielem,1) = k * ( NX + 1 ) * ( NY + 1 ) + j * ( NX + 1 ) + i + 1;
254 elemToNode(ielem,2) = k * ( NX + 1 ) * ( NY + 1 ) + ( j + 1 ) * ( NX + 1 ) + i + 1;
255 elemToNode(ielem,3) = k * ( NX + 1 ) * ( NY + 1 ) + ( j + 1 ) * ( NX + 1 ) + i;
256 elemToNode(ielem,4) = ( k + 1 ) * ( NX + 1 ) * ( NY + 1 ) + j * ( NX + 1 ) + i;
257 elemToNode(ielem,5) = ( k + 1 ) * ( NX + 1 ) * ( NY + 1 ) + j * ( NX + 1 ) + i + 1;
258 elemToNode(ielem,6) = ( k + 1 ) * ( NX + 1 ) * ( NY + 1 ) + ( j + 1 ) * ( NX + 1 ) + i + 1;
259 elemToNode(ielem,7) = ( k + 1 ) * ( NX + 1 ) * ( NY + 1 ) + ( j + 1 ) * ( NX + 1 ) + i;
260 ielem++;
261 }
262 }
263 }
264#ifdef DUMP_DATA
265 // Output connectivity
266 ofstream fe2nout("elem2node.dat");
267 for (int k=0;k<NZ;k++)
268 {
269 for (int j=0; j<NY; j++)
270 {
271 for (int i=0; i<NX; i++)
272 {
273 ielem = i + j * NX + k * NY * NY;
274 for (int m=0; m<numNodesPerElem; m++)
275 {
276 fe2nout << elemToNode(ielem,m) <<" ";
277 }
278 fe2nout <<"\n";
279 }
280 }
281 }
282 fe2nout.close();
283#endif
284
285 // ************************************ CUBATURE **************************************
286 *outStream << "Getting cubature ... \n\n";
287
288 // Get numerical integration points and weights
290 int cubDegree = 2*deg;
291 Teuchos::RCP<Cubature<double> > quadCub = cubFactory.create(hex_8, cubDegree);
292
293 int cubDim = quadCub->getDimension();
294 int numCubPoints = quadCub->getNumPoints();
295
296 FieldContainer<double> cubPoints(numCubPoints, cubDim);
297 FieldContainer<double> cubWeights(numCubPoints);
298
299 quadCub->getCubature(cubPoints, cubWeights);
300
301
302 // ************************************** BASIS ***************************************
303
304 *outStream << "Getting basis ... \n\n";
305
306 // Define basis
307 Basis_HGRAD_HEX_Cn_FEM<double, FieldContainer<double> > quadHGradBasis(deg,POINTTYPE_SPECTRAL);
308 int numFieldsG = quadHGradBasis.getCardinality();
309 FieldContainer<double> quadGVals(numFieldsG, numCubPoints);
310 FieldContainer<double> quadGrads(numFieldsG, numCubPoints, spaceDim);
311
312 // Evaluate basis values and gradients at cubature points
313 quadHGradBasis.getValues(quadGVals, cubPoints, OPERATOR_VALUE);
314 quadHGradBasis.getValues(quadGrads, cubPoints, OPERATOR_GRAD);
315
316 // create the local-global mapping
317 FieldContainer<int> ltgMapping(numElems,numFieldsG);
318 const int numDOF = (NX*deg+1)*(NY*deg+1)*(NZ*deg+1);
319 ielem=0;
320 for (int k=0;k<NZ;k++)
321 {
322 for (int j=0;j<NY;j++)
323 {
324 for (int i=0;i<NX;i++)
325 {
326 const int start = k * ( NY * deg + 1 ) * ( NX * deg + 1 ) + j * ( NX * deg + 1 ) + i * deg;
327 // loop over local dof on this cell
328 int local_dof_cur=0;
329 for (int kloc=0;kloc<=deg;kloc++)
330 {
331 for (int jloc=0;jloc<=deg;jloc++)
332 {
333 for (int iloc=0;iloc<=deg;iloc++)
334 {
335 ltgMapping(ielem,local_dof_cur) = start
336 + kloc * ( NX * deg + 1 ) * ( NY * deg + 1 )
337 + jloc * ( NX * deg + 1 )
338 + iloc;
339 local_dof_cur++;
340 }
341 }
342 }
343 ielem++;
344 }
345 }
346 }
347#ifdef DUMP_DATA
348 // Output ltg mapping
349 ofstream ltgout("ltg.dat");
350 ielem=0;
351 for (int k=0;k<NZ;k++)
352 {
353 for (int j=0; j<NY; j++)
354 {
355 for (int i=0; i<NX; i++)
356 {
357 ielem = i + j * NX + k * NX * NY;
358 for (int m=0; m<numFieldsG; m++)
359 {
360 ltgout << ltgMapping(ielem,m) <<" ";
361 }
362 ltgout <<"\n";
363 }
364 }
365 }
366 ltgout.close();
367#endif
368
369 // ********** DECLARE GLOBAL OBJECTS *************
370 Epetra_SerialComm Comm;
371 Epetra_Map globalMapG(numDOF, 0, Comm);
372 Epetra_FEVector u(globalMapG); u.Random();
373 Epetra_FEVector Ku(globalMapG);
374
375 // Let's preallocate the graph before we instantiate the matrix
376 Epetra_Time graphTimer(Comm);
377 Epetra_CrsGraph grph( Copy , globalMapG , 4 * numFieldsG );
378 for (int k=0;k<numElems;k++)
379 {
380 for (int i=0;i<numFieldsG;i++)
381 {
382 grph.InsertGlobalIndices(ltgMapping(k,i),numFieldsG,&ltgMapping(k,0));
383 }
384 }
385 grph.FillComplete();
386 const double graphTime = graphTimer.ElapsedTime();
387
388
389 // time the instantiation
390 Epetra_Time instantiateTimer(Comm);
391 Epetra_FECrsMatrix StiffMatrix(Copy,grph);
392 const double instantiateTime = instantiateTimer.ElapsedTime();
393
394
395 // ********** CONSTRUCT AND INSERT LOCAL STIFFNESS MATRICES ***********
396 *outStream << "Building local stiffness matrices...\n\n";
398 typedef FunctionSpaceTools fst;
399 int numCells = numElems;
400
401 // vertices
402 FieldContainer<double> cellVertices(numCells,numNodesPerElem,spaceDim);
403
404 // jacobian information
405 FieldContainer<double> cellJacobian(numCells,numCubPoints,spaceDim,spaceDim);
406 FieldContainer<double> cellJacobInv(numCells,numCubPoints,spaceDim,spaceDim);
407 FieldContainer<double> cellJacobDet(numCells,numCubPoints);
408
409 // element stiffness matrices and supporting storage space
410 FieldContainer<double> localStiffMatrices(numCells, numFieldsG, numFieldsG);
411 FieldContainer<double> transformedBasisGradients(numCells,numFieldsG,numCubPoints,spaceDim);
412 FieldContainer<double> weightedTransformedBasisGradients(numCells,numFieldsG,numCubPoints,spaceDim);
413 FieldContainer<double> weightedMeasure(numCells, numCubPoints);
414
415
416 // get vertices of cells (for computing Jacobians)
417 for (int i=0;i<numElems;i++)
418 {
419 for (int j=0;j<numNodesPerElem;j++)
420 {
421 const int nodeCur = elemToNode(i,j);
422 for (int k=0;k<spaceDim;k++)
423 {
424 cellVertices(i,j,k) = nodeCoord(nodeCur,k);
425 }
426 }
427 }
428
429 Epetra_Time localConstructTimer( Comm );
430
431 // jacobian evaluation
432 CellTools::setJacobian(cellJacobian,cubPoints,cellVertices,hex_8);
433 CellTools::setJacobianInv(cellJacobInv, cellJacobian );
434 CellTools::setJacobianDet(cellJacobDet, cellJacobian );
435
436 // transform reference element gradients to each cell
437 fst::HGRADtransformGRAD<double>(transformedBasisGradients, cellJacobInv, quadGrads);
438
439 // compute weighted measure
440 fst::computeCellMeasure<double>(weightedMeasure, cellJacobDet, cubWeights);
441
442 // multiply values with weighted measure
443 fst::multiplyMeasure<double>(weightedTransformedBasisGradients,
444 weightedMeasure, transformedBasisGradients);
445
446 // integrate to compute element stiffness matrix
447 fst::integrate<double>(localStiffMatrices,
448 transformedBasisGradients, weightedTransformedBasisGradients , COMP_BLAS);
449
450 const double localConstructTime = localConstructTimer.ElapsedTime();
451
452
453 Epetra_Time insertionTimer(Comm);
454
455 // *** Element loop ***
456 for (int k=0; k<numElems; k++)
457 {
458 // assemble into global matrix
459 StiffMatrix.InsertGlobalValues(numFieldsG,&ltgMapping(k,0),numFieldsG,&ltgMapping(k,0),&localStiffMatrices(k,0,0));
460
461 }
462 StiffMatrix.GlobalAssemble(); StiffMatrix.FillComplete();
463 const double insertionTime = insertionTimer.ElapsedTime( );
464
465 *outStream << "Time to construct matrix graph: " << graphTime << "\n";
466 *outStream << "Time to instantiate global stiffness matrix: " << instantiateTime << "\n";
467 *outStream << "Time to build local matrices (including Jacobian computation): "<< localConstructTime << "\n";
468 *outStream << "Time to assemble global matrix from local matrices: " << insertionTime << "\n";
469 *outStream << "Total construction time: " << graphTime + instantiateTime + localConstructTime + insertionTime << "\n";
470
471 Epetra_Time applyTimer(Comm);
472 StiffMatrix.Apply(u,Ku);
473 const double multTime = applyTimer.ElapsedTime();
474 *outStream << "Time to multiply onto a vector: " << multTime << "\n";
475
476 *outStream << "End Result: TEST PASSED\n";
477
478 // reset format state of std::cout
479 std::cout.copyfmt(oldFormatState);
480
481 return 0;
482}
483
Header file for the Intrepid::CellTools class.
Header file for the abstract base class Intrepid::DefaultCubatureFactory.
Header file for utility class to provide multidimensional containers.
Header file for the Intrepid::FunctionSpaceTools class.
Header file for the Intrepid::HGRAD_HEX_Cn_FEM class.
Intrepid utilities.
Implementation of the default H(grad)-compatible FEM basis of degree 2 on Hexahedron cell.
A stateless class for operations on cell data. Provides methods for:
static void setJacobianDet(ArrayJacDet &jacobianDet, const ArrayJac &jacobian)
Computes the determinant of the Jacobian matrix DF of the reference-to-physical frame map F.
static void setJacobianInv(ArrayJacInv &jacobianInv, const ArrayJac &jacobian)
Computes the inverse of the Jacobian matrix DF of the reference-to-physical frame map F.
A factory class that generates specific instances of cubatures.
Teuchos::RCP< Cubature< Scalar, ArrayPoint, ArrayWeight > > create(const shards::CellTopology &cellTopology, const std::vector< int > &degree)
Factory method.
Implementation of a templated lexicographical container for a multi-indexed scalar quantity....
Defines expert-level interfaces for the evaluation of functions and operators in physical space (supp...