integrator.hpp

Go to the documentation of this file.

/*************************************************************************
 * Copyright (C) 2011 by Saleh Dindar and the Swarm-NG Development Team  *
 *                                                                       *
 * This program 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.        *
 *                                                                       *
 * This program 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 this program; if not, write to the                         *
 * Free Software Foundation, Inc.,                                       *
 * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ************************************************************************/
#pragma once

#include "types/ensemble.hpp"
#include "ensemble_alloc.hpp"
#include "types/config.hpp"
#include "log/logmanager.hpp"


namespace swarm {

class integrator {      
        public:
        
        const static int _default_max_iterations;
        const static int _default_max_attempts;
        protected:

        defaultEnsemble _ens;          

        double _destination_time;

        log::Pmanager _logman;

        //  WARNING: Why do we store a raw pointer here?  
        // Any reason not to just use host_log stored in _logman?
        // Answer to WARNING: we may have different log streams and each
        // integrator can use their own log stream
        gpulog::host_log* _log;

        int _max_iterations;
        int _max_attempts;

        virtual void launch_integrator() = 0 ;

        public:
        integrator(const config &cfg);

        virtual void integrate();

        virtual void flush_log() {
          _logman->flush();       
        }

        virtual defaultEnsemble& get_ensemble() {
                return _ens;
        }

        virtual void set_ensemble(defaultEnsemble& ens) {
                _ens = ens;
        }

        virtual void set_destination_time(const double& destination_time) {
                _destination_time = destination_time;
        }

        virtual double get_destination_time()const{
                return _destination_time;
        }

        static shared_ptr<integrator> create(const config &cfg);

        virtual void set_log_manager(log::Pmanager& l);
        virtual gpulog::host_log* get_host_log();

        virtual void set_max_iterations( const int& mi ) { _max_iterations = mi; }
        virtual void set_max_attempts( const int& ma ) { _max_attempts = ma; }

};
typedef shared_ptr<integrator> Pintegrator;


int number_of_active_systems(defaultEnsemble ens) ;


namespace gpu {

class integrator : public swarm::integrator {
        typedef swarm::integrator Base;
        protected:
        hostEnsemble& _hens;
        deviceEnsemble _dens;

        gpulog::device_log* _log;

        public: 

        integrator(const config &cfg);

        virtual void integrate();

        virtual void core_integrate() {
                launch_integrator();
                flush_log();
        }

        virtual void set_log_manager(log::Pmanager& l);

        void set_log(gpulog::device_log* log) { _log = log; }

        gpulog::device_log* get_device_log() { return _log; }

        void set_ensemble(defaultEnsemble& ens) {
                _hens = ens;
                _dens = _hens.cloneTo<deviceEnsemble>();
        }

        void set_ensemble(defaultEnsemble& host_ens, deviceEnsemble& device_ens) {
                _hens = host_ens;
                _dens = device_ens;
        }

        void upload_ensemble() {
                _hens.copyTo( _dens );
        }
                
        void download_ensemble() {
                _dens.copyTo( _hens );
        }

};
typedef shared_ptr<integrator> Pintegrator;


}

}