This file is indexed.

/usr/include/palabos/multiGrid/multiGridLattice2D.h is in libplb-dev 1.5~r1+repack1-3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
/* This file is part of the Palabos library.
 *
 * Copyright (C) 2011-2015 FlowKit Sarl
 * Route d'Oron 2
 * 1010 Lausanne, Switzerland
 * E-mail contact: contact@flowkit.com
 *
 * The most recent release of Palabos can be downloaded at 
 * <http://www.palabos.org/>
 *
 * The library Palabos is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * The library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

/* Main author: Daniel Lagrava
 **/

#ifndef MULTI_GRID_LATTICE_2D_H
#define MULTI_GRID_LATTICE_2D_H

#include "multiGrid/multiGrid2D.h"
#include "core/globalDefs.h"
#include "core/geometry2D.h"
#include "core/array.h"
#include "multiBlock/multiBlock2D.h"
#include "multiBlock/multiBlockManagement2D.h"
#include "multiBlock/blockCommunicator2D.h"
#include "multiBlock/combinedStatistics.h"
#include "core/block2D.h"
#include "core/blockStatistics.h"

#include "multiGrid/multiGridParameterManager.h"
#include "multiGrid/coarseGridProcessors2D.h"
#include "multiGrid/fineGridProcessors2D.h"
#include "multiGrid/gridRefinement.h"
#include "multiGrid/gridRefinementDynamics.h"
#include "multiGrid/multiGridGenerator2D.h"

#include <memory>

namespace plb {

/// Main class when dealing with grid refinement
template <typename T, template <typename U> class Descriptor>
class MultiGridLattice2D : public BlockLatticeBase2D< T,Descriptor >, public MultiGrid2D {

  public:
    MultiGridLattice2D(MultiGridManagement2D management,
                       std::vector<BlockCommunicator2D* > communicators_,
                       std::vector<CombinedStatistics*> combinedStatistics_, 
                       Dynamics<T,Descriptor>* backgroundDynamics, plint behaviorLevel,
                       FineGridInterfaceInstantiator<T,Descriptor> *fineGridInstantiator_,
                       CoarseGridInterfaceInstantiator<T,Descriptor> *coarseGridInstantiator_
                        );

    MultiGridLattice2D( MultiGridManagement2D management,
                       Dynamics<T,Descriptor>* backgroundDynamics, plint behaviorLevel,
                       FineGridInterfaceInstantiator<T,Descriptor> *fineGridInstantiator_,
                       CoarseGridInterfaceInstantiator<T,Descriptor> *coarseGridInstantiator_ 
                        );

    /// Copy constructor for the whole multi grid
    MultiGridLattice2D(MultiGridLattice2D<T,Descriptor> const& rhs);
    /// Copy constructor for a subdomain of the multi grid
    MultiGridLattice2D(MultiGridLattice2D<T,Descriptor> const& rhs, Box2D subDomain, bool crop=true);
    
    MultiGridLattice2D(MultiGrid2D const& rhs);
    MultiGridLattice2D(MultiGrid2D const& rhs, Box2D subDomain, bool crop=true);
    
    MultiGridLattice2D<T,Descriptor>& operator=(MultiGridLattice2D<T,Descriptor> const& rhs);
    ~MultiGridLattice2D();
    
    /// Create the couplings between lattices
    void initialize();
    
    /// Create a single multiBlock that represents the multiGrid. 
    std::auto_ptr<MultiBlockLattice2D<T,Descriptor> > convertToLevel(plint level) const;
    
    /* *** MultiGrid2D methods *** */
    int getBlockId () const;
    
    /// Retrieve the lattices representing each a refinement level
    MultiBlockLattice2D<T,Descriptor>& getComponent(plint iBlock);
    const MultiBlockLattice2D<T,Descriptor>& getComponent(plint iBlock) const;
    
    /* **** BlockLatticeBase2D methods **** */
    
    virtual Cell<T,Descriptor>& get(plint iX, plint iY);
    virtual Cell<T,Descriptor> const& get(plint iX, plint iY) const;
    virtual void specifyStatisticsStatus (Box2D domain, bool status);
    virtual void collide(Box2D domain);
    virtual void collide();
    virtual void stream(Box2D domain);
    virtual void stream();              
    virtual void collideAndStream(Box2D domain);
    virtual void collideAndStream();    
    virtual void incrementTime();
    TimeCounter& getTimeCounter();
    TimeCounter const& getTimeCounter() const;
  private:
    void createInterfaces();
    void iterateMultiGrid(plint level);
    void eliminateStatisticsInOverlap();
  private:
    std::vector<MultiBlockLattice2D<T,Descriptor>*> lattices;
    // the objects to create the interfaces
    FineGridInterfaceInstantiator<T,Descriptor> *fineGridInstantiator;
    CoarseGridInterfaceInstantiator<T,Descriptor> *coarseGridInstantiator;
};

template<typename T, template<typename U> class Descriptor>
double getStoredAverageDensity(MultiGridLattice2D<T,Descriptor> const& multiGrid);

template<typename T, template<typename U> class Descriptor>
double getStoredAverageEnergy(MultiGridLattice2D<T,Descriptor> const& multiGrid);

template<typename T, template<typename U> class Descriptor>
double getStoredMaxVelocity(MultiGridLattice2D<T,Descriptor> const& multiGrid);

}// namespace plb

#endif