diff --git a/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.cxx b/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.cxx
index eb4be8cb27c1ef2dfdef59319ca17e024549c658..340a2d6adc5fcd5393ded3140c6d2ca0d9da4748 100644
--- a/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.cxx
+++ b/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.cxx
@@ -22,7 +22,7 @@ InputMakerForRoI:: InputMakerForRoI( const std::string& name,
 
 StatusCode  InputMakerForRoI::initialize() {
   ATH_MSG_DEBUG("Will produce output RoI collections: " << m_RoIs);
-  CHECK( m_RoIs.initialize() );
+  CHECK( m_RoIs.initialize( SG::AllowEmpty ) );
   return StatusCode::SUCCESS;
 }
 
@@ -35,7 +35,7 @@ StatusCode  InputMakerForRoI::execute( const EventContext& context ) const {
   ATH_CHECK(outputHandle.isValid());
   
   // Prepare Outputs
-  std::unique_ptr< TrigRoiDescriptorCollection > oneRoIColl( new TrigRoiDescriptorCollection() );
+  std::unique_ptr<TrigRoiDescriptorCollection> oneRoIColl = std::make_unique<TrigRoiDescriptorCollection>();
 
   // use also this:    ElementLinkVector<xAOD::MuonRoIContainer> getMuonRoILinks = obj->objectCollectionLinks<xAOD::MuonRoIContainer>("ManyMuonRoIs");
   std::vector <ElementLink<TrigRoiDescriptorCollection> > RoIsFromDecision;  // used to check for duplicate features linked to different inputHandles
@@ -70,11 +70,15 @@ StatusCode  InputMakerForRoI::execute( const EventContext& context ) const {
   } // loop over decisions      
   
   
-    // Finally, record output
-  ATH_MSG_DEBUG("Produced "<<oneRoIColl->size() <<" output RoIs");
-  auto roi_outputHandle = SG::makeHandle(m_RoIs, context);
-  ATH_CHECK( roi_outputHandle.record(std::move(oneRoIColl)) );
-  
+  // Finally, record output
+  if (m_RoIs.empty()) {
+    ATH_MSG_DEBUG("No concrete output ROI collection required from this InputMaker.");
+  } else {
+    ATH_MSG_DEBUG("Produced "<<oneRoIColl->size() <<" output RoIs");
+    auto roi_outputHandle = SG::makeHandle(m_RoIs, context);
+    ATH_CHECK( roi_outputHandle.record(std::move(oneRoIColl)) );
+  }
+
   // call base class helper method to print some debug messages summarising the content of the outputHandles.
   if (msgLvl(MSG::DEBUG)) {
     debugPrintOut(context, outputHandle);
diff --git a/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.h b/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.h
index fda2d2b0cc6a0f4668c589cb4f37f2cee27198a9..9f5119fd46c7a6a628a24efa4bd3ea233c0fd1ae 100644
--- a/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.h
+++ b/Trigger/TrigSteer/DecisionHandling/src/InputMakerForRoI.h
@@ -26,7 +26,8 @@
     virtual StatusCode  execute(const EventContext&) const override;
 
   private: 
-    SG::WriteHandleKey<TrigRoiDescriptorCollection> m_RoIs {this,"RoIs", "Unspecified", "Name of the RoIs extracted from the decisions"};
+    SG::WriteHandleKey<TrigRoiDescriptorCollection> m_RoIs {this,"RoIs", "",
+      "Name of the collection of ROI extrated from the input Decision Objects. Used as cocnrete starting handle for step's reconstruction."};
 
   }; 
 
diff --git a/Trigger/TrigValidation/TrigUpgradeTest/python/EmuStepProcessingConfig.py b/Trigger/TrigValidation/TrigUpgradeTest/python/EmuStepProcessingConfig.py
index c6bac567b7aec9ede80e13324458f5e34c710021..eedfbce25f172727b2c8c6829fc6f36bf992d505 100644
--- a/Trigger/TrigValidation/TrigUpgradeTest/python/EmuStepProcessingConfig.py
+++ b/Trigger/TrigValidation/TrigUpgradeTest/python/EmuStepProcessingConfig.py
@@ -5,9 +5,10 @@ from AthenaCommon.AlgScheduler import AlgScheduler
 from AthenaCommon.CFElements import parOR
 from AthenaCommon.Logging import logging
 from L1Decoder.L1DecoderConf import CTPUnpackingEmulationTool, RoIsUnpackingEmulationTool, L1Decoder
-
+from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import EmptyMenuSequence
 log = logging.getLogger('EmuStepProcessingConfig')
 
+
 def thresholdToChains( chains ):
     """
     Produces list "threshod : chain" for all chains passed. Uses the L1Thresholds/vseeds Chain property
@@ -53,7 +54,7 @@ def generateL1DecoderAndChains():
  
     # event 2: 2e+ 3mu : HLT_e5_e8_2mu6_L1EM3_EM5_L12MU6, HLT_mu6_e8_L1MU6_EM5
     data['ctp'] [2]      =  'HLT_mu6_L1MU6 HLT_mu8_L1MU10 HLT_mu10_L1MU10 HLT_mu8_1step_L1MU6 HLT_e20_L1EM10 HLT_e8_L1EM7 HLT_mu6_e8_L1MU6_EM5 HLT_mu6Comb_e8_L1MU6_EM5 HLT_e3_e5_L1EM3_EM5 HLT_2mu6_L12MU6 HLT_2mu6Comb_L12MU6 HLT_2mu4_bDimu_L12MU4 HLT_e5_e8_L1EM3_EM5 HLT_e5_e8_2mu6_L1EM3_EM5_L12MU6 HLT_mu6_mu6noL1_L1MU6'
-    data['l1emroi'][2]   =  '2,0.2,0,EM3,EM5, EM7,EM15,EM20,EM50,EM100; 1,-1.1,0,EM3,EM5,EM7,EM15,EM20,EM50;'
+    data['l1emroi'][2]   =  '2,0.2,0,EM3,EM5,EM7,EM15,EM20,EM50,EM100; 1,-1.1,0,EM3,EM5,EM7,EM15,EM20,EM50;'
     data['emclusters'][2]=  'eta:0.5,phi:0,et:120000; eta:1,phi:-1.2,et:65000;'
     data['l1muroi'][2]   =  '2,0.5,0,MU6,MU8; 3,0.5,0,MU6,MU8,MU10;2.2,0.6,0,MU6;'
     data['msmu'][2]      =  'eta:-1.2,phi:0.7,pt:6500,pt2:8500; eta:-1.1,phi:0.6,pt:8500,pt2:8500;eta:-1.1,phi:0.6,pt:8500,pt2:8500;'
@@ -167,6 +168,8 @@ def generateL1DecoderAndChains():
 
     # combined chain
     if doCombo:
+        emptySeq1 = EmptyMenuSequence("step1EmptySeqence")
+        emptySeq2 = EmptyMenuSequence("step2EmptySeqence")
         if not doElectron:
             from TrigUpgradeTest.HLTSignatureConfig import elMenuSequence        
             el11 = elMenuSequence(step="1",reconame="v1", hyponame="v1")    
@@ -185,7 +188,6 @@ def generateL1DecoderAndChains():
             mu32 = muMenuSequence(step="3",reconame="v2", hyponame="v2")
             #step4
             mu41 = muMenuSequence(step="4",reconame="v1", hyponame="v1")
-
            
            
         from TrigUpgradeTest.HLTSignatureHypoTools import dimuDrComboHypoTool
@@ -199,9 +201,9 @@ def generateL1DecoderAndChains():
 
      
         CombChains =[
-
-            makeChain(name='HLT_mu6_e8_L1MU6_EM5',  L1Thresholds=["MU6","EM5"], ChainSteps=[ ChainStep("Step1_mu_em", [mu11, el11], multiplicity=[1,1], comboToolConfs=[dimuDrComboHypoTool]),
-                                                                                             ChainStep("Step2_mu_em", [mu21, el21], multiplicity=[1,1])] ),
+            # This is an example of a chain running in "serial"
+            makeChain(name='HLT_mu6_e8_L1MU6_EM5',  L1Thresholds=["MU6","EM5"], ChainSteps=[ ChainStep("Step1_mu_em_serial", [mu11, emptySeq1], multiplicity=[1,1]),
+                                                                                             ChainStep("Step2_mu_em_serial", [emptySeq2, el21], multiplicity=[1,1])] ),
 
             makeChain(name='HLT_mu6Comb_e8_L1MU6_EM5', L1Thresholds=["MU6","EM5"], ChainSteps=[ ChainStep("Step1_mu2_em", [mu12, el11], multiplicity=[1,1]),
                                                                                                 ChainStep("Step2_mu_em", [mu21, el21], multiplicity=[1,1])] ),
@@ -238,7 +240,6 @@ def generateL1DecoderAndChains():
 
     l1Decoder = L1Decoder( RoIBResult="", L1TriggerResult="" )
     l1Decoder.L1DecoderSummaryKey = "L1DecoderSummary"
-    
     ctpUnpacker = CTPUnpackingEmulationTool( ForceEnableAllChains=False , InputFilename="ctp.dat" )
     l1Decoder.ctpUnpacker = ctpUnpacker
 
diff --git a/Trigger/TrigValidation/TrigUpgradeTest/python/HLTSignatureConfig.py b/Trigger/TrigValidation/TrigUpgradeTest/python/HLTSignatureConfig.py
index 0922cc1392923e757bcaf846f9116ef407aa467b..eb705d0050f8e8bbffd497220eeb1120e858438c 100644
--- a/Trigger/TrigValidation/TrigUpgradeTest/python/HLTSignatureConfig.py
+++ b/Trigger/TrigValidation/TrigUpgradeTest/python/HLTSignatureConfig.py
@@ -1,3 +1,4 @@
+
 # Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 
 from AthenaConfiguration.ComponentFactory import CompFactory
diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/ChainMerging.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/ChainMerging.py
index f24e9e05ac3913cec9b1e987931c9b65da525300..d9b38c02be58c63bfd59e6e8edc02131d08b221f 100644
--- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/ChainMerging.py
+++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/ChainMerging.py
@@ -4,20 +4,21 @@ from AthenaCommon.Logging import logging
 log = logging.getLogger( __name__ )
 
 
-from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import Chain, ChainStep
+from TriggerMenuMT.HLTMenuConfig.Menu.MenuComponents import Chain, ChainStep, EmptyMenuSequence
 from copy import deepcopy
 
 
-def mergeChainDefs(listOfChainDefs, chainDict, strategy="parallel", offset=-1):
+def mergeChainDefs(listOfChainDefs, chainDict):
 
-    log.debug("Combine by using %s merging", strategy)
+    strategy = chainDict["mergingStrategy"]
+    offset = chainDict["mergingOffset"]
+    log.info(chainDict['chainName'])
+    log.info("Combine by using %s merging", strategy)
 
     if strategy=="parallel":
         return mergeParallel(listOfChainDefs,  offset)
     elif strategy=="serial":
-        #return mergeSerial(listOfChainDefs,offset)
-        log.error("Serial mergin not yet implemented.")
-        return -1
+        return mergeSerial(listOfChainDefs)
     else:
         log.error("Merging failed for %s. Merging strategy '%s' not known.", (listOfChainDefs, strategy))
         return -1
@@ -54,9 +55,9 @@ def mergeParallel(chainDefList, offset):
     myOrderedSteps = deepcopy(orderedSteps)
 
     combChainSteps =[]
-    for steps in myOrderedSteps:
+    for step_index, steps in enumerate(myOrderedSteps):
         mySteps = list(steps)
-        combStep = makeChainSteps(mySteps)
+        combStep = makeChainSteps(mySteps, step_index+1)
         combChainSteps.append(combStep)
 
     # check if all chain parts have the same number of steps
@@ -68,24 +69,95 @@ def mergeParallel(chainDefList, offset):
                                   
     combinedChainDef = Chain(chainName, ChainSteps=combChainSteps, L1Thresholds=l1Thresholds)
 
-    log.debug("Merged chain %s with these steps:", chainName)
+    log.info("Parallel merged chain %s with these steps:", chainName)
     for step in combinedChainDef.steps:
         log.debug('   %s', step)
 
     return combinedChainDef
 
+def serial_zip(allSteps, chainName):
+    n_chains = len(allSteps)
+    newsteps = []
+    for chain_index, chainsteps in enumerate(allSteps):
+        for step_index, step in enumerate(chainsteps):
+            log.info('chain_index: ' + str(chain_index) + " step_index: " + str(step_index))
+            # create list of correct length
+            stepList = [None]*n_chains
+            
+            # put the step from the current sub-chain into the right place
+            stepList[chain_index] = step
+            log.info('Put step: ' + str(step))
+
+            # all other steps should contain an empty sequence
+            for step_index2, emptyStep in enumerate(stepList):
+                if emptyStep is None:
+                    seqName = chainName + 'EmptySeq' + str(chain_index) + '_' + str(step_index+1)
+                    emptySeq = EmptyMenuSequence(seqName)
+                    stepList[step_index2] = ChainStep('Step' + str(step_index+1) + "_" + seqName, Sequences=[emptySeq], chainDicts=step.chainDicts)
+
+            # first create a list of chain steps where each step is an empty sequence
+            #seqName = chainName + 'EmptySeq' + str(chain_index) + '_'
+            #emptySeqList = [EmptyMenuSequence(seqName + str(_x)) for _x in range(n_chains)]
+            #stepList = [ChainStep('Step_' + seqName, Sequences=[seq], chainDicts=step.chainDicts) for seq in emptySeqList]
+            # now overwrite one of these steps from the step in the current sub-chain
+            #stepList[chain_index] = step
+            
+            newsteps.append(stepList)
+    log.debug('After serial_zip')
+    for s in newsteps:
+        log.debug( s )
+    return newsteps
+
+def mergeSerial(chainDefList):
+    allSteps = []
+    nSteps = []
+    chainName = ''
+    l1Thresholds = []
+
+    log.info('Merge chainDefList:')
+    log.info(chainDefList)
 
+    for cConfig in chainDefList:
+        if chainName == '':
+            chainName = cConfig.name
+        elif chainName != cConfig.name:
+            log.error("Something is wrong with the combined chain name: cConfig.name = %s while chainName = %s", cConfig.name, chainName)
+            
+        allSteps.append(cConfig.steps)
+        nSteps.append(len(cConfig.steps))
+        l1Thresholds.extend(cConfig.vseeds)
+
+    serialSteps = serial_zip(allSteps, chainName)
+    mySerialSteps = deepcopy(serialSteps)
+    combChainSteps =[]
+    for step_index, steps in enumerate(mySerialSteps):
+        mySteps = list(steps)
+        combStep = makeChainSteps(mySteps, step_index+1)
+        combChainSteps.append(combStep)
+
+    # check if all chain parts have the same number of steps
+    sameNSteps = all(x==nSteps[0] for x in nSteps) 
+    if sameNSteps is True:
+        log.info("All chain parts have the same number of steps")
+    else:
+        log.info("Have to deal with uneven number of chain steps, there might be none's appearing in sequence list => to be fixed")
+                                  
+    combinedChainDef = Chain(chainName, ChainSteps=combChainSteps, L1Thresholds=l1Thresholds)
+
+    log.info("Serial merged chain %s with these steps:", chainName)
+    for step in combinedChainDef.steps:
+        log.info('   %s', step)
+
+    return combinedChainDef
 
 
-def makeChainSteps(steps):
+def makeChainSteps(steps, stepNumber):
     from copy import deepcopy
     from TrigCompositeUtils.TrigCompositeUtils import legName
-    stepName = ''
+    stepName = 'merged_Step' + str(stepNumber)
     stepSeq = []
     stepMult = []
-    stepNumber = ''
     log.verbose(" steps %s ", steps)
-    stepName = "merged"
     stepDicts = []
     count = 0
     comboHypoTools = []
@@ -93,9 +165,9 @@ def makeChainSteps(steps):
     for step in steps:
         if step is None:
             continue
-        log.debug("  step %s, multiplicity  = %s", step.name, str(step.multiplicity))
+        log.info("  step %s, multiplicity  = %s", step.name, str(step.multiplicity))
         if len(step.sequences):
-            log.debug("      with sequences = %s", ' '.join(map(str, [seq.name for seq in step.sequences])))
+            log.info("      with sequences = %s", ' '.join(map(str, [seq.name for seq in step.sequences])))
 
          # this function only works if the input chains are single-object chains (one menu seuqnce)
         if len(step.sequences) > 1:
@@ -103,12 +175,9 @@ def makeChainSteps(steps):
 
 
         currentStep = step.name
-        stepNameParts = currentStep.split('_')
-        if stepNumber == '':
-            stepNumber = stepNameParts[0]
 
         # the step naming for combined chains needs to be revisted!!
-        stepName += '_' +step.name
+        stepName += '_' + currentStep
         if len(step.sequences):
             seq = step.sequences[0]
             stepSeq.append(seq)
@@ -123,7 +192,7 @@ def makeChainSteps(steps):
         
     comboHypoTools = list(set(comboHypoTools))
     theChainStep = ChainStep(stepName, Sequences=stepSeq, multiplicity=stepMult, chainDicts=stepDicts, comboToolConfs=comboHypoTools) 
-    log.debug("Merged step: \n %s", theChainStep)
+    log.info("Merged step: \n %s", theChainStep)
   
     
     return theChainStep
diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/GenerateMenuMT.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/GenerateMenuMT.py
index cd1cc1aa225bc8d3b3f4616913b6d9f231c73454..72387ca1dc292c2d1ec5a8398bf75764f6b5de3d 100755
--- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/GenerateMenuMT.py
+++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/GenerateMenuMT.py
@@ -304,7 +304,7 @@ class GenerateMenuMT(object):
 
         elif len(listOfChainConfigs)>1:
                 log.debug("Merging strategy from dictionary: %s", mainChainDict["mergingStrategy"])
-                theChainConfig = mergeChainDefs(listOfChainConfigs, mainChainDict, mainChainDict["mergingStrategy"], mainChainDict["mergingOffset"])
+                theChainConfig = mergeChainDefs(listOfChainConfigs, mainChainDict)
 
                 # This needs to be added for topological chains - needs implementation
                 #doTopo = self.CheckIntraSignatureTopo(chainDicts) and chainDict["topo"]
diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/HLTCFConfig.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/HLTCFConfig.py
index 724347f48ebc3bfafb3746e91bb68a93f5c4f0fb..533f10f729b8d6d0ff7dfcd88140043ab47d5305 100644
--- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/HLTCFConfig.py
+++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/HLTCFConfig.py
@@ -253,8 +253,10 @@ def matrixDisplay( allCFSeq ):
         for cfseq in cfseq_list:
             chains = __getHyposOfStep(cfseq.step)
             for seq in cfseq.step.sequences:
-                mx[stepNumber, seq.sequence.Alg.name()].extend(chains)
-
+                if seq.name == "Empty":
+                    mx[stepNumber, "Empty"].extend(chains)
+                else:
+                    mx[stepNumber, seq.sequence.Alg.name()].extend(chains)
 
     # sort dictionary by fist key=step
     from collections import  OrderedDict
diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/LS2_v1.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/LS2_v1.py
index dd1b29d9edd5f7964dfa8c1bc8d1c21fdb1bc531..2c88fd2e5dccf5ab3625f2984ec5f25dc6784d10 100644
--- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/LS2_v1.py
+++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/LS2_v1.py
@@ -36,8 +36,10 @@ def setupMenu():
         ChainProp(name='HLT_mu6_idperf_L1MU6', groups=SingleMuonGroup),
         ChainProp(name='HLT_mu24_idperf_L1MU20', groups=SingleMuonGroup),
 
-        #ATR-20049
+        # Test chain for di-muon with full-scan, not yet working due to problem with FS seeding
+        #ChainProp(name='HLT_mu6_mu6noL1_L1MU6', l1SeedThresholds=['MU6','FSNOSEED'], mergingStrategy='serial', groups=MultiMuonGroup),
 
+        #ATR-20049
         ChainProp(name='HLT_mu6fast_L1MU6', groups=SingleMuonGroup),
         ChainProp(name='HLT_mu6Comb_L1MU6', groups=SingleMuonGroup),
         ChainProp(name='HLT_mu6_L1MU6',     groups=SingleMuonGroup),
@@ -45,7 +47,7 @@ def setupMenu():
         ChainProp(name='HLT_mu20_ivar_L1MU6',      groups=SingleMuonGroup),
         ChainProp(name='HLT_mu6_ivarmedium_L1MU6', groups=SingleMuonGroup),
         ChainProp(name='HLT_mu6noL1_L1MU6', l1SeedThresholds=['FSNOSEED'], groups=SingleMuonGroup),
-#        ChainProp(name='HLT_mu6_mu6noL1_L1MU6', l1SeedThresholds=['MU6','FSNOSEED'], groups=MultiMuonGroup),
+
         ChainProp(name='HLT_mu6_msonly_L1MU6',     groups=SingleMuonGroup),
 
         ChainProp(name='HLT_2mu6_10invm70_L1MU6', groups=SingleMuonGroup),
diff --git a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/MenuComponents.py b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/MenuComponents.py
index e3a954f71084993d73400fb3fb3bb0886d41f6d6..ade757ddfef7de1a6ee95abed975643f08a4295d 100644
--- a/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/MenuComponents.py
+++ b/Trigger/TriggerCommon/TriggerMenuMT/python/HLTMenuConfig/Menu/MenuComponents.py
@@ -1,4 +1,3 @@
-
 # Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
 
 from AthenaCommon.Logging import logging
@@ -131,6 +130,8 @@ def algColor(alg):
         return "cyan3"
     if isFilterAlg(alg):
         return "chartreuse3"
+    if isEmptyAlg(alg):
+        return "peachpuff3"
     if isComboHypoAlg(alg):
         return "darkorange"
     return "cadetblue1"
@@ -294,7 +295,10 @@ def isHypoBase(alg):
     if  'HypoInputDecisions'  in alg.__class__.__dict__:
         return True
     prop = alg.__class__.__dict__.get('_properties')
-    return  ('HypoInputDecisions'  in prop)
+    if type(prop) is dict:
+        return  ('HypoInputDecisions'  in prop)
+    else:
+        return False
 
 def isInputMakerBase(alg):
     return  ('InputMakerInputDecisions'  in alg.__class__.__dict__)
@@ -302,13 +306,88 @@ def isInputMakerBase(alg):
 def isFilterAlg(alg):
     return isinstance(alg, RoRSeqFilter)
 
+def isEmptyAlg(alg):
+    if alg is None:
+        return True
+    else:
+        return False
+
 def isComboHypoAlg(alg):
     return isinstance(alg, ComboHypo)
 
 
+
 ##########################################################
-# NOW sequences and chains
+# Now sequences and chains
 ##########################################################
+from DecisionHandling.DecisionHandlingConf import InputMakerForRoI
+
+class EmptyMenuSequence(object):
+    """ Class to emulate reco sequences with no Hypo"""
+    """ By construction it has no Hypo;"""
+    
+    def __init__(self, name):
+        Maker = InputMakerForRoI("IM"+name)
+        self._name = name
+        self._maker       = InputMakerNode( Alg = Maker )
+        self._seed=''
+        self._sequence     = Node( Alg = seqAND(name, [Maker]))
+
+    @property
+    def sequence(self):
+        return self._sequence
+
+    @property
+    def seed(self):
+        return self._seed
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def __maker(self):
+        return self._maker
+
+    def getOutputList(self):
+        return self.__maker.readOutputList() # Only one since it's merged
+
+    def connectToFilter(self, outfilter):
+        """ Connect filter to the InputMaker"""
+        self.__maker.addInput(outfilter)
+
+    def createHypoTools(self, chainDict):
+        log.debug("This sequence is empty. No Hypo to conficure")
+
+    def addToSequencer(self, stepReco, seqAndView, already_connected):
+        # menu sequence empty do not add to athena sequencer
+        log.debug("This sequence is empty. Adding Maker node only to athena sequencer")
+        ath_sequence = self.sequence.Alg
+        name = ath_sequence.name()
+        if name in already_connected:
+            log.debug("AthSequencer %s already in the Tree, not added again",name)
+            return stepReco, seqAndView, already_connected
+        else:
+            already_connected.append(name)
+            stepReco += ath_sequence
+        return stepReco, seqAndView, already_connected        
+
+    def buildCFDot(self, cfseq_algs, all_hypos, isCombo, last_step_hypo_nodes, file):
+        file.write("    %s[fillcolor=%s]\n"%("none", algColor(None)))
+        return cfseq_algs, all_hypos, last_step_hypo_nodes
+
+    def getTools(self):
+        # No tools for empty sequences - needs to return empty list?
+        log.debug("No tools for empty menu sequences")
+
+    def setSeed( self, seed ):
+        self._seed = seed
+
+    def __repr__(self):
+        return "MenuSequence::%s \n Hypo::%s \n Maker::%s \n Sequence::%s \n HypoTool::%s\n"\
+            %("Empty", "Empty", "Empty", "Empty", None)
+
+
 
 class MenuSequence(object):
     """ Class to group reco sequences with the Hypo"""
@@ -366,18 +445,22 @@ class MenuSequence(object):
            HypoAlg::%s.output=%s",\
                            self.hypo.Alg.name(), input_maker_output, self.hypo.Alg.name(), self.hypo.readOutputList()[0])
 
+
     @property
     def seed(self):
         return self._seed
 
+
     @property
     def name(self):
         return self._name
 
+
     @property
     def sequence(self):
         return self._sequence
 
+
     @property
     def maker(self):
         return self._maker
@@ -556,7 +639,6 @@ class CAMenuSequence(MenuSequence):
         return self._hypo
 
 
-
 class Chain(object):
     """Basic class to define the trigger menu """
     __slots__='name','steps','vseeds','L1decisions'