Right now, everything is inside the GQCP namespace. Could it be beneficial to add more namespaces inside this one?

Test the following public methods of TwoRDM:

• TwoRDM::reduce
• TwoRDM::trace

Consider adding some more types of initial guesses for the Davidson CI solvers. Examples could include:

• random: see #92.
• constant: see #145.
• proportional to the diagonal of the CI Hamiltonian matrix

Cristina has a reference energy for H2@OO-DOCI//6-31G**: -1.1651486697. The geometry is said to be

2

H 0.0 0.0 0.371000028
H 0.0 0.0 -0.371000028

Orbital optimization should be implemented as (a) separate class(es).

We should also keep in mind that we should be able to implement simulated annealing using the interface.

The two orbital-optimizing algorithms we already have are for AP1roG and DOCI:

• DOCI: see #62
• AP1roG: see #46

Right now, there are only indirect tests for ONV.operatorPhaseFactor, as for example in the annihilate_sign_onv and create_sign_onv boost test cases. It would be more unit-test-minded if operatorPhaseFactor were to be tested directly.

After #59, we are able to provide users with documentation built with Doxygen. However, the current in-source documentation doesn't really provide the best documentation through Doxygen. We should provide proper comments/documentation such that the Oxygen-Created documentation is more relevant.

HamiltonianBuilder takes care of how the Hamiltonian matrix gets represented: using a full (dense) matrix or as a matrix-vector product.

• DOCI: see #35
• FCI: see #45

Bringing over an issue from libwint:

Is there a possibility for:
A dimension getter for AOBasis similar to that of SOBasis::get_K() (making it a private member)?
An AOBasis partitioner, a module such that for example AOBasisPartioner(AOBasis ao, std::vector<size_t> partition) creates two new AOBasis one with the indexes in partition and one without them. With methods AOBasisPartioner::get_partitioned() and AOBasisPartioner::get_remainder().

Consider making the code const correct.

CISolver, FockSpace, WaveFunction (also see numopt)

For the FCIDUMPReader we find:
https://github.com/GQCG/gqcp/blob/8cdabb04f8d698a773f21b51649ce4830a3e22be/src/HamiltonianParameters/HamiltonianParameters_constructors.cpp#L201

This should be Eigen::Matrix::Identity(K, K) not Eigen::Matrix::Zero(K, K)

We have discussed that we are abandoning friend functions/classes.

Remove all friend functions and classes, and replace occurrences with standard getters.

Bring over the RMP2-routines from the previous library.

It would be nice to add support for custom basissets, i.e. sets with custom basis functions: specifying GTOs with exponents and cGTOs with contraction coefficients.

Add a FockSpace inside a SelectedFockSpace:

• Potentially use addresses of ONVs in the FockSpace
• As a fail-safe to easily check duplicate configurations
• This could be useful in the future for implementing other algorithms

Implement density matrices (1-RDMs and 2-RDMs) as separate classes. Use a 'Builder' for derived classes that implement the formulas for:

• DOCI density matrices: see #43
• FCI density matrices: see #55
• selected CI density matrices: see #80

We should also implement functions like

• OneRDM.trace()
• OneRDM.diagonalize()
• TwoRDM.contract()
• TwoRDM.trace()

Implement functions that calculate the Shannon entropy for a wave function.

When doing post-HF methods, e.g. DOCI, we assume that the user supplies (molecular) HamiltonianParameters in an orthonormal underlying basis. Should we implement checks/warnings/errors that notify the user if they don't supply valid Hamiltonian parameters?

Given HamiltonianParameters that are read in from an FCIDUMP file, however, we can't know if the underlying basis is orthonormal.

Extend the FCI and FCIRDMBuilder with test where the number of alpha electrons and beta electrons are not equal.

Port the old (unsupported) Hubbard code into this library, so that we can reliably calculate the S_z = 0 ground state for 6-site lattices.

Add the following functions to the BaseRHFSCFSolver:

