ATLAS Offline Software
Loading...
Searching...
No Matches
Functions | Variables
CaloRingerAlgsConfig Namespace Reference

Functions

 CaloRingsElectronBuilderCfg (flags, name="CaloRingsElectronBuilder", **kwargs)
 CaloRingsAsymElectronBuilderCfg (flags, name="CaloRingsAsymElectronBuilder", **kwargs)
 CaloRingsStripsElectronBuilderCfg (flags, name="CaloRingsStripsElectronBuilder", **kwargs)
 CaloRingsCornerElectronBuilderCfg (flags, name="CaloRingsCornerElectronBuilder", **kwargs)
 CaloRingsPhotonBuilderCfg (flags, name="CaloRingsPhotonBuilder", **kwargs)
 CaloRingsAsymPhotonBuilderCfg (flags, name="CaloRingsAsymPhotonBuilder", **kwargs)
 CaloRingsStripsPhotonBuilderCfg (flags, name="CaloRingsStripsPhotonBuilder", **kwargs)
 CaloRingsCornerPhotonBuilderCfg (flags, name="CaloRingsCornerPhotonBuilder", **kwargs)
 CaloRingsJetBuilderCfg (flags, name="CaloRingsJetBuilder", **kwargs)
 CaloRingsAsymJetBuilderCfg (flags, name="CaloRingsAsymJetBuilder", **kwargs)
 CaloRingsStripsJetBuilderCfg (flags, name="CaloRingsStripsJetBuilder", **kwargs)
 CaloRingsCornerJetBuilderCfg (flags, name="CaloRingsCornerJetBuilder", **kwargs)
 CaloRingerElectronsInputReaderCfg (flags, name="CaloRingerElectronsReader", **kwargs)
 CaloRingerPhotonsInputReaderCfg (flags, name="CaloRingerPhotonsReader", **kwargs)
 CaloRingerJetsInputReaderCfg (flags, name="CaloRingerJetsReader", **kwargs)
 CaloRingerElectronAlgsCfg (flags, name="CaloRingerElectronAlgorithm", **kwargs)
 CaloRingerAsymElectronAlgsCfg (flags, name="CaloRingerAsymElectronAlgorithm", **kwargs)
 CaloRingerStripsElectronAlgsCfg (flags, name="CaloRingerStripsElectronAlgorithm", **kwargs)
 CaloRingerCornerElectronAlgsCfg (flags, name="CaloRingerCornerAlgorithm", **kwargs)
 CaloRingerPhotonAlgsCfg (flags, name="CaloRingerPhotonAlgorithm", **kwargs)
 CaloRingerAsymPhotonAlgsCfg (flags, name="CaloAsymRingerAlgorithm", **kwargs)
 CaloRingerStripsPhotonAlgsCfg (flags, name="CaloRingerStripsAlgorithm", **kwargs)
 CaloRingerCornerPhotonAlgsCfg (flags, name="CaloRingerCornerAlgorithm", **kwargs)
 CaloRingerJetAlgsCfg (flags, name="CaloRingerJetAlgorithm", **kwargs)
 CaloRingerAsymJetAlgsCfg (flags, name="CaloAsymRingerAlgorithm", **kwargs)
 CaloRingerStripsJetAlgsCfg (flags, name="CaloRingerStripsAlgorithm", **kwargs)
 CaloRingerCornerJetAlgsCfg (flags, name="CaloRingerCornerAlgorithm", **kwargs)
 CaloRingerOutputCfg (flags, name="CaloRingerOutputList")
 CaloRingerSteeringCfg (flags, name="CaloRingerSteering")

Variables

 flags = initConfigFlags()
 Files
 doWriteAOD
 ESDFileName
 cfg = MainServicesCfg(flags)

Function Documentation

◆ CaloRingerAsymElectronAlgsCfg()

CaloRingerAlgsConfig.CaloRingerAsymElectronAlgsCfg ( flags,
name = "CaloRingerAsymElectronAlgorithm",
** kwargs )

Definition at line 850 of file CaloRingerAlgsConfig.py.

852):
853 electronAsymInputReaderTool, electronAsymBuilderTool = (
854 CaloRingerElectronsInputReaderCfg(flags, name="CaloRingerAsymElectronAlgorithm")
855 )
856 acc = ComponentAccumulator()
857 acc.addPublicTool(electronAsymBuilderTool)
858 acc.addPublicTool(electronAsymInputReaderTool)
859 kwargs.setdefault("inputReaderTools", [electronAsymInputReaderTool])
860
861 CaloRingerAsymAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
862 name="CaloRingerAsymAlgorithm", **kwargs
863 )
864 acc.addEventAlgo(CaloRingerAsymAlgorithm)
865 return acc
866
867

◆ CaloRingerAsymJetAlgsCfg()

CaloRingerAlgsConfig.CaloRingerAsymJetAlgsCfg ( flags,
name = "CaloAsymRingerAlgorithm",
** kwargs )

Definition at line 980 of file CaloRingerAlgsConfig.py.

980def CaloRingerAsymJetAlgsCfg(flags, name="CaloAsymRingerAlgorithm", **kwargs):
981 jetAsymInputReaderTool, jetAsymBuilderTool = CaloRingerJetsInputReaderCfg(
982 flags, name="CaloAsymRingerJetReader"
983 )
984 acc = ComponentAccumulator()
985 acc.addPublicTool(jetAsymBuilderTool)
986 acc.addPublicTool(jetAsymInputReaderTool)
987 kwargs.setdefault("inputReaderTools", [jetAsymInputReaderTool])
988
989 CaloAsymRingerAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
990 name="CaloAsymRingerAlgorithm", **kwargs
991 )
992 acc.addEventAlgo(CaloAsymRingerAlgorithm)
993 return acc
994
995

◆ CaloRingerAsymPhotonAlgsCfg()

CaloRingerAlgsConfig.CaloRingerAsymPhotonAlgsCfg ( flags,
name = "CaloAsymRingerAlgorithm",
** kwargs )

Definition at line 917 of file CaloRingerAlgsConfig.py.

917def CaloRingerAsymPhotonAlgsCfg(flags, name="CaloAsymRingerAlgorithm", **kwargs):
918 photonAsymInputReaderTool, photonAsymBuilderTool = CaloRingerPhotonsInputReaderCfg(
919 flags, name="CaloAsymRingerPhotonReader"
920 )
921 acc = ComponentAccumulator()
922 acc.addPublicTool(photonAsymBuilderTool)
923 acc.addPublicTool(photonAsymInputReaderTool)
924 kwargs.setdefault("inputReaderTools", [photonAsymInputReaderTool])
925
926 CaloAsymRingerAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
927 name="CaloAsymRingerAlgorithm", **kwargs
928 )
929 acc.addEventAlgo(CaloAsymRingerAlgorithm)
930 return acc
931
932

◆ CaloRingerCornerElectronAlgsCfg()

CaloRingerAlgsConfig.CaloRingerCornerElectronAlgsCfg ( flags,
name = "CaloRingerCornerAlgorithm",
** kwargs )

Definition at line 886 of file CaloRingerAlgsConfig.py.

886def CaloRingerCornerElectronAlgsCfg(flags, name="CaloRingerCornerAlgorithm", **kwargs):
887 electronCornerInputReaderTool, electronCornerBuilderTool = (
888 CaloRingerElectronsInputReaderCfg(flags, name="CaloCornerRingerElectronReader")
889 )
890 acc = ComponentAccumulator()
891 acc.addPublicTool(electronCornerBuilderTool)
892 acc.addPublicTool(electronCornerInputReaderTool)
893 kwargs.setdefault("inputReaderTools", [electronCornerInputReaderTool])
894
895 CaloRingerCornerAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
896 name="CaloRingerCornerAlgorithm", **kwargs
897 )
898 acc.addEventAlgo(CaloRingerCornerAlgorithm)
899 return acc
900
901
902# Algs Photons

