multiGrid3D.h

Go to the documentation of this file.

/* This file is part of the Palabos library.
 *
 * Copyright (C) 2011 FlowKit Sarl
 * Avenue de Chailly 23
 * 1012 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_3D_H
#define MULTI_GRID_3D_H

#include "core/globalDefs.h"
#include "core/geometry3D.h"
#include "core/array.h"
#include "multiBlock/multiBlock3D.h"
#include "multiBlock/multiBlockManagement3D.h"
#include "multiBlock/blockCommunicator3D.h"
#include "multiBlock/combinedStatistics.h"
#include "core/block3D.h"
#include "core/blockStatistics.h"
#include "multiGrid/multiScale.h"
#include "multiGrid/multiGridManagement3D.h"


namespace plb {
  
class MultiGrid3D;

class MultiGridPeriodicitySwitch3D {
  public:
    MultiGridPeriodicitySwitch3D(MultiGrid3D *block_);
    MultiGridPeriodicitySwitch3D(MultiGridPeriodicitySwitch3D const& rhs);
    MultiGridPeriodicitySwitch3D& operator=(MultiGridPeriodicitySwitch3D const& rhs);
    
    void swap(MultiGridPeriodicitySwitch3D& rhs);
 
    void toggle(int direction, bool periodicity);
    void toggleAll(bool periodicity);
 
    Array<bool,3> const& getPeriodicityArray() const;
    
  private:
    MultiGrid3D* block;
    Array<bool,3> periodicityArray;
    
};


class MultiGridStatSubscriber3D {
public:
    MultiGridStatSubscriber3D(MultiGrid3D* multiGrid_);
    MultiGridStatSubscriber3D(MultiGridStatSubscriber3D const& rhs);
    
    void swap(MultiGridStatSubscriber3D& rhs);
    MultiGridStatSubscriber3D& operator=(MultiGridStatSubscriber3D const& rhs);
    
    plint subscribeAverage(plint dimDx, plint dimDt);
    plint subscribeSum(plint dimDx, plint dimDt);
    plint subscribeMax(plint dimDx, plint dimDt);
    plint subscribeIntSum(plint dimDx, plint dimDt);
    void initialize();    
    
    std::vector<int> const& getDimensionsX() const;
    std::vector<int> const& getDimensionsT() const;
    
private:
    MultiGrid3D* multiGrid;
    std::vector<int> dimensionsX;
    std::vector<int> dimensionsT;
};

  
class MultiGrid3D : public Block3D
{
  public:
    MultiGrid3D( MultiGridManagement3D management, 
                 plint behaviorLevel_);
    // Copy constructor
    MultiGrid3D(const MultiGrid3D& rhs);
    MultiGrid3D(MultiGrid3D const& rhs, Box3D subDomain, bool crop);
    virtual ~MultiGrid3D();
    
    void swap(MultiGrid3D& rhs);
    
    virtual MultiBlock3D const& getComponent(plint level) const = 0;
    virtual MultiBlock3D& getComponent(plint level)             = 0;
    
    MultiGridManagement3D const& getMultiGridManagement() const;
    MultiGridManagement3D& getMultiGridManagement();
     
    plint getNx() const;
    plint getNy() const;
    plint getNz() const;
    
    virtual Box3D getBoundingBox() const;
    
    plint getReferenceLevel() const;
    plint getNumLevels() const;
    plint getBehaviorLevel() const;
    void setBehaviorLevel(plint behaviorLevel_);
    
    void initialize();
    
    void executeInternalProcessors();
    void executeInternalProcessors(plint level);   

    void subscribeProcessor(plint level);
    
    BlockStatistics& getInternalStatistics();
    BlockStatistics const& getInternalStatistics() const;
    
    void reduceStatistics();
    void evaluateStatistics();
    void toggleInternalStatistics(bool statisticsOn_);
    bool isInternalStatisticsOn() const;
    
    MultiGridPeriodicitySwitch3D const& periodicity() const;
    MultiGridPeriodicitySwitch3D& periodicity();
    void signalPeriodicity();
    
    MultiGridStatSubscriber3D& internalStatSubscription();
    
    MultiScaleManager const& getScaleManager() const;

    virtual DataSerializer* getBlockSerializer (
            Box3D const& domain, IndexOrdering::OrderingT ordering ) const;
    virtual DataUnSerializer* getBlockUnSerializer (
            Box3D const& domain, IndexOrdering::OrderingT ordering );

    virtual int getBlockId () const =0;

  private:
    // reference level management
    MultiGridManagement3D management; 

    plint behaviorLevel;
    MultiGridPeriodicitySwitch3D periodicitySwitch;

    plint maxProcessorLevel;
    bool statisticsOn;
    
    MultiGridStatSubscriber3D statsSubscriber;
    BlockStatistics internalStatistics;
    
    // Used to easen the scale conversion in this class
    MultiScaleManager *scaleManager; 
};

// checkpointing for the multiGrid
void saveBinaryGrid(MultiGrid3D const& block, std::string fName, bool enforceUint=false);
void loadBinaryGrid(MultiGrid3D& block, std::string fName, bool enforceUint=false);



} // namespace plb

#endif  // MULTI_GRID_3D_H