• Eigen::MatrixXd calculateRHFAO1RDM(const Eigen::MatrixXd& C, size_t N);
• Eigen::MatrixXd calculateRHFAOFockMatrix(const Eigen::MatrixXd& D_AO, GQCP::HamiltonianParameters ham_par)

Add the following to the RHF class:

• Add double calculateRHFElectronicEnergy(const Eigen::MatrixXd& D_AO, const Eigen::MatrixXd& H_core_AO, const Eigen::MatrixXd& F_AO) to the constructor of the RHF class and add a constructor.
• Add N and K to the RHF class.

The RHF-related classes could also

• use SCFSolverOptions
• rename calculateNewFockMatrix() to updateFockMatrix()
• use OneRDM and OneElectronOperator instead of the bare matrix representations

Given a molecule with an odd number of electrons, the RHFSCFSolver should throw an error.

HamiltonianParameters should get a function that is able to calculate effective one-electron integrals. See the following stub:

Eigen::MatrixXd k_SO = hamiltonian_parameters.get_h().get_matrix_representation();
for (size_t p = 0; p < K; p++) {
    for (size_t q = 0; q < K; q++) {
        for (size_t r = 0; r < K; r++) {
            k_SO(p,q) -= 0.5 * hamiltonian_parameters.get_g().get(p, r, r, q);
        }
    }
}

A Basis could be a class that has one- and two-electron integrals.

In any case, we should keep in mind that we eventually want to do visualization, so there should(?) be a pointer to the basis functions (i.e. orbitals and spinors) that are used

Right now we aren't using the permutational symmetries of the integrals calculated by LibintCommunicator and LibcintCommunicator. We could have a speed gain if we would use these permutational symmetries.

Describe the feature you'd like
An interface to libcint, for standard, magnetic and relativistic integrals.

• standard integrals
• magnetic integrals (complex): these are the integrals over the GIAOs up to first order, i.e. (1+x) instead of exp(x)
• relativistic integrals (complex)

Describe what the current code offers in relation to what it lacks
Currently, the code offers one- and two-electron engines and buffers, which should help a great deal in implementing these new integrals.

Additional context
Since we are planning some major refactoring concerning single-particle bases, the implementation of the relativistic integral should not be started before #382 and #333 are finished.

This would then just be a field that can be used to shift energy values, as for example the internuclear nuclear repulsion energy does.

The value would then correspond to the last entry in an FCIDUMP-file.

A PES diagram (for starters: diatomic molecules) represents an energy surface of calculations that are done for a range of internuclear distances.

The current way to create PES diagrams is to write a driver for an electronic structure method that handles an input specification and writes the energy to a file.

It would be nice if we added a PESCalculator kind of class that does a kind of calculation for a repeated amount of times. Some of the advantages would be:

• easier use of previous results in new initial guess for Davidsonsolvers
• bypassing the creation of hundreds of input files

The name ProductFockSpace seems more in line with a 'product space'.

There seems to be duplicate/extremely similar code in the CI builder methods.

Write drivers for

• DOCI
• OO-DOCI
• FCI

We can use these drivers to profile our library.

It would be good if we could specify which basis functions could be used in an AOBasis. Right now we rely on libint2 to parse a basisset-file (e.g. for STO-3G) to internally create a libint2::BasisSet.

If we implement our own GQCG::BasisSet, we should add an interface conversion through LibintCommunicator.

The very high test durations of the Davidson timings could be indicative of an underlying issue.

It would be nice to implement .isEqualTo(other, tolerance) and operator==() that refers to a default tolerance for the matrix representations of both OneElectronOperator and TwoElectronOperator.

Make the library work with MKL so that the diagonalization is parallelized.

The version.hpp-file should also include the copyright notice. This should be fixed in the new repository that should be created when doing #14.

Given the nature of the RDMBuilders the way the RDMs are built is 100% dependant on the type of Fock space as compared to CIBuilders where things can be done differently for the same Fock space (FCI vs Hubbard).

