def getOverlay(self, nbevts):
""" Create an overlay step
"""
pathToFiles = None
from ILCDIRAC.Interfaces.API.NewInterface.Applications import OverlayInput
overlay = OverlayInput()
if self.energy == 350:
if self.detectorModel == "ILD_o1_v05":
pathToFiles = "/ilc/user/s/sailer/testFiles/overlay/ild_350/"
if pathToFiles:
overlay.setPathToFiles(pathToFiles)
else:
self.log.warn(
"better define pathToFiles for this overlay: %s, %s, %s" %
(self.energy, self.machine, self.backgroundType))
overlay.setMachine(self.machine)
overlay.setEnergy(self.energy)
overlay.setDetectorModel(self.detectorModel)
overlay.setBkgEvtType(self.backgroundType)
overlay.setBXOverlay(60)
overlay.setGGToHadInt(0.3)
overlay.setNumberOfSignalEventsPerJob(nbevts)
return overlay
def createOverlayApplication( self, energy ):
""" create Overlay Application """
from ILCDIRAC.Interfaces.API.NewInterface.Applications import OverlayInput
overlay = OverlayInput()
overlay.setMachine( 'clic_opt' )
overlay.setEnergy( energy )
overlay.setBackgroundType( self._overlayEventType )
overlay.setDetectorModel( self.detectorModel )
try:
overlayEnergy = energyToInt( self.overlayEvents ) if self.overlayEvents else energy
self.overlayParameterDict().get( overlayEnergy ) ( overlay )
except TypeError:
raise RuntimeError( "No overlay parameters defined for %r GeV and %s " % ( energy, self._overlayEventType ) )
if self.overlayEvents:
overlay.setUseEnergyForFileLookup( False )
return overlay
res = fc.findFilesByMetadata(meta)
if not res['OK']:
print "Found no files"
exit()
lfns = res['Value']
print "found %s files" % len(lfns)
ovi = OverlayInput()
ovi.setEnergy(500.)
ovi.setBXOverlay(300)
ovi.setGGToHadInt(0.3)
ovi.setNbSigEvtsPerJob(10)
ovi.setBkgEvtType("gghad")
ovi.setDetectorModel("CLIC_ILD_CDR")
overlay = [True, False]
for ov in overlay:
d = DiracILC(True, "repo_overlay_%s.rep" % ov)
for lfn in lfns:
j = UserJob()
steeringf = "clic_ild_cdr_steering.xml"
if ov:
steeringf = "clic_ild_cdr_steering_overlay.xml"
res = j.append(ovi)
if not res['OK']:
print res['Message']
continue
ma = Marlin()
slicpandora.setPandoraSettings(pandoraSettings)
slicpandora.getInputFromApp(lcsim_prepandora)
slicpandora.setOutputFile('pandora.slcio')
lcsim_postpandora = LCSIM()
lcsim_postpandora.setVersion(lcsimVers)
lcsim_postpandora.getInputFromApp(slicpandora)
lcsim_postpandora.setSteeringFile(lcsimSteering2)
lcsim_postpandora.setTrackingStrategy(strategies)
lcsim_postpandora.setDetectorModel(detectorName)
### Now with overlay
overlay = OverlayInput()
overlay.setBXOverlay(60)
overlay.setGGToHadInt(1.3) ##When running at 1.4TeV
overlay.setDetectorModel("CLIC_SID_CDR")
overlay.setBkgEvtType("gghad")
lcsim_prepandora_ov = LCSIM()
lcsim_prepandora_ov.setVersion(lcsimVers)
lcsim_prepandora_ov.setSteeringFile(lcsimSteering1_ov)
lcsim_prepandora_ov.setTrackingStrategy(strategies)
lcsim_prepandora_ov.setDetectorModel(detectorName)
lcsim_prepandora_ov.setOutputFile("prePandora.slcio")
slicpandora_ov = SLICPandora()
slicpandora_ov.setVersion(pandoraVers)
slicpandora_ov.setDetectorModel(detectorName)
slicpandora_ov.setPandoraSettings(pandoraSettings)
slicpandora_ov.getInputFromApp(lcsim_prepandora_ov)
slicpandora_ov.setOutputFile('pandora.slcio')
if UseDD4hepGeometry:
ddsim = DDSim()
ddsim.setVersion(DDSimVer) ###SET HERE YOUR MOKKA VERSION, the software will come from the ILDConfig
ddsim.setDetectorModel(detectorModel)
ddsim.setSteeringFile("ddsim_steer.py")
##Split
split = SLCIOSplit()
split.setNumberOfEventsPerFile(nbevtsperfile)
##Define the overlay
overlay = OverlayInput()
overlay.setMachine("ilc_dbd") #Don't touch, this is how the system knows what files to get
overlay.setEnergy(energy) #Don't touch, this is how the system knows what files to get
overlay.setDetectorModel(detectorModel) #Don't touch, this is how the system knows what files to get
if energy==500.: #here you chose the overlay parameters as this determines how many files you need
#it does NOT affect the content of the marlin steering file whatsoever, you need to make sure the values
#there are correct. Only the file names are handled properly so that you don't need to care
overlay.setBXOverlay(BXOverlay)
overlay.setGGToHadInt(GGToHadInt500)
overlay.setBkgEvtType("aa_lowpt2") ## lowpt2: correct number of events (500),
## not increased to 2500 to reduce number
## of downloaded files
elif energy == 1000.:
overlay.setBXOverlay(BXOverlay)
overlay.setGGToHadInt(GGToHadInt1000)
overlay.setBkgEvtType("aa_lowpt")
elif energy == 350.:
overlay.setBXOverlay(BXOverlay)
overlay.setGGToHadInt(GGToHadInt350)
slic.setDetectorModel('clic_sid_cdr')
##Split
split = SLCIOSplit()
split.setNumberOfEventsPerFile(nbevtsperfile)
overlay = OverlayInput()
overlay.setMachine("clic_cdr")
overlay.setEnergy(energy)
overlay.setBkgEvtType("gghad")
if energy==500.:
overlay.setBXOverlay(300)
overlay.setGGToHadInt(0.3)##When running at 500geV
overlay.setDetectorModel("CLIC_ILD_CDR500")
elif energy == 350.:
overlay.setBXOverlay(300)
overlay.setGGToHadInt(0.0464)##When running at 350geV
overlay.setDetectorModel("CLIC_ILD_CDR500")
elif energy == 3000.:
overlay.setBXOverlay(60)
overlay.setGGToHadInt(3.2)##When running at 3TeV
overlay.setDetectorModel("CLIC_ILD_CDR")
elif energy == 1400.:
overlay.setBXOverlay(60)
overlay.setGGToHadInt(1.3)##When running at 1.4TeV
overlay.setDetectorModel("CLIC_ILD_CDR")
else:
print "Overlay ILD: No overlay parameters defined for this energy"
lcsim_postpandora.getInputFromApp(lcfivertex)
lcsim_postpandora.setSteeringFile(
"clic_cdr_postPandoraOverlay.lcsim") #This will change only once
lcsim_postpandora.setTrackingStrategy(tracking_strategy)
#lcsim_postpandora.setDetectorModel(detector_model)
## SID Reco w/o overlay
overlay_sid_gg = OverlayInput()
overlay_sid_gg.setBkgEvtType("gghad") #DO NOT TOUCH THIS
overlay_sid_gg.setEnergy(energy)
if energy == 1000.:
overlay_sid_gg.setBXOverlay(1)
overlay_sid_gg.setGGToHadInt(4.1) ##When running at 3TeV
else:
print "Overlay SID: No overlay parameters defined for this energy"
overlay_sid_gg.setDetectorModel("sidloi3") #DO NOT TOUCH THIS
overlay_sid_pairs = OverlayInput()
overlay_sid_pairs.setBkgEvtType("pairs") #DO NOT TOUCH THIS
overlay_sid_pairs.setEnergy(energy)
if energy == 1000.:
overlay_sid_pairs.setBXOverlay(1)
overlay_sid_pairs.setGGToHadInt(1) ##When running at 3TeV
else:
print "Overlay SID: No overlay parameters defined for this energy"
overlay_sid_pairs.setDetectorModel("sidloi3") #DO NOT TOUCH THIS
lcsim_prepandora_ov = LCSIM()
lcsim_prepandora_ov.setVersion('CLIC_CDR') #This will change only once
if energy == 1000.0:
lcsim_prepandora_ov.setSteeringFile(
class OverlayInputTestCase(unittest.TestCase):
""" Base class for the OverlayInput test cases
"""
def setUp(self):
"""set up the objects"""
self.olin = OverlayInput({})
def test_setters(self):
assertEqualsImproved(
(self.olin.machine, self.olin.prodID,
self.olin.useEnergyForFileLookup, self.olin.detectorModel,
self.olin.backgroundEventType), ('clic_cdr', 0, True, '', ''),
self)
self.assertFalse(self.olin._errorDict)
self.olin.setMachine('mytestMachine')
assertDiracSucceeds(self.olin.setProdID(14983), self)
self.olin.setUseEnergyForFileLookup(False)
self.olin.setDetectorModel('mytestDetector')
self.olin.setBackgroundType('myBackgroundParticle.Testme')
assertEqualsImproved(
(self.olin.machine, self.olin.prodID,
self.olin.useEnergyForFileLookup, self.olin.detectorModel,
self.olin.backgroundEventType),
('mytestMachine', 14983, False, 'mytestDetector',
'myBackgroundParticle.Testme'), self)
self.assertFalse(self.olin._errorDict)
def test_setters_checks(self):
self.olin.setMachine({'138rj': True})
self.olin.setProdID([])
self.olin.setUseEnergyForFileLookup('False')
self.olin.setDetectorModel(9024)
self.olin.setBackgroundType(8914)
assertEqualsImproved(len(self.olin._errorDict['_checkArgs']), 5, self)
def test_userjobmodules(self):
with patch.object(self.olin,
'_setApplicationModuleAndParameters',
new=Mock(return_value=S_OK())):
assertDiracSucceeds(self.olin._userjobmodules(Mock()), self)
def test_userjobmodules_fails(self):
with patch.object(self.olin,
'_setApplicationModuleAndParameters',
new=Mock(return_value=S_ERROR('bla'))):
assertDiracFailsWith(self.olin._userjobmodules(Mock()),
'userjobmodules failed', self)
def test_prodjobmodules(self):
with patch.object(self.olin,
'_setApplicationModuleAndParameters',
new=Mock(return_value=S_OK())):
assertDiracSucceeds(self.olin._prodjobmodules(Mock()), self)
def test_prodjobmodules_fails(self):
with patch.object(self.olin,
'_setApplicationModuleAndParameters',
new=Mock(return_value=S_ERROR('bla'))):
assertDiracFailsWith(self.olin._prodjobmodules(Mock()),
'prodjobmodules failed', self)
def test_addparameterstostep_fails(self):
with patch.object(self.olin,
'_addBaseParameters',
new=Mock(return_value=S_ERROR('bla'))):
assertDiracFailsWith(self.olin._addParametersToStep(Mock()),
'failed to set base param', self)
def test_addparameterstostep(self):
with patch.object(self.olin,
'_addBaseParameters',
new=Mock(return_value=S_OK())):
assertDiracSucceeds(self.olin._addParametersToStep(Mock()), self)
def test_checkconsistency(self):
self.olin.pathToOverlayFiles = ''
self.olin.bxToOverlay = True
self.olin.numberOfGGToHadronInteractions = 1345
self.olin.backgroundEventType = 'myTestBGEvt'
self.olin._jobtype = 'notUser'
assertDiracSucceeds(self.olin._checkConsistency(), self)
assertEqualsImproved((self.olin.prodparameters['detectorModel'],
self.olin.prodparameters['BXOverlay'],
self.olin.prodparameters['GGtoHadInt']),
('', True, 1345), self)
def test_checkconsistency_nofilesinpath(self):
self.olin.pathToOverlayFiles = '/my/path/overlay.files'
with patch(
'DIRAC.Resources.Catalog.FileCatalogClient.FileCatalogClient.findFilesByMetadata',
new=Mock(return_value=S_OK([]))) as fcc_mock:
assertDiracFailsWith(self.olin._checkConsistency(),
'no files in that path', self)
fcc_mock.assert_called_once_with({}, '/my/path/overlay.files')
def test_checkconsistency_no_bunchcrossings(self):
self.olin.pathToOverlayFiles = ''
self.olin.bxToOverlay = None
assertDiracFailsWith(self.olin._checkConsistency(),
'number of overlay bunch crossings not defined',
self)
def test_checkconsistency_no_backgroundevts(self):
self.olin.pathToOverlayFiles = ''
self.olin.bxToOverlay = True
self.olin.numberOfGGToHadronInteractions = 0
assertDiracFailsWith(
self.olin._checkConsistency(),
'background events per bunch crossing is not defined', self)
def test_checkconsistency_no_bgevttype(self):
self.olin.pathToOverlayFiles = ''
self.olin.bxToOverlay = True
self.olin.numberOfGGToHadronInteractions = 1345
self.olin.backgroundEventType = ''
assertDiracFailsWith(self.olin._checkConsistency(),
'event type is not defined', self)
def test_checkconsistency_nosignalevtperjob(self):
self.olin.pathToOverlayFiles = ''
self.olin.bxToOverlay = True
self.olin.numberOfGGToHadronInteractions = 1345
self.olin.backgroundEventType = 'gghad'
self.olin._jobtype = 'User'
self.olin.numberOfSignalEventsPerJob = 0
assertDiracFailsWith(self.olin._checkConsistency(),
'signal event per job is not defined', self)
def test_checkfinalconsistency_simple(self):
self.olin.pathToOverlayFiles = 'some/path'
assertDiracSucceeds(self.olin._checkFinalConsistency(), self)
def test_checkfinalconsistency_noenergy(self):
self.olin.energy = 0
assertDiracFailsWith(self.olin._checkFinalConsistency(),
'energy must be specified', self)
def test_checkfinalconsistency_ops_fails(self):
ops_mock = Mock()
ops_mock.getSections.return_value = S_ERROR('some_ops_error')
self.olin._ops = ops_mock
self.olin.energy = 198
assertDiracFailsWith(self.olin._checkFinalConsistency(),
'could not resolve the cs path', self)
def test_checkfinalconsistency_machinemissing(self):
ops_mock = Mock()
ops_mock.getSections.return_value = S_OK(
['allowed_machine_1', 'other_mach'])
self.olin._ops = ops_mock
self.olin.machine = 'myTestMachineVeryRare'
self.olin.energy = 198
assertDiracFailsWith(
self.olin._checkFinalConsistency(),
'machine mytestmachineveryrare does not have overlay data', self)
def test_checkfinalconsistency_energynotfound(self):
self.olin.energy = 824
section_dict = {
'/Overlay': ['myTestMachineVeryRare'],
'/Overlay/myTestMachineVeryRare': ['other_energy_tev', '824tev']
}
ops_mock = Mock()
ops_mock.getSections.side_effect = lambda path: S_OK(section_dict[path]
)
self.olin._ops = ops_mock
self.olin.machine = 'myTestMachineVeryRare'
assertDiracFailsWith(self.olin._checkFinalConsistency(),
'no overlay files corresponding to 824gev', self)
def test_checkfinalconsistency_nodetectormodels(self):
self.olin.energy = 1000.0
section_dict = {
'/Overlay': S_OK(['myTestMachineVeryRare']),
'/Overlay/myTestMachineVeryRare':
S_OK(['other_energy_tev', '1tev']),
'/Overlay/myTestMachineVeryRare/1tev': S_ERROR('bla')
}
ops_mock = Mock()
ops_mock.getSections.side_effect = lambda path: section_dict[path]
self.olin._ops = ops_mock
self.olin.machine = 'myTestMachineVeryRare'
assertDiracFailsWith(self.olin._checkFinalConsistency(),
'could not find the detector models', self)
def test_checkfinalconsistency_detectormodelnotfound(self):
self.olin.energy = 981324
section_dict = {
'/Overlay': ['myTestMachineVeryRare'],
'/Overlay/myTestMachineVeryRare': ['other_energy_tev', '981.3gev'],
'/Overlay/myTestMachineVeryRare/981.3tev':
['some_other_detector_model', 'neither_this']
}
ops_mock = Mock()
ops_mock.getSections.side_effect = lambda path: S_OK(section_dict[path]
)
self.olin._ops = ops_mock
self.olin.machine = 'myTestMachineVeryRare'
assertDiracFailsWith(self.olin._checkFinalConsistency(),
'no overlay files corresponding to 981.3tev',
self)
def test_checkfinalconsistency_nobkg(self):
self.olin.detectorModel = 'testDetMod'
self.olin.energy = 981000
section_dict = {
'/Overlay': ['myTestMachineVeryRare'],
'/Overlay/myTestMachineVeryRare': ['other_energy_tev', '981tev'],
'/Overlay/myTestMachineVeryRare/981tev': ['testDetMod']
}
ops_mock = Mock()
ops_mock.getSections.side_effect = lambda path: S_OK(section_dict[path]
)
self.olin._ops = ops_mock
self.olin.machine = 'myTestMachineVeryRare'
with patch.object(inspect.getmodule(OverlayInput),
'allowedBkg',
new=Mock(return_value=S_ERROR('bkg_test_err'))):
assertDiracFailsWith(self.olin._checkFinalConsistency(),
'bkg_test_err', self)
def test_checkfinalconsistency_negativeprodid(self):
self.olin.detectorModel = 'testDetMod'
self.olin.energy = 981000
section_dict = {
'/Overlay': ['myTestMachineVeryRare'],
'/Overlay/myTestMachineVeryRare': ['other_energy_tev', '981tev'],
'/Overlay/myTestMachineVeryRare/981tev': ['testDetMod']
}
ops_mock = Mock()
ops_mock.getSections.side_effect = lambda path: S_OK(section_dict[path]
)
self.olin._ops = ops_mock
self.olin.machine = 'myTestMachineVeryRare'
with patch.object(inspect.getmodule(OverlayInput),
'allowedBkg',
new=Mock(return_value=S_OK(-147))):
assertDiracFailsWith(self.olin._checkFinalConsistency(),
'no proper production id found', self)
def test_checkfinalconsistency(self):
self.olin.detectorModel = 'testDetMod'
self.olin.energy = 981000
section_dict = {
'/Overlay': ['myTestMachineVeryRare'],
'/Overlay/myTestMachineVeryRare': ['other_energy_tev', '981tev'],
'/Overlay/myTestMachineVeryRare/981tev': ['testDetMod']
}
ops_mock = Mock()
ops_mock.getSections.side_effect = lambda path: S_OK(section_dict[path]
)
self.olin._ops = ops_mock
self.olin.machine = 'myTestMachineVeryRare'
with patch.object(inspect.getmodule(OverlayInput),
'allowedBkg',
new=Mock(return_value=S_OK(13987))):
assertDiracSucceeds(self.olin._checkFinalConsistency(), self)
