trajectorydiagnostics.hpp

Go to the documentation of this file.

/* Copyright (c) 2005-2012 Taneli Kalvas. All rights reserved.
 *
 * You can redistribute this software 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 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
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this library (file "COPYING" included in the package);
 * if not, write to the Free Software Foundation, Inc., 51 Franklin
 * Street, Fifth Floor, Boston, MA 02110-1301 USA
 * 
 * If you have questions about your rights to use or distribute this
 * software, please contact Berkeley Lab's Technology Transfer
 * Department at TTD@lbl.gov. Other questions, comments and bug
 * reports should be sent directly to the author via email at
 * taneli.kalvas@jyu.fi.
 * 
 * NOTICE. This software was developed under partial funding from the
 * U.S.  Department of Energy.  As such, the U.S. Government has been
 * granted for itself and others acting on its behalf a paid-up,
 * nonexclusive, irrevocable, worldwide license in the Software to
 * reproduce, prepare derivative works, and perform publicly and
 * display publicly.  Beginning five (5) years after the date
 * permission to assert copyright is obtained from the U.S. Department
 * of Energy, and subject to any subsequent five (5) year renewals,
 * the U.S. Government is granted for itself and others acting on its
 * behalf a paid-up, nonexclusive, irrevocable, worldwide license in
 * the Software to reproduce, prepare derivative works, distribute
 * copies to the public, perform publicly and display publicly, and to
 * permit others to do so.
 */

#ifndef TRAJECTORYDIAGNOSTICS_HPP
#define TRAJECTORYDIAGNOSTICS_HPP 1


#include <vector>
#include <limits>
#include "histogram.hpp"
#include "types.hpp"


class TrajectoryDiagnosticColumn 
{

    trajectory_diagnostic_e _diag; 
    std::vector<double>     _data; 
public:

    TrajectoryDiagnosticColumn( trajectory_diagnostic_e diag ) 
        : _diag(diag) {}

    void mirror( coordinate_axis_e axis, double level );

    void add_data( double x ) {
        _data.push_back( x );
    }

    std::vector<double> &data( void ) { return( _data ); }

    const std::vector<double> &data( void ) const { return( _data ); }

    size_t size( void ) const { return( _data.size() ); }

    trajectory_diagnostic_e diagnostic( void ) const { return( _diag ); }

    const double &operator()( size_t i ) const { return( _data[i] ); }

    double &operator()( size_t i ) { return( _data[i] ); }

    const double &operator[]( size_t i ) const { return( _data[i] ); }

    double &operator[]( size_t i ) { return( _data[i] ); }
};


class TrajectoryDiagnosticData 
{

    std::vector<TrajectoryDiagnosticColumn> _column; 
public:

    TrajectoryDiagnosticData() {}

    TrajectoryDiagnosticData( std::vector<trajectory_diagnostic_e> diag ) {
        for( size_t a = 0; a < diag.size(); a++ )
            _column.push_back( TrajectoryDiagnosticColumn( diag[a] ) );
    }

    void mirror( coordinate_axis_e axis, double level ) {
        for( size_t a = 0; a < _column.size(); a++ )
            _column[a].mirror( axis, level );
    }

    void clear() {
        _column.clear();
    }
    
    void add_data_column( trajectory_diagnostic_e diag ) {
        _column.push_back( TrajectoryDiagnosticColumn( diag ) );
    }

    size_t diag_size() const {
        return( _column.size() );
    }

    size_t traj_size() const {
        if( _column.size() > 0 )
            return( _column[0].size() );
        return( 0 );
    }

    trajectory_diagnostic_e diagnostic( size_t i ) const {
        return( _column[i].diagnostic() ); 
    }

    const TrajectoryDiagnosticColumn &operator()( size_t i ) const {
        return( _column[i] );
    }

    TrajectoryDiagnosticColumn &operator()( size_t i ) {
        return( _column[i] );
    }

    const double &operator()( size_t j, size_t i ) const {
        return( _column[i](j) );
    }

    double &operator()( size_t j, size_t i ) {
        return( _column[i](j) );
    }

    void add_data( size_t i, double x ) {
        _column[i].add_data( x );
    }

    void export_data( const std::string &filename );
};


class Emittance
{
protected:

    double _Isum;

    double _xave;
    double _xpave;

    double _x2;
    double _xp2;
    double _xxp;

    double _alpha;
    double _beta;
    double _gamma;
    double _epsilon;

    double _angle;
    double _rmajor;
    double _rminor;

public:

    Emittance();

    Emittance( const std::vector<double> &x,
               const std::vector<double> &xp,
               const std::vector<double> &I );

    Emittance( const std::vector<double> &x,
               const std::vector<double> &xp );

    Emittance( size_t xsize, size_t xpsize, const double range[4],
               const std::vector<double> &I );

    double xave( void ) const { return( _xave ); }

    double xpave( void ) const { return( _xpave ); }

    double alpha( void ) const { return( _alpha ); }

    double beta( void ) const { return( _beta ); }

    double gamma( void ) const { return( _gamma ); }

    double epsilon( void ) const { return( _epsilon ); }

    double angle( void ) const { return( _angle ); }

    double rmajor( void ) const { return( _rmajor ); }

    double rminor( void ) const { return( _rminor ); } 

    void debug_print( std::ostream &os ) const;
};



class EmittanceConv : public Emittance
{

    Histogram2D *_grid;

public:

    EmittanceConv( uint32_t n, uint32_t m,
                   const std::vector<double> &r,
                   const std::vector<double> &rp,
                   const std::vector<double> &ap,
                   const std::vector<double> &I,
                   uint32_t rotn = 100,
                   double xmin = std::numeric_limits<double>::quiet_NaN(), 
                   double xpmin = std::numeric_limits<double>::quiet_NaN(), 
                   double xmax = std::numeric_limits<double>::quiet_NaN(), 
                   double xpmax = std::numeric_limits<double>::quiet_NaN() );

    ~EmittanceConv();

    const Histogram2D &histogram( void ) const { return( *_grid ); }

    void free_histogram( void ) { delete _grid; _grid = NULL; }
};


#endif