value_type iterate( matrix_type const& initial_matrix, matrix_type& result_matrix ) { triple_homotopy_fitting<value_type> thf{ug_size}; size_type const tilt_number = diag_matrix.row(); matrix_type intensity{ intensity_matrix.col(), 1 }; for ( size_type index = 0; index != tilt_number; ++index ) { std::copy( intensity_matrix.row_begin(index), intensity_matrix.row_end(index), intensity.col_begin(0) ); //TODO -- optimizaton here thf.register_entry( ar, //C1 approximation alpha(progress_ratio), make_coefficient_matrix( thickness, diag_matrix.row_begin(index), diag_matrix.row_end(index), column_index ), //C/2 * C/2 approximation beta(progress_ratio), make_coefficient_matrix( thickness/2.0, diag_matrix.row_begin(index), diag_matrix.row_end(index) ), expm( make_structure_matrix(ar, initial_matrix, diag_matrix.row_begin(index), diag_matrix.row_end(index) ), thickness/2.0, column_index ), //standard expm gamma(progress_ratio), make_scattering_matrix( ar, initial_matrix, diag_matrix.row_begin(index), diag_matrix.row_end(index), thickness, column_index ), intensity, column_index ); } result_matrix.resize( ug_size, 1 ); value_type const residual = thf.output( result_matrix.begin() ); /* std::cout << "\n current residual is " << residual << "\n"; std::cout << "\n current ug is \n" << result_matrix.transpose() << "\n"; */ return residual; }
const complex_matrix_type make_ug( const matrix_type& G, const matrix_type& A, const matrix_type& D ) const { assert( G.col() == 3 ); assert( A.col() == 3 ); assert( D.col() == 1 ); assert( A.row() == D.row() ); auto const M = make_matrix(); auto const S = G * ( M.inverse() ); matrix_type s( 1, S.row() ); for ( size_type i = 0; i < S.row(); ++ i ) { s[0][i] = value_type( 0.5 ) * std::sqrt( std::inner_product( S.row_begin( i ), S.row_end( i ), S.row_begin( i ), value_type( 0 ) ) ); } auto const piomega = 3.141592553590 * feng::inner_product( array_type( M[0][0], M[1][0], M[2][0] ), feng::cross_product( array_type( M[0][1], M[1][1], M[2][1] ), array_type( M[0][2], M[1][2], M[2][2] ) ) ); auto const atomcellfacte = make_gaussian_electron( s, v0 ); const complex_matrix_type dwss = D * feng::pow( s, value_type( 2 ) ); const complex_matrix_type piag = A * G.transpose(); auto fact = feng::exp( - dwss - piag * complex_type( 0, 6.2831853071796 ) ); std::transform( fact.begin(), fact.end(), atomcellfacte.begin(), fact.begin(), [piomega]( const complex_type f, const value_type a ) { return f * a / piomega; } ); complex_matrix_type Ug( fact.col(), 1 ); for ( size_type i = 0; i < fact.col(); ++i ) { Ug[i][0] = std::accumulate( fact.col_begin( i ), fact.col_end( i ), complex_type() ); //if ( std::abs(Ug[i][0].real()) < 1.0e-8 ) Ug[i][0].real(0); //if ( std::abs(Ug[i][0].imag()) < 1.0e-8 ) Ug[i][0].imag(0); } return Ug; }
void register_entry( size_matrix_type const& ar, value_type alpha, complex_matrix_type const& lhs_matrix, complex_matrix_type const& rhs_matrix, value_type beta, complex_matrix_type const& expm_matrix, matrix_type const& intensity, size_type const column_index = 0 ) { assert( ar.row() == ar.col() ); assert( ar.row() == lhs_matrix.row() ); assert( lhs_matrix.row() == lhs_matrix.col() ); assert( ar.row() == rhs_matrix.row() ); assert( ar.row() == intensity.row() ); assert( 1 == intensity.col() ); assert( (*(std::max_element(ar.begin(), ar.end()))) < ug_size ); assert( alpha >= value_type{0} ); assert( beta >= value_type{0} ); assert( alpha <= value_type{1} ); assert( beta <= value_type{1} ); assert( std::abs(alpha+beta-value_type{1}) < value_type{ 1.0e-10} ); //assert( c1_matrix.row() == ar.row() ); //assert( c1_matrix.col() == 1 ); assert( expm_matrix.row() == ar.row() ); assert( expm_matrix.col() == 1 ); assert( column_index < ar.row() ); size_type const n = ar.row(); size_type const m = ug_size; matrix_type real_part(m, 1); matrix_type imag_part(m, 1); value_type norm_factor{0}; //norm only one column //std::for_each( expm_matrix.col_begin( column_index ), expm_matrix.col_end( column_index ), [&norm_factor]( complex_type const& c ){ norm_factor += std::norm(c); } ); std::for_each( expm_matrix.begin(), expm_matrix.end(), [&norm_factor]( complex_type const& c ){ norm_factor += std::norm(c); } ); norm_factor /= static_cast<value_type>( expm_matrix.row() ); for ( size_type r = 0; r != ar.row(); ++r ) { //for \beta C/2 C/2 part extract_inner_product_coefficients( m, n, ar.row_begin(r), lhs_matrix.row_begin(r), rhs_matrix.col_begin(column_index), real_part.begin(), imag_part.begin() ); real_part *= alpha; imag_part *= alpha; //for \gamma E part real_part[0][0] += beta * std::real( expm_matrix[r][column_index] ); imag_part[0][0] += beta * std::imag( expm_matrix[r][column_index] ); //real_part[0][0] += beta * std::real( expm_matrix[r][column_index] ) / norm_factor; //imag_part[0][0] += beta * std::imag( expm_matrix[r][column_index] ) / norm_factor; //needs modifying here dsm.register_entry( intensity[r][0], real_part.begin(), imag_part.begin() ); } #if 0 //register lambda, ensuring lambda to be 1 std::fill( real_part.begin(), real_part.end(), value_type{} ); value_type const factor = value_type{1.0}; value_type const weigh = factor * std::sqrt( static_cast<value_type>( intensity.row() ) ); real_part[0][0] = weigh; imag_part[0][0] = weigh; dsm.register_entry( value_type{2} * weigh * weigh, real_part.begin(), imag_part.begin() ); #endif }
void fit() { std::cerr << "\nbefore the fit, thickness is set to be " << thickness << "\n"; assert( ug_size ); assert( ar_dim ); assert( column_index < ar_dim ); assert( std::abs(std::real(thickness)) < 1.0e-10 ); assert( std::imag(thickness) > 1.0e-10 ); assert( diag_matrix.col() == ar_dim ); assert( diag_matrix.row() == intensity_matrix.row() ); assert( intensity_matrix.col() == ar_dim ); assert( initial_ug.row() == ug_size ); assert( initial_ug.col() == 1 ); assert( ar.row() == ar.col() ); assert( ar_dim == ar.row() ); assert( progress_ratio >= value_type{0} ); assert( progress_ratio <= value_type{1} ); assert( alpha ); assert( beta ); assert( gamma ); new_residual = iterate( initial_ug, new_ug ); matrix_type second_ug{ initial_ug }; size_type current_iteration = 0; matrix_vector_type vm; vector_type vr; vm.push_back( new_ug ); vr.push_back( new_residual ); value_type best_residual_so_far = new_residual; while ( true ) { value_type const second_residual = iterate( new_ug, second_ug ); bool break_flag = false; //?? if ( best_residual_so_far > max_iteration * second_residual ) break_flag = true; best_residual_so_far = std::min( second_residual, best_residual_so_far ); if( ++current_iteration > max_iteration ) break_flag = true; new_ug.swap( second_ug ); new_residual = second_residual; vm.push_back( new_ug ); vr.push_back( new_residual ); if ( break_flag ) break; } size_type const elite_index = std::distance( vr.begin(), std::min_element( vr.begin(), vr.end() ) ); std::copy( vm[elite_index].begin(), vm[elite_index].end(), new_ug.begin() ); //std::cout << "\ncurrent elite residual is " << vr[elite_index] << ", at iteration " << current_iteration << std::endl; }