◆ CaloRingerCornerJetAlgsCfg()

CaloRingerAlgsConfig.CaloRingerCornerJetAlgsCfg ( flags,
name = "CaloRingerCornerAlgorithm",
** kwargs )

Definition at line 1016 of file CaloRingerAlgsConfig.py.

1016def CaloRingerCornerJetAlgsCfg(flags, name="CaloRingerCornerAlgorithm", **kwargs):
1017 jetCornerInputReaderTool, jetCornerBuilderTool = CaloRingerJetsInputReaderCfg(
1018 flags, name="CaloCornerRingerJetReader"
1019 )
1020 acc = ComponentAccumulator()
1021 acc.addPublicTool(jetCornerBuilderTool)
1022 acc.addPublicTool(jetCornerInputReaderTool)
1023 kwargs.setdefault("inputReaderTools", [jetCornerInputReaderTool])
1024
1025 CaloRingerCornerAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
1026 name="CaloRingerCornerAlgorithm", **kwargs
1027 )
1028 acc.addEventAlgo(CaloRingerCornerAlgorithm)
1029 return acc
1030
1031
1032# Config Ringer

◆ CaloRingerCornerPhotonAlgsCfg()

CaloRingerAlgsConfig.CaloRingerCornerPhotonAlgsCfg ( flags,
name = "CaloRingerCornerAlgorithm",
** kwargs )

Definition at line 949 of file CaloRingerAlgsConfig.py.

949def CaloRingerCornerPhotonAlgsCfg(flags, name="CaloRingerCornerAlgorithm", **kwargs):
950 photonCornerInputReaderTool, photonCornerBuilderTool = (
951 CaloRingerPhotonsInputReaderCfg(flags, name="CaloCornerRingerPhotonReader")
952 )
953 acc = ComponentAccumulator()
954 acc.addPublicTool(photonCornerBuilderTool)
955 acc.addPublicTool(photonCornerInputReaderTool)
956 kwargs.setdefault("inputReaderTools", [photonCornerInputReaderTool])
957
958 CaloRingerCornerAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
959 name="CaloRingerCornerAlgorithm", **kwargs
960 )
961 acc.addEventAlgo(CaloRingerCornerAlgorithm)
962 return acc
963
964
965# Algs Jets

◆ CaloRingerElectronAlgsCfg()

CaloRingerAlgsConfig.CaloRingerElectronAlgsCfg ( flags,
name = "CaloRingerElectronAlgorithm",
** kwargs )

Definition at line 834 of file CaloRingerAlgsConfig.py.

834def CaloRingerElectronAlgsCfg(flags, name="CaloRingerElectronAlgorithm", **kwargs):
835 electronInputReaderTool, electronBuilderTool = CaloRingerElectronsInputReaderCfg(
836 flags
837 )
838 acc = ComponentAccumulator()
839 acc.addPublicTool(electronBuilderTool)
840 acc.addPublicTool(electronInputReaderTool)
841 kwargs.setdefault("inputReaderTools", [electronInputReaderTool])
842
843 CaloRingerAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
844 name="CaloRingerElectronAlgorithm", **kwargs
845 )
846 acc.addEventAlgo(CaloRingerAlgorithm)
847 return acc
848
849

◆ CaloRingerElectronsInputReaderCfg()

CaloRingerAlgsConfig.CaloRingerElectronsInputReaderCfg ( flags,
name = "CaloRingerElectronsReader",
** kwargs )

Definition at line 775 of file CaloRingerAlgsConfig.py.

777):
778 if "Asym" in name:
779 builderTool = CaloRingsAsymElectronBuilderCfg(flags)
780 elif "Strips" in name:
781 builderTool = CaloRingsStripsElectronBuilderCfg(flags)
782 elif "Corner" in name:
783 builderTool = CaloRingsCornerElectronBuilderCfg(flags)
784 else:
785 builderTool = CaloRingsElectronBuilderCfg(flags)
786
787 kwargs.setdefault("crBuilder", builderTool)
788 kwargs.setdefault("inputKey", flags.Egamma.Keys.Output.Electrons)
789 kwargs.setdefault("builderAvailable", True)
790 inputReaderTool = CompFactory.Ringer.CaloRingerElectronsReader(name, **kwargs)
791
792 return inputReaderTool, builderTool
793
794

◆ CaloRingerJetAlgsCfg()

CaloRingerAlgsConfig.CaloRingerJetAlgsCfg ( flags,
name = "CaloRingerJetAlgorithm",
** kwargs )

Definition at line 966 of file CaloRingerAlgsConfig.py.

966def CaloRingerJetAlgsCfg(flags, name="CaloRingerJetAlgorithm", **kwargs):
967 jetInputReaderTool, jetBuilderTool = CaloRingerJetsInputReaderCfg(flags)
968 acc = ComponentAccumulator()
969 acc.addPublicTool(jetBuilderTool)
970 acc.addPublicTool(jetInputReaderTool)
971 kwargs.setdefault("inputReaderTools", [jetInputReaderTool])
972
973 CaloRingerAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
974 name="CaloRingerJetAlgorithm", **kwargs
975 )
976 acc.addEventAlgo(CaloRingerAlgorithm)
977 return acc
978
979

◆ CaloRingerJetsInputReaderCfg()

CaloRingerAlgsConfig.CaloRingerJetsInputReaderCfg ( flags,
name = "CaloRingerJetsReader",
** kwargs )

Definition at line 813 of file CaloRingerAlgsConfig.py.

813def CaloRingerJetsInputReaderCfg(flags, name="CaloRingerJetsReader", **kwargs):
814 if "Asym" in name:
815 builderTool = CaloRingsAsymJetBuilderCfg(flags)
816 elif "Strips" in name:
817 builderTool = CaloRingsStripsJetBuilderCfg(flags)
818 elif "Corner" in name:
819 builderTool = CaloRingsCornerJetBuilderCfg(flags)
820 else:
821 builderTool = CaloRingsJetBuilderCfg(flags)
822
823 kwargs.setdefault("crBuilder", builderTool)
824 kwargs.setdefault(
825 "inputKey", "AntiKt4EMPFlowJets"
826 ) # need to get the jet container name
827 kwargs.setdefault("builderAvailable", True)
828 inputReaderTool = CompFactory.Ringer.CaloRingerJetsReader(name, **kwargs)
829
830 return inputReaderTool, builderTool
831
832
833# Algs Electrons

◆ CaloRingerOutputCfg()

CaloRingerAlgsConfig.CaloRingerOutputCfg ( flags,
name = "CaloRingerOutputList" )

Definition at line 1033 of file CaloRingerAlgsConfig.py.

