casa6

#ifndef _CASA_SAKURA_ARRAY_CONVERTER_H_

#define _CASA_SAKURA_ARRAY_CONVERTER_H_

​

#include <iostream>

#include <string>

#include <stdexcept>

//#include <libsakura/sakura.h>

#include <casacore/casa/aipstype.h>

​

// AIPS++

#include <casacore/casa/aips.h>

#include <casacore/casa/Utilities/CountedPtr.h>

#include <casacore/casa/Arrays/Vector.h>

#include <casacore/casa/Arrays/Matrix.h>

#include <casacore/casa/Arrays/Cube.h>

#include <casacore/casa/BasicSL/Complex.h>

​

using namespace std;

​

namespace casa { //# NAMESPACE CASA - BEGIN

​

class SakuraArrayConverter {

protected:

​

public:

    template<class T, class S> static void ConvertCASAToSakura(

            casacore::uInt const pol_index, casacore::uInt const num_data,

            const casacore::Matrix<T> &input_matrix, S *output_data) {

        casacore::uInt const max_pol = input_matrix.nrow();

        if (!(pol_index < max_pol)) {

            throw std::invalid_argument(

                    "pol_index must less than input_matrix.nrow()");

        }

        if (!(num_data == input_matrix.ncolumn())) {

            throw std::invalid_argument(

                    "num_data must equal to input_matrix.ncolumn()");

        }

        casacore::Bool deleteIn;

        const T* pin = input_matrix.getStorage(deleteIn);

        for (casacore::uInt i = 0; i < num_data; ++i) {

            CASAToSakura(max_pol * i + pol_index, i, pin, output_data);

        }

        input_matrix.freeStorage(pin, deleteIn);

    }

    template<class S, class T> static void ConvertSakuraToCASA(

            casacore::uInt const pol_index, casacore::uInt const num_data, S const *input_data,

            casacore::Matrix<T> &output_matrix) {

        casacore::uInt const max_pol = output_matrix.nrow();

        if (!(pol_index < max_pol)) {

            throw std::invalid_argument(

                    "pol_index must less than input_matrix.nrow()");

        }

        if (!(num_data == output_matrix.ncolumn())) {

            throw std::invalid_argument(

                    "num_data must equal to output_matrix.ncolumn()");

        }

        casacore::Bool deleteOut;

        T* pout = output_matrix.getStorage(deleteOut);

        for (casacore::uInt i = 0; i < num_data; ++i) {

            SakuraToCASA(i, max_pol * i + pol_index, input_data, pout);

        }

        output_matrix.putStorage(pout, deleteOut);

    }

​

private:

    template<class T, class S> static void CASAToSakura(casacore::uInt const index_in,

            casacore::uInt const index_out, const T* pin, S *output_data) {

        output_data[index_out] = pin[index_in];

    }

    template<class S, class T> static void SakuraToCASA(casacore::uInt const index_in,

            casacore::uInt const index_out, S const *input_data, T* pout) {

        pout[index_out] = input_data[index_in];

    }

};

​

template<> void SakuraArrayConverter::CASAToSakura<casacore::Complex, float>(

        casacore::uInt const index_in, casacore::uInt const index_out, const casacore::Complex* pin,

        float *output_data);

template<> void SakuraArrayConverter::SakuraToCASA<float, casacore::Complex>(

        casacore::uInt const index_in, casacore::uInt const index_out, float const *input_data,

        casacore::Complex* pout);

template<> void SakuraArrayConverter::CASAToSakura<casacore::Bool, bool>(

        casacore::uInt const index_in, casacore::uInt const index_out, const casacore::Bool* pin,

        bool *output_data);

template<> void SakuraArrayConverter::SakuraToCASA<bool, casacore::Bool>(

        casacore::uInt const index_in, casacore::uInt const index_out, bool const *input_data,

        casacore::Bool* pout);

} //# NAMESPACE CASA - END

​

#endif /* _CASA_SINGLEDISH_DUMMY_H_ */