Making a Custom DMRG Observer

The Observer system lets you define custom measurements to be performed within algorithms such as DMRG and time evolution. For the DMRG algorithm, you can make a subclass of the DMRGObserver type to implement custom measurements and printing of information from the ITensor dmrg function.

Let's see how to make a custom DMRG Observer by way of example.

Making our CustomObserver type

First make a type that is a subclass of DMRGObserver. We will call ours CustomObserver:

class CustomObserver : public DMRGObserver
    {
    public:

    CustomObserver(MPS const& psi,
                   Args const& args = Args::global())
        : DMRGObserver(psi)
        {}

    }; // class CustomObserver

Note that the parent type, DMRGObserver, requires an MPS to be passed to it, so we also require our CustomObserver to take an MPS in its constructor. This MPS is a reference to the one being optimized by the dmrg function.

Overloading the measure method

The DMRGObserver::measure method is what gets called by the dmrg function after each step. We can overload this method to change the information that gets printed by the dmrg function or to perform other custom measurements.

To overload measure, first we need to declare it as one of CustomObserver's methods:

class CustomObserver : public DMRGObserver
    {
    public:

    CustomObserver(MPS const& psi,
                   Args const& args = Args::global())
        : DMRGObserver(psi)
        {}

    void virtual
    measure(Args const& args);

    }; // class CustomObserver

Next we need to actually define this method (outside of the class):

void CustomObserver::
measure(Args const& args = Args::global())
    {
    // your custom measurement code goes here
    }

Now we can put any code we want into measure to measure the state being optimized by dmrg or report on the status of the DMRG optimization process.

Customizing the measure method

What kind of properties are available to measure? First of all, we can access the MPS being optimized by DMRG by calling DMRGObserver::psi():

void CustomObserver::
measure(Args const& args = Args::global())
    {
    // Obtain a reference to psi, the MPS being optimized:
    auto& psi = DMRGObserver::psi();
    }

Just as usefully, we can get a lot of information from the dmrg function itself that gets passed as named arguments through the args object. Here are the different named arguments available:

void CustomObserver::
measure(Args const& args = Args::global())
    {
    // Obtain a reference to psi, the MPS being optimized:
    auto& psi = DMRGObserver::psi();

    // How many sweeps of DMRG are to be performed:
    auto nsweep = args.getInt("NSweep",0);
    // Which sweep of DMRG we are on:
    auto sw = args.getInt("Sweep",0);
    // Which half sweep of DMRG we are on:
    auto ha = args.getInt("HalfSweep",0);
    // Which bond DMRG is on:
    auto b = args.getInt("AtBond",1);

    // What is the current energy?
    auto energy = args.getReal("Energy",0);
    // What was the last truncation error computed?
    auto truncerr = args.getReal("Truncerr",0);
    // What is the current truncation error cutoff?
    auto cutoff = args.getReal("Cutoff",0);
    // What is the current maximum bond dimension?
    auto maxdim = args.getInt("MaxDim",0);

    // Should output be silenced?
    auto silent = args.getBool("Silent",false);


    }

You do not have to define all of these variables. The code above is just to illustrate which named arguments are available to you to use.

Calling the default DMRGObserver::measure method

When you overload measure, by default it "shadows" the one defined by DMRGObserver which will no longer get called. However, the implementation of measure inside of DMRGObserver performs a number of useful measurements, such as reporting the entanglement entropy at the center of the MPS during each sweep.

To still run the DMRGObserver::measure method while also having your own custom implementation, just put the line DMRGObserver::measure(args); somewhere inside your own measure function.

Overloading the checkDone method

Subclasses of DMRGObserver can also overload a method named checkDone which returns a bool. If checkDone returns true, then the dmrg function will exit, returning the current energy and MPS wavefunction.

To overload checkDone, first declare it in your CustomObserver class:

class CustomObserver : public DMRGObserver
    {
    public:

    CustomObserver(MPS const& psi,
                   Args const& args = Args::global())
        : DMRGObserver(psi)
        {}

    void virtual
    measure(Args const& args);

    bool virtual
    checkDone(Args const& args);

    }; // class CustomObserver

Next define the checkDone method itself (outside of the class):

bool virtual
checkDone(Args const& args = Args::global())
    {
    return false;
    }

To customize this method, you can read in the same set of named arguments as in the measure function above. Let's use just one of them, the energy, to determine when we are going to stop our dmrg calculation:

bool virtual
checkDone(Args const& args = Args::global())
    {
    auto energy = args.getReal("Energy");
    if(energy < -100.0) return true;
    return false;
    }

This is just a contrived example, with -100 being a made-up value, and in your own application you might want to store the last reported energy inside your CustomObserver and check whether the latest energy differs from the last one by some relative amount. Or you could set a checkDone criterion based on the truncation error, entanglement entropy, or any other quantity you wish.