1033def CaloRingerOutputCfg(flags, name="CaloRingerOutputList"):
1034 from OutputStreamAthenaPool.OutputStreamConfig import addToAOD, addToESD
1035
1036 acc = ComponentAccumulator()
1037
1038 toOutput = []
1039 if flags.CaloRinger.buildElectronRings:
1040 toOutput += [
1041 "xAOD::RingSetContainer#ElectronRingSets",
1042 "xAOD::RingSetAuxContainer#ElectronRingSetsAux.",
1043 "xAOD::CaloRingsContainer#ElectronCaloRings",
1044 "xAOD::CaloRingsAuxContainer#ElectronCaloRingsAux.",
1045 ]
1046 if flags.CaloRinger.buildElectronAsymRings:
1047 toOutput += [
1048 "xAOD::RingSetContainer#ElectronAsymRingSets",
1049 "xAOD::RingSetAuxContainer#ElectronAsymRingSetsAux.",
1050 "xAOD::CaloRingsContainer#ElectronCaloAsymRings",
1051 "xAOD::CaloRingsAuxContainer#ElectronCaloAsymRingsAux.",
1052 ]
1053 if flags.CaloRinger.buildElectronStripsRings:
1054 toOutput += [
1055 "xAOD::RingSetContainer#ElectronStripsRingSets",
1056 "xAOD::RingSetAuxContainer#ElectronStripsRingSetsAux.",
1057 "xAOD::CaloRingsContainer#ElectronCaloStripsRings",
1058 "xAOD::CaloRingsAuxContainer#ElectronCaloStripsRingsAux.",
1059 ]
1060 if flags.CaloRinger.buildElectronCornerRings:
1061 toOutput += [
1062 "xAOD::RingSetContainer#ElectronCornerRingSets",
1063 "xAOD::RingSetAuxContainer#ElectronCornerRingSetsAux.",
1064 "xAOD::CaloRingsContainer#ElectronCaloCornerRings",
1065 "xAOD::CaloRingsAuxContainer#ElectronCaloCornerRingsAux.",
1066 ]
1067 if flags.CaloRinger.buildPhotonRings:
1068 toOutput += [
1069 "xAOD::RingSetContainer#PhotonRingSets",
1070 "xAOD::RingSetAuxContainer#PhotonRingSetsAux.",
1071 "xAOD::CaloRingsContainer#PhotonCaloRings",
1072 "xAOD::CaloRingsAuxContainer#PhotonCaloRingsAux.",
1073 ]
1074 if flags.CaloRinger.buildPhotonAsymRings:
1075 toOutput += [
1076 "xAOD::RingSetContainer#PhotonAsymRingSets",
1077 "xAOD::RingSetAuxContainer#PhotonAsymRingSetsAux.",
1078 "xAOD::CaloRingsContainer#PhotonCaloAsymRings",
1079 "xAOD::CaloRingsAuxContainer#PhotonCaloAsymRingsAux.",
1080 ]
1081 if flags.CaloRinger.buildPhotonStripsRings:
1082 toOutput += [
1083 "xAOD::RingSetContainer#PhotonStripsRingSets",
1084 "xAOD::RingSetAuxContainer#PhotonStripsRingSetsAux.",
1085 "xAOD::CaloRingsContainer#PhotonCaloStripsRings",
1086 "xAOD::CaloRingsAuxContainer#PhotonCaloStripsRingsAux.",
1087 ]
1088 if flags.CaloRinger.buildPhotonCornerRings:
1089 toOutput += [
1090 "xAOD::RingSetContainer#PhotonCornerRingSets",
1091 "xAOD::RingSetAuxContainer#PhotonCornerRingSetsAux.",
1092 "xAOD::CaloRingsContainer#PhotonCaloCornerRings",
1093 "xAOD::CaloRingsAuxContainer#PhotonCaloCornerRingsAux.",
1094 ]
1095 if flags.CaloRinger.buildJetRings:
1096 toOutput += [
1097 "xAOD::RingSetContainer#JetRingSets",
1098 "xAOD::RingSetAuxContainer#JetRingSetsAux.",
1099 "xAOD::CaloRingsContainer#JetCaloRings",
1100 "xAOD::CaloRingsAuxContainer#JetCaloRingsAux.",
1101 ]
1102 if flags.CaloRinger.buildJetAsymRings:
1103 toOutput += [
1104 "xAOD::RingSetContainer#JetAsymRingSets",
1105 "xAOD::RingSetAuxContainer#JetAsymRingSetsAux.",
1106 "xAOD::CaloRingsContainer#JetCaloAsymRings",
1107 "xAOD::CaloRingsAuxContainer#JetCaloAsymRingsAux.",
1108 ]
1109 if flags.CaloRinger.buildJetStripsRings:
1110 toOutput += [
1111 "xAOD::RingSetContainer#JetStripsRingSets",
1112 "xAOD::RingSetAuxContainer#JetStripsRingSetsAux.",
1113 "xAOD::CaloRingsContainer#JetCaloStripsRings",
1114 "xAOD::CaloRingsAuxContainer#JetCaloStripsRingsAux.",
1115 ]
1116 if flags.CaloRinger.buildJetCornerRings:
1117 toOutput += [
1118 "xAOD::RingSetContainer#JetCornerRingSets",
1119 "xAOD::RingSetAuxContainer#JetCornerRingSetsAux.",
1120 "xAOD::CaloRingsContainer#JetCaloCornerRings",
1121 "xAOD::CaloRingsAuxContainer#JetCaloCornerRingsAux.",
1122 ]
1123
1124 if flags.Output.doWriteAOD:
1125 acc.merge(addToAOD(flags, toOutput))
1126 if flags.Output.doWriteESD:
1127 acc.merge(addToESD(flags, toOutput))
1128
1129 return acc
1130
1131

◆ CaloRingerPhotonAlgsCfg()

CaloRingerAlgsConfig.CaloRingerPhotonAlgsCfg ( flags,
name = "CaloRingerPhotonAlgorithm",
** kwargs )

Definition at line 903 of file CaloRingerAlgsConfig.py.

903def CaloRingerPhotonAlgsCfg(flags, name="CaloRingerPhotonAlgorithm", **kwargs):
904 photonInputReaderTool, photonBuilderTool = CaloRingerPhotonsInputReaderCfg(flags)
905 acc = ComponentAccumulator()
906 acc.addPublicTool(photonBuilderTool)
907 acc.addPublicTool(photonInputReaderTool)
908 kwargs.setdefault("inputReaderTools", [photonInputReaderTool])
909
910 CaloRingerAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
911 name="CaloRingerPhotonAlgorithm", **kwargs
912 )
913 acc.addEventAlgo(CaloRingerAlgorithm)
914 return acc
915
916

◆ CaloRingerPhotonsInputReaderCfg()

CaloRingerAlgsConfig.CaloRingerPhotonsInputReaderCfg ( flags,
name = "CaloRingerPhotonsReader",
** kwargs )

Definition at line 795 of file CaloRingerAlgsConfig.py.

795def CaloRingerPhotonsInputReaderCfg(flags, name="CaloRingerPhotonsReader", **kwargs):
796 if "Asym" in name:
797 builderTool = CaloRingsAsymPhotonBuilderCfg(flags)
798 elif "Strips" in name:
799 builderTool = CaloRingsStripsPhotonBuilderCfg(flags)
800 elif "Corner" in name:
801 builderTool = CaloRingsCornerPhotonBuilderCfg(flags)
802 else:
803 builderTool = CaloRingsPhotonBuilderCfg(flags)
804
805 kwargs.setdefault("crBuilder", builderTool)
806 kwargs.setdefault("inputKey", flags.Egamma.Keys.Output.Photons)
807 kwargs.setdefault("builderAvailable", True)
808 inputReaderTool = CompFactory.Ringer.CaloRingerPhotonsReader(name, **kwargs)
809
810 return inputReaderTool, builderTool
811
812

◆ CaloRingerSteeringCfg()

CaloRingerAlgsConfig.CaloRingerSteeringCfg ( flags,
name = "CaloRingerSteering" )

Definition at line 1132 of file CaloRingerAlgsConfig.py.