Therefore I suggest making a stand-alone class RDMBuilder (or a different name) which contains the same (but not overridden) functions as the current RDMBuilder (the BaseRDMBuilder). And dynamically allocates a derived BaseRDMBuilder based on its constructor parameter (the Fock space).

class RDMBuilder {
private:
    std::shared_ptr<BaseRDMBuilder> rdm_builder;
public:
    RDMBuilder( FockSpace fock_space);  // allocate DOCIRDMBuilder  
    RDMBuilder( FockSpaceProduct fock_space);  // allocate FCIRDMBuilder
    RDMBuilder( SelectedFockSpace fock_space);  // allocate SelectedRDMBuilder
    RDMBuilder( BaseFockSpace fock_space);  // allocate dynamic_cast and call corresponding constructor 

    OneRDMs calculate1RDMs ( const Eigen::VectorXd& x ) { return rdm_builder->calculate1RDMs(x); }  
...

}

Thereby circumventing any cumbersomeness associated with polymorphism.

Here are the logs from the 'PR':

Log from Clang 6.0.1:

Running 3 test cases...
Will read basis set from /usr/local/libint/2.3.1/share/libint/2.3.1/basis/sto-3g.g94
Will read basis set from /usr/local/libint/2.3.1/share/libint/2.3.1/basis/sto-3g.g94
Will read basis set from /usr/local/libint/2.3.1/share/libint/2.3.1/basis/6-31g**.g94
AP1roGPSESolver_test(2761,0x11ad1c5c0) malloc: *** error for object 0x7fd963d02620: pointer being freed was not allocated
AP1roGPSESolver_test(2761,0x11ad1c5c0) malloc: *** set a breakpoint in malloc_error_break to debug
unknown location:0: fatal error: in "h2_631gdp": signal: SIGABRT (application abort requested)
/Users/laurentlemmens/Software/gqcg/tests/AP1roG/AP1roGPSESolver_test.cpp:41: last checkpoint: "h2_631gdp" test entry

*** 1 failure is detected in the test module "AP1roGPSESolver"

AppleClang (in Xcode 10.0) also fails, so we're sure it's not a compiler issue. Here's a log report when using an Address Sanitizer:

Running 3 test cases...
Will read basis set from /usr/local/libint/2.3.1/share/libint/2.3.1/basis/sto-3g.g94

