esputr_YN.cpp

Go to the documentation of this file.

//    Copyright (c) 2016  Forschungszentrum Juelich GmbH
//                        Markus Brenneis, Vladislav Kotov 
//
//    This file is part of ESPUTR.
//
//    ESPUTR 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, or
//    (at your option) any later version.
//
//    ESPUTR 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 ESPUTR.  If not, see <http://www.gnu.org/licenses/>.
//

#include <octave/oct.h>
#include <cstring>
#include <string>
#include "esputr_octave.hpp"

DEFUN_DLD (esputr_YN, args, nargout,
"\n\
  Calculate sputtering yields for normal incidence (interface to ESPUTR)\n\
\n\
   [Y1 Y2 ...] = esputr_YN(E0, proj, targ, version, fileN)\n\
\n\
   Y1, Y2 ... : row vectors of sputtering yields - \n\
                - one vector for each projectile-target combination \n\
   E0         : row vector of the projectile energies, eV \n\
   proj       : column vector  of the projectile names \n\
   targ       : column vector of the target names \n\
   version    : designation of the model ('1993' or '2001') \n\
   fileN      : name of the file (full path) with fitting parameters \n\
\n\
   If the lengths of proj and targ differ, the last element of the shorter vector is repeated \n\
\n\
  Examples: \n\
\n\
  D on Be, 2007 model (2001 with coefficients from [Eckstein 2007]) \n\
   y = esputr_YN([[0:10:200],[2000:1000:10000]], 'D', 'Be', '2001', '../data/ECKSTEIN2007N') \n\
\n\
  D/T on Be and Be on Be, 1993-model (old EIRENE) \n\
   [D_Be,T_Be,Be_Be] = esputr_YN([10,100,3000],strvcat('D','T','self'), 'Beryllium', '1993', '../data/SPUTER') \n\
\n\
  H on Be, D on C, T on Mo, 2007 model \n\
   [H_Be,D_C,T_Mo] = esputr_YN([10,100,3000], strvcat('H','D','T'), strvcat('Be','C ','Mo'), '2001', '../data/ECKSTEIN2007N')") {
    octave_value_list retval;
    int nargin = args.length();

    if(nargin != 5) {
        error("5 input arguments required");
    //vk        print_usage();
    } else {
        NDArray E0s = args(0).array_value();
        if(!error_state) {
            double* E0s_v = E0s.fortran_vec();
            octave_idx_type n_E0s = E0s.numel();
            
            charMatrix projs = args(1).char_matrix_value();
            octave_idx_type n_projs = projs.rows();
            charMatrix targs = args(2).char_matrix_value();
            octave_idx_type n_targs = targs.rows();
            
            octave_idx_type n_combinations = std::max(n_projs, n_targs);
            
            std::string version_str = args(3).char_matrix_value().row_as_string(0);
            const char* version = version_str.c_str();
            octave_idx_type version_length = version_str.length();
                      
            std::string fileN = args(4).char_matrix_value().row_as_string(0);
            
            int err = 0;
            
            if(error_state) {
                error("sth went wrong");
            }


            
            if(version_str == "1993") {
                F77_XFCN(esputr1993_init_wrapper, FORTSUB, (fileN.c_str(), err, fileN.length()));
            } else if(version_str == "2001") {
                F77_XFCN(esputr2001_initn_wrapper, FORTSUB, (fileN.c_str(), err, fileN.length()));
            } else {
                error("unknown model");
                F77_XFCN(esputr_deallocate, FORTSUB, (err));
                return retval;
            }
            if(err != 0) {
                error("error during initialization of ESPUTR");
                F77_XFCN(esputr_deallocate, FORTSUB, (err));
                return retval;
            }
            
            for(int c = 0; c < n_combinations; c++) {
                std::string proj = projs.row_as_string(std::min(c, n_projs-1));
                std::string targ = targs.row_as_string(std::min(c, n_targs-1));
                Matrix YNs (1, n_E0s);
                F77_XFCN(esputr_yn, FORTSUB,
                            (E0s_v, n_E0s,
                            proj.c_str(),
                            targ.c_str(),
                            version,
                            YNs.fortran_vec(),
                            err
                            F77_CHAR_ARG_LEN(proj.length())
                            F77_CHAR_ARG_LEN(targ.length())
                            F77_CHAR_ARG_LEN(version_length)
                            ));
                if(err != 0) {
                    error("error in esputr_matlab_yn");
                    F77_XFCN(esputr_deallocate, FORTSUB, (err));
                    return retval;
                }
                retval(c) = YNs;
            }
            
            F77_XFCN(esputr_deallocate, FORTSUB, (err));
        }
    }
    return retval;
}