1132def CaloRingerSteeringCfg(flags, name="CaloRingerSteering"):
1133 acc = ComponentAccumulator()
1134
1135 if flags.CaloRinger.buildElectronRings:
1136 acc.merge(CaloRingerElectronAlgsCfg(flags))
1137 if flags.CaloRinger.buildElectronAsymRings:
1138 acc.merge(CaloRingerAsymElectronAlgsCfg(flags))
1139 if flags.CaloRinger.buildElectronStripsRings:
1140 acc.merge(CaloRingerStripsElectronAlgsCfg(flags))
1141 if flags.CaloRinger.buildElectronCornerRings:
1142 acc.merge(CaloRingerCornerElectronAlgsCfg(flags))
1143
1144 if flags.CaloRinger.buildPhotonRings:
1145 acc.merge(CaloRingerPhotonAlgsCfg(flags))
1146 if flags.CaloRinger.buildPhotonAsymRings:
1147 acc.merge(CaloRingerAsymPhotonAlgsCfg(flags))
1148 if flags.CaloRinger.buildPhotonStripsRings:
1149 acc.merge(CaloRingerStripsPhotonAlgsCfg(flags))
1150 if flags.CaloRinger.buildPhotonCornerRings:
1151 acc.merge(CaloRingerCornerPhotonAlgsCfg(flags))
1152
1153 if flags.CaloRinger.buildJetRings:
1154 acc.merge(CaloRingerJetAlgsCfg(flags))
1155 if flags.CaloRinger.buildJetAsymRings:
1156 acc.merge(CaloRingerAsymJetAlgsCfg(flags))
1157 if flags.CaloRinger.buildJetStripsRings:
1158 acc.merge(CaloRingerStripsJetAlgsCfg(flags))
1159 if flags.CaloRinger.buildJetCornerRings:
1160 acc.merge(CaloRingerCornerJetAlgsCfg(flags))
1161
1162 acc.merge(CaloRingerOutputCfg(flags))
1163 return acc
1164
1165

◆ CaloRingerStripsElectronAlgsCfg()

CaloRingerAlgsConfig.CaloRingerStripsElectronAlgsCfg ( flags,
name = "CaloRingerStripsElectronAlgorithm",
** kwargs )

Definition at line 868 of file CaloRingerAlgsConfig.py.

870):
871 electronStripsInputReaderTool, electronStripsBuilderTool = (
872 CaloRingerElectronsInputReaderCfg(flags, name="CaloRingerStripsElectronReader")
873 )
874 acc = ComponentAccumulator()
875 acc.addPublicTool(electronStripsBuilderTool)
876 acc.addPublicTool(electronStripsInputReaderTool)
877 kwargs.setdefault("inputReaderTools", [electronStripsInputReaderTool])
878
879 CaloRingerStripsAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
880 name="CaloRingerStripsElectronAlgorithm", **kwargs
881 )
882 acc.addEventAlgo(CaloRingerStripsAlgorithm)
883 return acc
884
885

◆ CaloRingerStripsJetAlgsCfg()

CaloRingerAlgsConfig.CaloRingerStripsJetAlgsCfg ( flags,
name = "CaloRingerStripsAlgorithm",
** kwargs )

Definition at line 996 of file CaloRingerAlgsConfig.py.

1000):
1001 jetStripsInputReaderTool, jetStripsBuilderTool = CaloRingerJetsInputReaderCfg(
1002 flags, name="CaloStripsRingerJetReader"
1003 )
1004 acc = ComponentAccumulator()
1005 acc.addPublicTool(jetStripsBuilderTool)
1006 acc.addPublicTool(jetStripsInputReaderTool)
1007 kwargs.setdefault("inputReaderTools", [jetStripsInputReaderTool])
1008
1009 CaloRingerStripsAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
1010 name="CaloRingerStripsAlgorithm", **kwargs
1011 )
1012 acc.addEventAlgo(CaloRingerStripsAlgorithm)
1013 return acc
1014
1015

◆ CaloRingerStripsPhotonAlgsCfg()

CaloRingerAlgsConfig.CaloRingerStripsPhotonAlgsCfg ( flags,
name = "CaloRingerStripsAlgorithm",
** kwargs )

Definition at line 933 of file CaloRingerAlgsConfig.py.

933def CaloRingerStripsPhotonAlgsCfg(flags, name="CaloRingerStripsAlgorithm", **kwargs):
934 photonStripsInputReaderTool, photonStripsBuilderTool = (
935 CaloRingerPhotonsInputReaderCfg(flags, name="CaloRingerStripsPhotonReader")
936 )
937 acc = ComponentAccumulator()
938 acc.addPublicTool(photonStripsBuilderTool)
939 acc.addPublicTool(photonStripsInputReaderTool)
940 kwargs.setdefault("inputReaderTools", [photonStripsInputReaderTool])
941
942 CaloRingerStripsAlgorithm = CompFactory.Ringer.CaloRingerAlgorithm(
943 name="CaloRingerStripsAlgorithm", **kwargs
944 )
945 acc.addEventAlgo(CaloRingerStripsAlgorithm)
946 return acc
947
948

◆ CaloRingsAsymElectronBuilderCfg()

CaloRingerAlgsConfig.CaloRingsAsymElectronBuilderCfg ( flags,
name = "CaloRingsAsymElectronBuilder",
** kwargs )

Definition at line 67 of file CaloRingerAlgsConfig.py.

69):
70 NRings = [8, 64, 8, 8, 4, 4, 4]
71 kwargs.setdefault("EtaWidth", [0.025, 0.003125, 0.025, 0.05, 0.1, 0.1, 0.2])
72 kwargs.setdefault(
73 "PhiWidth",
74 [
75 0.098174770424681,
76 0.098174770424681,
77 0.024543692606170,
78 0.024543692606170,
79 0.098174770424681,
80 0.098174770424681,
81 0.098174770424681,
82 ],
83 )
84 kwargs.setdefault("NRings", [(rings - 1) * 4 + 1 for rings in NRings])
85 kwargs.setdefault("CellMaxDEtaDist", 0.2)
86 kwargs.setdefault("CellMaxDPhiDist", 0.2)
87 kwargs.setdefault(
88 "Layers",
89 [
90 CaloCell_ID.PreSamplerB,
91 CaloCell_ID.PreSamplerE,
92 CaloCell_ID.EMB1,
93 CaloCell_ID.EME1,
94 CaloCell_ID.EMB2,
95 CaloCell_ID.EME2,
96 CaloCell_ID.EMB3,
97 CaloCell_ID.EME3,
98 CaloCell_ID.HEC0,
99 CaloCell_ID.TileBar0,
100 CaloCell_ID.TileGap3,
101 CaloCell_ID.TileExt0,
102 CaloCell_ID.HEC1,
103 CaloCell_ID.HEC2,
104 CaloCell_ID.TileBar1,
105 CaloCell_ID.TileGap1,
106 CaloCell_ID.TileExt1,
107 CaloCell_ID.HEC3,
108 CaloCell_ID.TileBar2,
109 CaloCell_ID.TileGap2,
110 CaloCell_ID.TileExt2,
111 ],
112 )
113 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
114 kwargs.setdefault(
115 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
116 )
117 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
118 kwargs.setdefault("CaloRingsContainerName", "ElectronCaloAsymRings")
119 kwargs.setdefault("RingSetContainerName", "ElectronAsymRingSets")
120 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minElectronEnergy * GeV)
121 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
122 kwargs.setdefault("doEtaAxesDivision", True)
123 kwargs.setdefault("doPhiAxesDivision", True)
124
125 tool = CompFactory.Ringer.CaloAsymRingsBuilder(name, **kwargs)
126 return tool
127
128

