globalDefs.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/>.
*/

#ifndef GLOBAL_DEFS_H
#define GLOBAL_DEFS_H

#ifdef PLB_MPI_PARALLEL
#include "mpi.h"
#endif

#include <limits>
#include <string>
#include <cstddef>

namespace plb {


#ifdef PLB_BGP
typedef long long int plint;
#else
typedef ptrdiff_t plint;
#endif


#ifdef PLB_BGP
typedef unsigned long long int pluint;
#else
typedef size_t pluint;
#endif

typedef unsigned long id_t;

enum Precision { FLT, DBL, LDBL };

template<typename T>
inline T getEpsilon(Precision precision)
{
    T epsilon;

    switch (precision) {
    case FLT:
        epsilon = std::numeric_limits<float>::epsilon();
        break;
    case DBL:
        epsilon = std::numeric_limits<double>::epsilon();
        break;
    case LDBL: default:
        epsilon = std::numeric_limits<long double>::epsilon();
        break;
    }

    T coef = 10.0; // hack for better results

    return (coef * epsilon);
}

enum SurfaceGeometryFileFormat { STL };


namespace IndexOrdering {
    enum OrderingT {forward, backward, memorySaving};
}


namespace BlockDomain {

    enum DomainT {bulk, envelope, bulkAndEnvelope};
    inline bool usesEnvelope(DomainT domain) {
        return domain==envelope || domain==bulkAndEnvelope;
    }

}

namespace modif {

    enum ModifT {
        nothing          =0,  //< No modification.
        staticVariables  =1,  //< Static cell content (populations+externals).
        dynamicVariables =2,  //< Only content of dynamics objects, but no static content.
        allVariables     =3,  //< Both the static and dynamic cell content.
        dataStructure    =4,  //< Recreate dynamics and copy both static and dynamic content.
        undefined        =5   //< Used for debugging purposes only.
    };

    enum { numConstants=5 };

    inline ModifT combine(ModifT type1, ModifT type2) {
        ModifT result = std::max(type1, type2);
        // Note: static+dynamic = all.
        if ( result==dynamicVariables &&
             (type1==staticVariables || type2==staticVariables) )
        {
            result = allVariables;
        }
        return result;
    }
}

namespace global {

class IOpolicyClass {
public:
    void setIndexOrderingForStreams(IndexOrdering::OrderingT streamOrdering_);
    IndexOrdering::OrderingT getIndexOrderingForStreams() const;

    void setEndianSwitchOnBase64out(bool doSwitch);
    bool getEndianSwitchOnBase64out();

    void setEndianSwitchOnBase64in(bool doSwitch);
    bool getEndianSwitchOnBase64in();

    void setStlFilesHaveLowerBound(bool flag);
    bool stlFilesHaveLowerBound() const;

    void setLowerBoundForStlFiles(double stlLowerBound_);
    double getLowerBoundForStlFiles() const;

    void activateParallelIO(bool activate);
    bool useParallelIO() const;
private:
    IOpolicyClass();
private:
    IndexOrdering::OrderingT streamOrdering;
    bool endianSwitchOnBase64out;
    bool endianSwitchOnBase64in;
    bool stlLowerBoundFlag;
    double stlLowerBound;
    bool parallelIOflag;
    friend IOpolicyClass& IOpolicy();
};
    
class Directories {
public:
    void setOutputDir(std::string outputDir_);
    void setLogOutDir(std::string logOutDir_);
    void setImageOutDir(std::string imageOutDir_);
    void setVtkOutDir(std::string inputDir_);
    void setInputDir(std::string inputDir);

    std::string getLogOutDir() const;
    std::string getImageOutDir() const;
    std::string getVtkOutDir() const;
    std::string getInputDir() const;
    std::string getOutputDir() const;
private:
    Directories();
private:
    std::string logOutDir;
    std::string imageOutDir;
    std::string vtkOutDir;
    std::string inputDir;
    std::string outputDir;
friend Directories& directories();
};

inline Directories& directories() {
    static Directories singleton;
    return singleton;
}

inline IOpolicyClass& IOpolicy() {
    static IOpolicyClass singleton;
    return singleton;
}

}  // namespace global

}  // namespace plb

#endif