class_docstr: Hawkes process simulation
  
  They are defined by the intensity:
  
  .. math::
      \forall i \in [1 \dots D], \quad
      \lambda_i(t) = \mu_i(t) + 
                      \sum_{j=1}^D \int \phi_{ij}(t - s) dN_j(s)
  
  where
  
  * :math:`D` is the number of nodes
  * :math:`\mu_i(t)` are the baseline intensities
  * :math:`\phi_{ij}` are the kernels
  * :math:`dN_j` are the processes differentiates
  
  Parameters
  ----------
  kernels : `np.ndarray`, shape=(n_nodes, n_nodes)
      A 2-dimensional arrays of kernels, also noted :math:`\phi_{ij}`
  
  baseline : `np.ndarray` or `list`
      The baseline of all intensities, also noted :math:`\mu(t)`. It might 
      be three different types:
      
      * `np.ndarray`, shape=(n_nodes,) : One baseline per node is given. 
        Hence baseline is assumed to be constant, ie.
        :math:`\mu_i(t) = \mu_i`
      * `np.ndarray`, shape=(n_nodes, n_intervals) : `n_intervals` baselines 
        are given per node. This assumes parameter `period_length` is also 
        given. In this case baseline is piecewise constant on intervals of 
        size `period_length / n_intervals` and periodic.
      * `list` of `tick.base.TimeFunction`, shape=(n_nodes,) : One function 
        is given per node, ie. :math:`\mu_i(t)` is explicitely given.
  
  n_nodes : `int`
      The number of nodes of the Hawkes process. If kernels and baseline
      are None this will create a Hawkes process with n_nodes nodes of zero
      kernels and with zero baseline
  
  end_time : `float`, default=None
      Time until which this point process will be simulated
      
  period_length : `float`, default=None
      Period of baseline in piecewise constant case. 
  
  max_jumps : `int`, default=None
      Simulation will stop if this number of jumps in reached
  
  seed : `int`, default = None
      The seed of the random sampling. If it is None then a random seed
      (different at each run) will be chosen.
  
  force_simulation : `bool`, default = False
      If force is not set to True, simulation won't be run if the matrix of
      the L1 norm of kernels has a spectral radius greater or equal to 1 as
      it would be unstable
  
  Attributes
  ----------
  timestamps : `list` of `np.ndarray`, size=n_nodes
      A list of n_nodes timestamps arrays, each array containing the
      timestamps of all the jumps for this node
  
  simulation_time : `float`
      Time until which this point process has been simulated
  
  n_total_jumps : `int`
      Total number of jumps simulated
  
  tracked_intensity : `list[np.ndarray]`, size=n_nodes
      A record of the intensity with which this point process has been
      simulated.
      Note: you must call track_intensity before simulation to record it
  
  intensity_tracked_times : `np.ndarray`
      The times at which intensity has been recorded.
      Note: you must call track_intensity before simulation to record it
  
  intensity_track_step : `float`
      Step with which the intensity has been recorded
code: def check_parameters_coherence(self, kernels, baseline, n_nodes):
      set_kernels = kernels is not None
      set_baseline = baseline is not None
      set_n_nodes = n_nodes is not None
  
      if set_n_nodes and (set_kernels or set_baseline):
          raise ValueError(
              "n_nodes will be automatically calculated if "
              "baseline or kernels is set"
          )
  
      if not set_n_nodes and not set_kernels and not set_baseline:
          raise ValueError(
              "n_nodes must be given if neither kernels, "
              "nor baseline are given"
          )
  
      if set_kernels and set_baseline and len(kernels) != len(baseline):
          raise ValueError(
              "kernels and baseline have different length. "
              "kernels has length %i, whereas baseline has "
              "length %i." % (len(kernels), len(baseline))
          )
  
imports: import warnings
  from itertools import product
  import numpy
  from numpy.linalg import eig, inv
  from tick.base import TimeFunction
  from tick.hawkes.simulation.base import SimuPointProcess
  from tick.hawkes.simulation.build.hawkes_simulation import Hawkes
  from .hawkes_kernels import HawkesKernel0
label_desc: Use image node_id 6 for calling the SimuHawkes obj's underlying member method code with example usage: obj.check_parameters_coherence(kernels, baseline, n_nodes) without return types