docs: def write(self, destination, source_model, name=None):
          """
          Save sources - to multiple
          shapefiles corresponding to different source typolgies/geometries
          ('_point', '_area', '_simple', '_complex', '_planar')
          """
          if os.path.exists(destination + ".shp"):
              os.system("rm %s.*" % destination)
          self.destination = destination
          self.filter_params(source_model)
  
          w_area = shapefile.Writer(shapefile.POLYGON)
          w_point = shapefile.Writer(shapefile.POINT)
          w_simple = shapefile.Writer(shapefile.POLYLINE)
          w_simple3d = shapefile.Writer(shapefile.POLYGONZ)
          w_complex = shapefile.Writer(shapefile.POLYLINEZ)
          w_planar = shapefile.Writer(shapefile.POLYGONZ)
  
          register_fields(w_area)
          register_fields(w_point)
          register_fields(w_simple)
          register_fields(w_simple3d)
          register_fields(w_complex)
          register_fields(w_planar)
  
          for src in source_model.sources:
  
              # Order is important here
              if "areaSource" in src.tag:
                  set_params(w_area, src)
                  set_area_geometry(w_area, src)
              elif "pointSource" in src.tag:
                  set_params(w_point, src)
                  set_point_geometry(w_point, src)
              elif "complexFaultSource" in src.tag:
                  set_params(w_complex, src)
                  set_complex_fault_geometry(w_complex, src)
              elif "simpleFaultSource" in src.tag:
                  set_params(w_simple, src)
                  set_simple_fault_geometry(w_simple, src)
                  # Create the 3D polygon
                  set_params(w_simple3d, src)
                  set_simple_fault_geometry_3D(w_simple3d, src)
              elif "characteristicFaultSource" in src.tag:
                  src_taglist = get_taglist(src)
                  surface_node = src.nodes[src_taglist.index("surface")]
                  for subnode in surface_node:
                      if "simpleFaultGeometry" in subnode.tag:
                          set_params(w_simple, src)
                          set_params(w_simple3d, src)
                      elif "complexFaultGeometry" in subnode.tag:
                          set_params(w_complex, src)
                      elif "planarSurface" in subnode.tag:
                          set_params(w_planar, src)
                      else:
                          raise ValueError(
                              'Geometry class %s not recognized'
                              % subnode.tag)
                      set_characteristic_geometry(w_simple, w_simple3d,
                                                  w_complex, w_planar, src)
              else:
                  raise ValueError('Source type %s not recognized'
                                   % src.tag)
  
          root = self.destination
          if len(w_area.shapes()) > 0:
              w_area.save('%s_area' % root)
          if len(w_point.shapes()) > 0:
              w_point.save('%s_point' % root)
          if len(w_complex.shapes()) > 0:
              w_complex.save('%s_complex' % root)
          if len(w_simple.shapes()) > 0:
              w_simple.save('%s_simple' % root)
              w_simple3d.save('%s_simple3d' % root)
          if len(w_planar.shapes()) > 0:
              w_planar.save('%s_planar' % root)