docs: def export(cls, folder, particles, datetimes, summary, **kwargs):
          """
              Export particle data to CF trajectory convention
              netcdf file
          """
          time_units = 'seconds since 1990-01-01 00:00:00'
  
          # Create netcdf file, overwrite existing
          if not os.path.exists(folder):
              os.makedirs(folder)
  
          filepath = os.path.join(folder, 'trajectories.nc')
          nc = netCDF4.Dataset(filepath, 'w')
          # Create netcdf dimensions
          nc.createDimension('time', None)
          nc.createDimension('particle', None)
  
          fillvalue = -9999.9
  
          # Create netcdf variables
          time = nc.createVariable('time', 'i', ('time',))
          part = nc.createVariable('particle', 'i', ('particle',))
          depth = nc.createVariable('depth', 'f', ('time', 'particle'))
          lat = nc.createVariable('lat', 'f', ('time', 'particle'), fill_value=fillvalue)
          lon = nc.createVariable('lon', 'f', ('time', 'particle'), fill_value=fillvalue)
          salt = nc.createVariable('salt', 'f', ('time', 'particle'), fill_value=fillvalue)
          temp = nc.createVariable('temp', 'f', ('time', 'particle'), fill_value=fillvalue)
          u = nc.createVariable('u', 'f', ('time', 'particle'), fill_value=fillvalue)
          v = nc.createVariable('v', 'f', ('time', 'particle'), fill_value=fillvalue)
          w = nc.createVariable('w', 'f', ('time', 'particle'), fill_value=fillvalue)
          settled = nc.createVariable('settled', 'f', ('time', 'particle'), fill_value=fillvalue)
          dead = nc.createVariable('dead', 'f', ('time', 'particle'), fill_value=fillvalue)
          halted = nc.createVariable('halted', 'f', ('time', 'particle'), fill_value=fillvalue)
  
          # Loop through locations in each particle,
          # add to netcdf file
          for j, particle in enumerate(particles):
              part[j] = particle.uid
              i = 0
  
              normalized_locations = particle.normalized_locations(datetimes)
              normalized_temps = [x if x is not None and not math.isnan(x) else fillvalue for x in particle.temps]
              normalized_salts = [x if x is not None and not math.isnan(x) else fillvalue for x in particle.salts]
              normalized_u = [x if x is not None and not math.isnan(x) else fillvalue for x in particle.u_vectors]
              normalized_v = [x if x is not None and not math.isnan(x) else fillvalue for x in particle.v_vectors]
              normalized_w = [x if x is not None and not math.isnan(x) else fillvalue for x in particle.w_vectors]
              normalized_settled = [x if x is not None and not math.isnan(x) else fillvalue for x in particle.settles]
              normalized_dead = [x if x is not None and not math.isnan(x) else fillvalue for x in particle.deads]
              normalized_halted = [x if x is not None and not math.isnan(x) else fillvalue for x in particle.halts]
  
              if len(normalized_locations) != len(normalized_temps):
                  logger.info("No temperature being added to netcdf.")
                  # Create list of 'fillvalue' equal to the length of locations
                  normalized_temps = [fillvalue] * len(normalized_locations)
  
              if len(normalized_locations) != len(normalized_salts):
                  logger.info("No salinity being added to netcdf.")
                  # Create list of 'fillvalue' equal to the length of locations
                  normalized_salts = [fillvalue] * len(normalized_locations)
  
              if len(normalized_locations) != len(normalized_u):
                  logger.info("No U being added to netcdf.")
                  # Create list of 'fillvalue' equal to the length of locations
                  normalized_u = [fillvalue] * len(normalized_locations)
  
              if len(normalized_locations) != len(normalized_v):
                  logger.info("No V being added to netcdf.")
                  # Create list of 'fillvalue' equal to the length of locations
                  normalized_v = [fillvalue] * len(normalized_locations)
  
              if len(normalized_locations) != len(normalized_w):
                  logger.info("No W being added to netcdf.")
                  # Create list of 'fillvalue' equal to the length of locations
                  normalized_w = [fillvalue] * len(normalized_locations)
  
              if len(normalized_locations) != len(normalized_settled):
                  logger.info("No Settled being added to shapefile.")
                  # Create list of 'fillvalue' equal to the length of locations
                  normalized_settled = [fillvalue] * len(normalized_locations)
  
              if len(normalized_locations) != len(normalized_dead):
                  logger.info("No Dead being added to shapefile.")
                  # Create list of 'fillvalue' equal to the length of locations
                  normalized_dead = [fillvalue] * len(normalized_locations)
  
              if len(normalized_locations) != len(normalized_halted):
                  logger.info("No Halted being added to shapefile.")
                  # Create list of 'fillvalue' equal to the length of locations
                  normalized_halted = [fillvalue] * len(normalized_locations)
  
              for loc, _temp, _salt, _u, _v, _w, _settled, _dead, _halted in zip(normalized_locations, normalized_temps, normalized_salts, normalized_u, normalized_v, normalized_w, normalized_settled, normalized_dead, normalized_halted):
  
                  if j == 0:
                      time[i] = int(round(netCDF4.date2num(loc.time, time_units)))
                  depth[i, j] = loc.depth
                  lat[i, j] = loc.latitude
                  lon[i, j] = loc.longitude
                  salt[i, j] = _salt
                  temp[i, j] = _temp
                  u[i, j] = _u
                  v[i, j] = _v
                  w[i, j] = _w
                  settled[i, j] = _settled
                  dead[i, j] = _dead
                  halted[i, j] = _halted
                  i += 1
  
          # Variable attributes
          depth.coordinates = "time particle lat lon"
          depth.standard_name = "depth_below_sea_surface"
          depth.units = "m"
          depth.POSITIVE = "up"
          depth.positive = "up"
  
          salt.coordinates = "time particle lat lon"
          salt.standard_name = "sea_water_salinity"
          salt.units = "psu"
  
          temp.coordinates = "time particle lat lon"
          temp.standard_name = "sea_water_temperature"
          temp.units = "degrees_C"
  
          u.coordinates = "time particle lat lon"
          u.standard_name = "eastward_sea_water_velocity"
          u.units = "m/s"
  
          v.coordinates = "time particle lat lon"
          v.standard_name = "northward_sea_water_velocity"
          v.units = "m/s"
  
          w.coordinates = "time particle lat lon"
          w.standard_name = "upward_sea_water_velocity"
          w.units = "m/s"
  
          settled.coordinates = "time particle lat lon"
          settled.description = "Is the particle settled"
          settled.standard_name = "particle_settled"
  
          dead.coordinates = "time particle lat lon"
          dead.description = "Is the particle dead"
          dead.standard_name = "particle_dead"
  
          halted.coordinates = "time particle lat lon"
          halted.description = "Is the particle prevented from being forced by currents"
          halted.standard_name = "particle_halted"
  
          time.units = time_units
          time.standard_name = "time"
  
          lat.units = "degrees_north"
  
          lon.units = "degrees_east"
  
          part.cf_role = "trajectory_id"
  
          # Global attributes
          nc.featureType = "trajectory"
          nc.summary = str(summary)
          for key in kwargs:
              nc.__setattr__(key, kwargs.get(key))
  
          nc.sync()
          nc.close()