code: def run(self):
          
          # Adapt series
          ## time
          if self.integral is None:
              if self.arg_t is not None:
                  import datetime
                  if type(self.arg_t[0]) == datetime.datetime:
                      self.arg_t = self.to_minutes(time_obj=self.arg_t)
                  else:
                      self.arg_t = np.round(self.arg_t)
              elif self.arg_dt is not None:
                  self.arg_dt = np.round(self.arg_dt)
                  self.arg_t = self.to_minutes(dt=self.arg_dt)
              else:
                  raise ValueError('At least one time parameter is needed.')
              self.diff_t = np.diff(self.arg_t)
          
          ## data
          if self.arg_data is None:
              self.arg_data = np.ones(self.arg_t.shape[0])
          dt = self.diff_t/60  # hs
          rect = self.arg_data[:-1]/1000*dt  # kilounits
          triang_side = np.diff(self.arg_data)
          triang = 0.5*triang_side*dt
          self.integral = rect + triang
          self.integral = np.hstack((0, self.integral))
  
          # Computation
          if self.azimuth_zenit is None:
              self.get_sunpos(self.arg_t, self.arg_run_true_time)
          if self.vor_centers is None:
              self.Vonoroi_SH(self.arg_vor_size)
          self.compute_shadows()
          self.project_data()
docs: Run the shadowing computation with the values stored in 
          ``self.arg_``. Precomputed information is stored in:
          
              * **.diff_t** (*ndarray*): ``np.diff(t)``
              * **.integral** (*ndarray*): Trapezoidal data integration 
                over time.
  
          The steps are:
          
              * :func:`get_sunpos`
              * :func:`Vonoroi_SH`
              * :func:`compute_shadows`
              * :func:`project_data`
          
          :retruns: None