UniformPlaneSampler.h

Go to the documentation of this file.

/*
 * Copyright (C) <2012> <EDF-R&D> <FRANCE>
 * 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 2 of the License, or
 * (at your option) any later version.
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
// Rajout de libraires pour creation fichier externe de sortie
#include <limits>
#include <iostream>
#include <fstream>
#include <sstream>
#include <deque>
#include <stack>
#include <string>
#include <math.h>
#include "Sampler.h"
#include "Tools/UnitConverter.h"
#include "Repere.h"
#include "Geometry/mathlib.h"
 
#ifndef UNIFORM_PLANE_SAMPLER
    #define UNIFORM_PLANE_SAMPLER
 
using namespace std;
 
class UniformPlaneSampler : public Sampler
{
public:
    UniformPlaneSampler(const vector<vec3> directions, const unsigned int& nbRays = 8)
        : Sampler(nbRays, (decimal)M_2PI, (decimal)M_2PI), _real_nb_rays(0), _nb_rays_per_direction(0),
          _nb_rays_per_plane(0), _nb_directions(0), _i(0), _j(0),
          _repere(Repere(vec3(1., 0., 0.), vec3(0., 1., 0.), vec3(0., 0., 1.), vec3(0., 0., 0.))),
          _directions(directions)
    {
        init();
    }
 
    UniformPlaneSampler(const UniformPlaneSampler& other) : Sampler(other)
    {
        _real_nb_rays = other._real_nb_rays;
        _nb_rays_per_direction = other._nb_rays_per_direction;
        _nb_rays_per_plane = other._nb_rays_per_plane;
        _nb_directions = other._nb_directions;
        _i = 0;
        _j = 0;
        _directions = other._directions;
        _repere = other._repere;
    }
 
    UniformPlaneSampler(UniformPlaneSampler* other) : Sampler(other)
    {
        _real_nb_rays = other->_real_nb_rays;
        _nb_rays_per_direction = other->_nb_rays_per_direction;
        _nb_rays_per_plane = other->_nb_rays_per_plane;
        _nb_directions = other->_nb_directions;
        _i = 0;
        _j = 0;
        _directions = other->_directions;
        _repere = other->_repere;
    }
 
    virtual Sampler* Clone()
    {
        Sampler* sampler = new UniformPlaneSampler(this);
        return sampler;
    }
    virtual ~UniformPlaneSampler() {}
 
    virtual vec3 getSample()
    {
        vec3 result(1., 0., 0.);
        if (_i >= _nb_rays_per_direction)
        {
            _i = 0;
            _j++;
        }
 
        if (_j < _nb_directions)
        {
            vec3 dir = _directions.at(_j);
 
            if (_i == 0)
            {
 
                // Compute the axises of the global repere
                vec3 ax2 = vec3(0., 0., 1.); // the second axis is orthogonal to the direction and th z-axis
                ax2.cross(dir);
                ax2.normalize();
 
                vec3 ax3 = dir;
                ax3.cross(ax2); // the second axis is orthogonal to the first one and to the directivity
                ax3.normalize();
 
                // Mapping from the local repere to the global one (the third axis is the directivity and
                // corresponds to the local z_axis)
                _repere = Repere(dir, ax2, ax3, vec3(0., 0., 0.));
            }
 
            if (_i >= _nb_rays_per_plane)
            {
                if (_i % (_nb_rays_per_plane / 2) == 0)
                    _i++; // skip the rays already launched on the other plane
                Tools::fromRadianToCarthesien((_i - _nb_rays_per_plane) * M_2PI / _nb_rays_per_plane, 0,
                                              result);
            }
            else
            {
                Tools::fromRadianToCarthesien(0, _i * M_2PI / _nb_rays_per_plane, result);
            }
            _i++;
        }
        // return result;
        return _repere.vectorFromLocalToGlobal(
            result); // rotate the sample according to the rotation between the z-axis and the directivity;
    }
 
    // v is acceptable if it lies in the beam's cone
    virtual bool isAcceptableSample(vec3 v)
    {
        return true;
    }
 
    virtual void init()
    {
 
        _nb_directions = _directions.size();
        _nb_rays_per_direction = floor(_nb_rays / 8. + 0.5) * 8;
        _nb_rays_per_plane = _nb_rays_per_direction / 2;
        _real_nb_rays =
            _nb_directions *
            (_nb_rays_per_direction -
             2); // We remove two rays per direction because the two planes have two rays in common
    }
    // Return the real number of launched rays
    unsigned int getRealNbRays() const
    {
        return _real_nb_rays;
    }
 
private:
    unsigned int _real_nb_rays;          
    unsigned int _nb_rays_per_direction; 
    unsigned int _nb_rays_per_plane;     
    unsigned int _nb_directions;         
    unsigned int _i, _j;                 
    vector<vec3> _directions;            
    Repere _repere;                      
};
 
#endif