Time series of Poisson Process
A)

The quantization of the photocurrent is an actual physical phenomenon.

I'll use $\Delta T$ in place of your $dT$. It is not a variable describing the actual physical process but rather the time step of your approximate model. Effectively you are filtering the continuous-time Poisson point process by a continuous-time "moving average" filter with a rectangular impulse response of length $\Delta T$ and sampling the filtered signal uniformly with a sampling period $\Delta T$. The filter acts similarly to a low-pass filter, but is not very effective at band-limiting the process. Therefore you have aliasing and it becomes difficult to interpret your results. If you don't know what aliasing means, have a look at the question: "explanation of Hybrid systems?" and its answers for an introduction on sampling of continuous-time signals.

Sampling the RC-filtered Poisson Process

Non-uniform sampling: The impulse response of a first-order low-pass filter is a right-sided exponential function. It would be easy to convolve the Poisson point process directly by it. Non-uniformly sampling the filtered signal at the event times would give an unambiguous representation of the signal that allows exact reconstruction of the signal from the samples. This would not be sampling of a band-limited signal but would take advantage of the special form of the signal. See math later below.

Uniform sampling: If the cut-off frequency of the first-order low-pass filter is low enough relative to the sampling frequency, then uniform sampling of the filtered signal does not cause much aliasing and you will have quite a clean discrete-time signal (time series) to work with. When time stepping, the signal decays exponentially from the previous sample to the current sample, unless there have been events within the last time step. In that case you'd calculate the contribution of the filtered events and add that into the current signal value. That's the beauty of the right-sided exponential impulse response: it allows to forget when the past events occurred, combining their contribution to a single value that keeps decaying exponentially. The drawback of uniform sampling is that if there are two or more events between successive samples, then their exact times cannot in general be reconstructed from the samples of the filtered signal.

There are two easy ways to generate the event times of a Poisson process: 1) The time between successive events follows an exponential distribution, so you just need a pseudo-random number generator with an exponential distribution, and generate the times of the events in order until you are at the simulation end time. The time of an event is obtained adding the exponentially distributed random number to the time of the previous event. Note that it is only a coincidence that also the low-pass filter impulse response is a one-sided exponential function. 2) Generate a Poisson distributed random number to get the number of events over the simulation length, pick that many event times from an uniform distribution that is as long as the simulation and sort the event times. Or you can generate event times for each sampling interval individually.

In this presentation I will not use units, for my own convenience. The impulse response $h$ of a resistor-capacitor (RC) filter, as function of continuous time $t$, is of form:

$$h(t) = \begin{cases}0&amp;\text{if }t&lt;0,\\\displaystyle a e^{-at}&amp;\text{if }t\ge0,\end{cases}\tag{1}$$

Figure 1. RC-filter impulse response (Eq. 1), with decay parameter $a = 1$.

where $a$ is a positive constant that determines the decay rate. If this is convolved with a realization of a Poisson process with $K$ Dirac impulse events at times $p_k$, $0 &lt; k \le K$, then we get the signal $y$ of which you can find some literature under the keyword filtered Poisson process:

$$y(t) = \sum_k^{K-1}h\left(t-p_k\right)\tag{2}$$

Figure 2. A realization of an RC-filtered Poisson process (Eq. 2), with $a = 1$.

We can set up a sample point at time $t_n$. If we know the signal value  $y(t_n)$ at that point, then we can forget the events at or before that time and still reconstruct $y(t)$ at later times $t \ge t_n$:

$$y(t) = y(t_n)\,e^{-a(t-t_n)} + \sum_{k=0}^{K-1}\begin{cases}0&amp;\text{if }p_k \le t_n,\\h(t-p_k)&amp;\text{if }p_k &gt; t_n,\end{cases}\quad t \ge t_n,\tag{3}$$

or in a less formal short-hand notation:

$$y(t) = y(t_n)\,e^{-a(t-t_n)} + \sum_{k,\,t_n &lt; p_k}h(t-p_k), \quad t \ge t_n.\tag{4}$$

This is a property unique to the one-sided exponential function $h(t)$. The effect of an event at time $p_k$ is already included in $y(p_k)$ with the way Eq. 1 is currently defined. We can make explicit also that because the impulse response is causal, the events happening after time $t$ do not affect $y(t)$:

$$y(t) = y(t_n)\,e^{-a(t-t_n)} + \sum_{k,\,t_n&lt;p_k\le t}h(t-p_k), \quad t \ge t_n.\tag{5}$$

You can do non-uniform sampling at the event times by setting $t_k = p_k$, or uniform sampling with sampling period $\Delta t$ by setting $t_n = t_0 + n\,\Delta t$. In your data structure you'd just store $t_n$ (no need in case of uniform sampling) and $y(t_n)$. Python example:

import numpy as np
import bisect
import matplotlib.pyplot as plt

sim_length = 10  # Simulation length
rate = 100  # Event rate per time unit
a = 1  # Filter decay constant

K = np.random.poisson(rate*sim_length)  # Number of events
N = K + 1  # Number of samples. Always have one sample at simulation start
ty = np.empty(N, dtype = [('time', float), ('value', float)])  # Sample times t and signal values y
ty['time'][0] = 0 
ty['value'][0] = 0  # Start signal at value 0
ty['time'][1:] = np.random.uniform(0, sim_length, K)  # Event times
ty[1:].sort(order='time')  # Sort events by time
for k in range(K):  # Sample signal at event times
    ty['value'][1 + k] = ty['value'][k]*np.exp(-a*(ty['time'][1 + k] - ty['time'][k])) + a

def sample_y(ty, t):  # Sample signal at arbitrary time t
    k = bisect.bisect(ty['time'], t) - 1     
    return ty['value'][k]*np.exp(-a*(t-ty['time'][k]))

# Create a time series of the RC-filtered Poisson process
t = np.arange(0, sim_length, 1/10000)  # Delta t = 1/10000
y = np.zeros(t.size)
for k in range(t.size):
    y[k] = sample_y(ty, t[k])

# Plot
plt.plot(t, y)
plt.xlabel('t')
plt.ylabel('y(t)')
plt.show()


Figure 3. RC-filtered Poisson process plotted by the above Python script.

Figure 4. RC-filtered Poisson process reparameterized with rate = 1 and a = 10.