◆ CaloRingsAsymJetBuilderCfg()

CaloRingerAlgsConfig.CaloRingsAsymJetBuilderCfg ( flags,
name = "CaloRingsAsymJetBuilder",
** kwargs )

Definition at line 573 of file CaloRingerAlgsConfig.py.

573def CaloRingsAsymJetBuilderCfg(flags, name="CaloRingsAsymJetBuilder", **kwargs):
574 NRings = [8, 64, 8, 8, 4, 4, 4]
575 kwargs.setdefault("EtaWidth", [0.025, 0.003125, 0.025, 0.05, 0.1, 0.1, 0.2])
576 kwargs.setdefault(
577 "PhiWidth",
578 [
579 0.098174770424681,
580 0.098174770424681,
581 0.024543692606170,
582 0.024543692606170,
583 0.098174770424681,
584 0.098174770424681,
585 0.098174770424681,
586 ],
587 )
588 kwargs.setdefault("NRings", [(rings - 1) * 4 + 1 for rings in NRings])
589 kwargs.setdefault("CellMaxDEtaDist", 0.2)
590 kwargs.setdefault("CellMaxDPhiDist", 0.2)
591 kwargs.setdefault(
592 "Layers",
593 [
594 CaloCell_ID.PreSamplerB,
595 CaloCell_ID.PreSamplerE,
596 CaloCell_ID.EMB1,
597 CaloCell_ID.EME1,
598 CaloCell_ID.EMB2,
599 CaloCell_ID.EME2,
600 CaloCell_ID.EMB3,
601 CaloCell_ID.EME3,
602 CaloCell_ID.HEC0,
603 CaloCell_ID.TileBar0,
604 CaloCell_ID.TileGap3,
605 CaloCell_ID.TileExt0,
606 CaloCell_ID.HEC1,
607 CaloCell_ID.HEC2,
608 CaloCell_ID.TileBar1,
609 CaloCell_ID.TileGap1,
610 CaloCell_ID.TileExt1,
611 CaloCell_ID.HEC3,
612 CaloCell_ID.TileBar2,
613 CaloCell_ID.TileGap2,
614 CaloCell_ID.TileExt2,
615 ],
616 )
617 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
618 kwargs.setdefault(
619 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
620 )
621 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
622 kwargs.setdefault("CaloRingsContainerName", "JetCaloAsymRings")
623 kwargs.setdefault("RingSetContainerName", "JetAsymRingSets")
624 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minJetEnergy * GeV)
625 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
626 kwargs.setdefault("doEtaAxesDivision", True)
627 kwargs.setdefault("doPhiAxesDivision", True)
628
629 tool = CompFactory.Ringer.CaloAsymRingsBuilder(name, **kwargs)
630 return tool
631
632

◆ CaloRingsAsymPhotonBuilderCfg()

CaloRingerAlgsConfig.CaloRingsAsymPhotonBuilderCfg ( flags,
name = "CaloRingsAsymPhotonBuilder",
** kwargs )

Definition at line 321 of file CaloRingerAlgsConfig.py.

321def CaloRingsAsymPhotonBuilderCfg(flags, name="CaloRingsAsymPhotonBuilder", **kwargs):
322 NRings = [8, 64, 8, 8, 4, 4, 4]
323 kwargs.setdefault("EtaWidth", [0.025, 0.003125, 0.025, 0.05, 0.1, 0.1, 0.2])
324 kwargs.setdefault(
325 "PhiWidth",
326 [
327 0.098174770424681,
328 0.098174770424681,
329 0.024543692606170,
330 0.024543692606170,
331 0.098174770424681,
332 0.098174770424681,
333 0.098174770424681,
334 ],
335 )
336 kwargs.setdefault("NRings", [(rings - 1) * 4 + 1 for rings in NRings])
337 kwargs.setdefault("CellMaxDEtaDist", 0.2)
338 kwargs.setdefault("CellMaxDPhiDist", 0.2)
339 kwargs.setdefault(
340 "Layers",
341 [
342 CaloCell_ID.PreSamplerB,
343 CaloCell_ID.PreSamplerE,
344 CaloCell_ID.EMB1,
345 CaloCell_ID.EME1,
346 CaloCell_ID.EMB2,
347 CaloCell_ID.EME2,
348 CaloCell_ID.EMB3,
349 CaloCell_ID.EME3,
350 CaloCell_ID.HEC0,
351 CaloCell_ID.TileBar0,
352 CaloCell_ID.TileGap3,
353 CaloCell_ID.TileExt0,
354 CaloCell_ID.HEC1,
355 CaloCell_ID.HEC2,
356 CaloCell_ID.TileBar1,
357 CaloCell_ID.TileGap1,
358 CaloCell_ID.TileExt1,
359 CaloCell_ID.HEC3,
360 CaloCell_ID.TileBar2,
361 CaloCell_ID.TileGap2,
362 CaloCell_ID.TileExt2,
363 ],
364 )
365 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
366 kwargs.setdefault(
367 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
368 )
369 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
370 kwargs.setdefault("CaloRingsContainerName", "PhotonCaloAsymRings")
371 kwargs.setdefault("RingSetContainerName", "PhotonAsymRingSets")
372 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minPhotonEnergy * GeV)
373 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
374 kwargs.setdefault("doEtaAxesDivision", True)
375 kwargs.setdefault("doPhiAxesDivision", True)
376
377 tool = CompFactory.Ringer.CaloAsymRingsBuilder(name, **kwargs)
378 return tool
379
380

◆ CaloRingsCornerElectronBuilderCfg()

CaloRingerAlgsConfig.CaloRingsCornerElectronBuilderCfg ( flags,
name = "CaloRingsCornerElectronBuilder",
** kwargs )

Definition at line 191 of file CaloRingerAlgsConfig.py.

193):
194 NRings = [8, 64, 8, 8, 4, 4, 4]
195 kwargs.setdefault(
196 "EtaWidth",
197 [
198 0.025,
199 0.003125,
200 0.025,
201 0.05,
202 0.1,
203 0.1,
204 0.2,
205 ],
206 )
207 kwargs.setdefault(
208 "PhiWidth",
209 [
210 0.098174770424681,
211 0.098174770424681,
212 0.024543692606170,
213 0.024543692606170,
214 0.098174770424681,
215 0.098174770424681,
216 0.098174770424681,
217 ],
218 )
219 kwargs.setdefault("NRings", [ring * 5 for ring in NRings])
220 kwargs.setdefault(
221 "Layers",
222 [
223 CaloCell_ID.PreSamplerB,
224 CaloCell_ID.PreSamplerE,
225 CaloCell_ID.EMB1,
226 CaloCell_ID.EME1,
227 CaloCell_ID.EMB2,
228 CaloCell_ID.EME2,
229 CaloCell_ID.EMB3,
230 CaloCell_ID.EME3,
231 CaloCell_ID.HEC0,
232 CaloCell_ID.TileBar0,
233 CaloCell_ID.TileGap3,
234 CaloCell_ID.TileExt0,
235 CaloCell_ID.HEC1,
236 CaloCell_ID.HEC2,
237 CaloCell_ID.TileBar1,
238 CaloCell_ID.TileGap1,
239 CaloCell_ID.TileExt1,
240 CaloCell_ID.HEC3,
241 CaloCell_ID.TileBar2,
242 CaloCell_ID.TileGap2,
243 CaloCell_ID.TileExt2,
244 ],
245 )
246 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
247 kwargs.setdefault(
248 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
249 )
250 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
251 kwargs.setdefault("CaloRingsContainerName", "ElectronCaloCornerRings")
252 kwargs.setdefault("RingSetContainerName", "ElectronCornerRingSets")
253 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minElectronEnergy * GeV)
254 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
255 kwargs.setdefault("CornerShift", flags.CaloRinger.cornerShift)
256 kwargs.setdefault("CellMaxDEtaDist", 0.2)
257 kwargs.setdefault("CellMaxDPhiDist", 0.2)
258
259 tool = CompFactory.Ringer.CaloCornerRingsBuilder(name, **kwargs)
260 return tool
261
262
263# Photons

