trajectorydiagnostics.hpp

Go to the documentation of this file.

 
/* Copyright (c) 2005-2012,2016,2021 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 "error.hpp"
#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 {
        if( i >= _column.size() )
            throw( ErrorRange( ERROR_LOCATION, i, _column.size() ) );
        return( _column[i] );
    }
 
    TrajectoryDiagnosticColumn &operator()( size_t i ) {
        if( i >= _column.size() )
            throw( ErrorRange( ERROR_LOCATION, i, _column.size() ) );
        return( _column[i] );
    }
 
    const double &operator()( size_t j, size_t i ) const {
        if( i >= _column.size() )
            throw( ErrorRange( ERROR_LOCATION, i, _column.size() ) );
        return( _column[i](j) );
    }
 
    double &operator()( size_t j, size_t i ) {
        if( i >= _column.size() )
            throw( ErrorRange( ERROR_LOCATION, i, _column.size() ) );
        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 current( void ) const { return( _Isum ); }
 
    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