dataAnalysisWrapper2D.h

00001 /* This file is part of the Palabos library.
00002  *
00003  * Copyright (C) 2011 FlowKit Sarl
00004  * Avenue de Chailly 23
00005  * 1012 Lausanne, Switzerland
00006  * E-mail contact: contact@flowkit.com
00007  *
00008  * The most recent release of Palabos can be downloaded at 
00009  * <http://www.palabos.org/>
00010  *
00011  * The library Palabos is free software: you can redistribute it and/or
00012  * modify it under the terms of the GNU Affero General Public License as
00013  * published by the Free Software Foundation, either version 3 of the
00014  * License, or (at your option) any later version.
00015  *
00016  * The library is distributed in the hope that it will be useful,
00017  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00018  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019  * GNU Affero General Public License for more details.
00020  *
00021  * You should have received a copy of the GNU Affero General Public License
00022  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
00023 */
00024 
00028 #ifndef DATA_ANALYSIS_WRAPPER_2D_H
00029 #define DATA_ANALYSIS_WRAPPER_2D_H
00030 
00031 #include "core/globalDefs.h"
00032 #include "atomicBlock/blockLattice2D.h"
00033 #include "atomicBlock/dataField2D.h"
00034 #include "multiBlock/multiBlockLattice2D.h"
00035 #include "multiBlock/multiDataField2D.h"
00036 #include "dataProcessors/dataAnalysisFunctional2D.h"
00037 #include <memory>
00038 
00039 
00040 namespace plb {
00041 
00042 /* ******************************************************************* */
00043 /* *************** PART I. Atomic-block wrappers: Block-Lattice ****** */
00044 /* ******************************************************************* */
00045 
00046 /* *************** Reductive operations ****************************** */
00047 
00048 template<typename T, template<typename U> class Descriptor> 
00049 T computeAverageDensity(BlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00050 
00051 template<typename T, template<typename U> class Descriptor> 
00052 T computeAverageDensity(BlockLattice2D<T,Descriptor>& lattice);
00053 
00054 
00055 template<typename T, template<typename U> class Descriptor> 
00056 T computeAverageRhoBar(BlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00057 
00058 template<typename T, template<typename U> class Descriptor> 
00059 T computeAverageRhoBar(BlockLattice2D<T,Descriptor>& lattice);
00060 
00061 
00062 template<typename T, template<typename U> class Descriptor> 
00063 T computeAverageEnergy(BlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00064 
00065 template<typename T, template<typename U> class Descriptor> 
00066 T computeAverageEnergy(BlockLattice2D<T,Descriptor>& lattice);
00067 
00068 
00069 template<typename T, template<typename U> class Descriptor, class BoolMask> 
00070 plint count(BlockLattice2D<T,Descriptor>& lattice, Box2D domain, BoolMask boolMask);
00071 
00072 template<typename T, template<typename U> class Descriptor, class BoolMask> 
00073 plint count(BlockLattice2D<T,Descriptor>& lattice, BoolMask boolMask);
00074 
00075 /* *************** Density ******************************************* */
00076 
00077 template<typename T, template<typename U> class Descriptor>
00078 void computeDensity(BlockLattice2D<T,Descriptor>& lattice, ScalarField2D<T>& density);
00079 
00080 template<typename T, template<typename U> class Descriptor>
00081 std::auto_ptr<ScalarField2D<T> > computeDensity(BlockLattice2D<T,Descriptor>& lattice);
00082 
00083 
00084 /* *************** RhoBar ******************************************** */
00085 
00086 template<typename T, template<typename U> class Descriptor>
00087 void computeRhoBar(BlockLattice2D<T,Descriptor>& lattice, ScalarField2D<T>& rhoBar);
00088 
00089 template<typename T, template<typename U> class Descriptor>
00090 std::auto_ptr<ScalarField2D<T> > computeRhoBar(BlockLattice2D<T,Descriptor>& lattice);
00091 
00092 
00093 /* *************** Kinetic Energy ************************************ */
00094 
00095 template<typename T, template<typename U> class Descriptor>
00096 void computeKineticEnergy(BlockLattice2D<T,Descriptor>& lattice, ScalarField2D<T>& energy);
00097 
00098 template<typename T, template<typename U> class Descriptor>
00099 std::auto_ptr<ScalarField2D<T> > computeKineticEnergy(BlockLattice2D<T,Descriptor>& lattice);
00100 
00101 
00102 /* *************** Velocity Norm ************************************* */
00103 
00104 template<typename T, template<typename U> class Descriptor>
00105 void computeVelocityNorm(BlockLattice2D<T,Descriptor>& lattice, ScalarField2D<T>& velocityNorm);
00106 
00107 template<typename T, template<typename U> class Descriptor>
00108 std::auto_ptr<ScalarField2D<T> > computeVelocityNorm(BlockLattice2D<T,Descriptor>& lattice);
00109 
00110 
00111 /* *************** Velocity Component ************************************ */
00112 
00113 template<typename T, template<typename U> class Descriptor>
00114 void computeVelocityComponent(BlockLattice2D<T,Descriptor>& lattice,
00115                               ScalarField2D<T>& velocityComponent,
00116                               plint iComponent);
00117 
00118 template<typename T, template<typename U> class Descriptor>
00119 std::auto_ptr<ScalarField2D<T> > computeVelocityComponent(BlockLattice2D<T,Descriptor>& lattice, plint iComponent);
00120 
00121 
00122 /* *************** Velocity ****************************************** */
00123 
00124 template<typename T, template<typename U> class Descriptor>
00125 void computeVelocity(BlockLattice2D<T,Descriptor>& lattice,
00126                      TensorField2D<T,Descriptor<T>::d>& velocity);
00127 
00128 template<typename T, template<typename U> class Descriptor>
00129 std::auto_ptr<TensorField2D<T,Descriptor<T>::d> >
00130     computeVelocity(BlockLattice2D<T,Descriptor>& lattice);
00131 
00132 
00133 /* *************** Deviatoric Stress ********************************* */
00134 
00135 template<typename T, template<typename U> class Descriptor>
00136 void computeDeviatoricStress(BlockLattice2D<T,Descriptor>& lattice,
00137                              TensorField2D<T,SymmetricTensor<T,Descriptor>::n>& PiNeq);
00138 
00139 template<typename T, template<typename U> class Descriptor>
00140 std::auto_ptr<TensorField2D<T,SymmetricTensor<T,Descriptor>::n> >
00141     computeDeviatoricStress(BlockLattice2D<T,Descriptor>& lattice);
00142 
00143 
00144 /* *************** Strain Rate from Stress *************************** */
00145 
00146 template<typename T, template<typename U> class Descriptor>
00147 void computeStrainRateFromStress(BlockLattice2D<T,Descriptor>& lattice,
00148                                  TensorField2D<T,SymmetricTensor<T,Descriptor>::n>& S);
00149 
00150 template<typename T, template<typename U> class Descriptor>
00151 std::auto_ptr<TensorField2D<T,SymmetricTensor<T,Descriptor>::n> >
00152     computeStrainRateFromStress(BlockLattice2D<T,Descriptor>& lattice);
00153     
00154 /* *************** Temperature ******************************************* */
00155 
00156 template<typename T, template<typename U> class Descriptor>
00157 void computeTemperature(BlockLattice2D<T,Descriptor>& lattice, ScalarField2D<T>& temperature);
00158 
00159 template<typename T, template<typename U> class Descriptor>
00160 std::auto_ptr<ScalarField2D<T> > computeTemperature(BlockLattice2D<T,Descriptor>& lattice);
00161 
00162 /* *************** SoundSpeed ******************************************* */
00163 
00164 template<typename T, template<typename U> class Descriptor>
00165 void computeSoundSpeed(BlockLattice2D<T,Descriptor>& lattice, ScalarField2D<T>& soundSpeed);
00166 
00167 template<typename T, template<typename U> class Descriptor>
00168 std::auto_ptr<ScalarField2D<T> > computeSoundSpeed(BlockLattice2D<T,Descriptor>& lattice);
00169 
00170 
00171 /* *************** Population **************************************** */
00172 
00173 template<typename T, template<typename U> class Descriptor>
00174 void computePopulation(BlockLattice2D<T,Descriptor>& lattice,
00175                        ScalarField2D<T>& population, plint iPop );
00176 
00177 template<typename T, template<typename U> class Descriptor>
00178 std::auto_ptr<ScalarField2D<T> >
00179     computePopulation(BlockLattice2D<T,Descriptor>& lattice, plint iPop);
00180     
00181 template<typename T, template<typename U> class Descriptor>
00182 void computeAllPopulations(BlockLattice2D<T,Descriptor>& lattice,
00183                            TensorField2D<T,Descriptor<T>::q>& populations);
00184 
00185 template<typename T, template<typename U> class Descriptor>
00186 std::auto_ptr<TensorField2D<T,Descriptor<T>::q> >
00187     computeAllPopulations(BlockLattice2D<T,Descriptor>& lattice);
00188     
00189 template<typename T, template<typename U> class Descriptor>
00190 void copyPopulations( BlockLattice2D<T,Descriptor>& latticeFrom,
00191                       BlockLattice2D<T,Descriptor>& latticeTo,
00192                       Box2D domain);
00193 
00194 /* ******************************************************************* */
00195 /* *************** PART II. Atomic-block wrappers: Scalar-Field ****** */
00196 /* ******************************************************************* */
00197 
00198 /* *************** Reductive functions ******************************* */
00199 
00200 template<typename T>
00201 T computeSum(ScalarField2D<T>& scalarField, Box2D domain);
00202 
00203 template<typename T>
00204 T computeSum(ScalarField2D<T>& scalarField);
00205 
00206 template<typename T>
00207 T computeAverage(ScalarField2D<T>& scalarField, Box2D domain);
00208 
00209 template<typename T>
00210 T computeAverage(ScalarField2D<T>& scalarField);
00211 
00212 
00213 template<typename T>
00214 T computeAverage(ScalarField2D<T>& scalarField, ScalarField2D<int>& mask, int flag, Box2D domain);
00215 
00216 template<typename T>
00217 T computeAverage(ScalarField2D<T>& scalarField, ScalarField2D<int>& mask, int flag);
00218 
00219 
00220 template<typename T>
00221 T computeMin(ScalarField2D<T>& scalarField, Box2D domain);
00222 
00223 template<typename T>
00224 T computeMin(ScalarField2D<T>& scalarField);
00225 
00226 
00227 template<typename T>
00228 T computeMax(ScalarField2D<T>& scalarField, Box2D domain);
00229 
00230 template<typename T>
00231 T computeMax(ScalarField2D<T>& scalarField);
00232 
00233 
00234 template<typename T>
00235 T computeBoundedAverage(ScalarField2D<T>& scalarField, Box2D domain);
00236 
00237 template<typename T>
00238 T computeBoundedAverage(ScalarField2D<T>& scalarField);
00239 
00240 
00241 template<typename T, class BoolMask> 
00242 plint count(ScalarField2D<T>& field, Box2D domain, BoolMask boolMask);
00243 
00244 template<typename T, class BoolMask> 
00245 plint count(ScalarField2D<T>& field, BoolMask boolMask);
00246 
00247 /* *************** Generic operations *************** */
00248 
00249 template<typename T, class Function>
00250 void apply(Function f, ScalarField2D<T>& field) {
00251     applyProcessingFunctional (
00252             new ApplyScalarFunctional2D<T,Function>(f), field.getBoundingBox(), field);
00253 }
00254 
00255 template<typename T, class Function>
00256 void evaluate(Function f, ScalarField2D<T>& field, ScalarField2D<T>& result) {
00257     applyProcessingFunctional (
00258             new EvaluateScalarFunctional2D<T,Function>(f), field.getBoundingBox(), field, result);
00259 }
00260 
00261 template<typename T, class Function>
00262 std::auto_ptr<ScalarField2D<T> > evaluate(Function f, ScalarField2D<T>& field) {
00263     ScalarField2D<T>* result = new ScalarField2D<T>(field.getNx(), field.getNy());
00264     evaluate(f, field, result);
00265     return std::auto_ptr<ScalarField2D<T> >(result);
00266 }
00267 
00268 
00269 /* *************** ScalarField - Scalar operations *************** */
00270 
00271 template<typename T>
00272 void add(T scalar, ScalarField2D<T>& field, ScalarField2D<T>& result);
00273 
00274 template<typename T>
00275 std::auto_ptr<ScalarField2D<T> > add(T scalar, ScalarField2D<T>& field);
00276 
00277 
00278 template<typename T>
00279 void add(ScalarField2D<T>& field, T scalar, ScalarField2D<T>& result);
00280 
00281 template<typename T>
00282 std::auto_ptr<ScalarField2D<T> > add(ScalarField2D<T>& field, T scalar);
00283 
00284 
00285 template<typename T>
00286 void subtract(T scalar, ScalarField2D<T>& field, ScalarField2D<T>& result);
00287 
00288 template<typename T>
00289 std::auto_ptr<ScalarField2D<T> > subtract(T scalar, ScalarField2D<T>& field);
00290 
00291 
00292 template<typename T>
00293 void subtract(ScalarField2D<T>& field, T scalar, ScalarField2D<T>& result);
00294 
00295 template<typename T>
00296 std::auto_ptr<ScalarField2D<T> > subtract(ScalarField2D<T>& field, T scalar);
00297 
00298 
00299 template<typename T>
00300 void multiply(T scalar, ScalarField2D<T>& field, ScalarField2D<T>& result);
00301 
00302 template<typename T>
00303 std::auto_ptr<ScalarField2D<T> > multiply(T scalar, ScalarField2D<T>& field);
00304 
00305 
00306 template<typename T>
00307 void multiply(ScalarField2D<T>& field, T scalar, ScalarField2D<T>& result);
00308 
00309 template<typename T>
00310 std::auto_ptr<ScalarField2D<T> > multiply(ScalarField2D<T>& field, T scalar);
00311 
00312 
00313 template<typename T>
00314 void divide(T scalar, ScalarField2D<T>& field, ScalarField2D<T>& result);
00315 
00316 template<typename T>
00317 std::auto_ptr<ScalarField2D<T> > divide(T scalar, ScalarField2D<T>& field);
00318 
00319 
00320 template<typename T>
00321 void divide(ScalarField2D<T>& field, T scalar, ScalarField2D<T>& result);
00322 
00323 template<typename T>
00324 std::auto_ptr<ScalarField2D<T> > divide(ScalarField2D<T>& field, T scalar);
00325 
00326 /* *************** ScalarField operations *************** */
00327 
00328 template<typename T>
00329 void computeSqrt(ScalarField2D<T>& field, ScalarField2D<T>& result, Box2D domain);
00330 
00331 template<typename T>
00332 std::auto_ptr<ScalarField2D<T> > computeSqrt(ScalarField2D<T>& field, Box2D domain);
00333 
00334 template<typename T>
00335 std::auto_ptr<ScalarField2D<T> > computeSqrt(ScalarField2D<T>& field);
00336 
00337 template<typename T>
00338 void computeAbsoluteValue(ScalarField2D<T>& field, ScalarField2D<T>& result, Box2D domain);
00339 
00340 template<typename T>
00341 std::auto_ptr<ScalarField2D<T> > computeAbsoluteValue(ScalarField2D<T>& field, Box2D domain);
00342 
00343 template<typename T>
00344 std::auto_ptr<ScalarField2D<T> > computeAbsoluteValue(ScalarField2D<T>& field);
00345 
00346 
00347 
00348 /* *************** ScalarField - Scalar inplace operations *************** */
00349 
00350 template<typename T>
00351 void addInPlace(ScalarField2D<T>& field, T scalar);
00352 
00353 template<typename T>
00354 void subtractInPlace(ScalarField2D<T>& field, T scalar);
00355 
00356 template<typename T>
00357 void multiplyInPlace(ScalarField2D<T>& field, T scalar);
00358 
00359 template<typename T>
00360 void divideInPlace(ScalarField2D<T>& field, T scalar);
00361 
00362 
00363 
00364 /* *************** ScalarField - ScalarField operations *************** */
00365 
00366 template<typename T1, typename T2>
00367 void copy( ScalarField2D<T1>& field,
00368            ScalarField2D<T2>& convertedField );
00369 
00370 template<typename T1, typename T2>
00371 std::auto_ptr<ScalarField2D<T2> > copyConvert(ScalarField2D<T1>& field);
00372 
00373 
00374 template<typename T>
00375 void add(ScalarField2D<T>& A, ScalarField2D<T>& B, ScalarField2D<T>& result);
00376 
00377 template<typename T>
00378 std::auto_ptr<ScalarField2D<T> > add(ScalarField2D<T>& A, ScalarField2D<T>& B);
00379 
00380 
00381 template<typename T>
00382 void subtract(ScalarField2D<T>& A, ScalarField2D<T>& B, ScalarField2D<T>& result);
00383 
00384 template<typename T>
00385 std::auto_ptr<ScalarField2D<T> > subtract(ScalarField2D<T>& A, ScalarField2D<T>& B);
00386 
00387 
00388 template<typename T>
00389 void multiply(ScalarField2D<T>& A, ScalarField2D<T>& B, ScalarField2D<T>& result);
00390 
00391 template<typename T>
00392 std::auto_ptr<ScalarField2D<T> > multiply(ScalarField2D<T>& A, ScalarField2D<T>& B);
00393 
00394 
00395 template<typename T>
00396 void divide(ScalarField2D<T>& A, ScalarField2D<T>& B, ScalarField2D<T>& result);
00397 
00398 template<typename T>
00399 std::auto_ptr<ScalarField2D<T> > divide(ScalarField2D<T>& A, ScalarField2D<T>& B);
00400 
00401 
00402 
00403 /* *************** ScalarField - ScalarField inplace operations *************** */
00404 
00405 template<typename T>
00406 void addInPlace(ScalarField2D<T>& A, ScalarField2D<T>& B);
00407 
00408 template<typename T>
00409 void subtractInPlace(ScalarField2D<T>& A, ScalarField2D<T>& B);
00410 
00411 template<typename T>
00412 void multiplyInPlace(ScalarField2D<T>& A, ScalarField2D<T>& B);
00413 
00414 template<typename T>
00415 void divideInPlace(ScalarField2D<T>& A, ScalarField2D<T>& B);
00416 
00417 
00418 /* ******************************************************************* */
00419 /* *************** PART III. Atomic-block wrappers: Tensor-field ***** */
00420 /* ******************************************************************* */
00421 
00422 /* *************** Reductive functions ********************************* */
00423 
00424 template<typename T, int nDim, class BoolMask> 
00425 plint count(TensorField2D<T,nDim>& field, Box2D domain, BoolMask boolMask);
00426 
00427 template<typename T, int nDim, class BoolMask> 
00428 plint count(TensorField2D<T,nDim>& field, BoolMask boolMask);
00429 
00430 /* *************** Component (scalar-field) out of a tensor-field ****** */
00431 
00432 template<typename T, int nDim>
00433 void extractComponent(TensorField2D<T,nDim>& tensorField, ScalarField2D<T>& component, int iComponent);
00434 
00435 template<typename T, int nDim>
00436 std::auto_ptr<ScalarField2D<T> > extractComponent(TensorField2D<T,nDim>& tensorField, int iComponent);
00437 
00438 
00439 /* *************** Copy-convert a tensor-field *************** */
00440 
00441 template<typename T1, typename T2, int nDim>
00442 void copy( TensorField2D<T1,nDim>& field,
00443            TensorField2D<T2,nDim>& convertedField );
00444 
00445 template<typename T1, typename T2, int nDim>
00446 std::auto_ptr<TensorField2D<T2,nDim> > copyConvert(TensorField2D<T1,nDim>& field);
00447 
00448 
00449 /* *************** Vector-norm of each cell in the field *************** */
00450 
00451 template<typename T, int nDim>
00452 void computeNorm(TensorField2D<T,nDim>& tensorField, ScalarField2D<T>& norm);
00453 
00454 template<typename T, int nDim>
00455 std::auto_ptr<ScalarField2D<T> > computeNorm(TensorField2D<T,nDim>& norm);
00456 
00457 
00458 /* *************** Squared vector-norm of each cell in the field ******** */
00459 
00460 template<typename T, int nDim>
00461 void computeNormSqr(TensorField2D<T,nDim>& tensorField, ScalarField2D<T>& normSqr);
00462 
00463 template<typename T, int nDim>
00464 std::auto_ptr<ScalarField2D<T> > computeNormSqr(TensorField2D<T,nDim>& normSqr);
00465 
00466 
00467 /* *************** Tensor-norm of each symmetric tensor of a field ***** */
00468 
00469 template<typename T>
00470 void computeSymmetricTensorNorm(TensorField2D<T,3>& tensorField, ScalarField2D<T>& norm);
00471 
00472 template<typename T>
00473 std::auto_ptr<ScalarField2D<T> > computeSymmetricTensorNorm(TensorField2D<T,3>& norm);
00474 
00475 
00476 /* *************** Squared Tensor-norm of each symmetric tensor of a field*/
00477 
00478 template<typename T>
00479 void computeSymmetricTensorNormSqr(TensorField2D<T,3>& tensorField, ScalarField2D<T>& normSqr);
00480 
00481 template<typename T>
00482 std::auto_ptr<ScalarField2D<T> > computeSymmetricTensorNormSqr(TensorField2D<T,3>& normSqr);
00483 
00484 
00485 /* *************** Trace of each symmetric tensor of a field ************ */
00486 
00487 template<typename T>
00488 void computeSymmetricTensorTrace(TensorField2D<T,3>& tensorField, ScalarField2D<T>& trace);
00489 
00490 template<typename T>
00491 std::auto_ptr<ScalarField2D<T> > computeSymmetricTensorTrace(TensorField2D<T,3>& trace);
00492 
00493 
00494 /* *************** Vorticity from Velocity field *********************** */
00495 
00496 template<typename T>
00497 void computeVorticity(TensorField2D<T,2>& velocity, ScalarField2D<T>& vorticity);
00498 
00499 template<typename T>
00500 std::auto_ptr<ScalarField2D<T> > computeVorticity(TensorField2D<T,2>& velocity);
00501 
00502 
00503 /* *************** Vorticity, witout boundary treatment, from Velocity field  */
00504 
00505 template<typename T>
00506 void computeBulkVorticity(TensorField2D<T,2>& velocity, ScalarField2D<T>& vorticity);
00507 
00508 template<typename T>
00509 std::auto_ptr<ScalarField2D<T> > computeBulkVorticity(TensorField2D<T,2>& velocity);
00510 
00511 
00512 /* *************** Strain Rate from Velocity field ********************* */
00513 
00514 template<typename T>
00515 void computeStrainRate(TensorField2D<T,2>& velocity, TensorField2D<T,3>& S);
00516 
00517 template<typename T>
00518 std::auto_ptr<TensorField2D<T,3> > computeStrainRate(TensorField2D<T,2>& velocity);
00519 
00520 
00521 /* *************** Str. rate, witout boundary treatment, from Velocity field  */
00522 
00523 template<typename T>
00524 void computeBulkStrainRate(TensorField2D<T,2>& velocity, TensorField2D<T,3>& S);
00525 
00526 template<typename T>
00527 std::auto_ptr<TensorField2D<T,3> > computeBulkStrainRate(TensorField2D<T,2>& velocity);
00528 
00529 
00530 /* *************** TensorField - TensorField operations *************** */
00531 
00532 template<typename T, int nDim>
00533 void add(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B, TensorField2D<T,nDim>& result);
00534 
00535 template<typename T, int nDim>
00536 std::auto_ptr<TensorField2D<T,nDim> > add(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B);
00537 
00538 
00539 template<typename T, int nDim>
00540 void subtract(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B, TensorField2D<T,nDim>& result);
00541 
00542 template<typename T, int nDim>
00543 std::auto_ptr<TensorField2D<T,nDim> > subtract(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B);
00544 
00545 
00546 template<typename T, int nDim>
00547 void multiply(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B, TensorField2D<T,nDim>& result);
00548 
00549 template<typename T, int nDim>
00550 std::auto_ptr<TensorField2D<T,nDim> > multiply(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B);
00551 
00552 template<typename T, int nDim>
00553 void multiply(T scalar, TensorField2D<T,nDim>& field, TensorField2D<T,nDim>& result, Box2D domain);
00554 
00555 template<typename T, int nDim>
00556 std::auto_ptr<TensorField2D<T,nDim> > multiply(T scalar, TensorField2D<T,nDim>& field);
00557 
00558 
00559 template<typename T, int nDim>
00560 void multiply(TensorField2D<T,nDim>& field, T scalar, TensorField2D<T,nDim>& result, Box2D domain);
00561 
00562 template<typename T, int nDim>
00563 std::auto_ptr<TensorField2D<T,nDim> > multiply(TensorField2D<T,nDim>& field, T scalar);
00564 
00565 
00566 template<typename T, int nDim>
00567 void divide(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B, TensorField2D<T,nDim>& result);
00568 
00569 template<typename T, int nDim>
00570 std::auto_ptr<TensorField2D<T,nDim> > divide(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B);
00571 
00572 
00573 
00574 /* *************** TensorField - TensorField inplace operations *************** */
00575 
00576 template<typename T, int nDim>
00577 void addInPlace(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B);
00578 
00579 template<typename T, int nDim>
00580 void subtractInPlace(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B);
00581 
00582 template<typename T, int nDim>
00583 void multiplyInPlace(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B);
00584 
00585 template<typename T, int nDim>
00586 void multiplyInPlace(TensorField2D<T,nDim>& A, T alpha);
00587 
00588 template<typename T, int nDim>
00589 void divideInPlace(TensorField2D<T,nDim>& A, TensorField2D<T,nDim>& B);
00590 
00591 
00592 /* ******************************************************************* */
00593 /* *************** PART IV : Multi-block wrappers: Block-Lattice ***** */
00594 /* ******************************************************************* */
00595 
00596 /* *************** Reductive functions ******************************* */
00597 
00598 template<typename T, template<typename U> class Descriptor> 
00599 T computeAverageDensity(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00600 
00601 template<typename T, template<typename U> class Descriptor> 
00602 T computeAverageDensity(MultiBlockLattice2D<T,Descriptor>& lattice);
00603 
00604 
00605 template<typename T, template<typename U> class Descriptor> 
00606 T computeAverageRhoBar(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00607 
00608 template<typename T, template<typename U> class Descriptor> 
00609 T computeAverageRhoBar(MultiBlockLattice2D<T,Descriptor>& lattice);
00610 
00611 
00612 template<typename T, template<typename U> class Descriptor> 
00613 T computeAverageEnergy(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00614 
00615 template<typename T, template<typename U> class Descriptor> 
00616 T computeAverageEnergy(MultiBlockLattice2D<T,Descriptor>& lattice);
00617 
00618 
00619 template<typename T, template<typename U> class Descriptor, class BoolMask> 
00620 plint count(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain, BoolMask boolMask);
00621 
00622 template<typename T, template<typename U> class Descriptor, class BoolMask> 
00623 plint count(MultiBlockLattice2D<T,Descriptor>& lattice, BoolMask boolMask);
00624 
00625 
00626 /* *************** Extract Sub-Lattice ******************************* */
00627 
00628 template<typename T, template<typename U> class Descriptor>
00629 void extractSubDomain( MultiBlockLattice2D<T,Descriptor>& lattice,
00630                        MultiBlockLattice2D<T,Descriptor>& extractedLattice,
00631                        Box2D domain);
00632 
00633 template<typename T, template<typename U> class Descriptor>
00634 std::auto_ptr<MultiBlockLattice2D<T,Descriptor> > extractSubDomain(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00635 
00636 
00637 /* *************** Density ******************************************* */
00638 
00639 template<typename T, template<typename U> class Descriptor>
00640 void computeDensity(MultiBlockLattice2D<T,Descriptor>& lattice, MultiScalarField2D<T>& density, Box2D domain);
00641 
00642 template<typename T, template<typename U> class Descriptor>
00643 std::auto_ptr<MultiScalarField2D<T> > computeDensity(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00644 
00645 template<typename T, template<typename U> class Descriptor>
00646 std::auto_ptr<MultiScalarField2D<T> > computeDensity(MultiBlockLattice2D<T,Descriptor>& lattice);
00647 
00648 
00649 /* *************** RhoBar ******************************************** */
00650 
00651 template<typename T, template<typename U> class Descriptor>
00652 void computeRhoBar(MultiBlockLattice2D<T,Descriptor>& lattice, MultiScalarField2D<T>& rhoBar, Box2D domain);
00653 
00654 template<typename T, template<typename U> class Descriptor>
00655 std::auto_ptr<MultiScalarField2D<T> > computeRhoBar(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00656 
00657 template<typename T, template<typename U> class Descriptor>
00658 std::auto_ptr<MultiScalarField2D<T> > computeRhoBar(MultiBlockLattice2D<T,Descriptor>& lattice);
00659 
00660 
00661 /* *************** RhoBarJ ******************************************** */
00662 
00663 template<typename T, template<typename U> class Descriptor>
00664 void computeRhoBarJ( MultiBlockLattice2D<T,Descriptor>& lattice,
00665                      MultiScalarField2D<T>& rhoBar, MultiTensorField2D<T,2>& j, Box2D domain );
00666 
00667 /* *************** Packed RhoBar J *********************************** */
00668 
00669 template<typename T, template<typename U> class Descriptor>
00670 void computePackedRhoBarJ(
00671         MultiBlockLattice2D<T,Descriptor>& lattice,
00672         MultiNTensorField2D<T>& rhoBarJ, Box2D domain);
00673 
00674 template<typename T, template<typename U> class Descriptor>
00675 std::auto_ptr<MultiNTensorField2D<T> > computePackedRhoBarJ(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00676 
00677 template<typename T, template<typename U> class Descriptor>
00678 std::auto_ptr<MultiNTensorField2D<T> > computePackedRhoBarJ(MultiBlockLattice2D<T,Descriptor>& lattice);
00679 
00680 
00681 
00682 /* *************** Kinetic Energy ************************************ */
00683 
00684 template<typename T, template<typename U> class Descriptor>
00685 void computeKineticEnergy(MultiBlockLattice2D<T,Descriptor>& lattice, MultiScalarField2D<T>& energy, Box2D domain);
00686 
00687 template<typename T, template<typename U> class Descriptor>
00688 std::auto_ptr<MultiScalarField2D<T> > computeKineticEnergy(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00689 
00690 template<typename T, template<typename U> class Descriptor>
00691 std::auto_ptr<MultiScalarField2D<T> > computeKineticEnergy(MultiBlockLattice2D<T,Descriptor>& lattice);
00692 
00693 
00694 /* *************** Velocity Norm ************************************* */
00695 
00696 template<typename T, template<typename U> class Descriptor>
00697 void computeVelocityNorm(MultiBlockLattice2D<T,Descriptor>& lattice, MultiScalarField2D<T>& velocityNorm, Box2D domain);
00698 
00699 template<typename T, template<typename U> class Descriptor>
00700 std::auto_ptr<MultiScalarField2D<T> > computeVelocityNorm(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00701 
00702 template<typename T, template<typename U> class Descriptor>
00703 std::auto_ptr<MultiScalarField2D<T> > computeVelocityNorm(MultiBlockLattice2D<T,Descriptor>& lattice);
00704 
00705 
00706 /* *************** Velocity Component ******************************** */
00707 
00708 template<typename T, template<typename U> class Descriptor>
00709 void computeVelocityComponent(MultiBlockLattice2D<T,Descriptor>& lattice, MultiScalarField2D<T>& velocityComponent,
00710                               Box2D domain, plint iComponent);
00711 
00712 template<typename T, template<typename U> class Descriptor>
00713 std::auto_ptr<MultiScalarField2D<T> > computeVelocityComponent(MultiBlockLattice2D<T,Descriptor>& lattice,
00714                                                                Box2D domain, plint iComponent);
00715 
00716 template<typename T, template<typename U> class Descriptor>
00717 std::auto_ptr<MultiScalarField2D<T> > computeVelocityComponent(MultiBlockLattice2D<T,Descriptor>& lattice, plint iComponent);
00718 
00719 
00720 /* *************** Velocity ****************************************** */
00721 
00722 template<typename T, template<typename U> class Descriptor>
00723 void computeVelocity(MultiBlockLattice2D<T,Descriptor>& lattice,
00724                      MultiTensorField2D<T,Descriptor<T>::d>& velocity, Box2D domain);
00725 
00726 template<typename T, template<typename U> class Descriptor>
00727 std::auto_ptr<MultiTensorField2D<T,Descriptor<T>::d> >
00728    computeVelocity(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00729 
00730 template<typename T, template<typename U> class Descriptor>
00731 std::auto_ptr<MultiTensorField2D<T,Descriptor<T>::d> >
00732     computeVelocity(MultiBlockLattice2D<T,Descriptor>& lattice);
00733 
00734 
00735 /* *************** Deviatoric Stress ********************************* */
00736 
00737 template<typename T, template<typename U> class Descriptor>
00738 void computeDeviatoricStress(MultiBlockLattice2D<T,Descriptor>& lattice,
00739                              MultiTensorField2D<T,SymmetricTensor<T,Descriptor>::n>& PiNeq, Box2D domain);
00740 
00741 template<typename T, template<typename U> class Descriptor>
00742 std::auto_ptr<MultiTensorField2D<T,SymmetricTensor<T,Descriptor>::n> >
00743    computeDeviatoricStress(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00744 
00745 template<typename T, template<typename U> class Descriptor>
00746 std::auto_ptr<MultiTensorField2D<T,SymmetricTensor<T,Descriptor>::n> >
00747     computeDeviatoricStress(MultiBlockLattice2D<T,Descriptor>& lattice);
00748 
00749 
00750 /* *************** Strain Rate from Stress *************************** */
00751 
00752 template<typename T, template<typename U> class Descriptor>
00753 void computeStrainRateFromStress(MultiBlockLattice2D<T,Descriptor>& lattice,
00754                                  MultiTensorField2D<T,SymmetricTensor<T,Descriptor>::n>& S, Box2D domain);
00755 
00756 template<typename T, template<typename U> class Descriptor>
00757 std::auto_ptr<MultiTensorField2D<T,SymmetricTensor<T,Descriptor>::n> >
00758    computeStrainRateFromStress(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00759 
00760 template<typename T, template<typename U> class Descriptor>
00761 std::auto_ptr<MultiTensorField2D<T,SymmetricTensor<T,Descriptor>::n> >
00762     computeStrainRateFromStress(MultiBlockLattice2D<T,Descriptor>& lattice);
00763     
00764 /* *************** Temperature ******************************************* */
00765 
00766 template<typename T, template<typename U> class Descriptor>
00767 void computeTemperature(MultiBlockLattice2D<T,Descriptor>& lattice, MultiScalarField2D<T>& temperature, Box2D domain);
00768 
00769 template<typename T, template<typename U> class Descriptor>
00770 std::auto_ptr<MultiScalarField2D<T> > computeTemperature(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00771 
00772 template<typename T, template<typename U> class Descriptor>
00773 std::auto_ptr<MultiScalarField2D<T> > computeTemperature(MultiBlockLattice2D<T,Descriptor>& lattice);
00774 
00775 /* *************** SoundSpeed ******************************************* */
00776 
00777 template<typename T, template<typename U> class Descriptor>
00778 void computeSoundSpeed(MultiBlockLattice2D<T,Descriptor>& lattice, MultiScalarField2D<T>& soundSpeed, Box2D domain);
00779 
00780 template<typename T, template<typename U> class Descriptor>
00781 std::auto_ptr<MultiScalarField2D<T> > computeSoundSpeed(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00782 
00783 template<typename T, template<typename U> class Descriptor>
00784 std::auto_ptr<MultiScalarField2D<T> > computeSoundSpeed(MultiBlockLattice2D<T,Descriptor>& lattice);
00785 
00786 
00787 /* *************** Population **************************************** */
00788 
00789 template<typename T, template<typename U> class Descriptor>
00790 void computePopulation(MultiBlockLattice2D<T,Descriptor>& lattice, MultiScalarField2D<T>& population,
00791                        Box2D domain, plint iPop);
00792 
00793 template<typename T, template<typename U> class Descriptor>
00794 std::auto_ptr<MultiScalarField2D<T> > computePopulation(MultiBlockLattice2D<T,Descriptor>& lattice,
00795                                                         Box2D domain, plint iPop);
00796 
00797 template<typename T, template<typename U> class Descriptor>
00798 std::auto_ptr<MultiScalarField2D<T> > computePopulation(MultiBlockLattice2D<T,Descriptor>& lattice, plint iPop);
00799 
00800 
00801 template<typename T, template<typename U> class Descriptor>
00802 void computeEquilibrium(MultiBlockLattice2D<T,Descriptor>& lattice, MultiScalarField2D<T>& equilibrium,
00803                        Box2D domain, plint iPop);
00804 
00805 template<typename T, template<typename U> class Descriptor>
00806 std::auto_ptr<MultiScalarField2D<T> > computeEquilibrium(MultiBlockLattice2D<T,Descriptor>& lattice,
00807                                                          Box2D domain, plint iPop);
00808 
00809 template<typename T, template<typename U> class Descriptor>
00810 std::auto_ptr<MultiScalarField2D<T> > computeEquilibrium(MultiBlockLattice2D<T,Descriptor>& lattice, plint iPop);
00811 
00812 template<typename T, template<typename U> class Descriptor>
00813 void computeAllPopulations(MultiBlockLattice2D<T,Descriptor>& lattice,
00814                            MultiTensorField2D<T,Descriptor<T>::q>& populations);
00815 
00816 template<typename T, template<typename U> class Descriptor>
00817 std::auto_ptr<MultiTensorField2D<T,Descriptor<T>::q> > computeAllPopulations(MultiBlockLattice2D<T,Descriptor>& lattice);
00818     
00819 template<typename T, template<typename U> class Descriptor>
00820 std::auto_ptr<MultiTensorField2D<T,Descriptor<T>::q> > computeAllPopulations(MultiBlockLattice2D<T,Descriptor>& lattice, 
00821                                                                              Box2D domain);
00822                                                         
00823 template<typename T, template<typename U> class Descriptor>
00824 void copyPopulations( MultiBlockLattice2D<T,Descriptor>& latticeFrom,
00825                       MultiBlockLattice2D<T,Descriptor>& latticeTo,
00826                       Box2D domain);
00827 
00828 template<typename T1, template<typename U1> class Descriptor1, typename T2, template<typename U2> class Descriptor2>
00829 void copyConvertPopulations( BlockLattice2D<T1,Descriptor1>& latticeFrom,
00830                              BlockLattice2D<T2,Descriptor2>& latticeTo,
00831                              Box2D domain);
00832 
00833 template<typename T, template<typename U> class Descriptor>
00834 void copyAll( MultiBlockLattice2D<T,Descriptor>& latticeFrom,
00835               MultiBlockLattice2D<T,Descriptor>& latticeTo,
00836               Box2D domain );
00837 
00838 template<typename T, template<typename U> class Descriptor>
00839 void copyRegenerate( MultiBlockLattice2D<T,Descriptor>& latticeFrom,
00840                      MultiBlockLattice2D<T,Descriptor>& latticeTo,
00841                      Box2D domain );
00842 
00843 /* *************** Omega ******************************************* */
00844 
00845 template<typename T, template<typename U> class Descriptor>
00846 void computeOmega(MultiBlockLattice2D<T,Descriptor>& lattice,
00847                   MultiScalarField2D<T>& omega, Box2D domain);
00848 
00849 template<typename T, template<typename U> class Descriptor>
00850 void computeOmega(MultiBlockLattice2D<T,Descriptor>& lattice,
00851                   MultiScalarField2D<T>& omega);
00852 
00853 template<typename T, template<typename U> class Descriptor>
00854 std::auto_ptr<MultiScalarField2D<T> > computeOmega(MultiBlockLattice2D<T,Descriptor>& lattice, Box2D domain);
00855 
00856 template<typename T, template<typename U> class Descriptor>
00857 std::auto_ptr<MultiScalarField2D<T> > computeOmega(MultiBlockLattice2D<T,Descriptor>& lattice);
00858 
00859 /* ******************************************************************* */
00860 /* *************** PART V : Multi-block wrappers: Scalar-Field ******* */
00861 /* ******************************************************************* */
00862 
00863 /* *************** Reductive functions ******************************* */
00864 
00865 template<typename T>
00866 T computeSum(MultiScalarField2D<T>& scalarField, Box2D domain);
00867 
00868 template<typename T>
00869 T computeSum(MultiScalarField2D<T>& scalarField);
00870 
00871 template<typename T>
00872 T computeAverage(MultiScalarField2D<T>& scalarField, Box2D domain);
00873 
00874 template<typename T>
00875 T computeAverage(MultiScalarField2D<T>& scalarField);
00876 
00877 
00878 template<typename T>
00879 T computeAverage(MultiScalarField2D<T>& scalarField, MultiScalarField2D<int>& mask, int flag, Box2D domain);
00880 
00881 template<typename T>
00882 T computeAverage(MultiScalarField2D<T>& scalarField, MultiScalarField2D<int>& mask, int flag);
00883 
00884 
00885 template<typename T>
00886 T computeMin(MultiScalarField2D<T>& scalarField, Box2D domain);
00887 
00888 template<typename T>
00889 T computeMin(MultiScalarField2D<T>& scalarField);
00890 
00891 
00892 template<typename T>
00893 T computeMax(MultiScalarField2D<T>& scalarField, Box2D domain);
00894 
00895 template<typename T>
00896 T computeMax(MultiScalarField2D<T>& scalarField);
00897 
00898 
00899 template<typename T>
00900 T computeBoundedAverage(MultiScalarField2D<T>& scalarField, Box2D domain);
00901 
00902 template<typename T>
00903 T computeBoundedAverage(MultiScalarField2D<T>& scalarField);
00904 
00905 
00906 template<typename T, class BoolMask> 
00907 plint count(MultiScalarField2D<T>& field, Box2D domain, BoolMask boolMask);
00908 
00909 template<typename T, class BoolMask> 
00910 plint count(MultiScalarField2D<T>& field, BoolMask boolMask);
00911 
00912 /* *************** Generic operations *************** */
00913 
00914 template<typename T, class Function>
00915 void apply(Function f, MultiScalarField2D<T>& field, Box2D domain) {
00916     applyProcessingFunctional (
00917             new ApplyScalarFunctional2D<T,Function>(f), domain, field);
00918 }
00919 
00920 template<typename T, class Function>
00921 void apply(Function f, MultiScalarField2D<T>& field) {
00922     apply(f, field, field.getBoundingBox());
00923 }
00924 
00925 
00926 template<typename T, class Function>
00927 void evaluate(Function f, MultiScalarField2D<T>& field, MultiScalarField2D<T>& result, Box2D domain) {
00928     applyProcessingFunctional (
00929             new EvaluateScalarFunctional2D<T,Function>(f), domain, field, result);
00930 }
00931 
00932 template<typename T, class Function>
00933 std::auto_ptr<MultiScalarField2D<T> > evaluate(Function f, MultiScalarField2D<T>& field, Box2D domain) {
00934     MultiScalarField2D<T>* result = new MultiScalarField2D<T>(field, domain);
00935     evaluate(f, field, *result, domain);
00936     return std::auto_ptr<MultiScalarField2D<T> >(result);
00937 }
00938 
00939 template<typename T, class Function>
00940 std::auto_ptr<MultiScalarField2D<T> > evaluate(Function f, MultiScalarField2D<T>& field) {
00941     return evaluate(f, field, field.getBoundingBox());
00942 }
00943 
00944 
00945 /* *************** Extract Sub-ScalarField *************************** */
00946 
00947 template<typename T>
00948 void extractSubDomain( MultiScalarField2D<T>& field,
00949                        MultiScalarField2D<T>& extractedField,
00950                        Box2D domain);
00951 
00952 template<typename T>
00953 std::auto_ptr<MultiScalarField2D<T> > extractSubDomain(MultiScalarField2D<T>& field, Box2D domain);
00954 
00955 
00956 /* *************** Copy and Convert ScalarField *************************** */
00957 
00958 template<typename T1, typename T2>
00959 void copy( MultiScalarField2D<T1>& field,
00960            MultiScalarField2D<T2>& convertedField, Box2D domain);
00961 
00962 template<typename T1, typename T2>
00963 std::auto_ptr<MultiScalarField2D<T2> > copyConvert(MultiScalarField2D<T1>& field, Box2D domain);
00964 
00965 template<typename T1, typename T2>
00966 std::auto_ptr<MultiScalarField2D<T2> > copyConvert(MultiScalarField2D<T1>& field);
00967 
00968 
00969 /* *************** MultiScalarField - Scalar operations *************** */
00970 
00971 template<typename T>
00972 void lessThan(MultiScalarField2D<T>& field, T scalar, MultiScalarField2D<int>& result, Box2D domain);
00973 
00974 template<typename T>
00975 std::auto_ptr<MultiScalarField2D<int> > lessThan(MultiScalarField2D<T>& field, T scalar, Box2D domain);
00976 
00977 template<typename T>
00978 std::auto_ptr<MultiScalarField2D<int> > lessThan(MultiScalarField2D<T>& field, T scalar);
00979 
00980 
00981 template<typename T>
00982 void greaterThan(MultiScalarField2D<T>& field, T scalar, MultiScalarField2D<int>& result, Box2D domain);
00983 
00984 template<typename T>
00985 std::auto_ptr<MultiScalarField2D<int> > greaterThan(MultiScalarField2D<T>& field, T scalar, Box2D domain);
00986 
00987 template<typename T>
00988 std::auto_ptr<MultiScalarField2D<int> > greaterThan(MultiScalarField2D<T>& field, T scalar);
00989 
00990 
00991 template<typename T>
00992 void add(T scalar, MultiScalarField2D<T>& field, MultiScalarField2D<T>& result, Box2D domain);
00993 
00994 template<typename T>
00995 std::auto_ptr<MultiScalarField2D<T> > add(T scalar, MultiScalarField2D<T>& field, Box2D domain);
00996 
00997 template<typename T>
00998 std::auto_ptr<MultiScalarField2D<T> > add(T scalar, MultiScalarField2D<T>& field);
00999 
01000 
01001 template<typename T>
01002 void add(MultiScalarField2D<T>& field, T scalar, MultiScalarField2D<T>& result, Box2D domain);
01003 
01004 template<typename T>
01005 std::auto_ptr<MultiScalarField2D<T> > add(MultiScalarField2D<T>& field, T scalar, Box2D domain);
01006 
01007 template<typename T>
01008 std::auto_ptr<MultiScalarField2D<T> > add(MultiScalarField2D<T>& field, T scalar);
01009 
01010 
01011 template<typename T>
01012 void subtract(T scalar, MultiScalarField2D<T>& field, MultiScalarField2D<T>& result, Box2D domain);
01013 
01014 template<typename T>
01015 std::auto_ptr<MultiScalarField2D<T> > subtract(T scalar, MultiScalarField2D<T>& field, Box2D domain);
01016 
01017 template<typename T>
01018 std::auto_ptr<MultiScalarField2D<T> > subtract(T scalar, MultiScalarField2D<T>& field);
01019 
01020 
01021 template<typename T>
01022 void subtract(MultiScalarField2D<T>& field, T scalar, MultiScalarField2D<T>& result, Box2D domain);
01023 
01024 template<typename T>
01025 std::auto_ptr<MultiScalarField2D<T> > subtract(MultiScalarField2D<T>& field, T scalar, Box2D domain);
01026 
01027 template<typename T>
01028 std::auto_ptr<MultiScalarField2D<T> > subtract(MultiScalarField2D<T>& field, T scalar);
01029 
01030 
01031 template<typename T>
01032 void multiply(T scalar, MultiScalarField2D<T>& field, MultiScalarField2D<T>& result, Box2D domain);
01033 
01034 template<typename T>
01035 std::auto_ptr<MultiScalarField2D<T> > multiply(T scalar, MultiScalarField2D<T>& field, Box2D domain);
01036 
01037 template<typename T>
01038 std::auto_ptr<MultiScalarField2D<T> > multiply(T scalar, MultiScalarField2D<T>& field);
01039 
01040 
01041 template<typename T>
01042 void multiply(MultiScalarField2D<T>& field, T scalar, MultiScalarField2D<T>& result, Box2D domain);
01043 
01044 template<typename T>
01045 std::auto_ptr<MultiScalarField2D<T> > multiply(MultiScalarField2D<T>& field, T scalar, Box2D domain);
01046 
01047 template<typename T>
01048 std::auto_ptr<MultiScalarField2D<T> > multiply(MultiScalarField2D<T>& field, T scalar);
01049 
01050 
01051 template<typename T>
01052 void divide(T scalar, MultiScalarField2D<T>& field, MultiScalarField2D<T>& result, Box2D domain);
01053 
01054 template<typename T>
01055 std::auto_ptr<MultiScalarField2D<T> > divide(T scalar, MultiScalarField2D<T>& field, Box2D domain);
01056 
01057 template<typename T>
01058 std::auto_ptr<MultiScalarField2D<T> > divide(T scalar, MultiScalarField2D<T>& field);
01059 
01060 
01061 template<typename T>
01062 void divide(MultiScalarField2D<T>& field, T scalar, MultiScalarField2D<T>& result, Box2D domain);
01063 
01064 template<typename T>
01065 std::auto_ptr<MultiScalarField2D<T> > divide(MultiScalarField2D<T>& field, T scalar, Box2D domain);
01066 
01067 template<typename T>
01068 std::auto_ptr<MultiScalarField2D<T> > divide(MultiScalarField2D<T>& field, T scalar);
01069 
01070 /* *************** MultiScalarField operations *************** */
01071 
01072 template<typename T>
01073 void computeSqrt(MultiScalarField2D<T>& field, MultiScalarField2D<T>& result, Box2D domain);
01074 
01075 template<typename T>
01076 std::auto_ptr<MultiScalarField2D<T> > computeSqrt(MultiScalarField2D<T>& field, Box2D domain);
01077 
01078 template<typename T>
01079 std::auto_ptr<MultiScalarField2D<T> > computeSqrt(MultiScalarField2D<T>& field);
01080 
01081 template<typename T>
01082 void computeLog(MultiScalarField2D<T>& field, MultiScalarField2D<T>& result, Box2D domain);
01083 
01084 template<typename T>
01085 std::auto_ptr<MultiScalarField2D<T> > computeLog(MultiScalarField2D<T>& field, Box2D domain);
01086 
01087 template<typename T>
01088 std::auto_ptr<MultiScalarField2D<T> > computeLog(MultiScalarField2D<T>& field);
01089 
01090 template<typename T>
01091 void computeAbsoluteValue(MultiScalarField2D<T>& field, MultiScalarField2D<T>& result, Box2D domain);
01092 
01093 template<typename T>
01094 std::auto_ptr<MultiScalarField2D<T> > computeAbsoluteValue(MultiScalarField2D<T>& field, Box2D domain);
01095 
01096 template<typename T>
01097 std::auto_ptr<MultiScalarField2D<T> > computeAbsoluteValue(MultiScalarField2D<T>& field);
01098 
01099 
01100 /* *************** MultiScalarField - Scalar inplace operations *************** */
01101 
01102 template<typename T>
01103 void addInPlace(MultiScalarField2D<T>& field, T scalar, Box2D domain);
01104 
01105 template<typename T>
01106 void addInPlace(MultiScalarField2D<T>& field, T scalar);
01107 
01108 template<typename T>
01109 void subtractInPlace(MultiScalarField2D<T>& field, T scalar, Box2D domain);
01110 
01111 template<typename T>
01112 void subtractInPlace(MultiScalarField2D<T>& field, T scalar);
01113 
01114 template<typename T>
01115 void multiplyInPlace(MultiScalarField2D<T>& field, T scalar, Box2D domain);
01116 
01117 template<typename T>
01118 void multiplyInPlace(MultiScalarField2D<T>& field, T scalar);
01119 
01120 template<typename T>
01121 void divideInPlace(MultiScalarField2D<T>& field, T scalar, Box2D domain);
01122 
01123 template<typename T>
01124 void divideInPlace(MultiScalarField2D<T>& field, T scalar);
01125 
01126 
01127 /* *************** MultiScalarField - MultiScalarField operations *************** */
01128 
01129 template<typename T>
01130 void lessThan(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, MultiScalarField2D<int>& result, Box2D domain);
01131 
01132 template<typename T>
01133 std::auto_ptr<MultiScalarField2D<int> > lessThan(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, Box2D domain);
01134 
01135 template<typename T>
01136 std::auto_ptr<MultiScalarField2D<int> > lessThan(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B);
01137 
01138 
01139 template<typename T>
01140 void greaterThan(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, MultiScalarField2D<int>& result, Box2D domain);
01141 
01142 template<typename T>
01143 std::auto_ptr<MultiScalarField2D<int> > greaterThan(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, Box2D domain);
01144 
01145 template<typename T>
01146 std::auto_ptr<MultiScalarField2D<int> > greaterThan(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B);
01147 
01148 
01149 template<typename T>
01150 void add(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, MultiScalarField2D<T>& result, Box2D domain);
01151 
01152 template<typename T>
01153 std::auto_ptr<MultiScalarField2D<T> > add(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, Box2D domain);
01154 
01155 template<typename T>
01156 std::auto_ptr<MultiScalarField2D<T> > add(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B);
01157 
01158 
01159 template<typename T>
01160 void subtract(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, MultiScalarField2D<T>& result, Box2D domain);
01161 
01162 template<typename T>
01163 std::auto_ptr<MultiScalarField2D<T> > subtract(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, Box2D domain);
01164 
01165 template<typename T>
01166 std::auto_ptr<MultiScalarField2D<T> > subtract(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B);
01167 
01168 
01169 template<typename T>
01170 void multiply(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, MultiScalarField2D<T>& result, Box2D domain);
01171 
01172 template<typename T>
01173 std::auto_ptr<MultiScalarField2D<T> > multiply(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, Box2D domain);
01174 
01175 template<typename T>
01176 std::auto_ptr<MultiScalarField2D<T> > multiply(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B);
01177 
01178 
01179 template<typename T>
01180 void divide(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, MultiScalarField2D<T>& result, Box2D domain);
01181 
01182 template<typename T>
01183 std::auto_ptr<MultiScalarField2D<T> > divide(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, Box2D domain);
01184 
01185 template<typename T>
01186 std::auto_ptr<MultiScalarField2D<T> > divide(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B);
01187 
01188 
01189 /* *************** MultiScalarField - MultiScalarField inplace operations *************** */
01190 
01191 template<typename T>
01192 void addInPlace(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, Box2D domain);
01193 
01194 template<typename T>
01195 void addInPlace(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B);
01196 
01197 
01198 template<typename T>
01199 void subtractInPlace(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, Box2D domain);
01200 
01201 template<typename T>
01202 void subtractInPlace(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B);
01203 
01204 
01205 template<typename T>
01206 void multiplyInPlace(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, Box2D domain);
01207 
01208 template<typename T>
01209 void multiplyInPlace(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B);
01210 
01211 
01212 template<typename T>
01213 void divideInPlace(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B, Box2D domain);
01214 
01215 template<typename T>
01216 void divideInPlace(MultiScalarField2D<T>& A, MultiScalarField2D<T>& B);
01217 
01218 /* ******************************************************************* */
01219 /* *************** PART VI : Multi-block wrappers: Tensor-field ****** */
01220 /* ******************************************************************* */
01221 
01222 /* *************** Reductive functions ******************************* */
01223 
01224 template<typename T, int nDim, class BoolMask> 
01225 plint count(MultiTensorField2D<T,nDim>& field, Box2D domain, BoolMask boolMask);
01226 
01227 template<typename T, int nDim, class BoolMask> 
01228 plint count(MultiTensorField2D<T,nDim>& field, BoolMask boolMask);
01229 
01230 
01231 /* *************** Copy-convert a tensor-field *************** */
01232 
01233 template<typename T1, typename T2, int nDim>
01234 void copy( MultiTensorField2D<T1,nDim>& field,
01235            MultiTensorField2D<T2,nDim>& convertedField,
01236            Box2D domain);
01237 
01238 template<typename T1, typename T2, int nDim>
01239 std::auto_ptr<MultiTensorField2D<T2,nDim> > copyConvert(MultiTensorField2D<T1,nDim>& field, Box2D domain);
01240 
01241 template<typename T1, typename T2, int nDim>
01242 std::auto_ptr<MultiTensorField2D<T2,nDim> > copyConvert(MultiTensorField2D<T1,nDim>& field);
01243 
01244 
01245 /* *************** Extract Sub-TensorField *************************** */
01246 
01247 template<typename T, int nDim>
01248 void extractSubDomain( MultiTensorField2D<T,nDim>& field,
01249                        MultiTensorField2D<T,nDim>& extractedField,
01250                        Box2D domain);
01251 
01252 template<typename T, int nDim>
01253 std::auto_ptr<MultiTensorField2D<T,nDim> > extractSubDomain(MultiTensorField2D<T,nDim>& field, Box2D domain);
01254 
01255 
01256 /* *************** Component (scalar-field) out of a tensor-field ****** */
01257 
01258 template<typename T, int nDim>
01259 void extractComponent(MultiTensorField2D<T,nDim>& tensorField, MultiScalarField2D<T>& component, Box2D domain, int iComponent);
01260 
01261 template<typename T, int nDim>
01262 std::auto_ptr<MultiScalarField2D<T> > extractComponent(MultiTensorField2D<T,nDim>& tensorField, Box2D domain, int iComponent);
01263 
01264 template<typename T, int nDim>
01265 std::auto_ptr<MultiScalarField2D<T> > extractComponent(MultiTensorField2D<T,nDim>& tensorField, int iComponent);
01266 
01267 
01268 /* *************** Vector-norm of each cell in the field *************** */
01269 
01270 template<typename T, int nDim>
01271 void computeNorm(MultiTensorField2D<T,nDim>& tensorField, MultiScalarField2D<T>& norm, Box2D domain);
01272 
01273 template<typename T, int nDim>
01274 std::auto_ptr<MultiScalarField2D<T> > computeNorm(MultiTensorField2D<T,nDim>& tensorField, Box2D domain);
01275 
01276 template<typename T, int nDim>
01277 std::auto_ptr<MultiScalarField2D<T> > computeNorm(MultiTensorField2D<T,nDim>& tensorField);
01278 
01279 
01280 /* *************** Squared vector-norm of each cell in the field ******** */
01281 
01282 template<typename T, int nDim>
01283 void computeNormSqr(MultiTensorField2D<T,nDim>& tensorField, MultiScalarField2D<T>& normSqr, Box2D domain);
01284 
01285 template<typename T, int nDim>
01286 std::auto_ptr<MultiScalarField2D<T> > computeNormSqr(MultiTensorField2D<T,nDim>& tensorField, Box2D domain);
01287 
01288 template<typename T, int nDim>
01289 std::auto_ptr<MultiScalarField2D<T> > computeNormSqr(MultiTensorField2D<T,nDim>& tensorField);
01290 
01291 
01292 /* *************** Tensor-norm of each symmetric tensor of a field ***** */
01293 
01294 template<typename T>
01295 void computeSymmetricTensorNorm(MultiTensorField2D<T,3>& tensorField, MultiScalarField2D<T>& norm, Box2D domain);
01296 
01297 template<typename T>
01298 std::auto_ptr<MultiScalarField2D<T> > computeSymmetricTensorNorm(MultiTensorField2D<T,3>& tensorField, Box2D domain);
01299 
01300 template<typename T>
01301 std::auto_ptr<MultiScalarField2D<T> > computeSymmetricTensorNorm(MultiTensorField2D<T,3>& tensorField);
01302 
01303 
01304 /* *************** Squared Tensor-norm of each symmetric tensor of a field*/
01305 
01306 template<typename T>
01307 void computeSymmetricTensorNormSqr(MultiTensorField2D<T,3>& tensorField, MultiScalarField2D<T>& normSqr, Box2D domain);
01308 
01309 template<typename T>
01310 std::auto_ptr<MultiScalarField2D<T> > computeSymmetricTensorNormSqr(MultiTensorField2D<T,3>& tensorField, Box2D domain);
01311 
01312 template<typename T>
01313 std::auto_ptr<MultiScalarField2D<T> > computeSymmetricTensorNormSqr(MultiTensorField2D<T,3>& tensorField);
01314 
01315 
01316 /* *************** Trace of each symmetric tensor of a field ************ */
01317 
01318 template<typename T>
01319 void computeSymmetricTensorTrace(MultiTensorField2D<T,3>& tensorField, MultiScalarField2D<T>& trace, Box2D domain);
01320 
01321 template<typename T>
01322 std::auto_ptr<MultiScalarField2D<T> > computeSymmetricTensorTrace(MultiTensorField2D<T,3>& tensorField, Box2D domain);
01323 
01324 template<typename T>
01325 std::auto_ptr<MultiScalarField2D<T> > computeSymmetricTensorTrace(MultiTensorField2D<T,3>& tensorField);
01326 
01327 
01328 /* *************** Vorticity from Velocity field *********************** */
01329 
01330 template<typename T>
01331 void computeVorticity(MultiTensorField2D<T,2>& velocity, MultiScalarField2D<T>& vorticity, Box2D domain);
01332 
01333 template<typename T>
01334 std::auto_ptr<MultiScalarField2D<T> > computeVorticity(MultiTensorField2D<T,2>& velocity, Box2D domain);
01335 
01336 template<typename T>
01337 std::auto_ptr<MultiScalarField2D<T> > computeVorticity(MultiTensorField2D<T,2>& velocity);
01338 
01339 
01340 /* *************** Vorticity, witout boundary treatment, from Velocity field  */
01341 
01342 template<typename T>
01343 void computeBulkVorticity(MultiTensorField2D<T,2>& velocity, MultiScalarField2D<T>& vorticity, Box2D domain);
01344 
01345 template<typename T>
01346 std::auto_ptr<MultiScalarField2D<T> > computeBulkVorticity(MultiTensorField2D<T,2>& velocity, Box2D domain);
01347 
01348 template<typename T>
01349 std::auto_ptr<MultiScalarField2D<T> > computeBulkVorticity(MultiTensorField2D<T,2>& velocity);
01350 
01351 
01352 /* *************** Strain rate from Velocity field ********************* */
01353 
01354 template<typename T>
01355 void computeStrainRate(MultiTensorField2D<T,2>& velocity, MultiTensorField2D<T,3>& S, Box2D domain);
01356 
01357 template<typename T>
01358 std::auto_ptr<MultiTensorField2D<T,3> > computeStrainRate(MultiTensorField2D<T,2>& velocity, Box2D domain);
01359 
01360 template<typename T>
01361 std::auto_ptr<MultiTensorField2D<T,3> > computeStrainRate(MultiTensorField2D<T,2>& velocity);
01362 
01363 
01364 /* *************** Str. rate, witout boundary treatment, from Velocity field  */
01365 
01366 template<typename T>
01367 void computeBulkStrainRate(MultiTensorField2D<T,2>& velocity, MultiTensorField2D<T,3>& S, Box2D domain);
01368 
01369 template<typename T>
01370 std::auto_ptr<MultiTensorField2D<T,3> > computeBulkStrainRate(MultiTensorField2D<T,2>& velocity, Box2D domain);
01371 
01372 template<typename T>
01373 std::auto_ptr<MultiTensorField2D<T,3> > computeBulkStrainRate(MultiTensorField2D<T,2>& velocity);
01374 
01375 
01376 /* *************** MultiTensorField - MultiTensorField operations *************** */
01377 
01378 template<typename T, int nDim>
01379 void add(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, MultiTensorField2D<T,nDim>& result, Box2D domain);
01380 
01381 template<typename T, int nDim>
01382 std::auto_ptr<MultiTensorField2D<T,nDim> > add(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, Box2D domain);
01383 
01384 template<typename T, int nDim>
01385 std::auto_ptr<MultiTensorField2D<T,nDim> > add(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B);
01386 
01387 
01388 template<typename T, int nDim>
01389 void subtract(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, MultiTensorField2D<T,nDim>& result, Box2D domain);
01390 
01391 template<typename T, int nDim>
01392 std::auto_ptr<MultiTensorField2D<T,nDim> > subtract(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, Box2D domain);
01393 
01394 template<typename T, int nDim>
01395 std::auto_ptr<MultiTensorField2D<T,nDim> > subtract(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B);
01396 
01397 
01398 template<typename T, int nDim>
01399 void multiply(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, MultiTensorField2D<T,nDim>& result, Box2D domain);
01400 
01401 template<typename T, int nDim>
01402 std::auto_ptr<MultiTensorField2D<T,nDim> > multiply(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, Box2D domain);
01403 
01404 template<typename T, int nDim>
01405 std::auto_ptr<MultiTensorField2D<T,nDim> > multiply(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B);
01406 
01407 
01408 template<typename T, int nDim>
01409 void multiply(T scalar, MultiTensorField2D<T,nDim>& field, MultiTensorField2D<T,nDim>& result, Box2D domain);
01410 
01411 template<typename T, int nDim>
01412 std::auto_ptr<MultiTensorField2D<T,nDim> > multiply(T scalar, MultiTensorField2D<T,nDim>& field, Box2D domain);
01413 
01414 template<typename T, int nDim>
01415 std::auto_ptr<MultiTensorField2D<T,nDim> > multiply(T scalar, MultiTensorField2D<T,nDim>& field);
01416 
01417 
01418 template<typename T, int nDim>
01419 void multiply(MultiTensorField2D<T,nDim>& field, T scalar, MultiTensorField2D<T,nDim>& result, Box2D domain);
01420 
01421 template<typename T, int nDim>
01422 std::auto_ptr<MultiTensorField2D<T,nDim> > multiply(MultiTensorField2D<T,nDim>& field, T scalar, Box2D domain);
01423 
01424 template<typename T, int nDim>
01425 std::auto_ptr<MultiTensorField2D<T,nDim> > multiply(MultiTensorField2D<T,nDim>& field, T scalar);
01426 
01427 
01428 template<typename T, int nDim>
01429 void divide(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, MultiTensorField2D<T,nDim>& result, Box2D domain);
01430 
01431 template<typename T, int nDim>
01432 std::auto_ptr<MultiTensorField2D<T,nDim> > divide(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, Box2D domain);
01433 
01434 template<typename T, int nDim>
01435 std::auto_ptr<MultiTensorField2D<T,nDim> > divide(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B);
01436 
01437 
01438 /* *************** MultiTensorField - MultiTensorField inplace operations *************** */
01439 
01440 template<typename T, int nDim>
01441 void addInPlace(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, Box2D domain);
01442 
01443 template<typename T, int nDim>
01444 void addInPlace(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B);
01445 
01446 
01447 template<typename T, int nDim>
01448 void subtractInPlace(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, Box2D domain);
01449 
01450 template<typename T, int nDim>
01451 void subtractInPlace(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B);
01452 
01453 
01454 template<typename T, int nDim>
01455 void multiplyInPlace(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, Box2D domain);
01456 
01457 template<typename T, int nDim>
01458 void multiplyInPlace(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B);
01459 
01460 
01461 template<typename T, int nDim>
01462 void multiplyInPlace(MultiTensorField2D<T,nDim>& A, T alpha, Box2D domain);
01463 
01464 template<typename T, int nDim>
01465 void multiplyInPlace(MultiTensorField2D<T,nDim>& A, T alpha);
01466 
01467 
01468 template<typename T, int nDim>
01469 void divideInPlace(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B, Box2D domain);
01470 
01471 template<typename T, int nDim>
01472 void divideInPlace(MultiTensorField2D<T,nDim>& A, MultiTensorField2D<T,nDim>& B);
01473 
01474 
01475 }  // namespace plb
01476 
01477 #endif  // DATA_ANALYSIS_WRAPPER_2D_H
01478