types.hpp

Go to the documentation of this file.

/*************************************************************************
 * Copyright (C) 2010 by Mario Juric 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"

namespace swarm { namespace log {

struct ALIGN(8) body
{
        double  x, y, z;
        double  vx, vy, vz;
        double   mass;
        int body_id; // EBF added

        GENERIC void set(const int& i,const ensemble::Body& b)
        {
                mass = b.mass();
                x = b[0].pos();
                y = b[1].pos();
                z = b[2].pos();
                vx = b[0].vel();
                vy = b[1].vel();
                vz = b[2].vel();
                body_id = i; 
        }
};

template<int N>
struct body_set
{
        const ensemble &ens;
        int sys, bod[N];

        GENERIC body_set(const ensemble &ens_, int sys_) : ens(ens_), sys(sys_) { }
};

GENERIC const body_set<1> make_body_set(const ensemble &ens, int sys, int bod0)
{
        body_set<1> br(ens, sys);
        br.bod[0] = bod0;
        return br;
}

GENERIC const body_set<2> make_body_set(const ensemble &ens, int sys, int bod0, int bod1)
{
        body_set<2> br(ens, sys);
        br.bod[0] = bod0;
        br.bod[1] = bod1;
        return br;
}

GENERIC const body_set<3> make_body_set(const ensemble &ens, int sys, int bod0, int bod1, int bod2)
{
        body_set<3> br(ens, sys);
        br.bod[0] = bod0;
        br.bod[1] = bod1;
        br.bod[2] = bod2;
        return br;
}

} } 



namespace gpulog {      namespace internal {  


using namespace swarm::log;

template<int N> struct alignment<body_set<N> > : public alignment<body[N]> { };
template<int N> struct    ttrait<body_set<N> > : public    ttrait<body[N]> { }; 

template<int N> struct     argio<body_set<N> >
{
        GENERIC static void put(char *ptr, const body_set<N> &br, int start, int datalen)
        {
                DHOST( std::cerr << "Writing [" << br << "] start=" << start << " len=" << datalen << "\n" );
                DGPU( printf("Writing start=%d len=%d\n", start, datalen); );
                dev_assert(sizeof(body)*N == datalen);

                // write out N bodies
                body *bodies = (body *)(ptr + start);
                for(int i=0; i < N; i++)
                {
                        bodies[i].set(i,br.ens[br.sys][br.bod[i]]);
                }
        }
};

} }