==6940==ERROR: AddressSanitizer: attempting free on address which was not malloc()-ed: 0x60400005a9e0 in thread T0
#0 0x101a7e10d in wrap_free (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x5710d)
#1 0x1001f9af4 in Eigen::internal::aligned_free(void*) Memory.h:177
#2 0x1001f9ad4 in void Eigen::internal::conditional_aligned_free(void*) Memory.h:230
#3 0x1001f9a7b in void Eigen::internal::conditional_aligned_delete_auto<double, true>(double*, unsigned long) Memory.h:416
#4 0x1001fdcc6 in Eigen::DenseStorage<double, -1, -1, 1, 0>::~DenseStorage() DenseStorage.h:542
#5 0x1001fdc34 in Eigen::DenseStorage<double, -1, -1, 1, 0>::~DenseStorage() DenseStorage.h:542
#6 0x1001fdc14 in Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >::~PlainObjectBase() PlainObjectBase.h:98
#7 0x1001fdbf4 in Eigen::Matrix<double, -1, 1, 0, -1, 1>::~Matrix() Matrix.h:178
#8 0x1000ced24 in Eigen::Matrix<double, -1, 1, 0, -1, 1>::~Matrix() Matrix.h:178
#9 0x1001fdbb8 in GQCG::AP1roGGeminalCoefficients::~AP1roGGeminalCoefficients() AP1roGGeminalCoefficients.hpp:11
#10 0x1000cec14 in GQCG::AP1roGGeminalCoefficients::~AP1roGGeminalCoefficients() AP1roGGeminalCoefficients.hpp:11
#11 0x1001f97d4 in GQCG::AP1roGPSESolver::~AP1roGPSESolver() AP1roGPSESolver.hpp:15
#12 0x1000c84c4 in GQCG::AP1roGPSESolver::~AP1roGPSESolver() AP1roGPSESolver.hpp:15
#13 0x1000c8140 in constructor::test_method() AP1roGPSESolver_test.cpp:23
#14 0x1000c7117 in constructor_invoker() AP1roGPSESolver_test.cpp:14
#15 0x10028e729 in boost::detail::function::void_function_invoker0<void ()(), void>::invoke(boost::detail::function::function_buffer&) function_template.hpp:118
#16 0x10026450e in boost::function0::operator()() const function_template.hpp:759
#17 0x10026436a in boost::detail::forward::operator()() execution_monitor.ipp:1300
#18 0x10026384c in boost::detail::function::function_obj_invoker0<boost::detail::forward, int>::invoke(boost::detail::function::function_buffer&) function_template.hpp:138
#19 0x10026255e in boost::function0::operator()() const function_template.hpp:759
#20 0x10005abed in int boost::detail::do_invoke<boost::shared_ptrboost::detail::translator_holder_base, boost::function<int ()> >(boost::shared_ptrboost::detail::translator_holder_base const&, boost::function<int ()> const&) execution_monitor.ipp:281
#21 0x10005a563 in boost::execution_monitor::catch_signals(boost::function<int ()> const&) execution_monitor.ipp:864
#22 0x10005b1ba in boost::execution_monitor::execute(boost::function<int ()> const&) execution_monitor.ipp:1203
#23 0x100035a62 in boost::execution_monitor::vexecute(boost::function<void ()> const&) execution_monitor.ipp:1309
#24 0x100046ea4 in boost::unit_test::unit_test_monitor_t::execute_and_translate(boost::function<void ()> const&, unsigned int) unit_test_monitor.ipp:46
#25 0x1000526d9 in boost::unit_test::framework::state::execute_test_tree(unsigned long, unsigned int, boost::unit_test::framework::state::random_generator_helper const) framework.ipp:771
#26 0x10004f19a in boost::unit_test::framework::state::execute_test_tree(unsigned long, unsigned int, boost::unit_test::framework::state::random_generator_helper const*) framework.ipp:717
#27 0x100044e40 in boost::unit_test::framework::run(unsigned long, bool) framework.ipp:1577
#28 0x1000a1556 in boost::unit_test::unit_test_main(boost::unit_test::test_suite* (*)(int, char**), int, char**) unit_test_main.ipp:231
#29 0x1000a1eb0 in main unit_test_main.ipp:286
#30 0x7fff6f618084 in start (libdyld.dylib:x86_64+0x17084)

