docs: def resolve_structure(self, fc, ct):
          """
          Resolve structure specifications.
          """
          if self.debug: print("++++++++ Resolving structure of (%s) with %s"%(fc, ct))
          for w in ct.structure.withs:
              try:
                  if w.instance == 'parent' or w.instance == 'this':
                      w2 = With(w.instance, w.as_)
                  else:
                      w2 = With(fc.paths[w.instance].value,
                                w.as_)
              except:
                  raise ModelError("Unable to resolve With parameters for "
                                   "'{0}' in component '{1}'",
                                   w.as_, fc.id)
              fc.structure.add(w2)
              
          if len(ct.structure.tunnels) > 0:
              raise ModelError("Tunnel is not yet supported in PyLEMS!");
              
          for fe in ct.structure.for_eachs:
              fc.structure.add_for_each(fe)
              
          for ev in ct.structure.event_connections:
              try:
                  
                  from_inst = fc.structure.withs[ev.from_].instance
                  to_inst = fc.structure.withs[ev.to].instance
                  
                  if self.debug: print("EC..: "+from_inst+" to "+to_inst+ " in "+str(fc.paths))
                  
                  if len(fc.texts) > 0 or len(fc.paths) > 0:
                      
                      source_port = fc.texts[ev.source_port].value if ev.source_port and len(ev.source_port)>0 and ev.source_port in fc.texts else None
                      target_port = fc.texts[ev.target_port].value if ev.target_port and len(ev.target_port)>0 and ev.target_port in fc.texts else None
                      
                      if self.debug: print("sp: %s"%source_port)
                      if self.debug: print("tp: %s"%target_port)
  
                      receiver = None
  
                      # TODO: Get more efficient way to find parent comp
                      if '../' in ev.receiver:
                          receiver_id = None
                          parent_attr = ev.receiver[3:]
                          if self.debug: print("Finding %s in the parent of: %s (%i)"%(parent_attr, fc, id(fc)))
                          
                          for comp in self.components.values():
                              if self.debug: print(" - Checking %s (%i)" %(comp.id,id(comp))) 
                              for child in comp.children:
                                  if self.debug: print("    - Checking %s (%i)" %(child.id,id(child))) 
                                  for child2 in child.children:
                                      if child2.id == fc.id and child2.type == fc.type and child.id == fc.parent_id:
                                          if self.debug: print("    - Got it?: %s (%i), child: %s"%(child.id, id(child), child2))
                                          receiver_id = child.parameters[parent_attr]
                                          if self.debug: print("Got it: "+receiver_id)
                                          break
  
                          if receiver_id is not None:            
                              for comp in self.fat_components:
                                  if comp.id == receiver_id:
                                          receiver = comp
                                          if self.debug: print("receiver is: %s"%receiver)
  
                      if self.debug: print("rec1: %s"%receiver)
                      if not receiver:
                          receiver = fc.component_references[ev.receiver].referenced_component if ev.receiver else None
                      receiver_container = fc.texts[ev.receiver_container].value if (fc.texts and ev.receiver_container) else ''
  
                      if self.debug: print("rec2: %s"%receiver)
                      if len(receiver_container)==0:
                          # TODO: remove this hard coded check!
                          receiver_container = 'synapses'
  
                  else:
                      #if from_inst == 'parent':
                          #par = fc.component_references[ev.receiver]
                      
                      if self.debug: 
                          print("+++++++++++++++++++")
                          print(ev.toxml())
                          print(ev.source_port)
                          print(fc)
                      source_port = ev.source_port
                      target_port = ev.target_port
                      receiver = None
                      receiver_container = None
                      
                  ev2 = EventConnection(from_inst,
                                        to_inst,
                                        source_port,
                                        target_port,
                                        receiver,
                                        receiver_container)
                  if self.debug: 
                      print("Created EC: "+ev2.toxml())
                      print(receiver)
                      print(receiver_container)
              except:
                  logging.exception("Something awful happened!")
                  raise ModelError("Unable to resolve event connection parameters in component '{0}'",fc)
              fc.structure.add(ev2)
                  
          for ch in ct.structure.child_instances:
              try:
                  if self.debug: print(ch.toxml())
                  if '../' in ch.component:
                      parent = self.get_parent_component(fc)
                      if self.debug: print("Parent: %s"%parent)
                      comp_ref = ch.component[3:]
                      if self.debug: print("comp_ref: %s"%comp_ref)
                      comp_id = parent.parameters[comp_ref]
                      comp = self.fat_components[comp_id]
                      ch2 = ChildInstance(ch.component, comp)
                  else:    
                      ref_comp = fc.component_references[ch.component].referenced_component
                      ch2 = ChildInstance(ch.component, ref_comp)
              except Exception as e:
                  if self.debug: print(e)
                  raise ModelError("Unable to resolve child instance parameters for "
                                   "'{0}' in component '{1}'",
                                   ch.component, fc.id)
              fc.structure.add(ch2)
  
          for mi in ct.structure.multi_instantiates:
              try:
                  if mi.component:
                      mi2 = MultiInstantiate(component=fc.component_references[mi.component].referenced_component,
                                             number=int(fc.parameters[mi.number].numeric_value))
                  else:
                      mi2 = MultiInstantiate(component_type=fc.component_references[mi.component_type].referenced_component,
                                             number=int(fc.parameters[mi.number].numeric_value))                    
              except:
                  raise ModelError("Unable to resolve multi-instantiate parameters for "
                                   "'{0}' in component '{1}'",
                                   mi.component, fc)
              fc.structure.add(mi2)