ProblemSetup.hpp

Go to the documentation of this file.

/*
 *  This file is part of AQUAgpusph, a free CFD program based on SPH.
 *  Copyright (C) 2012  Jose Luis Cercos Pita <jl.cercos@upm.es>
 *
 *  AQUAgpusph is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  AQUAgpusph 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with AQUAgpusph.  If not, see <http://www.gnu.org/licenses/>.
 */

 
#ifndef PROBLEMSETUP_H_INCLUDED
#define PROBLEMSETUP_H_INCLUDED

#define __NO_OUTPUT_MODE__ 0
#define __FPS_MODE__ 1 << 0
#define __IPF_MODE__ 1 << 1
#define __TIME_MODE__ 1 << 0
#define __ITER_MODE__ 1 << 1
#define __FRAME_MODE__ 1 << 2
 
#include "sphPrerequisites.hpp"
 
#include <math.h>
#include <string>
#include <vector>
#include <vector>
#include <map>
 
#if __APPLE__
#include <OpenCL/cl.h>
#else
#include <CL/cl.h>
#endif
 
namespace Aqua {
namespace InputOutput {

class DECLDIR ProblemSetup
{
  public:
        ProblemSetup();

        ProblemSetup(const ProblemSetup& p);

        ~ProblemSetup();

        inline void dims(unsigned int n) { _dims = n; }

        inline unsigned int dims() const { return _dims; }

        inline void nCmdQueues(unsigned int n) { _n_cmd_queues = n; }

        inline unsigned int nCmdQueues() const { return _n_cmd_queues; }

        class sphSettings
        {
          public:
                sphSettings();
                ~sphSettings(){};

                bool save_on_fail;

                typedef enum _debug {
                        NO_DEBUG = 0,
                        DEBUG_EVENTS = 1<<0,
                        DEBUG_ARGS = 1<<1,
                        DEBUG_DEPS_SYNC = 1<<2,
                        DEBUG_SYNC = 1<<3
                } debug_opts;

                int debug_tools;

                std::string base_path;

                class device
                {
                  public:
                        typedef enum _patch {
                                AUTO = 0,
                                ENABLED = 1,
                                DISABLED = 2
                        } patch_state;

                        device(const unsigned int platform_index,
                               const unsigned int device_index,
                               const cl_device_type t = CL_DEVICE_TYPE_ALL,
                               const unsigned int bits = 32,
                                   const std::string compile_flags = "")
                          : platform_id(platform_index)
                          , device_id(device_index)
                          , device_type(t)
                          , addr_bits(bits)
                          , compilation_flags(compile_flags)
                          , patches({{"nvidia_#4665567", patch_state::AUTO},
                                     {"nvidia_#9999999", patch_state::AUTO},
                                    })
                        {};

                        ~device(){};

                        unsigned int platform_id;

                        unsigned int device_id;

                        cl_device_type device_type;

                        unsigned int addr_bits;

                        std::string compilation_flags;

                        std::map<std::string, int> patches;

                        inline bool isPatchEnabled(const std::string name) const
                        {
                                return patches.at(name) == patch_state::ENABLED;
                        }

                        inline bool isPatchDisabled(const std::string name) const
                        {
                                return patches.at(name) == patch_state::DISABLED;
                        }
                };

                std::vector<ProblemSetup::sphSettings::device> devices;
 
        };

        sphSettings settings;

        class sphVariables
        {
          public:
                sphVariables(){};
                ~sphVariables(){};

                std::vector<std::string> names;
                std::vector<std::string> types;
                std::vector<std::string> lengths;
                std::vector<std::string> values;

                void registerVariable(std::string name,
                                      std::string type,
                                      std::string length,
                                      std::string value);
        };

        sphVariables variables;

        struct sphDefinitions
        {
                sphDefinitions(){};
                ~sphDefinitions(){};

                std::vector<std::string> names;
                std::vector<std::string> values;
                std::vector<bool> evaluations;

                void define(const std::string name,
                            const std::string value,
                            const bool evaluate);

                bool isDefined(std::string name);

                void undefine(std::string name);
        };

        sphDefinitions definitions;

        class sphTool
        {
          public:
                sphTool(){};

                ~sphTool(){};

                void set(const std::string name, const std::string value);

                const std::string get(const std::string name);

                const std::string get(unsigned int index);

                const std::string getName(unsigned int index);

                unsigned int n() const { return _data.size(); }
 
          private:
                bool has(const std::string name);

                std::map<std::string, std::string> _data;
        };

        std::vector<sphTool*> tools;

        unsigned int toolInstances(ProblemSetup::sphTool* tool);

        std::vector<sphTool*> reports;

        struct sphTimingParameters
        {
                unsigned int sim_end_mode;

                float sim_end_time;

                int sim_end_step;

                int sim_end_frame;

                unsigned int output_mode;

                float output_fps;

                int output_ipf;

                unsigned int dt_mode;
        } time_opts;

        class sphParticlesSet
        {
          public:
                sphParticlesSet();

                ~sphParticlesSet();

                void n(size_t N) { _n = N; }

                size_t n() const { return _n; }

                void addScalar(std::string name, std::string value);

                std::vector<std::string> scalarNames() const { return _snames; }

                std::vector<std::string> scalarValues() const { return _svalues; }

                void input(std::string path, std::string format, std::string fields);

                const std::string inputPath() const { return _in_path; }

                const std::string inputFormat() const { return _in_format; }

                std::vector<std::string> inputFields() const { return _in_fields; }

                void output(std::string path, std::string format, std::string fields);

                const std::string outputPath() const { return _out_path; }

                const std::string outputFormat() const { return _out_format; }

                std::vector<std::string> outputFields() const { return _out_fields; }
 
          private:
                size_t _n;

                std::vector<std::string> _snames;
                std::vector<std::string> _svalues;

                std::string _in_path;

                std::string _in_format;

                std::vector<std::string> _in_fields;

                std::string _out_path;

                std::string _out_format;

                std::vector<std::string> _out_fields;
        };

        std::vector<sphParticlesSet*> sets;
 
  private:
        unsigned int _dims;

        unsigned int _n_cmd_queues;

        bool _copy;
};
 
}
} // namespace
 
#endif // PROBLEMSETUP_H_INCLUDED