0x60400005a9e0 is located 16 bytes inside of 40-byte region [0x60400005a9d0,0x60400005a9f8)
allocated by thread T0 here:
#0 0x101a7df53 in wrap_malloc (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x56f53)
#1 0x100328329 in GQCG::AP1roGPSESolver::AP1roGPSESolver(unsigned long, GQCG::HamiltonianParameters const&, GQCG::AP1roGGeminalCoefficients const&) Memory.h:88
#2 0x100328889 in GQCG::AP1roGPSESolver::AP1roGPSESolver(unsigned long, GQCG::HamiltonianParameters const&) AP1roGPSESolver.cpp:19
#3 0x1000c8132 in constructor::test_method() AP1roGPSESolver_test.cpp:22
#4 0x1000c7117 in constructor_invoker() AP1roGPSESolver_test.cpp:14
#5 0x10028e729 in boost::detail::function::void_function_invoker0<void ()(), void>::invoke(boost::detail::function::function_buffer&) function_template.hpp:118
#6 0x10026450e in boost::function0::operator()() const function_template.hpp:759
#7 0x10026436a in boost::detail::forward::operator()() execution_monitor.ipp:1300
#8 0x10026384c in boost::detail::function::function_obj_invoker0<boost::detail::forward, int>::invoke(boost::detail::function::function_buffer&) function_template.hpp:138
#9 0x10026255e in boost::function0::operator()() const function_template.hpp:759
#10 0x10005abed in int boost::detail::do_invoke<boost::shared_ptrboost::detail::translator_holder_base, boost::function<int ()> >(boost::shared_ptrboost::detail::translator_holder_base const&, boost::function<int ()> const&) execution_monitor.ipp:281
#11 0x10005a563 in boost::execution_monitor::catch_signals(boost::function<int ()> const&) execution_monitor.ipp:864
#12 0x10005b1ba in boost::execution_monitor::execute(boost::function<int ()> const&) execution_monitor.ipp:1203
#13 0x100035a62 in boost::execution_monitor::vexecute(boost::function<void ()> const&) execution_monitor.ipp:1309
#14 0x100046ea4 in boost::unit_test::unit_test_monitor_t::execute_and_translate(boost::function<void ()> const&, unsigned int) unit_test_monitor.ipp:46
#15 0x1000526d9 in boost::unit_test::framework::state::execute_test_tree(unsigned long, unsigned int, boost::unit_test::framework::state::random_generator_helper const) framework.ipp:771
#16 0x10004f19a in boost::unit_test::framework::state::execute_test_tree(unsigned long, unsigned int, boost::unit_test::framework::state::random_generator_helper const*) framework.ipp:717
#17 0x100044e40 in boost::unit_test::framework::run(unsigned long, bool) framework.ipp:1577
#18 0x1000a1556 in boost::unit_test::unit_test_main(boost::unit_test::test_suite* (*)(int, char**), int, char**) unit_test_main.ipp:231
#19 0x1000a1eb0 in main unit_test_main.ipp:286
#20 0x7fff6f618084 in start (libdyld.dylib:x86_64+0x17084)

