LifeV
Integrate.hpp
Go to the documentation of this file.
1 //@HEADER
2 /*
3 *******************************************************************************
4 
5  Copyright (C) 2004, 2005, 2007 EPFL, Politecnico di Milano, INRIA
6  Copyright (C) 2010 EPFL, Politecnico di Milano, Emory UNiversity
7 
8  This file is part of the LifeV library
9 
10  LifeV is free software; you can redistribute it and/or modify
11  it under the terms of the GNU Lesser General Public License as published by
12  the Free Software Foundation; either version 3 of the License, or
13  (at your option) any later version.
14 
15  LifeV is distributed in the hope that it will be useful,
16  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  Lesser General Public License for more details.
19 
20  You should have received a copy of the GNU Lesser General Public
21  License along with this library; if not, see <http://www.gnu.org/licenses/>
22 
23 
24 *******************************************************************************
25 */
26 //@HEADER
27 
28 /*!
29  * @file
30  @brief This file contains the definition of the integrate function.
31 
32  @date 06/2011
33  @author Samuel Quinodoz <samuel.quinodoz@epfl.ch>
34  */
35 
36 #ifndef INTEGRATE_HPP
37 #define INTEGRATE_HPP
38 
39 #include <lifev/core/LifeV.hpp>
40 
41 #include <lifev/core/util/OpenMPParameters.hpp>
42 
43 #include <lifev/eta/expression/RequestLoopElement.hpp>
44 #include <lifev/eta/expression/RequestLoopVolumeID.hpp>
45 #include <lifev/eta/expression/RequestLoopFaceID.hpp>
46 
47 #include <lifev/core/fem/QuadratureRule.hpp>
48 #include <lifev/eta/fem/QRAdapterBase.hpp>
49 #include <lifev/eta/fem/QRAdapterNeverAdapt.hpp>
50 
51 #include <lifev/eta/expression/IntegrateMatrixElement.hpp>
52 #include <lifev/eta/expression/IntegrateVectorElement.hpp>
53 #include <lifev/eta/expression/IntegrateValueElement.hpp>
54 #include <lifev/eta/expression/EvaluateAtQuadraturePoint.hpp>
55 #include <lifev/eta/expression/ComputeFineScaleVelocity.hpp>
56 #include <lifev/eta/expression/ComputeFineScalePressure.hpp>
57 
58 //Integration over portions of the domain
59 #include <lifev/eta/expression/IntegrateMatrixVolumeID.hpp>
60 #include <lifev/eta/expression/IntegrateVectorVolumeID.hpp>
61 #include <lifev/eta/expression/IntegrateVectorFaceID.hpp>
62 #include <lifev/eta/expression/IntegrateMatrixFaceID.hpp>
63 
64 #include <lifev/eta/expression/IntegrateValueElementLSAdapted.hpp>
65 #include <lifev/eta/expression/IntegrateVectorElementLSAdapted.hpp>
66 #include <lifev/eta/expression/IntegrateMatrixElementLSAdapted.hpp>
67 
68 #include <lifev/eta/expression/IntegrateMatrixFaceIDLSAdapted.hpp>
69 #include <lifev/eta/expression/IntegrateVectorFaceIDLSAdapted.hpp>
70 
71 namespace LifeV
72 {
73 
74 /*!
75  \namespace ExpressionAssembly
76 
77  Namespace for the assembly via expressions
78 
79  */
80 namespace ExpressionAssembly
81 {
82 
83 //! Integrate function for matricial expressions
84 /*!
85  @author Samuel Quinodoz <samuel.quinodoz@epfl.ch>
86 
87  This class is an helper function to instantiate the class
88  for performing an integration, here to assemble a matrix
89  with a loop on the elements.
90 
91  This function is repeated 4 times:
92  versions with and without QR adapter
93  versions with and without Offset
94 
95  */
96 template < typename MeshType, typename TestSpaceType, typename SolutionSpaceType, typename ExpressionType, typename QRAdapterType>
97 IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterType>
98 integrate ( const RequestLoopElement<MeshType>& request,
99  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
100  const std::shared_ptr<TestSpaceType>& testSpace,
101  const std::shared_ptr<SolutionSpaceType>& solutionSpace,
102  const ExpressionType& expression,
103  const UInt offsetUp = 0,
104  const UInt offsetLeft = 0);
105 template < typename MeshType, typename TestSpaceType, typename SolutionSpaceType, typename ExpressionType, typename QRAdapterType>
106 IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterType>
107 integrate ( const RequestLoopElement<MeshType>& request,
108  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
109  const std::shared_ptr<TestSpaceType>& testSpace,
110  const std::shared_ptr<SolutionSpaceType>& solutionSpace,
111  const ExpressionType& expression,
112  const UInt offsetUp,
113  const UInt offsetLeft)
114 {
115  return IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterType>
116  ( request.mesh(), qrAdapterBase.implementation(), testSpace,
117  solutionSpace, expression, offsetUp, offsetLeft,
118  request.numVolumes(), request.regionFlag(), request.getElementsRegionFlag(),
119  request.getIfSubDomain() );
120 }
121 
122 template < typename MeshType, typename TestSpaceType, typename SolutionSpaceType, typename ExpressionType>
123 IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterNeverAdapt>
124 integrate ( const RequestLoopElement<MeshType>& request,
125  const QuadratureRule& quadrature,
126  const std::shared_ptr<TestSpaceType>& testSpace,
127  const std::shared_ptr<SolutionSpaceType>& solutionSpace,
128  const ExpressionType& expression,
129  const UInt offsetUp = 0,
130  const UInt offsetLeft = 0);
131 template < typename MeshType, typename TestSpaceType, typename SolutionSpaceType, typename ExpressionType>
132 IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterNeverAdapt>
133 integrate ( const RequestLoopElement<MeshType>& request,
134  const QuadratureRule& quadrature,
135  const std::shared_ptr<TestSpaceType>& testSpace,
136  const std::shared_ptr<SolutionSpaceType>& solutionSpace,
137  const ExpressionType& expression,
138  const UInt offsetUp,
139  const UInt offsetLeft)
140 {
141  return IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterNeverAdapt>
142  ( request.mesh(), QRAdapterNeverAdapt (quadrature),
143  testSpace, solutionSpace, expression, offsetUp, offsetLeft, request.regionFlag(),
144  request.numVolumes(), request.getElementsRegionFlag(), request.getIfSubDomain() );
145 }
146 
147 //! Integrate function for matricial expressions (multi-threaded path)
148 /*!
149  @author Samuel Quinodoz <samuel.quinodoz@epfl.ch>
150 
151  This class is an helper function to instantiate the class
152  for performing an integration, here to assemble a matrix
153  with a loop on the elements.
154 
155  This is an overload of the integrate function for matrices, which
156  uses multiple threads to do assembly
157 
158  This function is repeated 4 times:
159  versions with and without QR adapter
160  versions with and without Offset
161 
162  */
163 template < typename MeshType, typename TestSpaceType, typename SolutionSpaceType, typename ExpressionType, typename QRAdapterType>
164 IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterType>
165 integrate ( const RequestLoopElement<MeshType>& request,
166  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
167  const std::shared_ptr<TestSpaceType>& testSpace,
168  const std::shared_ptr<SolutionSpaceType>& solutionSpace,
169  const ExpressionType& expression,
170  const OpenMPParameters& ompParams,
171  const UInt offsetUp = 0,
172  const UInt offsetLeft = 0);
173 template < typename MeshType, typename TestSpaceType, typename SolutionSpaceType, typename ExpressionType, typename QRAdapterType>
174 IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterType>
175 integrate ( const RequestLoopElement<MeshType>& request,
176  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
177  const std::shared_ptr<TestSpaceType>& testSpace,
178  const std::shared_ptr<SolutionSpaceType>& solutionSpace,
179  const ExpressionType& expression,
180  const OpenMPParameters& ompParams,
181  const UInt offsetUp,
182  const UInt offsetLeft)
183 {
184  return IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterNeverAdapt>
185  (request.mesh(), qrAdapterBase.implementation(), testSpace, solutionSpace, expression,
186  ompParams, offsetUp, offsetLeft, request.regionFlag(), request.numVolumes(), request.getElementsRegionFlag(),
187  request.getIfSubDomain() );
188 }
189 template < typename MeshType, typename TestSpaceType, typename SolutionSpaceType, typename ExpressionType>
190 IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterNeverAdapt>
191 integrate ( const RequestLoopElement<MeshType>& request,
192  const QuadratureRule& quadrature,
193  const std::shared_ptr<TestSpaceType>& testSpace,
194  const std::shared_ptr<SolutionSpaceType>& solutionSpace,
195  const ExpressionType& expression,
196  const OpenMPParameters& ompParams,
197  const UInt offsetUp = 0,
198  const UInt offsetLeft = 0);
199 template < typename MeshType, typename TestSpaceType, typename SolutionSpaceType, typename ExpressionType>
200 IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterNeverAdapt>
201 integrate ( const RequestLoopElement<MeshType>& request,
202  const QuadratureRule& quadrature,
203  const std::shared_ptr<TestSpaceType>& testSpace,
204  const std::shared_ptr<SolutionSpaceType>& solutionSpace,
205  const ExpressionType& expression,
206  const OpenMPParameters& ompParams,
207  const UInt offsetUp,
208  const UInt offsetLeft)
209 {
210  return IntegrateMatrixElement<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterNeverAdapt>
211  (request.mesh(), QRAdapterNeverAdapt (quadrature), testSpace, solutionSpace, expression,
212  ompParams, offsetUp, offsetLeft, request.regionFlag(), request.numVolumes(), request.getElementsRegionFlag(),
213  request.getIfSubDomain() );
214 }
215 
216 
217 
218 //! Integrate function for vectorial expressions
219 /*!
220  @author Samuel Quinodoz <samuel.quinodoz@epfl.ch>
221 
222  This class is an helper function to instantiate the class
223  for performing an integration, here to assemble a vector
224  with a loop on the elements.
225 
226  This function is repeated 4 times:
227  versions with and without QR adapter
228  versions with and without Offset
229 
230  */
231 template < typename MeshType, typename TestSpaceType, typename ExpressionType, typename QRAdapterType>
232 IntegrateVectorElement<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
233 integrate ( const RequestLoopElement<MeshType>& request,
234  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
235  const std::shared_ptr<TestSpaceType>& testSpace,
236  const ExpressionType& expression,
237  const UInt offset = 0);
238 template < typename MeshType, typename TestSpaceType, typename ExpressionType, typename QRAdapterType>
239 IntegrateVectorElement<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
240 integrate ( const RequestLoopElement<MeshType>& request,
241  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
242  const std::shared_ptr<TestSpaceType>& testSpace,
243  const ExpressionType& expression,
244  const UInt offset)
245 {
246  return IntegrateVectorElement<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
247  (request.mesh(), qrAdapterBase.implementation(), testSpace, expression, offset);
248 }
249 
250 template < typename MeshType, typename TestSpaceType, typename ExpressionType>
251 IntegrateVectorElement<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
252 integrate ( const RequestLoopElement<MeshType>& request,
253  const QuadratureRule& quadrature,
254  const std::shared_ptr<TestSpaceType>& testSpace,
255  const ExpressionType& expression,
256  const UInt offset = 0);
257 template < typename MeshType, typename TestSpaceType, typename ExpressionType>
258 IntegrateVectorElement<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
259 integrate ( const RequestLoopElement<MeshType>& request,
260  const QuadratureRule& quadrature,
261  const std::shared_ptr<TestSpaceType>& testSpace,
262  const ExpressionType& expression,
263  const UInt offset)
264 {
265  return IntegrateVectorElement<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
266  (request.mesh(), QRAdapterNeverAdapt (quadrature), testSpace, expression, offset);
267 }
268 
269 //! Compute stress function for vectorial expressions
270 /*!
271  @author Samuel Quinodoz <samuel.quinodoz@epfl.ch>
272 
273  This class is an helper function to instantiate the class
274  for performing an integration, here to assemble a vector
275  with a loop on the elements.
276 
277  This function is repeated 4 times:
278  versions with and without QR adapter
279  versions with and without Offset
280 
281  */
282 template < typename MeshType, typename TestSpaceType, typename ExpressionType, typename QRAdapterType>
283 ComputeFineScaleVelocity<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
284 ComputeFineScaleVel ( const RequestLoopElement<MeshType>& request,
285  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
286  const std::shared_ptr<TestSpaceType>& testSpace,
287  const ExpressionType& expression,
288  const UInt offset = 0);
289 template < typename MeshType, typename TestSpaceType, typename ExpressionType, typename QRAdapterType>
290 ComputeFineScaleVelocity<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
291 ComputeFineScaleVel ( const RequestLoopElement<MeshType>& request,
292  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
293  const std::shared_ptr<TestSpaceType>& testSpace,
294  const ExpressionType& expression,
295  const UInt offset)
296 {
297  return ComputeFineScaleVelocity<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
298  (request.mesh(), qrAdapterBase.implementation(), testSpace, expression, offset );
299 }
300 
301 template < typename MeshType, typename TestSpaceType, typename ExpressionType>
302 ComputeFineScaleVelocity<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
303 ComputeFineScaleVel ( const RequestLoopElement<MeshType>& request,
304  const QuadratureRule& quadrature,
305  const std::shared_ptr<TestSpaceType>& testSpace,
306  const ExpressionType& expression,
307  const UInt offset = 0);
308 template < typename MeshType, typename TestSpaceType, typename ExpressionType>
309 ComputeFineScaleVelocity<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
310 ComputeFineScaleVel ( const RequestLoopElement<MeshType>& request,
311  const QuadratureRule& quadrature,
312  const std::shared_ptr<TestSpaceType>& testSpace,
313  const ExpressionType& expression,
314  const UInt offset)
315 {
316  return ComputeFineScaleVelocity<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
317  (request.mesh(), QRAdapterNeverAdapt (quadrature), testSpace, expression, offset );
318 }
319 
320 //! Compute stress function for vectorial expressions
321 /*!
322  @author Samuel Quinodoz <samuel.quinodoz@epfl.ch>
323 
324  This class is an helper function to instantiate the class
325  for performing an integration, here to assemble a vector
326  with a loop on the elements.
327 
328  This function is repeated 4 times:
329  versions with and without QR adapter
330  versions with and without Offset
331 
332  */
333 template < typename MeshType, typename TestSpaceType, typename ExpressionType, typename QRAdapterType>
334 ComputeFineScalePressure<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
335 ComputeFineScalePres ( const RequestLoopElement<MeshType>& request,
336  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
337  const std::shared_ptr<TestSpaceType>& testSpace,
338  const ExpressionType& expression,
339  const UInt offset = 0);
340 template < typename MeshType, typename TestSpaceType, typename ExpressionType, typename QRAdapterType>
341 ComputeFineScalePressure<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
342 ComputeFineScalePres ( const RequestLoopElement<MeshType>& request,
343  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
344  const std::shared_ptr<TestSpaceType>& testSpace,
345  const ExpressionType& expression,
346  const UInt offset)
347 {
348  return ComputeFineScalePressure<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
349  (request.mesh(), qrAdapterBase.implementation(), testSpace, expression, offset );
350 }
351 
352 template < typename MeshType, typename TestSpaceType, typename ExpressionType>
353 ComputeFineScalePressure<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
354 ComputeFineScalePres ( const RequestLoopElement<MeshType>& request,
355  const QuadratureRule& quadrature,
356  const std::shared_ptr<TestSpaceType>& testSpace,
357  const ExpressionType& expression,
358  const UInt offset = 0);
359 template < typename MeshType, typename TestSpaceType, typename ExpressionType>
360 ComputeFineScalePressure<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
361 ComputeFineScalePres ( const RequestLoopElement<MeshType>& request,
362  const QuadratureRule& quadrature,
363  const std::shared_ptr<TestSpaceType>& testSpace,
364  const ExpressionType& expression,
365  const UInt offset)
366 {
367  return ComputeFineScalePressure<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
368  (request.mesh(), QRAdapterNeverAdapt (quadrature), testSpace, expression, offset );
369 }
370 
371 //! Integrate function for vectorial expressions
372 /*!
373  @author Davide Forti <davide.forti@epfl.ch>
374 
375  This class is an helper function to instantiate the class
376  for performing an integration, here to assemble a vector
377  with a loop on the elements.
378 
379  This function is repeated 4 times:
380  versions with and without QR adapter
381  versions with and without Offset
382 
383  */
384 template < typename MeshType, typename TestSpaceType, typename ExpressionType, typename QRAdapterType>
385 EvaluateAtQuadraturePoint<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
386 EvaluateAtQuadrature ( const RequestLoopElement<MeshType>& request,
387  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
388  const std::shared_ptr<TestSpaceType>& testSpace,
389  const ExpressionType& expression,
390  const UInt offset = 0);
391 template < typename MeshType, typename TestSpaceType, typename ExpressionType, typename QRAdapterType>
392 EvaluateAtQuadraturePoint<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
393 EvaluateAtQuadrature ( const RequestLoopElement<MeshType>& request,
394  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
395  const std::shared_ptr<TestSpaceType>& testSpace,
396  const ExpressionType& expression,
397  const UInt offset)
398 {
399  return EvaluateAtQuadraturePoint<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
400  (request.mesh(), qrAdapterBase.implementation(), testSpace, expression, offset);
401 }
402 
403 template < typename MeshType, typename TestSpaceType, typename ExpressionType>
404 EvaluateAtQuadraturePoint<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
405 EvaluateAtQuadrature ( const RequestLoopElement<MeshType>& request,
406  const QuadratureRule& quadrature,
407  const std::shared_ptr<TestSpaceType>& testSpace,
408  const ExpressionType& expression,
409  const UInt offset = 0);
410 template < typename MeshType, typename TestSpaceType, typename ExpressionType>
411 EvaluateAtQuadraturePoint<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
412 EvaluateAtQuadrature ( const RequestLoopElement<MeshType>& request,
413  const QuadratureRule& quadrature,
414  const std::shared_ptr<TestSpaceType>& testSpace,
415  const ExpressionType& expression,
416  const UInt offset)
417 {
418  return EvaluateAtQuadraturePoint<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
419  (request.mesh(), QRAdapterNeverAdapt (quadrature), testSpace, expression, offset);
420 }
421 
422 //! Integrate function for benchmark expressions
423 /*!
424  @author Samuel Quinodoz <samuel.quinodoz@epfl.ch>
425 
426  This class is an helper function to instantiate the class
427  for performing an integration, here to assemble a benchmark
428  with a loop on the elements.
429 
430  This function is repeated 2 times:
431  versions with and without QR adapter
432 
433  */
434 template < typename MeshType, typename ExpressionType, typename QRAdapterType>
435 IntegrateValueElement<MeshType, ExpressionType, QRAdapterType>
436 integrate ( const RequestLoopElement<MeshType>& request,
437  const QRAdapterBase<QRAdapterType>& qrAdapterBase,
438  const ExpressionType& expression)
439 {
440  return IntegrateValueElement<MeshType, ExpressionType, QRAdapterType>
441  (request.mesh(), qrAdapterBase.implementation(), expression);
442 }
443 
444 template < typename MeshType, typename ExpressionType>
445 IntegrateValueElement<MeshType, ExpressionType, QRAdapterNeverAdapt>
446 integrate ( const RequestLoopElement<MeshType>& request,
447  const QuadratureRule& quadrature,
448  const ExpressionType& expression)
449 {
450  return IntegrateValueElement<MeshType, ExpressionType, QRAdapterNeverAdapt>
451  (request.mesh(), QRAdapterNeverAdapt (quadrature), expression);
452 }
453 
454 // =============================================================
455 // Methods to integrate over a portion of the mesh
456 // =============================================================
457 template < typename MeshType, typename TestSpaceType, typename SolutionSpaceType, typename ExpressionType>
458 IntegrateMatrixVolumeID<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterNeverAdapt>
459 integrate ( const RequestLoopVolumeID<MeshType>& request,
460  const QuadratureRule& quadrature,
461  const std::shared_ptr<TestSpaceType>& testSpace,
462  const std::shared_ptr<SolutionSpaceType>& solutionSpace,
463  const ExpressionType& expression)
464 {
465  return IntegrateMatrixVolumeID<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterNeverAdapt>
466  (request.volumeList(), request.indexList(), QRAdapterNeverAdapt (quadrature), testSpace, solutionSpace, expression);
467 }
468 
469 template < typename MeshType, typename TestSpaceType, typename SolutionSpaceType, typename ExpressionType, typename QRAdapterType>
470 IntegrateMatrixVolumeID<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterType>
471 integrate ( const RequestLoopVolumeID<MeshType>& request,
472  const QRAdapterBase<QRAdapterType>& qrAdapter,
473  const std::shared_ptr<TestSpaceType>& testSpace,
474  const std::shared_ptr<SolutionSpaceType>& solutionSpace,
475  const ExpressionType& expression)
476 {
477  return IntegrateMatrixVolumeID<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, QRAdapterType>
478  (request.volumeList(), request.indexList(), qrAdapter.implementation(), testSpace, solutionSpace, expression);
479 }
480 
481 template < typename MeshType, typename TestSpaceType, typename ExpressionType>
482 IntegrateVectorVolumeID<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt>
483 integrate ( const RequestLoopVolumeID<MeshType>& request,
484  const QuadratureRule& quadrature,
485  const std::shared_ptr<TestSpaceType>& testSpace,
486  const ExpressionType& expression)
487 {
488  return IntegrateVectorVolumeID<MeshType, TestSpaceType, ExpressionType, QRAdapterNeverAdapt> (request.volumeList(), request.indexList(), QRAdapterNeverAdapt (quadrature), testSpace, expression);
489 }
490 
491 template < typename MeshType, typename TestSpaceType, typename ExpressionType, typename QRAdapterType>
492 IntegrateVectorVolumeID<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
493 integrate ( const RequestLoopVolumeID<MeshType>& request,
494  const QRAdapterBase<QRAdapterType>& qrAdapter,
495  const std::shared_ptr<TestSpaceType>& testSpace,
496  const ExpressionType& expression)
497 {
498  return IntegrateVectorVolumeID<MeshType, TestSpaceType, ExpressionType, QRAdapterType>
499  (request.volumeList(), request.indexList(), qrAdapter.implementation(), testSpace, expression);
500 }
501 
502 /* Integration on the boundary of the domain */
503 
504 
505 template < typename MeshType, typename TestSpaceType, typename ExpressionType>
506 IntegrateVectorFaceID<MeshType, TestSpaceType, ExpressionType>
507 integrate ( const RequestLoopFaceID<MeshType>& request,
508  const QuadratureBoundary& quadratureBoundary,
509  const std::shared_ptr<TestSpaceType>& testSpace,
510  const ExpressionType& expression)
511 {
512  return IntegrateVectorFaceID<MeshType, TestSpaceType, ExpressionType>
513  (request.mesh(), request.id(), quadratureBoundary, testSpace, expression);
514 }
515 
516 
517 template < typename MeshType, typename TestSpaceType, typename SolutionSpaceType, typename ExpressionType>
518 IntegrateMatrixFaceID<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType>
519 integrate ( const RequestLoopFaceID<MeshType>& request,
520  const QuadratureBoundary& quadratureBoundary,
521  const std::shared_ptr<TestSpaceType> testSpace,
522  const std::shared_ptr<SolutionSpaceType> solutionSpace,
523  const ExpressionType& expression)
524 {
525  return IntegrateMatrixFaceID<MeshType, TestSpaceType, SolutionSpaceType, ExpressionType>
526  (request.mesh(), request.id(), quadratureBoundary, testSpace, solutionSpace, expression);
527 }
528 
529 
530 template < typename MeshType,
531  typename TestSpaceType,
532  typename SolutionSpaceType,
533  typename ExpressionType,
534  typename LSFESpaceType,
535  typename LSVectorType >
536 IntegrateMatrixFaceIDLSAdapted < MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, LSFESpaceType, LSVectorType>
537 integrate (const RequestLoopFaceID<MeshType>& request,
538  const LevelSetBDQRAdapter<LSFESpaceType, LSVectorType>& quadratureAdapter,
539  const std::shared_ptr<TestSpaceType> testSpace,
540  const std::shared_ptr<SolutionSpaceType> solutionSpace,
541  const ExpressionType& expression)
542 {
543  return IntegrateMatrixFaceIDLSAdapted < MeshType, TestSpaceType, SolutionSpaceType, ExpressionType, LSFESpaceType, LSVectorType> (request.mesh(), request.id(), quadratureAdapter, testSpace, solutionSpace, expression);
544 }
545 
546 template < typename MeshType,
547  typename TestSpaceType,
548  typename ExpressionType,
549  typename LSFESpaceType,
550  typename LSVectorType >
551 IntegrateVectorFaceIDLSAdapted < MeshType, TestSpaceType, ExpressionType, LSFESpaceType, LSVectorType>
552 integrate (const RequestLoopFaceID<MeshType>& request,
553  const LevelSetBDQRAdapter<LSFESpaceType, LSVectorType>& quadratureAdapter,
554  const std::shared_ptr<TestSpaceType> testSpace,
555  const ExpressionType& expression)
556 {
557  return IntegrateVectorFaceIDLSAdapted < MeshType, TestSpaceType, ExpressionType, LSFESpaceType, LSVectorType> (request.mesh(), request.id(), quadratureAdapter, testSpace, expression);
558 }
559 
560 
561 
562 } // Namespace ExpressionAssembly
563 
564 } // Namespace LifeV
565 #endif