◆ CaloRingsCornerJetBuilderCfg()

CaloRingerAlgsConfig.CaloRingsCornerJetBuilderCfg ( flags,
name = "CaloRingsCornerJetBuilder",
** kwargs )

Definition at line 704 of file CaloRingerAlgsConfig.py.

704def CaloRingsCornerJetBuilderCfg(flags, name="CaloRingsCornerJetBuilder", **kwargs):
705 NRings = [8, 64, 8, 8, 4, 4, 4]
706 kwargs.setdefault(
707 "EtaWidth",
708 [
709 0.025,
710 0.003125,
711 0.025,
712 0.05,
713 0.1,
714 0.1,
715 0.2,
716 ],
717 )
718 kwargs.setdefault(
719 "PhiWidth",
720 [
721 0.098174770424681,
722 0.098174770424681,
723 0.024543692606170,
724 0.024543692606170,
725 0.098174770424681,
726 0.098174770424681,
727 0.098174770424681,
728 ],
729 )
730 kwargs.setdefault("NRings", [ring * 5 for ring in NRings])
731 kwargs.setdefault(
732 "Layers",
733 [
734 CaloCell_ID.PreSamplerB,
735 CaloCell_ID.PreSamplerE,
736 CaloCell_ID.EMB1,
737 CaloCell_ID.EME1,
738 CaloCell_ID.EMB2,
739 CaloCell_ID.EME2,
740 CaloCell_ID.EMB3,
741 CaloCell_ID.EME3,
742 CaloCell_ID.HEC0,
743 CaloCell_ID.TileBar0,
744 CaloCell_ID.TileGap3,
745 CaloCell_ID.TileExt0,
746 CaloCell_ID.HEC1,
747 CaloCell_ID.HEC2,
748 CaloCell_ID.TileBar1,
749 CaloCell_ID.TileGap1,
750 CaloCell_ID.TileExt1,
751 CaloCell_ID.HEC3,
752 CaloCell_ID.TileBar2,
753 CaloCell_ID.TileGap2,
754 CaloCell_ID.TileExt2,
755 ],
756 )
757 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
758 kwargs.setdefault(
759 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
760 )
761 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
762 kwargs.setdefault("CaloRingsContainerName", "JetCaloCornerRings")
763 kwargs.setdefault("RingSetContainerName", "JetCornerRingSets")
764 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minJetEnergy * GeV)
765 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
766 kwargs.setdefault("CornerShift", flags.CaloRinger.cornerShift)
767 kwargs.setdefault("CellMaxDEtaDist", 0.2)
768 kwargs.setdefault("CellMaxDPhiDist", 0.2)
769
770 tool = CompFactory.Ringer.CaloCornerRingsBuilder(name, **kwargs)
771 return tool
772
773
774# Readers

◆ CaloRingsCornerPhotonBuilderCfg()

CaloRingerAlgsConfig.CaloRingsCornerPhotonBuilderCfg ( flags,
name = "CaloRingsCornerPhotonBuilder",
** kwargs )

Definition at line 443 of file CaloRingerAlgsConfig.py.

445):
446 NRings = [8, 64, 8, 8, 4, 4, 4]
447 kwargs.setdefault(
448 "EtaWidth",
449 [
450 0.025,
451 0.003125,
452 0.025,
453 0.05,
454 0.1,
455 0.1,
456 0.2,
457 ],
458 )
459 kwargs.setdefault(
460 "PhiWidth",
461 [
462 0.098174770424681,
463 0.098174770424681,
464 0.024543692606170,
465 0.024543692606170,
466 0.098174770424681,
467 0.098174770424681,
468 0.098174770424681,
469 ],
470 )
471 kwargs.setdefault("NRings", [ring * 5 for ring in NRings])
472 kwargs.setdefault(
473 "Layers",
474 [
475 CaloCell_ID.PreSamplerB,
476 CaloCell_ID.PreSamplerE,
477 CaloCell_ID.EMB1,
478 CaloCell_ID.EME1,
479 CaloCell_ID.EMB2,
480 CaloCell_ID.EME2,
481 CaloCell_ID.EMB3,
482 CaloCell_ID.EME3,
483 CaloCell_ID.HEC0,
484 CaloCell_ID.TileBar0,
485 CaloCell_ID.TileGap3,
486 CaloCell_ID.TileExt0,
487 CaloCell_ID.HEC1,
488 CaloCell_ID.HEC2,
489 CaloCell_ID.TileBar1,
490 CaloCell_ID.TileGap1,
491 CaloCell_ID.TileExt1,
492 CaloCell_ID.HEC3,
493 CaloCell_ID.TileBar2,
494 CaloCell_ID.TileGap2,
495 CaloCell_ID.TileExt2,
496 ],
497 )
498 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
499 kwargs.setdefault(
500 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
501 )
502 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
503 kwargs.setdefault("CaloRingsContainerName", "PhotonCaloCornerRings")
504 kwargs.setdefault("RingSetContainerName", "PhotonCornerRingSets")
505 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minPhotonEnergy * GeV)
506 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
507 kwargs.setdefault("CornerShift", flags.CaloRinger.cornerShift)
508 kwargs.setdefault("CellMaxDEtaDist", 0.2)
509 kwargs.setdefault("CellMaxDPhiDist", 0.2)
510
511 tool = CompFactory.Ringer.CaloCornerRingsBuilder(name, **kwargs)
512 return tool
513
514
515# Jets

◆ CaloRingsElectronBuilderCfg()

CaloRingerAlgsConfig.CaloRingsElectronBuilderCfg ( flags,
name = "CaloRingsElectronBuilder",
** kwargs )

Definition at line 10 of file CaloRingerAlgsConfig.py.

10def CaloRingsElectronBuilderCfg(flags, name="CaloRingsElectronBuilder", **kwargs):
11 kwargs.setdefault("EtaWidth", [0.025, 0.003125, 0.025, 0.05, 0.1, 0.1, 0.2])
12 kwargs.setdefault(
13 "PhiWidth",
14 [
15 0.098174770424681,
16 0.098174770424681,
17 0.024543692606170,
18 0.024543692606170,
19 0.098174770424681,
20 0.098174770424681,
21 0.098174770424681,
22 ],
23 )
24 kwargs.setdefault("NRings", [8, 64, 8, 8, 4, 4, 4])
25 kwargs.setdefault("CellMaxDEtaDist", 0.2)
26 kwargs.setdefault("CellMaxDPhiDist", 0.2)
27 kwargs.setdefault(
28 "Layers",
29 [
30 CaloCell_ID.PreSamplerB,
31 CaloCell_ID.PreSamplerE,
32 CaloCell_ID.EMB1,
33 CaloCell_ID.EME1,
34 CaloCell_ID.EMB2,
35 CaloCell_ID.EME2,
36 CaloCell_ID.EMB3,
37 CaloCell_ID.EME3,
38 CaloCell_ID.HEC0,
39 CaloCell_ID.TileBar0,
40 CaloCell_ID.TileGap3,
41 CaloCell_ID.TileExt0,
42 CaloCell_ID.HEC1,
43 CaloCell_ID.HEC2,
44 CaloCell_ID.TileBar1,
45 CaloCell_ID.TileGap1,
46 CaloCell_ID.TileExt1,
47 CaloCell_ID.HEC3,
48 CaloCell_ID.TileBar2,
49 CaloCell_ID.TileGap2,
50 CaloCell_ID.TileExt2,
51 ],
52 )
53 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
54 kwargs.setdefault(
55 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
56 )
57 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
58 kwargs.setdefault("CaloRingsContainerName", "ElectronCaloRings")
59 kwargs.setdefault("RingSetContainerName", "ElectronRingSets")
60 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minElectronEnergy * GeV)
61 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
62
63 tool = CompFactory.Ringer.CaloRingsBuilder(name, **kwargs)
64 return tool
65
66

