esputr_YTH.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"

//    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/>.
//

DEFUN_DLD (esputr_YTH, args, nargout,
"  \n\
  Calculate the angular dependency factor of the sputtering yield Y(E,tehta)/Y(E,0) (interface to ESPUTR) \n\
\n\
   [Y1 Y2 ...] = esputr_YN(TH, E0, proj, targ, version, fileTH) \n\
\n\
   Y1, Y2 ... : matrices with calculated angular factors -         \n\
              - one matrix for each projectile-target combination,    \n\
                rows: over angle THs, columns: over eneregy E0s    \n\
   TH         : column vector of the incident agles, radian        \n\
                Incident angle is the angle between surface normal \n\
                and velocity of the incident particle              \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\
  1993-model\n\
   f = esputr_YTH([0:5:90]*pi/180, 100, 'E', 'l', '1993')\n\
\n\
 D on Be, 2007 model (2001 with coefficients from [Eckstein 2007]) \n\
   f = esputr_YTH([0:5:90]*pi/180, [500,700,1000], 'D', 'Be', '2001','../data/ECKSTEIN2007TH')\n\
\n\
 D on W, D on Mo, He on W, 2007 model\n\
  [D_W,D_Mo,He_W] = esputr_YTH([0:1:90]*pi/180, [500,1000], strvcat('D','D','He'),strvcat('W','Mo','W'), '2001', ... \n\
                                   '/home/v.kotov/JuNiPlib/esputr/data/ECKSTEIN2007TH')") {
    octave_value_list retval;
    int nargin = args.length();

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

            if(version_str != "2001" && version_str !="1993") {
               error("unknown model");
               F77_XFCN(esputr_deallocate, FORTSUB, (err));
               return retval;
            }

            if(version_str == "2001" && nargin == 6) {
                fileTH = args(5).char_matrix_value().row_as_string(0);
            } else if(version_str == "2001" && nargin < 6)  {
                error("6 arguments required");
                F77_XFCN(esputr_deallocate, FORTSUB, (err));
                return retval;
            }
            
            if(error_state) {
                error("sth went wrong");
                return retval;
            }
            
            if(version_str == "2001") {
                F77_XFCN(esputr2001_initth_wrapper, FORTSUB, (fileTH.c_str(), err, fileTH.length()));
                if(err != 0) {
                    error("error in esputr_matlab_init");
                    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 (n_THs, n_E0s);
                F77_XFCN(esputr_yth, FORTSUB,
                            (THs_v, n_THs,
                            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_yth");
                    F77_XFCN(esputr_deallocate, FORTSUB, (err));
                    return retval;
                }
                retval(c) = YNs;
            }
            
            F77_XFCN(esputr_deallocate, FORTSUB, (err));
        }
    }
    return retval;
}