Below is an example of building LUT:

identity = np.arange(256, dtype = np.dtype('uint8'))
zeros = np.zeros(256, np.dtype('uint8'))
lut = np.dstack((identity, identity, zeros))

Note, there is much simpler and straightforward way zeroing the red channel:

img[:,:,2] = 0

Also calling LUT function should look like this:

dstImage = cv2.LUT(img, lut)

Set blue values greater than b_max to b_max:

b_max = 20
img[img[:,:,0] > b_max, 0] = b_max;

You looked into documentation of yet to be released version of OpenCV (version 3.0). I guess you are using OpenCV 2.4.8 or lower. Check this documentation. Notice the differences in usage of LUT function. At the top of the page you will see the version of OpenCV to which this documentation belong.

LUT(srcImage, lookupTable, dstImage)

As you've already discovered, the implementation of OpenCV's LUT method only supports 8-bit LUTs. However, you can implement your own for arbitrary bit resolutions and it's actually quite simple. For each value in the image, this is directly used to access the LUT which will output the desired value. Because OpenCV interfaces with NumPy, you can just use the input image and index into the LUT directly in order to obtain the final output, taking advantage of NumPy array indexing.

First define a LUT - you'll need to ensure it's 16-bit and I'm assuming you have values that go from 0 to 65535 to respect the 16-bit resolution. Once you do that, use the table to index into your image. Here's an example using gamma adjusting:

import numpy as np

def adjust_gamma(image, gamma=1.0):
    # build a lookup table mapping the pixel values [0, 65535] to
    # their adjusted gamma values
    inv_gamma = 1.0 / gamma
    table = ((np.arange(0, 65536) / 65535) ** inv_gamma) * 65535

    # Ensure table is 16-bit
    table = table.astype(np.uint16)

    # Now just index into this with the intensities to get the output
    return table[image]

This applies inverse gamma adjusting of an input image, where we first generate a LUT that is 16-bit, then the image is used to directly index into it to create the output image. Take note that the input image is also assumed to be 16-bit. If you have any values that are beyond the 0-65535 range, this will give you an out-of-bounds indexing error.

Note - Multi-channel images

Take note that the above case assumes a single-channel image. If you want to apply this for multi-channel (i.e. RGB images), then you'll need to define a LUT for each channel and apply the LUT to each channel separately. The easiest way to do this would be a for loop across all channels. There are definitely more vectorized ways to do this in one-shot, but I will not diverge from the intent of your question and I want this to be as simple to read as possible.

First define a 2D LUT where each row in this matrix is a single LUT. Specifically, row i corresponds to the LUT to apply to channel i of the image. Once you're finished, loop through the channel dimension and apply the LUT. What we can also do to save some time is to preallocate the output image so that it's all zeroes, then fill in each channel accordingly.

Something like:

# Assume LUT is defined as `table` and it's a 2D NumPy array
output = np.zeros_like(image)
for i in range(image.shape[2]):
    output[..., i] = table[i, image[..., i]]

output will contain the desired result. However, for the special case where the LUT is the same across all channels, you can just use the same 1D LUT you had previously and you can use the same indexing method that I talked about earlier:

output = table[image]

Thanks to @Dan Mašek's comment above. I'm adding it as answer here so the question can be marked answered.

For a 3 channel lookup table, the input also needs to be 3 channel. Just merge 3 copies of the L channel back into a 3 channel Mat, and apply the LUT to the result.

Updated code:

void MainWindow::convertLightToDarkColorMap(const cv::Mat inputMat)
{
    // Create lookup table (LUT)

    cv::Mat lookupTable(1, 256, CV_8UC(3));
    for (int i=0; i<256; i++)
    {
        lookupTable.at<cv::Vec3b>(i)[0]= 255-i; // first channel  (B)
        lookupTable.at<cv::Vec3b>(i)[1]= 0;     // second channel (G)
        lookupTable.at<cv::Vec3b>(i)[2]= 255+i; // ...            (R)
    }

    // Convert to LAB color space.
    cv::Mat convertedLAB;
    cv::cvtColor(inputMat, convertedLAB, CV_BGR2Lab);

    // Isolate the L, A, B channels.
    cv::Mat convertedLABSplit[3];
    cv::split(convertedLAB, convertedLABSplit);

    // 3 channel LUT only works on a 3 channel input.  So take (3) copes of the L channel and merge them into one.
    cv::Mat trippleL;
    std::vector<cv::Mat> trippleLArr;
    trippleLArr.push_back(convertedLABSplit[0]);
    trippleLArr.push_back(convertedLABSplit[0]);
    trippleLArr.push_back(convertedLABSplit[0]);
    cv::merge( trippleLArr, trippleL);

    // Apply our custom lookup table to L channel.
    cv::Mat outputMat(inputMat.rows, inputMat.cols, CV_8UC3);
    cv::LUT(trippleL, lookupTable, outputMat);

    // Show the output image
    cv::imshow("Output", outputMat);
}