SUMMARY: AddressSanitizer: bad-free (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x5710d) in wrap_free
2018-10-18 13:27:24.930903+0200 AP1roGPSESolver_test[6940:9758680] =================================================================
2018-10-18 13:27:24.930975+0200 AP1roGPSESolver_test[6940:9758680] ==6940==ERROR: AddressSanitizer: attempting free on address which was not malloc()-ed: 0x60400005a9e0 in thread T0
2018-10-18 13:27:24.930987+0200 AP1roGPSESolver_test[6940:9758680] #0 0x101a7e10d in wrap_free (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x5710d)
2018-10-18 13:27:24.931003+0200 AP1roGPSESolver_test[6940:9758680] #1 0x1001f9af4 in Eigen::internal::aligned_free(void*) Memory.h:177
2018-10-18 13:27:24.931012+0200 AP1roGPSESolver_test[6940:9758680] #2 0x1001f9ad4 in void Eigen::internal::conditional_aligned_free(void*) Memory.h:230
2018-10-18 13:27:24.931021+0200 AP1roGPSESolver_test[6940:9758680] #3 0x1001f9a7b in void Eigen::internal::conditional_aligned_delete_auto<double, true>(double*, unsigned long) Memory.h:416
2018-10-18 13:27:24.931030+0200 AP1roGPSESolver_test[6940:9758680] #4 0x1001fdcc6 in Eigen::DenseStorage<double, -1, -1, 1, 0>::~DenseStorage() DenseStorage.h:542
2018-10-18 13:27:24.931039+0200 AP1roGPSESolver_test[6940:9758680] #5 0x1001fdc34 in Eigen::DenseStorage<double, -1, -1, 1, 0>::~DenseStorage() DenseStorage.h:542
2018-10-18 13:27:24.931148+0200 AP1roGPSESolver_test[6940:9758680] #6 0x1001fdc14 in Eigen::PlainObjectBase<Eigen::Matrix<double, -1, 1, 0, -1, 1> >::~PlainObjectBase() PlainObjectBase.h:98
2018-10-18 13:27:24.931159+0200 AP1roGPSESolver_test[6940:9758680] #7 0x1001fdbf4 in Eigen::Matrix<double, -1, 1, 0, -1, 1>::~Matrix() Matrix.h:178
2018-10-18 13:27:24.931168+0200 AP1roGPSESolver_test[6940:9758680] #8 0x1000ced24 in Eigen::Matrix<double, -1, 1, 0, -1, 1>::~Matrix() Matrix.h:178
2018-10-18 13:27:24.931176+0200 AP1roGPSESolver_test[6940:9758680] #9 0x1001fdbb8 in GQCG::AP1roGGeminalCoefficients::~AP1roGGeminalCoefficients() AP1roGGeminalCoefficients.hpp:11
2018-10-18 13:27:24.931185+0200 AP1roGPSESolver_test[6940:9758680] #10 0x1000cec14 in GQCG::AP1roGGeminalCoefficients::~AP1roGGeminalCoefficients() AP1roGGeminalCoefficients.hpp:11
2018-10-18 13:27:24.931193+0200 AP1roGPSESolver_test[6940:9758680] #11 0x1001f97d4 in GQCG::AP1roGPSESolver::~AP1roGPSESolver() AP1roGPSESolver.hpp:15
2018-10-18 13:27:24.931276+0200 AP1roGPSESolver_test[6940:9758680] #12 0x1000c84c4 in GQCG::AP1roGPSESolver::~AP1roGPSESolver() AP1roGPSESolver.hpp:15
2018-10-18 13:27:24.931285+0200 AP1roGPSESolver_test[6940:9758680] #13 0x1000c8140 in constructor::test_method() AP1roGPSESolver_test.cpp:23
2018-10-18 13:27:24.931293+0200 AP1roGPSESolver_test[6940:9758680] #14 0x1000c7117 in constructor_invoker() AP1roGPSESolver_test.cpp:14
2018-10-18 13:27:24.931303+0200 AP1roGPSESolver_test[6940:9758680] #15 0x10028e729 in boost::detail::function::void_function_invoker0<void ()(), void>::invoke(boost::detail::function::function_buffer&) function_template.hpp:118
2018-10-18 13:27:24.931312+0200 AP1roGPSESolver_test[6940:9758680] #16 0x10026450e in boost::function0::operator()() const function_template.hpp:759
2018-10-18 13:27:24.931320+0200 AP1roGPSESolver_test[6940:9758680] #17 0x10026436a in boost::detail::forward::operator()() execution_monitor.ipp:1300
2018-10-18 13:27:24.931419+0200 AP1roGPSESolver_test[6940:9758680] #18 0x10026384c in boost::detail::function::function_obj_invoker0<boost::detail::forward, int>::invoke(boost::detail::function::function_buffer&) function_template.hpp:138
2018-10-18 13:27:24.931428+0200 AP1roGPSESolver_test[6940:9758680] #19 0x10026255e in boost::function0::operator()() const function_template.hpp:759
2018-10-18 13:27:24.931437+0200 AP1roGPSESolver_test[6940:9758680] #20 0x10005abed in int boost::detail::do_invoke<boost::shared_ptrboost::detail::translator_holder_base, boost::function<int ()> >(boost::shared_ptrboost::detail::translator_holder_base const&, boost::function<int ()> const&) execution_monitor.ipp:281
2018-10-18 13:27:24.931447+0200 AP1roGPSESolver_test[6940:9758680] #21 0x10005a563 in boost::execution_monitor::catch_signals(boost::function<int ()> const&) execution_monitor.ipp:864
2018-10-18 13:27:24.931456+0200 AP1roGPSESolver_test[6940:9758680] #22 0x10005b1ba in boost::execution_monitor::execute(boost::function<int ()> const&) execution_monitor.ipp:1203
2018-10-18 13:27:24.931579+0200 AP1roGPSESolver_test[6940:9758680] #23 0x100035a62 in boost::execution_monitor::vexecute(boost::function<void ()> const&) execution_monitor.ipp:1309
2018-10-18 13:27:24.931598+0200 AP1roGPSESolver_test[6940:9758680] #24 0x100046ea4 in boost::unit_test::unit_test_monitor_t::execute_and_translate(boost::function<void ()> const&, unsigned int) unit_test_monitor.ipp:46
2018-10-18 13:27:24.931650+0200 AP1roGPSESolver_test[6940:9758680] #25 0x1000526d9 in boost::unit_test::framework::state::execute_test_tree(unsigned long, unsigned int, boost::unit_test::framework::state::random_generator_helper const) framework.ipp:771
2018-10-18 13:27:24.931665+0200 AP1roGPSESolver_test[6940:9758680] #26 0x10004f19a in boost::unit_test::framework::state::execute_test_tree(unsigned long, unsigned int, boost::unit_test::framework::state::random_generator_helper const*) framework.ipp:717
2018-10-18 13:27:24.931732+0200 AP1roGPSESolver_test[6940:9758680] #27 0x100044e40 in boost::unit_test::framework::run(unsigned long, bool) framework.ipp:1577
2018-10-18 13:27:24.931778+0200 AP1roGPSESolver_test[6940:9758680] #28 0x1000a1556 in boost::unit_test::unit_test_main(boost::unit_test::test_suite* ()(int, char**), int, char**) unit_test_main.ipp:231
2018-10-18 13:27:24.931798+0200 AP1roGPSESolver_test[6940:9758680] #29 0x1000a1eb0 in main unit_test_main.ipp:286
2018-10-18 13:27:24.931808+0200 AP1roGPSESolver_test[6940:9758680] #30 0x7fff6f618084 in start (libdyld.dylib:x86_64+0x17084)
2018-10-18 13:27:24.931816+0200 AP1roGPSESolver_test[6940:9758680]
2018-10-18 13:27:24.931823+0200 AP1roGPSESolver_test[6940:9758680] 0x60400005a9e0 is located 16 bytes inside of 40-byte region [0x60400005a9d0,0x60400005a9f8)
2018-10-18 13:27:24.931832+0200 AP1roGPSESolver_test[6940:9758680] allocated by thread T0 here:
2018-10-18 13:27:24.931841+0200 AP1roGPSESolver_test[6940:9758680] #0 0x101a7df53 in wrap_malloc (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x56f53)
2018-10-18 13:27:24.931850+0200 AP1roGPSESolver_test[6940:9758680] #1 0x100328329 in GQCG::AP1roGPSESolver::AP1roGPSESolver(unsigned long, GQCG::HamiltonianParameters const&, GQCG::AP1roGGeminalCoefficients const&) Memory.h:88
2018-10-18 13:27:24.931859+0200 AP1roGPSESolver_test[6940:9758680] #2 0x100328889 in GQCG::AP1roGPSESolver::AP1roGPSESolver(unsigned long, GQCG::HamiltonianParameters const&) AP1roGPSESolver.cpp:19
2018-10-18 13:27:24.931868+0200 AP1roGPSESolver_test[6940:9758680] #3 0x1000c8132 in constructor::test_method() AP1roGPSESolver_test.cpp:22
2018-10-18 13:27:24.931876+0200 AP1roGPSESolver_test[6940:9758680] #4 0x1000c7117 in constructor_invoker() AP1roGPSESolver_test.cpp:14
2018-10-18 13:27:24.931953+0200 AP1roGPSESolver_test[6940:9758680] #5 0x10028e729 in boost::detail::function::void_function_invoker0<void ()(), void>::invoke(boost::detail::function::function_buffer&) function_template.hpp:118
2018-10-18 13:27:24.931968+0200 AP1roGPSESolver_test[6940:9758680] #6 0x10026450e in boost::function0::operator()() const function_template.hpp:759
2018-10-18 13:27:24.931977+0200 AP1roGPSESolver_test[6940:9758680] #7 0x10026436a in boost::detail::forward::operator()() execution_monitor.ipp:1300
2018-10-18 13:27:24.931986+0200 AP1roGPSESolver_test[6940:9758680] #8 0x10026384c in boost::detail::function::function_obj_invoker0<boost::detail::forward, int>::invoke(boost::detail::function::function_buffer&) function_template.hpp:138
2018-10-18 13:27:24.931994+0200 AP1roGPSESolver_test[6940:9758680] #9 0x10026255e in boost::function0::operator()() const function_template.hpp:759
2018-10-18 13:27:24.932096+0200 AP1roGPSESolver_test[6940:9758680] #10 0x10005abed in int boost::detail::do_invoke<boost::shared_ptrboost::detail::translator_holder_base, boost::function<int ()> >(boost::shared_ptrboost::detail::translator_holder_base const&, boost::function<int ()> const&) execution_monitor.ipp:281
2018-10-18 13:27:24.932108+0200 AP1roGPSESolver_test[6940:9758680] #11 0x10005a563 in boost::execution_monitor::catch_signals(boost::function<int ()> const&) execution_monitor.ipp:864
2018-10-18 13:27:24.932125+0200 AP1roGPSESolver_test[6940:9758680] #12 0x10005b1ba in boost::execution_monitor::execute(boost::function<int ()> const&) execution_monitor.ipp:1203
2018-10-18 13:27:24.932135+0200 AP1roGPSESolver_test[6940:9758680] #13 0x100035a62 in boost::execution_monitor::vexecute(boost::function<void ()> const&) execution_monitor.ipp:1309
2018-10-18 13:27:24.932144+0200 AP1roGPSESolver_test[6940:9758680] #14 0x100046ea4 in boost::unit_test::unit_test_monitor_t::execute_and_translate(boost::function<void ()> const&, unsigned int) unit_test_monitor.ipp:46
2018-10-18 13:27:24.932230+0200 AP1roGPSESolver_test[6940:9758680] #15 0x1000526d9 in boost::unit_test::framework::state::execute_test_tree(unsigned long, unsigned int, boost::unit_test::framework::state::random_generator_helper const*) framework.ipp:771
2018-10-18 13:27:24.932239+0200 AP1roGPSESolver_test[6940:9758680] #16 0x10004f19a in boost::unit_test::framework::state::execute_test_tree(unsigned long, unsigned int, boost::unit_test::framework::state::random_generator_helper const*) framework.ipp:717
2018-10-18 13:27:24.932251+0200 AP1roGPSESolver_test[6940:9758680] #17 0x100044e40 in boost::unit_test::framework::run(unsigned long, bool) framework.ipp:1577
2018-10-18 13:27:24.932260+0200 AP1roGPSESolver_test[6940:9758680] #18 0x1000a1556 in boost::unit_test::unit_test_main(boost::unit_test::test_suite* (*)(int, char**), int, char**) unit_test_main.ipp:231
2018-10-18 13:27:24.932291+0200 AP1roGPSESolver_test[6940:9758680] #19 0x1000a1eb0 in main unit_test_main.ipp:286
2018-10-18 13:27:24.932384+0200 AP1roGPSESolver_test[6940:9758680] #20 0x7fff6f618084 in start (libdyld.dylib:x86_64+0x17084)
2018-10-18 13:27:24.932397+0200 AP1roGPSESolver_test[6940:9758680]
2018-10-18 13:27:24.932405+0200 AP1roGPSESolver_test[6940:9758680] SUMMARY: AddressSanitizer: bad-free (libclang_rt.asan_osx_dynamic.dylib:x86_64h+0x5710d) in wrap_free
2018-10-18 13:27:24.932414+0200 AP1roGPSESolver_test[6940:9758680]
==6940==ABORTING