◆ CaloRingsJetBuilderCfg()

CaloRingerAlgsConfig.CaloRingsJetBuilderCfg ( flags,
name = "CaloRingsJetBuilder",
** kwargs )

Definition at line 516 of file CaloRingerAlgsConfig.py.

516def CaloRingsJetBuilderCfg(flags, name="CaloRingsJetBuilder", **kwargs):
517 kwargs.setdefault("EtaWidth", [0.025, 0.003125, 0.025, 0.05, 0.1, 0.1, 0.2])
518 kwargs.setdefault(
519 "PhiWidth",
520 [
521 0.098174770424681,
522 0.098174770424681,
523 0.024543692606170,
524 0.024543692606170,
525 0.098174770424681,
526 0.098174770424681,
527 0.098174770424681,
528 ],
529 )
530 kwargs.setdefault("NRings", [8, 64, 8, 8, 4, 4, 4])
531 kwargs.setdefault("CellMaxDEtaDist", 0.2)
532 kwargs.setdefault("CellMaxDPhiDist", 0.2)
533 kwargs.setdefault(
534 "Layers",
535 [
536 CaloCell_ID.PreSamplerB,
537 CaloCell_ID.PreSamplerE,
538 CaloCell_ID.EMB1,
539 CaloCell_ID.EME1,
540 CaloCell_ID.EMB2,
541 CaloCell_ID.EME2,
542 CaloCell_ID.EMB3,
543 CaloCell_ID.EME3,
544 CaloCell_ID.HEC0,
545 CaloCell_ID.TileBar0,
546 CaloCell_ID.TileGap3,
547 CaloCell_ID.TileExt0,
548 CaloCell_ID.HEC1,
549 CaloCell_ID.HEC2,
550 CaloCell_ID.TileBar1,
551 CaloCell_ID.TileGap1,
552 CaloCell_ID.TileExt1,
553 CaloCell_ID.HEC3,
554 CaloCell_ID.TileBar2,
555 CaloCell_ID.TileGap2,
556 CaloCell_ID.TileExt2,
557 ],
558 )
559 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
560 kwargs.setdefault(
561 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
562 )
563 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
564 kwargs.setdefault("CaloRingsContainerName", "JetCaloRings")
565 kwargs.setdefault("RingSetContainerName", "JetRingSets")
566 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minJetEnergy * GeV)
567 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
568
569 tool = CompFactory.Ringer.CaloRingsBuilder(name, **kwargs)
570 return tool
571
572

◆ CaloRingsPhotonBuilderCfg()

CaloRingerAlgsConfig.CaloRingsPhotonBuilderCfg ( flags,
name = "CaloRingsPhotonBuilder",
** kwargs )

Definition at line 264 of file CaloRingerAlgsConfig.py.

264def CaloRingsPhotonBuilderCfg(flags, name="CaloRingsPhotonBuilder", **kwargs):
265 kwargs.setdefault("EtaWidth", [0.025, 0.003125, 0.025, 0.05, 0.1, 0.1, 0.2])
266 kwargs.setdefault(
267 "PhiWidth",
268 [
269 0.098174770424681,
270 0.098174770424681,
271 0.024543692606170,
272 0.024543692606170,
273 0.098174770424681,
274 0.098174770424681,
275 0.098174770424681,
276 ],
277 )
278 kwargs.setdefault("NRings", [8, 64, 8, 8, 4, 4, 4])
279 kwargs.setdefault("CellMaxDEtaDist", 0.2)
280 kwargs.setdefault("CellMaxDPhiDist", 0.2)
281 kwargs.setdefault(
282 "Layers",
283 [
284 CaloCell_ID.PreSamplerB,
285 CaloCell_ID.PreSamplerE,
286 CaloCell_ID.EMB1,
287 CaloCell_ID.EME1,
288 CaloCell_ID.EMB2,
289 CaloCell_ID.EME2,
290 CaloCell_ID.EMB3,
291 CaloCell_ID.EME3,
292 CaloCell_ID.HEC0,
293 CaloCell_ID.TileBar0,
294 CaloCell_ID.TileGap3,
295 CaloCell_ID.TileExt0,
296 CaloCell_ID.HEC1,
297 CaloCell_ID.HEC2,
298 CaloCell_ID.TileBar1,
299 CaloCell_ID.TileGap1,
300 CaloCell_ID.TileExt1,
301 CaloCell_ID.HEC3,
302 CaloCell_ID.TileBar2,
303 CaloCell_ID.TileGap2,
304 CaloCell_ID.TileExt2,
305 ],
306 )
307 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
308 kwargs.setdefault(
309 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
310 )
311 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
312 kwargs.setdefault("CaloRingsContainerName", "PhotonCaloRings")
313 kwargs.setdefault("RingSetContainerName", "PhotonRingSets")
314 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minPhotonEnergy * GeV)
315 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
316
317 tool = CompFactory.Ringer.CaloRingsBuilder(name, **kwargs)
318 return tool
319
320

◆ CaloRingsStripsElectronBuilderCfg()

CaloRingerAlgsConfig.CaloRingsStripsElectronBuilderCfg ( flags,
name = "CaloRingsStripsElectronBuilder",
** kwargs )

Definition at line 129 of file CaloRingerAlgsConfig.py.

131):
132 kwargs.setdefault("EtaWidth", [0.025, 0.003125, 0.025, 0.05, 0.1, 0.1, 0.2])
133 kwargs.setdefault(
134 "PhiWidth",
135 [
136 0.098174770424681,
137 0.098174770424681,
138 0.024543692606170,
139 0.024543692606170,
140 0.098174770424681,
141 0.098174770424681,
142 0.098174770424681,
143 ],
144 )
145 kwargs.setdefault("NRings", [28, 252, 28, 14, 8, 8, 4])
146 kwargs.setdefault("Axis", 0)
147 kwargs.setdefault("CellMaxDEtaDist", 0.2)
148 kwargs.setdefault("CellMaxDPhiDist", 0.2)
149 kwargs.setdefault(
150 "Layers",
151 [
152 CaloCell_ID.PreSamplerB,
153 CaloCell_ID.PreSamplerE,
154 CaloCell_ID.EMB1,
155 CaloCell_ID.EME1,
156 CaloCell_ID.EMB2,
157 CaloCell_ID.EME2,
158 CaloCell_ID.EMB3,
159 CaloCell_ID.EME3,
160 CaloCell_ID.HEC0,
161 CaloCell_ID.TileBar0,
162 CaloCell_ID.TileGap3,
163 CaloCell_ID.TileExt0,
164 CaloCell_ID.HEC1,
165 CaloCell_ID.HEC2,
166 CaloCell_ID.TileBar1,
167 CaloCell_ID.TileGap1,
168 CaloCell_ID.TileExt1,
169 CaloCell_ID.HEC3,
170 CaloCell_ID.TileBar2,
171 CaloCell_ID.TileGap2,
172 CaloCell_ID.TileExt2,
173 ],
174 )
175 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
176 kwargs.setdefault(
177 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
178 )
179 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
180 kwargs.setdefault("CaloRingsContainerName", "ElectronCaloStripsRings")
181 kwargs.setdefault("RingSetContainerName", "ElectronStripsRingSets")
182 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minElectronEnergy * GeV)
183 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
184 kwargs.setdefault("doEtaAxesDivision", True)
185 kwargs.setdefault("doPhiAxesDivision", True)
186
187 tool = CompFactory.Ringer.CaloStripsRingsBuilder(name, **kwargs)
188 return tool
189
190

