It is hard to tell without more information but methods are meant to perform a single operation. If it is doing two related but different things, each thing should be moved into a separate method. There is nothing wrong with having multiple template methods, particularly if one thing may want to be modified (that is overridden) but not the other.

Moreover, if the class is doing multiple things (such as drawing and calculating), it may violate the “Single Responsibility Principle”, however this digresses from the question.

There is nothing really that prohibits you from calling two things from the template method. In your case you could do it like this:

public abstract class ContextObject {

    // The template method
    public void PerformDraw() {
        Draw();
        Calculate();
    }

    public abstract void Draw();

    public abstract void Calculate();

}

// The implementation is rather obvious:

public class ConcreteObject : ContextObject {

     public void Draw() { ... }

     public void Calculate() { ... }

}

// For all the concrete objects you only need to call 
// the template method, regardless of the implementation

for (ContextObject context : contextObjectList) {
    context.PerformDraw();
}

The only drawback with this template object class is that everyone needs to implement the Draw and the Calculate methods. So if all subclasses need to mix between draw and calculate in several combinations you might want to use strategy pattern instead like this:

// Strategy #1
public interface IDrawable {
    void Draw();
}

// Strategy #2
public interface ICalculatable {
    void Calculate();
}

// the previous class needs to use the interfaces above:
public abstract class ContextObject {

    private IDrawable drawable;
    private ICalculatable calculatable;

    public ContextObject(IDrawable drawable, ICalculatable calculatable) {
        this.calculatable = calculatable;
        this.drawable = drawable;
    }

    public void PerformDraw() {
        drawable.Draw();
        calculatable.Calculate();
    }

}

// The implementations
public class DrawUno : IDrawable { ... }
public class CalcUno : ICalculatable { ... }

public class ConcreteObject : ContextObject {

    // call the base class's constructor with the implementations
    public ConcreteObject() : 
        base( 
            new DrawUno(), 
                // can be mixed with any other of type IDrawable
            new CalcUno()
                // can be mixed with any other type of ICalculatable
        ) 
    {
        // no-op, the base constructor does the stuff you need...
    }

}

You could also mix and match, it all depends on what you actually need to do.