generalizedBoundaryCondition2D.hh

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 GENERALIZED_BOUNDARY_CONDITION_2D_HH
00029 #define GENERALIZED_BOUNDARY_CONDITION_2D_HH
00030 
00031 #include "boundaryCondition/boundaryCondition2D.h"
00032 #include "boundaryCondition/boundaryCondition2D.hh"
00033 #include "generalizedBoundaryDynamics.h"
00034 #include "boundaryCondition/generalizedBoundaryCondition2D.h"
00035 #include "boundaryCondition/boundaryInstantiator2D.h"
00036 #include "atomicBlock/blockLattice2D.h"
00037 #include "multiBlock/multiBlockLattice2D.h"
00038 #include "core/blockSurface2D.h"
00039 #include "core/plbDebug.h"
00040 
00041 namespace plb {
00042     
00044 
00045 template<typename T, template<typename U> class Descriptor>
00046 class GeneralizedBoundaryManager2D {
00047 public:
00048     template<int direction, int orientation>
00049         static BoundaryCompositeDynamics<T,Descriptor>*
00050             getVelocityBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics);
00051     template<int direction, int orientation>
00052         static BoxProcessingFunctional2D_L<T,Descriptor>*
00053             getVelocityBoundaryFunctional();
00054 
00055     template<int direction, int orientation>
00056         static BoundaryCompositeDynamics<T,Descriptor>*
00057             getPressureBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics);
00058     template<int direction, int orientation>
00059         static BoxProcessingFunctional2D_L<T,Descriptor>*
00060             getPressureBoundaryFunctional();
00061 
00062     template<int xNormal, int yNormal>
00063         static BoundaryCompositeDynamics<T,Descriptor>*
00064             getExternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics);
00065     template<int xNormal, int yNormal>
00066         static BoxProcessingFunctional2D_L<T,Descriptor>*
00067             getExternalVelocityCornerFunctional();
00068 
00069     template<int xNormal, int yNormal>
00070         static BoundaryCompositeDynamics<T,Descriptor>*
00071             getInternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics);
00072     template<int xNormal, int yNormal>
00073         static BoxProcessingFunctional2D_L<T,Descriptor>*
00074             getInternalVelocityCornerFunctional();
00075 };
00076 
00077 
00078 template<typename T, template<typename U> class Descriptor>
00079 class WrappedGeneralizedBoundaryManager2D {
00080 public:
00081     template<int direction, int orientation>
00082         static BoundaryCompositeDynamics<T,Descriptor>*
00083             getVelocityBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics);
00084     template<int direction, int orientation>
00085         static BoxProcessingFunctional2D_L<T,Descriptor>*
00086             getVelocityBoundaryFunctional();
00087 
00088     template<int direction, int orientation>
00089         static BoundaryCompositeDynamics<T,Descriptor>*
00090             getPressureBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics);
00091     template<int direction, int orientation>
00092         static BoxProcessingFunctional2D_L<T,Descriptor>*
00093             getPressureBoundaryFunctional();
00094 
00095     template<int xNormal, int yNormal>
00096         static BoundaryCompositeDynamics<T,Descriptor>*
00097             getExternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics);
00098     template<int xNormal, int yNormal>
00099         static BoxProcessingFunctional2D_L<T,Descriptor>*
00100             getExternalVelocityCornerFunctional();
00101 
00102     template<int xNormal, int yNormal>
00103         static BoundaryCompositeDynamics<T,Descriptor>*
00104             getInternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics);
00105     template<int xNormal, int yNormal>
00106         static BoxProcessingFunctional2D_L<T,Descriptor>*
00107             getInternalVelocityCornerFunctional();
00108 };
00109 
00111 
00112 template<typename T, template<typename U> class Descriptor>
00113 class MassConservingGeneralizedBoundaryManager2D {
00114 public:
00115     template<int direction, int orientation>
00116         static BoundaryCompositeDynamics<T,Descriptor>*
00117             getVelocityBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics);
00118     template<int direction, int orientation>
00119         static BoxProcessingFunctional2D_L<T,Descriptor>*
00120             getVelocityBoundaryFunctional();
00121 
00122     template<int direction, int orientation>
00123         static BoundaryCompositeDynamics<T,Descriptor>*
00124             getPressureBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics);
00125     template<int direction, int orientation>
00126         static BoxProcessingFunctional2D_L<T,Descriptor>*
00127             getPressureBoundaryFunctional();
00128 
00129     template<int xNormal, int yNormal>
00130         static BoundaryCompositeDynamics<T,Descriptor>*
00131             getExternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics);
00132     template<int xNormal, int yNormal>
00133         static BoxProcessingFunctional2D_L<T,Descriptor>*
00134             getExternalVelocityCornerFunctional();
00135 
00136     template<int xNormal, int yNormal>
00137         static BoundaryCompositeDynamics<T,Descriptor>*
00138             getInternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics);
00139     template<int xNormal, int yNormal>
00140         static BoxProcessingFunctional2D_L<T,Descriptor>*
00141             getInternalVelocityCornerFunctional();
00142 };
00143 
00144 
00145 template<typename T, template<typename U> class Descriptor>
00146 class WrappedMassConservingGeneralizedBoundaryManager2D {
00147 public:
00148     template<int direction, int orientation>
00149         static BoundaryCompositeDynamics<T,Descriptor>*
00150             getVelocityBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics);
00151     template<int direction, int orientation>
00152         static BoxProcessingFunctional2D_L<T,Descriptor>*
00153             getVelocityBoundaryFunctional();
00154 
00155     template<int direction, int orientation>
00156         static BoundaryCompositeDynamics<T,Descriptor>*
00157             getPressureBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics);
00158     template<int direction, int orientation>
00159         static BoxProcessingFunctional2D_L<T,Descriptor>*
00160             getPressureBoundaryFunctional();
00161 
00162     template<int xNormal, int yNormal>
00163         static BoundaryCompositeDynamics<T,Descriptor>*
00164             getExternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics);
00165     template<int xNormal, int yNormal>
00166         static BoxProcessingFunctional2D_L<T,Descriptor>*
00167             getExternalVelocityCornerFunctional();
00168 
00169     template<int xNormal, int yNormal>
00170         static BoundaryCompositeDynamics<T,Descriptor>*
00171             getInternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics);
00172     template<int xNormal, int yNormal>
00173         static BoxProcessingFunctional2D_L<T,Descriptor>*
00174             getInternalVelocityCornerFunctional();
00175 };
00176 
00177 
00179 
00180 template<typename T, template<typename U> class Descriptor>
00181 template<int direction, int orientation>
00182 BoundaryCompositeDynamics<T,Descriptor>*
00183     GeneralizedBoundaryManager2D<T,Descriptor>::
00184         getVelocityBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics)
00185 {
00186     std::vector<plint> const& missingIndices = 
00187         indexTemplates::subIndexOutgoing<Descriptor<T>,direction,orientation>();
00188     return new GeneralizedVelocityBoundaryDynamics<T,Descriptor>(baseDynamics,missingIndices);
00189 }
00190 
00191 template<typename T, template<typename U> class Descriptor>
00192 template<int direction, int orientation>
00193 BoxProcessingFunctional2D_L<T,Descriptor>*
00194     GeneralizedBoundaryManager2D<T,Descriptor>::
00195         getVelocityBoundaryFunctional()
00196 {
00197     return 0;
00198 }
00199 
00200 template<typename T, template<typename U> class Descriptor>
00201 template<int direction, int orientation>
00202 BoundaryCompositeDynamics<T,Descriptor>*
00203     GeneralizedBoundaryManager2D<T,Descriptor>::
00204         getPressureBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics)
00205 {
00206     std::vector<plint> const& missingIndices = 
00207         indexTemplates::subIndexOutgoing<Descriptor<T>,direction,orientation>();
00208     return new GeneralizedDensityBoundaryDynamics<T,Descriptor,direction,orientation>(baseDynamics,missingIndices);
00209 }
00210 
00211 template<typename T, template<typename U> class Descriptor>
00212 template<int direction, int orientation>
00213 BoxProcessingFunctional2D_L<T,Descriptor>*
00214     GeneralizedBoundaryManager2D<T,Descriptor>::
00215         getPressureBoundaryFunctional()
00216 {
00217     return 0;
00218 }
00219 
00220 template<typename T, template<typename U> class Descriptor>
00221 template<int xNormal, int yNormal>
00222 BoundaryCompositeDynamics<T,Descriptor>* GeneralizedBoundaryManager2D<T,Descriptor>::
00223     getExternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics)
00224 {
00225     std::vector<plint> const& missingIndices = 
00226         indexTemplates::subIndexOutgoingCorner2D<Descriptor<T>,xNormal,yNormal>();
00227         
00228     return new GeneralizedVelocityBoundaryDynamics<T,Descriptor>(baseDynamics,missingIndices);
00229 }
00230 
00231 template<typename T, template<typename U> class Descriptor>
00232 template<int xNormal, int yNormal>
00233 BoxProcessingFunctional2D_L<T,Descriptor>*
00234     GeneralizedBoundaryManager2D<T,Descriptor>::
00235         getExternalVelocityCornerFunctional()
00236 {
00237     return 0;
00238 }
00239 
00240 template<typename T, template<typename U> class Descriptor>
00241 template<int xNormal, int yNormal>
00242 BoundaryCompositeDynamics<T,Descriptor>*
00243     GeneralizedBoundaryManager2D<T,Descriptor>::
00244         getInternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics)
00245 {
00246     std::vector<plint> const& missingIndices =   
00247         indexTemplates::subIndexOutgoingInternalCorner2D<Descriptor<T>,xNormal,yNormal>();
00248     
00249     return new GeneralizedVelocityBoundaryDynamics<T,Descriptor>(baseDynamics,missingIndices);
00250 }
00251 
00252 template<typename T, template<typename U> class Descriptor>
00253 template<int xNormal, int yNormal>
00254 BoxProcessingFunctional2D_L<T,Descriptor>*
00255     GeneralizedBoundaryManager2D<T,Descriptor>::getInternalVelocityCornerFunctional()
00256 {
00257     return 0;
00258 }
00259 
00260 
00261 
00263 
00264 template<typename T, template<typename U> class Descriptor>
00265 template<int direction, int orientation>
00266 BoundaryCompositeDynamics<T,Descriptor>*
00267     WrappedGeneralizedBoundaryManager2D<T,Descriptor>::
00268         getVelocityBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics)
00269 {
00270     std::vector<plint> const& missingIndices = 
00271         indexTemplates::subIndexOutgoing<Descriptor<T>,direction,orientation>();
00272     bool automaticPrepareCollision = false;
00273     return new GeneralizedVelocityBoundaryDynamics<T,Descriptor>
00274                    (baseDynamics,missingIndices,automaticPrepareCollision);
00275 }
00276 
00277 template<typename T, template<typename U> class Descriptor>
00278 template<int direction, int orientation>
00279 BoxProcessingFunctional2D_L<T,Descriptor>*
00280     WrappedGeneralizedBoundaryManager2D<T,Descriptor>::
00281         getVelocityBoundaryFunctional()
00282 {
00283     return new WrappedLocalBoundaryFunctional2D<T,Descriptor>();
00284 }
00285 
00286 template<typename T, template<typename U> class Descriptor>
00287 template<int direction, int orientation>
00288 BoundaryCompositeDynamics<T,Descriptor>*
00289     WrappedGeneralizedBoundaryManager2D<T,Descriptor>::
00290         getPressureBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics)
00291 {
00292     std::vector<plint> const& missingIndices = 
00293         indexTemplates::subIndexOutgoing<Descriptor<T>,direction,orientation>();
00294     bool automaticPrepareCollision = false;
00295     return new GeneralizedDensityBoundaryDynamics<T,Descriptor,direction,orientation>
00296                    (baseDynamics,missingIndices,automaticPrepareCollision);
00297 }
00298 
00299 template<typename T, template<typename U> class Descriptor>
00300 template<int direction, int orientation>
00301 BoxProcessingFunctional2D_L<T,Descriptor>*
00302     WrappedGeneralizedBoundaryManager2D<T,Descriptor>::
00303         getPressureBoundaryFunctional()
00304 {
00305     return new WrappedLocalBoundaryFunctional2D<T,Descriptor>();
00306 }
00307 
00308 template<typename T, template<typename U> class Descriptor>
00309 template<int xNormal, int yNormal>
00310 BoundaryCompositeDynamics<T,Descriptor>* WrappedGeneralizedBoundaryManager2D<T,Descriptor>::
00311     getExternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics)
00312 {
00313     std::vector<plint> const& missingIndices = 
00314         indexTemplates::subIndexOutgoingCorner2D<Descriptor<T>,xNormal,yNormal>();
00315     bool automaticPrepareCollision = false;
00316     return new GeneralizedVelocityBoundaryDynamics<T,Descriptor>(baseDynamics,missingIndices,automaticPrepareCollision);
00317 }
00318 
00319 template<typename T, template<typename U> class Descriptor>
00320 template<int xNormal, int yNormal>
00321 BoxProcessingFunctional2D_L<T,Descriptor>*
00322     WrappedGeneralizedBoundaryManager2D<T,Descriptor>::
00323         getExternalVelocityCornerFunctional()
00324 {
00325     return new WrappedLocalBoundaryFunctional2D<T,Descriptor>();
00326 }
00327 
00328 template<typename T, template<typename U> class Descriptor>
00329 template<int xNormal, int yNormal>
00330 BoundaryCompositeDynamics<T,Descriptor>*
00331     WrappedGeneralizedBoundaryManager2D<T,Descriptor>::
00332         getInternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics)
00333 {
00334     std::vector<plint> const& missingIndices =   
00335         indexTemplates::subIndexOutgoingInternalCorner2D<Descriptor<T>,xNormal,yNormal>();
00336     bool automaticPrepareCollision = false;
00337     
00338     return new GeneralizedVelocityBoundaryDynamics<T,Descriptor>(baseDynamics,missingIndices,automaticPrepareCollision);
00339 }
00340 
00341 template<typename T, template<typename U> class Descriptor>
00342 template<int xNormal, int yNormal>
00343 BoxProcessingFunctional2D_L<T,Descriptor>*
00344     WrappedGeneralizedBoundaryManager2D<T,Descriptor>::getInternalVelocityCornerFunctional()
00345 {
00346     return new WrappedLocalBoundaryFunctional2D<T,Descriptor>();
00347 }
00348 
00349 
00351 
00352 template<typename T, template<typename U> class Descriptor>
00353 template<int direction, int orientation>
00354 BoundaryCompositeDynamics<T,Descriptor>*
00355     MassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00356         getVelocityBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics)
00357 {
00358     std::vector<plint> const& missingIndices = 
00359         indexTemplates::subIndexOutgoing<Descriptor<T>,direction,orientation>();
00360         
00361     std::vector<plint> const& knownIndices = 
00362         indexTemplates::opposite<Descriptor<T> >(missingIndices);
00363 //         indexTemplates::remainingIndexes<Descriptor<T> >(missingIndices);
00364         
00365     return new GeneralizedMassConservingVelocityBoundaryDynamics<T,Descriptor>(
00366                     baseDynamics,knownIndices,missingIndices,missingIndices);
00367 }
00368 
00369 template<typename T, template<typename U> class Descriptor>
00370 template<int direction, int orientation>
00371 BoxProcessingFunctional2D_L<T,Descriptor>*
00372     MassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00373         getVelocityBoundaryFunctional()
00374 {
00375     return 0;
00376 }
00377 
00378 template<typename T, template<typename U> class Descriptor>
00379 template<int direction, int orientation>
00380 BoundaryCompositeDynamics<T,Descriptor>*
00381     MassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00382         getPressureBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics)
00383 {
00384     std::vector<plint> const& missingIndices = 
00385         indexTemplates::subIndexOutgoing<Descriptor<T>,direction,orientation>();
00386         
00387     return new GeneralizedDensityBoundaryDynamics<T,Descriptor,direction,orientation>(baseDynamics,missingIndices);
00388 }
00389 
00390 template<typename T, template<typename U> class Descriptor>
00391 template<int direction, int orientation>
00392 BoxProcessingFunctional2D_L<T,Descriptor>*
00393     MassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00394         getPressureBoundaryFunctional()
00395 {
00396     return 0;
00397 }
00398 
00399 template<typename T, template<typename U> class Descriptor>
00400 template<int xNormal, int yNormal>
00401 BoundaryCompositeDynamics<T,Descriptor>* MassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00402     getExternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics)
00403 {
00404     std::vector<plint> const& missingIndices = 
00405         indexTemplates::subIndexOutgoingCorner2D<Descriptor<T>,xNormal,yNormal>();
00406     std::vector<plint> const& knownIndices = 
00407         indexTemplates::opposite<Descriptor<T> >(indexTemplates::subIndexIngoingCorner2D<Descriptor<T>,xNormal,yNormal>());
00408     
00409     std::vector<plint> inGoingIndices;
00410     inGoingIndices.push_back(indexTemplates::findVelocity<Descriptor<T> >(Array<plint,2>(-xNormal,-yNormal)));
00411         
00412     return new GeneralizedMassConservingVelocityBoundaryDynamics<T,Descriptor>(
00413                     baseDynamics,missingIndices,knownIndices,inGoingIndices);
00414 }
00415 
00416 template<typename T, template<typename U> class Descriptor>
00417 template<int xNormal, int yNormal>
00418 BoxProcessingFunctional2D_L<T,Descriptor>*
00419     MassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00420         getExternalVelocityCornerFunctional()
00421 {
00422     return 0;
00423 }
00424 
00425 template<typename T, template<typename U> class Descriptor>
00426 template<int xNormal, int yNormal>
00427 BoundaryCompositeDynamics<T,Descriptor>*
00428     MassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00429         getInternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics)
00430 {
00431     std::vector<plint> const& missingIndices =   
00432         indexTemplates::subIndexOutgoingInternalCorner2D<Descriptor<T>,xNormal,yNormal>();
00433     
00434     return new GeneralizedMassConservingVelocityBoundaryDynamics<T,Descriptor>(
00435                     baseDynamics,missingIndices,missingIndices);
00436 }
00437 
00438 template<typename T, template<typename U> class Descriptor>
00439 template<int xNormal, int yNormal>
00440 BoxProcessingFunctional2D_L<T,Descriptor>*
00441     MassConservingGeneralizedBoundaryManager2D<T,Descriptor>::getInternalVelocityCornerFunctional()
00442 {
00443     return 0;
00444 }
00445 
00446 
00447 
00449 
00450 template<typename T, template<typename U> class Descriptor>
00451 template<int direction, int orientation>
00452 BoundaryCompositeDynamics<T,Descriptor>*
00453     WrappedMassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00454         getVelocityBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics)
00455 {
00456     std::vector<plint> const& missingIndices = 
00457         indexTemplates::subIndexOutgoing<Descriptor<T>,direction,orientation>();
00458         
00459     std::vector<plint> const& knownIndices = 
00460         indexTemplates::opposite<Descriptor<T> >(missingIndices);
00461 //         indexTemplates::remainingIndexes<Descriptor<T> >(missingIndices);
00462     bool automaticPrepareCollision = false;
00463     
00464     return new GeneralizedMassConservingVelocityBoundaryDynamics<T,Descriptor>
00465         (baseDynamics,missingIndices,knownIndices,missingIndices,automaticPrepareCollision);
00466 }
00467 
00468 template<typename T, template<typename U> class Descriptor>
00469 template<int direction, int orientation>
00470 BoxProcessingFunctional2D_L<T,Descriptor>*
00471     WrappedMassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00472         getVelocityBoundaryFunctional()
00473 {
00474     return new WrappedLocalBoundaryFunctional2D<T,Descriptor>();
00475 }
00476 
00477 template<typename T, template<typename U> class Descriptor>
00478 template<int direction, int orientation>
00479 BoundaryCompositeDynamics<T,Descriptor>*
00480     WrappedMassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00481         getPressureBoundaryDynamics(Dynamics<T,Descriptor>* baseDynamics)
00482 {
00483     std::vector<plint> const& missingIndices = 
00484         indexTemplates::subIndexOutgoing<Descriptor<T>,direction,orientation>();
00485     bool automaticPrepareCollision = false;
00486     return new GeneralizedDensityBoundaryDynamics<T,Descriptor,direction,orientation>
00487                    (baseDynamics,missingIndices,automaticPrepareCollision);
00488 }
00489 
00490 template<typename T, template<typename U> class Descriptor>
00491 template<int direction, int orientation>
00492 BoxProcessingFunctional2D_L<T,Descriptor>*
00493     WrappedMassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00494         getPressureBoundaryFunctional()
00495 {
00496     return new WrappedLocalBoundaryFunctional2D<T,Descriptor>();
00497 }
00498 
00499 template<typename T, template<typename U> class Descriptor>
00500 template<int xNormal, int yNormal>
00501 BoundaryCompositeDynamics<T,Descriptor>* WrappedMassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00502     getExternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics)
00503 {
00504     std::vector<plint> const& missingIndices = 
00505         indexTemplates::subIndexOutgoingCorner2D<Descriptor<T>,xNormal,yNormal>();
00506         
00507     std::vector<plint> const& knownIndices = 
00508         indexTemplates::opposite<Descriptor<T> >(indexTemplates::subIndexIngoingCorner2D<Descriptor<T>,xNormal,yNormal>());
00509     
00510     std::vector<plint> inGoingIndices;
00511     inGoingIndices.push_back(indexTemplates::findVelocity<Descriptor<T> >(Array<plint,2>(-xNormal,-yNormal)));
00512         
00513     bool automaticPrepareCollision = false;
00514     return new GeneralizedMassConservingVelocityBoundaryDynamics<T,Descriptor>(
00515             baseDynamics,missingIndices,knownIndices,inGoingIndices,automaticPrepareCollision);
00516 }
00517 
00518 template<typename T, template<typename U> class Descriptor>
00519 template<int xNormal, int yNormal>
00520 BoxProcessingFunctional2D_L<T,Descriptor>*
00521     WrappedMassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00522         getExternalVelocityCornerFunctional()
00523 {
00524     return new WrappedLocalBoundaryFunctional2D<T,Descriptor>();
00525 }
00526 
00527 template<typename T, template<typename U> class Descriptor>
00528 template<int xNormal, int yNormal>
00529 BoundaryCompositeDynamics<T,Descriptor>*
00530     WrappedMassConservingGeneralizedBoundaryManager2D<T,Descriptor>::
00531         getInternalVelocityCornerDynamics(Dynamics<T,Descriptor>* baseDynamics)
00532 {
00533     std::vector<plint> const& missingIndices =   
00534         indexTemplates::subIndexOutgoingInternalCorner2D<Descriptor<T>,xNormal,yNormal>();
00535         
00536     std::vector<plint> const& knownIndices = 
00537         indexTemplates::opposite<Descriptor<T> >(missingIndices);
00538         
00539     bool automaticPrepareCollision = false;
00540     
00541     return new GeneralizedMassConservingVelocityBoundaryDynamics<T,Descriptor>(
00542             baseDynamics,missingIndices,knownIndices,missingIndices,automaticPrepareCollision);
00543 }
00544 
00545 template<typename T, template<typename U> class Descriptor>
00546 template<int xNormal, int yNormal>
00547 BoxProcessingFunctional2D_L<T,Descriptor>*
00548     WrappedMassConservingGeneralizedBoundaryManager2D<T,Descriptor>::getInternalVelocityCornerFunctional()
00549 {
00550     return new WrappedLocalBoundaryFunctional2D<T,Descriptor>();
00551 }
00552 
00554 
00555 template<typename T, template<typename U> class Descriptor>
00556 OnLatticeBoundaryCondition2D<T,Descriptor>* createGeneralizedBoundaryCondition2D() {
00557     return new BoundaryConditionInstantiator2D <
00558                    T, Descriptor,
00559                    WrappedGeneralizedBoundaryManager2D<T,Descriptor> >;
00560 }
00561 
00562 template<typename T, template<typename U> class Descriptor>
00563 OnLatticeBoundaryCondition2D<T,Descriptor>* createDynamicsBasedGeneralizedBoundaryCondition2D() {
00564     return new BoundaryConditionInstantiator2D <
00565                    T, Descriptor,
00566                    GeneralizedBoundaryManager2D<T,Descriptor> >;
00567 }
00568 
00569 template<typename T, template<typename U> class Descriptor>
00570 OnLatticeBoundaryCondition2D<T,Descriptor>* createGeneralizedMassConservingBoundaryCondition2D() {
00571     return new BoundaryConditionInstantiator2D <
00572                    T, Descriptor,
00573                    WrappedMassConservingGeneralizedBoundaryManager2D<T,Descriptor> >;
00574 }
00575 
00576 template<typename T, template<typename U> class Descriptor>
00577 OnLatticeBoundaryCondition2D<T,Descriptor>* createDynamicsBasedMassConservingGeneralizedBoundaryCondition2D() {
00578     return new BoundaryConditionInstantiator2D <
00579                    T, Descriptor,
00580                    MassConservingGeneralizedBoundaryManager2D<T,Descriptor> >;
00581 }
00582 
00583 }  // namespace plb
00584 
00585 #endif  // GENERALIZED_BOUNDARY_CONDITION_2D_HH