◆ CaloRingsStripsJetBuilderCfg()

CaloRingerAlgsConfig.CaloRingsStripsJetBuilderCfg ( flags,
name = "CaloRingsStripsJetBuilder",
** kwargs )

Definition at line 633 of file CaloRingerAlgsConfig.py.

633def CaloRingsStripsJetBuilderCfg(flags, name="CaloRingsStripsJetBuilder", **kwargs):
634 kwargs.setdefault(
635 "EtaWidth",
636 [
637 0.025,
638 0.003125,
639 0.025,
640 0.05,
641 0.1,
642 0.1,
643 0.2,
644 ],
645 )
646 kwargs.setdefault(
647 "PhiWidth",
648 [
649 0.098174770424681,
650 0.098174770424681,
651 0.024543692606170,
652 0.024543692606170,
653 0.098174770424681,
654 0.098174770424681,
655 0.098174770424681,
656 ],
657 )
658 kwargs.setdefault("NRings", [28, 252, 28, 14, 8, 8, 4])
659 kwargs.setdefault("Axis", 0)
660 kwargs.setdefault("CellMaxDEtaDist", 0.2)
661 kwargs.setdefault("CellMaxDPhiDist", 0.2)
662 kwargs.setdefault(
663 "Layers",
664 [
665 CaloCell_ID.PreSamplerB,
666 CaloCell_ID.PreSamplerE,
667 CaloCell_ID.EMB1,
668 CaloCell_ID.EME1,
669 CaloCell_ID.EMB2,
670 CaloCell_ID.EME2,
671 CaloCell_ID.EMB3,
672 CaloCell_ID.EME3,
673 CaloCell_ID.HEC0,
674 CaloCell_ID.TileBar0,
675 CaloCell_ID.TileGap3,
676 CaloCell_ID.TileExt0,
677 CaloCell_ID.HEC1,
678 CaloCell_ID.HEC2,
679 CaloCell_ID.TileBar1,
680 CaloCell_ID.TileGap1,
681 CaloCell_ID.TileExt1,
682 CaloCell_ID.HEC3,
683 CaloCell_ID.TileBar2,
684 CaloCell_ID.TileGap2,
685 CaloCell_ID.TileExt2,
686 ],
687 )
688 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
689 kwargs.setdefault(
690 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
691 )
692 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
693 kwargs.setdefault("CaloRingsContainerName", "JetCaloStripsRings")
694 kwargs.setdefault("RingSetContainerName", "JetStripsRingSets")
695 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minJetEnergy * GeV)
696 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
697 kwargs.setdefault("doEtaAxesDivision", True)
698 kwargs.setdefault("doPhiAxesDivision", True)
699
700 tool = CompFactory.Ringer.CaloStripsRingsBuilder(name, **kwargs)
701 return tool
702
703

◆ CaloRingsStripsPhotonBuilderCfg()

CaloRingerAlgsConfig.CaloRingsStripsPhotonBuilderCfg ( flags,
name = "CaloRingsStripsPhotonBuilder",
** kwargs )

Definition at line 381 of file CaloRingerAlgsConfig.py.

383):
384 kwargs.setdefault("EtaWidth", [0.025, 0.003125, 0.025, 0.05, 0.1, 0.1, 0.2])
385 kwargs.setdefault(
386 "PhiWidth",
387 [
388 0.098174770424681,
389 0.098174770424681,
390 0.024543692606170,
391 0.024543692606170,
392 0.098174770424681,
393 0.098174770424681,
394 0.098174770424681,
395 ],
396 )
397 kwargs.setdefault("NRings", [28, 252, 28, 14, 8, 8, 4])
398 kwargs.setdefault("Axis", 0)
399 kwargs.setdefault("CellMaxDEtaDist", 0.2)
400 kwargs.setdefault("CellMaxDPhiDist", 0.2)
401 kwargs.setdefault(
402 "Layers",
403 [
404 CaloCell_ID.PreSamplerB,
405 CaloCell_ID.PreSamplerE,
406 CaloCell_ID.EMB1,
407 CaloCell_ID.EME1,
408 CaloCell_ID.EMB2,
409 CaloCell_ID.EME2,
410 CaloCell_ID.EMB3,
411 CaloCell_ID.EME3,
412 CaloCell_ID.HEC0,
413 CaloCell_ID.TileBar0,
414 CaloCell_ID.TileGap3,
415 CaloCell_ID.TileExt0,
416 CaloCell_ID.HEC1,
417 CaloCell_ID.HEC2,
418 CaloCell_ID.TileBar1,
419 CaloCell_ID.TileGap1,
420 CaloCell_ID.TileExt1,
421 CaloCell_ID.HEC3,
422 CaloCell_ID.TileBar2,
423 CaloCell_ID.TileGap2,
424 CaloCell_ID.TileExt2,
425 ],
426 )
427 kwargs.setdefault("RingSetNLayers", [2, 2, 2, 2, 4, 5, 4])
428 kwargs.setdefault(
429 "useShowerShapeBarycenter", flags.CaloRinger.useShowerShapeBarycenter
430 )
431 kwargs.setdefault("CellsContainerName", flags.Egamma.Keys.Input.CaloCells)
432 kwargs.setdefault("CaloRingsContainerName", "PhotonCaloStripsRings")
433 kwargs.setdefault("RingSetContainerName", "PhotonStripsRingSets")
434 kwargs.setdefault("MinPartEnergy", flags.CaloRinger.minPhotonEnergy * GeV)
435 kwargs.setdefault("doTransverseEnergy", flags.CaloRinger.doTransverseEnergy)
436 kwargs.setdefault("doEtaAxesDivision", True)
437 kwargs.setdefault("doPhiAxesDivision", True)
438
439 tool = CompFactory.Ringer.CaloStripsRingsBuilder(name, **kwargs)
440 return tool
441
442

Variable Documentation

◆ cfg

CaloRingerAlgsConfig.cfg = MainServicesCfg(flags)

Definition at line 1177 of file CaloRingerAlgsConfig.py.

◆ doWriteAOD

CaloRingerAlgsConfig.doWriteAOD

Definition at line 1172 of file CaloRingerAlgsConfig.py.

◆ ESDFileName

CaloRingerAlgsConfig.ESDFileName

Definition at line 1173 of file CaloRingerAlgsConfig.py.

◆ Files

CaloRingerAlgsConfig.Files

Definition at line 1171 of file CaloRingerAlgsConfig.py.

◆ flags

CaloRingerAlgsConfig.flags = initConfigFlags()

Definition at line 1170 of file CaloRingerAlgsConfig.py.

Generated on for ATLAS Offline Software by doxygen 1.16.1