path_result.hpp

Go to the documentation of this file.

//This file is part of Bertini 2.
//
//bertini2/parallel/path_result.hpp 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.
//
//bertini2/parallel/path_result.hpp 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 bertini2/parallel/path_result.hpp.  If not, see <http://www.gnu.org/licenses/>.
//
// Copyright(C) Bertini2 Development Team

 
#pragma once
 
#include <deque>
#include <limits>
 
#include "bertini2/num_traits.hpp"
#include "bertini2/eigen_extensions.hpp"   // defines Vec<T> and sets up Eigen serialization plugin
#include "bertini2/mpfr_extensions.hpp"    // Boost.Serialization for real_mp, mpc_complex
#include "bertini2/common/config.hpp"      // SuccessCode (needs Vec<T> and <deque> first)
 
#include <boost/serialization/vector.hpp>
 
namespace bertini {
namespace parallel {
 
constexpr int TAG_WORK_ITEM = 1;  
constexpr int TAG_RESULT    = 2;  
constexpr int TAG_CAPACITY  = 3;  
 
 

template<typename ComplexT>
struct StartPointTask
{
    using SolnIndT = std::size_t;  
 
    SolnIndT      path_index = std::numeric_limits<SolnIndT>::max();  
    Vec<ComplexT> start_point;  

    bool is_sentinel() const
    {
        return path_index == std::numeric_limits<SolnIndT>::max();
    }

    static StartPointTask sentinel()
    {
        return StartPointTask{};  // default path_index == max
    }

    template<class Archive>
    void serialize(Archive& ar, unsigned const)
    {
        ar & path_index;
        ar & start_point;
    }
};
 

template<typename ComplexT>
struct FullPathResult
{
    using SolnIndT = std::size_t;  
    using RealT    = typename NumTraits<ComplexT>::Real;  
 
    SolnIndT      path_index             = 0;  
 
    // boundary (pre-endgame) data
    SuccessCode   pre_endgame_success_code    = SuccessCode::NeverStarted;  
    Vec<ComplexT> boundary_point;  
    RealT         boundary_stepsize      = RealT(0);  
    unsigned      boundary_precision     = DoublePrecision();  
 
    // endgame data
    SuccessCode   endgame_success_code        = SuccessCode::NeverStarted;  
    Vec<ComplexT> solution;  
    double        function_residual              = 0;  
    double        condition_number               = 0;  
    Vec<double>   singular_values;  
    double        newton_residual                = 0;  
    ComplexT      final_time_used;  
    double        accuracy_estimate_internal_coords = 0;  
    double        accuracy_estimate_user_coords  = 0;  
    unsigned      cycle_num                      = 0;  
    unsigned      precision_digits             = 0;   
    unsigned      accuracy_digits              = 0;   
 
    // precision metadata (spans the whole path)
    bool          precision_changed              = false;  
    ComplexT      time_of_first_prec_increase;  
    unsigned      max_precision_used             = 0;  
 
    // wall-clock time to execute the whole path (pre-endgame + endgame), in seconds
    double        path_time_seconds              = 0;  
 
    // where the path got to (the stamp every path carries; the point only when it did not succeed)
    unsigned      num_successful_steps           = 0;  
    unsigned      num_failed_steps               = 0;  
    Vec<ComplexT> latest_path_point;  
    double        wall_clock_limit_seconds       = 0;  
 
    // the endgame-boundary crossing verdict.  Unlike everything above it, this is not known when
    // the path finishes -- whether a path crossed another is only decidable once every path has
    // reached the boundary -- so the manager writes it afterwards and the path is reported again.
    bool          crossing_unresolved            = false;  

    template<class Archive>
    void serialize(Archive& ar, unsigned const)
    {
        ar & path_index;
        ar & pre_endgame_success_code;
        ar & boundary_point;
        ar & boundary_stepsize;
        ar & boundary_precision;
        ar & endgame_success_code;
        ar & solution;
        ar & function_residual;
        ar & condition_number;
        ar & singular_values;
        ar & newton_residual;
        ar & final_time_used;
        ar & accuracy_estimate_internal_coords;
        ar & accuracy_estimate_user_coords;
        ar & cycle_num;
        ar & precision_digits;
        ar & accuracy_digits;
        ar & precision_changed;
        ar & time_of_first_prec_increase;
        ar & max_precision_used;
        ar & path_time_seconds;
        ar & num_successful_steps;
        ar & num_failed_steps;
        ar & latest_path_point;
        ar & wall_clock_limit_seconds;
        ar & crossing_unresolved;
    }
};
 
namespace detail {
 
// Sentinel detection and factory for the work-item type.  The work item is a StartPointTask whose
// max path_index marks "no more work".  (The plain-size_t overloads remain for any other caller.)

inline bool is_sentinel(std::size_t v)
{
    return v == std::numeric_limits<std::size_t>::max();
}

inline std::size_t make_sentinel(std::size_t)
{
    return std::numeric_limits<std::size_t>::max();
}

template<typename ComplexT>
bool is_sentinel(StartPointTask<ComplexT> const& t)
{
    return t.is_sentinel();
}

template<typename ComplexT>
StartPointTask<ComplexT> make_sentinel(StartPointTask<ComplexT> const&)
{
    return StartPointTask<ComplexT>::sentinel();
}
 
} // namespace detail
 
} // namespace parallel
} // namespace bertini