How to force template <class> to be derived from BaseClassA?

The easiest solution is to add a snippet of code that compiles only if it's what you expected:

template <class T>
void SomeManager::Add(T t)
{
    assert((Base const*)&t); // T must inherit from Base to allow T*->Base* conversion.
    t.CallTsBaseClassFunction();
    //... do other stuff
}

Sure, you can combine type traits with SFINAE:

#include <type_traits>

template <class T>
typename std::enable_if<std::is_base_of<your_base_class, T>::value, void>::type
SomeManager::Add(T)
{
    T->CallTsBaseClassFunction();
    //... do other stuff
}

Although I don't really see the benefit here.

Worth to mention that it can be done at compile time in a more readable fashion with static_assert. Something in the lines of:

class Base {};

template<class B>
class Template{
    static_assert(std::is_base_of<Base, B>::value, "B must derive from nmspc::Base");
}

It works even when B is exactly Base. If Base is itself a templated class it becomes more complicated but it can still be done and there's plenty of resources online.