def defGridJob(jobName, jobGroup, inputFile):
'''Defines Grid job'''
from ILCDIRAC.Interfaces.API.NewInterface.UserJob import UserJob
job = UserJob()
job.setName(jobName)
job.setJobGroup(jobGroup)
job.setCPUTime(86400)
job.dontPromptMe()
job.setBannedSites([
'LCG.IN2P3-CC.fr', 'OSG.UConn.us', 'LCG.Cracow.pl', 'OSG.MIT.us',
'LCG.Glasgow.uk', 'OSG.CIT.us', 'OSG.BNL.us', 'LCG.Brunel.uk'
])
job.setInputData(inputFile)
job.setInputSandbox([
'LFN:/ilc/user/l/lstroem/topasymmetry/lib_ilcsoft_2017-05-30_gcc62.tar.gz'
]) #only need LFN: for InputSandbox
job.setOutputSandbox(["*.out", "*.log"])
outputFile = jobName + ".slcio"
rootFile = jobName + ".root"
#job.setOutputData([outputFile, rootFile], jobGroup, "CERN-DST-EOS") #keep some files on the GRID for further processing
job.setOutputData([rootFile], jobGroup, "CERN-DST-EOS")
return job, outputFile, rootFile
def create_job(inputData, saveName, outputDir, dontPromptMe):
slcioFile = saveName + '.slcio'
rootFile = saveName + '.root'
if check_file_existence(outputDir, slcioFile, dontPromptMe):
remove_file(outputDir, slcioFile, dontPromptMe)
if check_file_existence(outputDir, rootFile, dontPromptMe):
remove_file(outputDir, rootFile, dontPromptMe)
dIlc = DiracILC()
job = UserJob()
job.setOutputSandbox(['*.out', '*.log', '*.sh', '*.py', '*.xml'])
if SAVE_SLCIO:
job.setOutputData([slcioFile, rootFile],
OutputPath=outputDir,
OutputSE=STORAGE_SE)
else:
job.setOutputData(rootFile, OutputPath=outputDir, OutputSE=STORAGE_SE)
job.setJobGroup('myMarlinRun1')
job.setName('MyMarlinJob1')
# job.setBannedSites(['LCG.IN2P3-CC.fr','OSG.UConn.us','LCG.Cracow.pl','OSG.MIT.us','LCG.Glasgow.uk','OSG.CIT.us','OSG.BNL.us','LCG.Brunel.uk'])
job.setInputSandbox(['LFN:/ilc/user/a/amaier/mylibs.tar.gz'])
marl = Marlin()
marl.setVersion('ILCSoft-2017-11-15_gcc62')
marl.setInputFile(inputData)
job.setInputData(list(map(lambda x: x.lstrip('LFN:'), inputData)))
# marl.setInputFile(['LFN:/ilc/prod/clic/1.4tev/qq_ln/ILD/DST/00003249/010/qq_ln_dst_3249_10000.slcio'])
marl.setSteeringFile('marlin/FullChain.xml')
# marl.setSteeringFile('marlin/FullChainNewDetModel.xml')
marl.setOutputFile(slcioFile)
gearFile = '/afs/cern.ch/user/a/amaier/projects/CLIC_analysis/grid/marlin/clic_ild_cdr.gear'
if not os.path.isfile(gearFile):
print('Error: gear file', gearFile,
'does not exist! Abort submission.')
return
marl.setGearFile(gearFile)
marl.setExtraCLIArguments(
"--MyNtupleMaker.OutputFileName={rootOutfile}".format(
rootOutfile=rootFile))
# marl.setNumberOfEvents(1000)
job.append(marl)
if dontPromptMe:
job.dontPromptMe()
job.submit(dIlc)
return False
#ma.getInputFromApp(sim)
ma.setInputFile([lcoutputSIM])
ma.setEnergy(energy)
ma.setNumberOfEvents(evtsPerRun)
ma.setOutputDstFile(lcoutputDST)
ma.setOutputRecFile(lcoutputREC)
RECoutput.append(lcoutputDST)
RECoutput.append(lcoutputREC)
job = UserJob()
job.setName(jobname)
job.setJobGroup(jobGrName)
job.setILDConfig(ILDConfigVer)
job.setCPUTime(86400)
job.setInputData([lcinputREC])
job.setInputSandbox(["runRecoSplit_all_Tmp.py"])
job.setOutputSandbox(["*.log","*.sh","MarlinStdRecoParsed.xml","marlin*.xml","*.py "])
#job.setOutputSandbox(["*.log","*.sh","MarlinStdRecoParsed.xml","marlin*.xml","*.py ","*.root"])
#job.setDestinationCE('lyogrid07.in2p3.fr')
job.dontPromptMe()
job.setBannedSites(['LCG.QMUL.uk'])
#job.setBannedSites(['LCG.IN2P3-CC.fr','LCG.DESYZN.de','LCG.DESY-HH.de','LCG.KEK.jp','OSG.UConn.us','LCG.Cracow.pl','OSG.MIT.us','LCG.Glasgow.uk','OSG.CIT.us','OSG.BNL.us','LCG.Brunel.uk','LCG.RAL-LCG2.uk','LCG.Oxford.uk','OSG.UCSDT2.us'])
# run Malrin reco jobs
mares = job.append(ma)
if not mares['OK']:
print mares['Not ok appending Marlin to job']
quit()
dIlc = DiracILC()
lcoutput = []
for i in range(1, 301):
lcoutput = "aa_%d.root" % i
job = UserJob()
job.setDestination('LCG.CERN.ch')
job.setInputSandbox([
"LFN:/ilc/user/k/kacarevic/hgamgam/PandoraPFA/PandoraLikelihoodData9EBin_CLIC_ILD.xml",
"LFN:/ilc/user/k/kacarevic/hgamgam/PandoraPFA/PandoraSettingsFast.xml",
"LFN:/ilc/user/k/kacarevic/hgamgam/PandoraPFA/MarlinRecoRootFiles/steering.xml",
"LFN:/ilc/user/k/kacarevic/hgamgam/PandoraPFA/clic_ild_cdr.gear",
"LFN:/ilc/user/k/kacarevic/hgamgam/PandoraPFA/MarlinRecoRootFiles/lib.tar.gz"
])
job.setInputData(
"LFN:/ilc/user/k/kacarevic/hgamgam/Marlin/newPandora/aa/aa_%d.slcio" %
i)
job.setOutputSandbox(
["*.log", "*.sh", "*.py", "*.out", "*.xml", "*.steer "])
job.setJobGroup("myRoot")
job.setName("root_aa_%d" % i)
marl = Marlin()
marl.setVersion('ILCSoft-2016-09-27_gcc48')
marl.setInputFile([
"LFN:/ilc/user/k/kacarevic/hgamgam/Marlin/newPandora/aa/aa_%d.slcio" %
i
])
# marl.setNumberOfEvents(10)
marl.setSteeringFile("steering.xml")
marl.setGearFile("clic_ild_cdr.gear")
marl.setExtraCLIArguments("--MyProcessor.RootFilename=%s" % lcoutput)
MRGoutput = []
# outputs to be saved onto grid SE
outpath="MyProd_" + ILDConfigVer + "/E250-TDR_ws/" + chann + "/" +ireq+ "/mrg"
jobname="m" + idin + "_" + str(mrgix1)
print jobname
job = UserJob()
job.setName(jobname)
job.setJobGroup(jobGrName)
job.setILDConfig(ILDConfigVer)
job.setCPUTime(6400)
job.setInputSandbox(["runDSTmerge_Tmp.py"])
job.setOutputSandbox( ["*.log","*.sh","*.py"] )
job.setInputData(mergeList)
#job.setInputData(mergeList[0])
#job.setOutputData( lcoutputMRG, outpath, "CERN-SRM" )
job.setOutputData( lcoutputMRG, outpath, "IN2P3-SRM" )
job.dontPromptMe()
slcioconcat = SLCIOConcatenate()
slcioconcat.setInputFile(mergeList)
#slcioconcat.setInputFile(mergeList[0])
slcioconcat.setNumberOfEvents(evtsPerMrg)
slcioconcat.setOutputFile( lcoutputMRG, outpath)
slcioconcat.setLogFile("merge.log")
mergejob = job.append(slcioconcat)
if not mergejob['OK']:
print mergejob['Not ok appending slcioconcat to job']
from ILCDIRAC.Interfaces.API.NewInterface.UserJob import UserJob
from ILCDIRAC.Interfaces.API.NewInterface.Applications import GenericApplication
from ILCDIRAC.Interfaces.API.DiracILC import DiracILC
datadir = "/ilc/prod/ilc/mc-opt-3/ild/dst-merged/500-TDR_ws/higgs_ffh/ILD_l5_o1_v02/v02-00-01/"
filepref = "rv02-00-01.sv02-00-01.mILD_l5_o1_v02.E500-TDR_ws.I106523.Pnnh.eL.pR.n001.d_dstm_10763_"
indata = [datadir + filepref + "0.slcio", datadir + filepref + "1.slcio"]
d = DiracILC(True, "repo.rep")
################################################
j = UserJob()
j.setJobGroup("Tutorial")
j.setName("GenericExec")
j.setInputSandbox(["mypre.sh", "myanal.sh"])
j.setInputData(indata)
j._setSoftwareTags(["marlin.ILCSoft-02-00-02_gcc49"])
# j._setSoftwareTags(["lcio.ILCSoft-02-00-01_gcc49"])
j.setILDConfig("v02-00-02")
################################################
appre = GenericApplication()
appre.setScript("mypre.sh")
appre.setArguments("This is input arguments")
res = j.append(appre)
if not res['OK']:
print res['Message']
exit(1)
################################################
appost = GenericApplication()
def main():
# Take the input arguments from the argument parser, and check they exist...
args = parse_args()
if not args:
print 'Invalid Arguments'
sys.exit(1)
#### Software Versions ####
softVersions = ["v3r0p3", "HEAD", "ILC_DBD", "0116"] # Working (recommended)
# softVersions = ["v3r0p3", "2.5", "ILC_DBD", "0116"] # Working
# softVersions = ["v3r0p3", "HEAD", "ILC_DBD", "ILCSoft-01-17-07"] # Working
# Check the --runs and --split arguments to make sure they are compatible, if not exit...
if not check_events_arguments(args.events, args.split):
sys.exit(1)
# Check the input LFN given by user, it needs to have .stdhep extension and should not have LFN: at the beginning...
lfn_check, lfn = check_input_LFN(args.stdhepInput)
if not lfn_check:
sys.exit(1)
# Call when you begin ILC-DIRAC jobs, the true indicates a repository file is included...
dirac = DiracILC(True, setup_repository_name(args.stdhepInput, args.detector))
# Prepares the input and output sandboxes, if -f, then adds the files required for flavortagging,
# into the input sandbox
inputSandbox, outputSandbox = setup_sandboxes(args.macFile, args.flavortag)
# Prepares values for the job loop...
if args.split < 0:
nInputEvents = int(args.events)
nOutputEvents = int(args.events)
if args.split > 0:
nInputEvents = int(args.events)
nOutputEvents = int(args.split)
# Loop that runs through the required number of jobs to be executed...
for startEvent in range(0, nInputEvents, nOutputEvents):
################## Job Initialise ########################################
job = UserJob()
job.setName(path.basename(args.stdhepInput))
job.setJobGroup('JobGroup')
job.setInputSandbox(inputSandbox)
fileNumber = startEvent/nOutputEvents
print "Job ", fileNumber
outputFiles = setup_output_dict(args.stdhepInput, args.detector, fileNumber, args.outputPath, softVersions)
slicOutput=outputFiles['slicOutput']
prePandoraOutput=outputFiles['prePandoraOutput']
pandoraOutput=outputFiles['pandoraOutput']
vertexingOutput=outputFiles['vertexingOutput']
lcsimRecOutput=outputFiles['lcsimRecOutput']
lcsimDstOutput=outputFiles['lcsimDstOutput']
flavortagOutput=outputFiles['flavortagOutput']
diracOutput=outputFiles['diracOutput']
################## SLIC ##################################################
slic = SLIC()
slic.setVersion(softVersions[0])
slic.setSteeringFile(args.macFile)
# slic.setInputFile(lfn)
slic.setOutputFile(slicOutput)
slic.setDetectorModel(args.detector)
slic.setNumberOfEvents(nOutputEvents)
slic.setStartFrom(startEvent)
#print slic.listAttributes()
result = job.append(slic)
if not result['OK']:
print result['Message']
sys.exit(2)
################## lcsim (digitization and tracking) #####################
lcsim = LCSIM()
lcsim.setVersion(softVersions[1])
lcsim.setSteeringFile('steeringFiles/sid_dbd_prePandora_noOverlay_v22.xml') # Another version is included in /steeringFiles
lcsim.getInputFromApp(slic)
lcsim.setTrackingStrategy('steeringFiles/sidloi3_trackingStrategies_default.xml')
# lcsim.setAliasProperties('alias.properties')
lcsim.setDetectorModel('geometryFiles/sidloi3.zip')
lcsim.setOutputFile(prePandoraOutput)
lcsim.setNumberOfEvents(nOutputEvents)
#print lcsim.listAttributes()
result = job.append(lcsim)
if not result['OK']:
print result['Message']
sys.exit(2)
################## slicPandora ###########################################
slicPandora = SLICPandora()
slicPandora.setVersion(softVersions[2])
slicPandora.setDetectorModel(args.detector)
slicPandora.getInputFromApp(lcsim)
slicPandora.setOutputFile(pandoraOutput)
slicPandora.setPandoraSettings('pandoraSettings.xml')
slicPandora.setNumberOfEvents(nOutputEvents)
#print slicPandora.listAttributes()
result = job.append(slicPandora)
if not result['OK']:
print result['Message']
sys.exit(2)
################## Marlin, LCFIPlus Vertexing ############################
vertexing = Marlin()
vertexing.setVersion(softVersions[3])
vertexing.setSteeringFile('steeringFiles/sid_dbd_vertexing.xml')
vertexing.setGearFile('steeringFiles/sidloi3.gear')
vertexing.getInputFromApp(slicPandora)
vertexing.setOutputFile(vertexingOutput)
vertexing.setNumberOfEvents(nOutputEvents)
#print vertexing.listAttributes()
result = job.append(vertexing)
if not result['OK']:
print result['Message']
sys.exit(2)
################## lcsim (DST production) ################################
lcsimDst = LCSIM()
lcsimDst.setVersion(softVersions[1])
lcsimDst.setSteeringFile('steeringFiles/sid_dbd_postPandora.xml')
lcsimDst.getInputFromApp(vertexing)
lcsimDst.setNumberOfEvents(nOutputEvents)
# lcsimDst.setAliasProperties('alias.properties')
lcsimDst.setDetectorModel('geometryFiles/sidloi3.zip')
lcsimDst.setOutputRecFile(lcsimRecOutput)
lcsimDst.setOutputDstFile(lcsimDstOutput)
#print lcsimDst.listAttributes()
result = job.append(lcsimDst)
if not result['OK']:
print result['Message']
sys.exit(2)
################## Marlin, LCFIPlus flavortag ############################
if args.flavortag:
flavortag = Marlin()
flavortag.setVersion(softVersions[3])
flavortag.setSteeringFile('steeringFiles/sid_dbd_flavortag.xml')
flavortag.setGearFile('steeringFiles/sidloi3.gear')
flavortag.setInputFile(lcsimDstOutput)
flavortag.setOutputFile(flavortagOutput)
flavortag.setNumberOfEvents(nOutputEvents)
#print flavortag.listAttributes()
result = job.append(flavortag)
if not result['OK']:
print result['Message']
sys.exit(2)
################## Job Finalise ##########################################
# List of banned sites that the job shall not be sent too. These are sites that jobs tend to fail on,
# This list is likely to change.
job.setBannedSites(['LCG.IN2P3-CC.fr', 'LCG.RAL-LCG2.uk', 'LCG.DESY-HH.de', 'LCG.DESYZN.de', 'LCG.KEK.jp',
'OSG.PNNL.us',])
job.setCPUTime(50000)
job.setPlatform('x86_64-slc5-gcc43-opt')
# Sets the output data file according to if -f is selcted, ships ouput to your /ilc/user/a/aPerson/
# directory on the grid.
if args.flavortag:
job.setOutputData(flavortagOutput, diracOutput, args.SE)
else:
job.setOutputData(lcsimDstOutput, diracOutput, args.SE)
job.setOutputSandbox(outputSandbox)
job.setInputData(lfn)
if args.dontPromptMe:
job.dontPromptMe()
# Submits Job!!!
job.submit()
return 0;
def main():
# Take the input arguments from the argument parser, and check they exist...
args = parse_args()
if not args:
print 'Invalid Arguments'
sys.exit(1)
#### Software Versions ####
softVersions = ["v3r0p3", "HEAD", "ILC_DBD",
"0116"] # Working (recommended)
# softVersions = ["v3r0p3", "2.5", "ILC_DBD", "0116"] # Working
# softVersions = ["v3r0p3", "HEAD", "ILC_DBD", "ILCSoft-01-17-07"] # Working
# Check the --runs and --split arguments to make sure they are compatible, if not exit...
if not check_events_arguments(args.events, args.split):
sys.exit(1)
# Check the input LFN given by user, it needs to have .stdhep extension and should not have LFN: at the beginning...
lfn_check, lfn = check_input_LFN(args.stdhepInput)
if not lfn_check:
sys.exit(1)
# Call when you begin ILC-DIRAC jobs, the true indicates a repository file is included...
dirac = DiracILC(True,
setup_repository_name(args.stdhepInput, args.detector))
# Prepares the input and output sandboxes, if -f, then adds the files required for flavortagging,
# into the input sandbox
inputSandbox, outputSandbox = setup_sandboxes(args.macFile, args.flavortag)
# Prepares values for the job loop...
if args.split < 0:
nInputEvents = int(args.events)
nOutputEvents = int(args.events)
if args.split > 0:
nInputEvents = int(args.events)
nOutputEvents = int(args.split)
# Loop that runs through the required number of jobs to be executed...
for startEvent in range(0, nInputEvents, nOutputEvents):
################## Job Initialise ########################################
job = UserJob()
job.setName(path.basename(args.stdhepInput))
job.setJobGroup('JobGroup')
job.setInputSandbox(inputSandbox)
fileNumber = startEvent / nOutputEvents
print "Job ", fileNumber
outputFiles = setup_output_dict(args.stdhepInput, args.detector,
fileNumber, args.outputPath,
softVersions)
slicOutput = outputFiles['slicOutput']
prePandoraOutput = outputFiles['prePandoraOutput']
pandoraOutput = outputFiles['pandoraOutput']
vertexingOutput = outputFiles['vertexingOutput']
lcsimRecOutput = outputFiles['lcsimRecOutput']
lcsimDstOutput = outputFiles['lcsimDstOutput']
flavortagOutput = outputFiles['flavortagOutput']
diracOutput = outputFiles['diracOutput']
################## SLIC ##################################################
slic = SLIC()
slic.setVersion(softVersions[0])
slic.setSteeringFile(args.macFile)
# slic.setInputFile(lfn)
slic.setOutputFile(slicOutput)
slic.setDetectorModel(args.detector)
slic.setNumberOfEvents(nOutputEvents)
slic.setStartFrom(startEvent)
#print slic.listAttributes()
result = job.append(slic)
if not result['OK']:
print result['Message']
sys.exit(2)
################## lcsim (digitization and tracking) #####################
lcsim = LCSIM()
lcsim.setVersion(softVersions[1])
lcsim.setSteeringFile(
'steeringFiles/sid_dbd_prePandora_noOverlay_v22.xml'
) # Another version is included in /steeringFiles
lcsim.getInputFromApp(slic)
lcsim.setTrackingStrategy(
'steeringFiles/sidloi3_trackingStrategies_default.xml')
# lcsim.setAliasProperties('alias.properties')
lcsim.setDetectorModel('geometryFiles/sidloi3.zip')
lcsim.setOutputFile(prePandoraOutput)
lcsim.setNumberOfEvents(nOutputEvents)
#print lcsim.listAttributes()
result = job.append(lcsim)
if not result['OK']:
print result['Message']
sys.exit(2)
################## slicPandora ###########################################
slicPandora = SLICPandora()
slicPandora.setVersion(softVersions[2])
slicPandora.setDetectorModel(args.detector)
slicPandora.getInputFromApp(lcsim)
slicPandora.setOutputFile(pandoraOutput)
slicPandora.setPandoraSettings('pandoraSettings.xml')
slicPandora.setNumberOfEvents(nOutputEvents)
#print slicPandora.listAttributes()
result = job.append(slicPandora)
if not result['OK']:
print result['Message']
sys.exit(2)
################## Marlin, LCFIPlus Vertexing ############################
vertexing = Marlin()
vertexing.setVersion(softVersions[3])
vertexing.setSteeringFile('steeringFiles/sid_dbd_vertexing.xml')
vertexing.setGearFile('steeringFiles/sidloi3.gear')
vertexing.getInputFromApp(slicPandora)
vertexing.setOutputFile(vertexingOutput)
vertexing.setNumberOfEvents(nOutputEvents)
#print vertexing.listAttributes()
result = job.append(vertexing)
if not result['OK']:
print result['Message']
sys.exit(2)
################## lcsim (DST production) ################################
lcsimDst = LCSIM()
lcsimDst.setVersion(softVersions[1])
lcsimDst.setSteeringFile('steeringFiles/sid_dbd_postPandora.xml')
lcsimDst.getInputFromApp(vertexing)
lcsimDst.setNumberOfEvents(nOutputEvents)
# lcsimDst.setAliasProperties('alias.properties')
lcsimDst.setDetectorModel('geometryFiles/sidloi3.zip')
lcsimDst.setOutputRecFile(lcsimRecOutput)
lcsimDst.setOutputDstFile(lcsimDstOutput)
#print lcsimDst.listAttributes()
result = job.append(lcsimDst)
if not result['OK']:
print result['Message']
sys.exit(2)
################## Marlin, LCFIPlus flavortag ############################
if args.flavortag:
flavortag = Marlin()
flavortag.setVersion(softVersions[3])
flavortag.setSteeringFile('steeringFiles/sid_dbd_flavortag.xml')
flavortag.setGearFile('steeringFiles/sidloi3.gear')
flavortag.setInputFile(lcsimDstOutput)
flavortag.setOutputFile(flavortagOutput)
flavortag.setNumberOfEvents(nOutputEvents)
#print flavortag.listAttributes()
result = job.append(flavortag)
if not result['OK']:
print result['Message']
sys.exit(2)
################## Job Finalise ##########################################
# List of banned sites that the job shall not be sent too. These are sites that jobs tend to fail on,
# This list is likely to change.
job.setBannedSites([
'LCG.IN2P3-CC.fr',
'LCG.RAL-LCG2.uk',
'LCG.DESY-HH.de',
'LCG.DESYZN.de',
'LCG.KEK.jp',
'OSG.PNNL.us',
])
job.setCPUTime(50000)
job.setPlatform('x86_64-slc5-gcc43-opt')
# Sets the output data file according to if -f is selcted, ships ouput to your /ilc/user/a/aPerson/
# directory on the grid.
if args.flavortag:
job.setOutputData(flavortagOutput, diracOutput, args.SE)
else:
job.setOutputData(lcsimDstOutput, diracOutput, args.SE)
job.setOutputSandbox(outputSandbox)
job.setInputData(lfn)
if args.dontPromptMe:
job.dontPromptMe()
# Submits Job!!!
job.submit()
return 0
class UserJobTestCase(unittest.TestCase):
"""Base class for the UserJob test cases."""
def setUp(self):
"""Set up the objects."""
self.log_mock = Mock(name="SubMock")
with patch('%s.getProxyInfo' % MODULE_NAME, new=Mock(return_value=None)):
self.ujo = UserJob()
def test_submit_noproxy( self ):
self.ujo.proxyinfo = S_ERROR()
assertDiracFailsWith( self.ujo.submit(),
"Not allowed to submit a job, you need a ['ilc_user', 'calice_user'] proxy", self )
def test_submit_wrongproxygroup( self ):
self.ujo.proxyinfo = S_OK( { 'group' : 'my_test_group.notInallowed_list' } )
assertDiracFailsWith( self.ujo.submit(),
"Not allowed to submit job, you need a ['ilc_user', 'calice_user'] proxy", self )
def test_submit_noproxygroup( self ):
self.ujo.proxyinfo = S_OK( { 'some_key' : 'Value', True : 1, False : [], 135 : {} } )
assertDiracFailsWith( self.ujo.submit(), 'Could not determine group, you do not have the right proxy', self )
def test_submit_addtoworkflow_fails( self ):
self.ujo.proxyinfo = S_OK( { 'group' : 'ilc_user' } )
with patch('%s.UserJob._addToWorkflow' % MODULE_NAME, new=Mock(return_value=S_ERROR('workflow_testadd_error'))):
assertDiracFailsWith( self.ujo.submit(), 'workflow_testadd_error', self )
def test_submit_addtoworkflow_fails_2( self ):
self.ujo.proxyinfo = S_OK( { 'group' : 'calice_user' } )
with patch('%s.UserJob._addToWorkflow' % MODULE_NAME, new=Mock(return_value=S_ERROR('err_workflow_testadd'))):
assertDiracFailsWith( self.ujo.submit(), 'err_workflow_testadd', self )
def test_submit_createnew_dirac_instance( self ):
ilc_mock = Mock()
ilc_mock().submitJob.return_value = S_OK('test_submission_successful')
self.ujo.proxyinfo = S_OK( { 'group' : 'ilc_user' } )
with patch('%s.UserJob._addToWorkflow' % MODULE_NAME, new=Mock(return_value=S_OK())), \
patch('%s.DiracILC' % MODULE_NAME, new=ilc_mock):
assertDiracSucceedsWith_equals( self.ujo.submit(), 'test_submission_successful', self )
ilc_mock().submitJob.assert_called_once_with(self.ujo, 'wms')
assert self.ujo.oktosubmit
def test_submit_existing_dirac_instance(self):
"""Test submit with dirac instance."""
ilc_mock = Mock()
ilc_mock.submitJob.return_value = S_OK('test_submission_successful')
self.ujo.proxyinfo = S_OK({'group': 'ilc_user'})
with patch('%s.UserJob._addToWorkflow' % MODULE_NAME, new=Mock(return_value=S_OK())):
assertDiracSucceedsWith_equals(self.ujo.submit(diracinstance=ilc_mock), 'test_submission_successful', self)
ilc_mock.submitJob.assert_called_once_with(self.ujo, 'wms')
assert self.ujo.oktosubmit
def test_setinputdata_failed( self ):
assertDiracFailsWith( self.ujo.setInputData( { '/mylfn1' : True, '/mylfn2' : False } ),
'expected lfn string or list of lfns for input data', self )
def test_setinputdata(self):
"""Test setting input data."""
assertDiracSucceeds(self.ujo.setInputData(['LFN:/mylfn1', 'LFN:/mylfn2']), self)
self.assertEqual(self.ujo.workflow.parameters.find('InputData').getValue(), '/mylfn1;/mylfn2')
assertDiracSucceeds(self.ujo.setInputData('/mylfn1'), self)
self.assertEqual(self.ujo.workflow.parameters.find('InputData').getValue(), '/mylfn1')
def test_inputsandbox( self ):
self.ujo.inputsandbox = Mock()
assertDiracSucceeds( self.ujo.setInputSandbox( 'LFN:/ilc/user/u/username/libraries.tar.gz' ), self )
self.ujo.inputsandbox.extend.assert_called_once_with( [ 'LFN:/ilc/user/u/username/libraries.tar.gz' ] )
def test_inputsandbox_dictpassed( self ):
assertDiracFailsWith( self.ujo.setInputSandbox( { '/some/file' : True, '/my/dict' : True } ),
'File passed must be either single file or list of files', self )
def test_setOutputData(self):
"""Test setting output data."""
assertDiracSucceeds(self.ujo.setOutputData(['/myFile1', '/myFile2']), self)
self.assertEqual(self.ujo.workflow.parameters.find('UserOutputData').getValue(), '/myFile1;/myFile2')
assertDiracSucceeds(self.ujo.setOutputData('/myFile2'), self)
self.assertEqual(self.ujo.workflow.parameters.find('UserOutputData').getValue(), '/myFile2')
assertDiracSucceeds(self.ujo.setOutputData('/myFile2', OutputSE="MY-SE"), self)
self.assertEqual(self.ujo.workflow.parameters.find('UserOutputData').getValue(), '/myFile2')
self.assertEqual(self.ujo.workflow.parameters.find('UserOutputSE').getValue(), 'MY-SE')
assertDiracSucceeds(self.ujo.setOutputData('/myFile2', OutputSE=["MY-SE", 'YOUR-SE']), self)
self.assertEqual(self.ujo.workflow.parameters.find('UserOutputData').getValue(), '/myFile2')
self.assertEqual(self.ujo.workflow.parameters.find('UserOutputSE').getValue(), 'MY-SE;YOUR-SE')
def test_setoutputdata_dictpassed( self ):
assertDiracFailsWith( self.ujo.setOutputData( { '/mydict' : True } ),
'Expected file name string or list of file names for output data', self )
def test_setoutputdata_nolistse( self ):
wf_mock = Mock()
self.ujo.workflow = wf_mock
with patch('%s.UserJob._addParameter' % MODULE_NAME, new=Mock()) as addparam_mock:
assertDiracFailsWith(self.ujo.setOutputData(['mylfn1', 'other_lfn', 'last___lfn'],
OutputSE={'mydict': True}),
'Expected string or list for OutputSE', self)
addparam_mock.assert_called_once_with(wf_mock, 'UserOutputData', 'JDL',
'mylfn1;other_lfn;last___lfn', 'List of output data files')
def test_setoutputdata_outputpath_nostring( self ):
wf_mock = Mock()
self.ujo.workflow = wf_mock
with patch('%s.UserJob._addParameter' % MODULE_NAME, new=Mock()) as addparam_mock:
assertDiracFailsWith( self.ujo.setOutputData( [ 'mylfn1', 'other_lfn', 'last___lfn' ],
OutputPath = { 'mydict' : True } ),
'Expected string for OutputPath', self )
addparam_mock.assert_called_once_with( wf_mock, 'UserOutputData', 'JDL',
'mylfn1;other_lfn;last___lfn', 'List of output data files' )
def test_setoutputdata_invalid_outputpath_1( self ):
wf_mock = Mock()
self.ujo.workflow = wf_mock
with patch('%s.UserJob._addParameter' % MODULE_NAME, new=Mock()) as addparam_mock:
assertDiracFailsWith( self.ujo.setOutputData( [ 'mylfn1', 'other_lfn', 'last___lfn' ],
OutputPath = '//ilc/user/somedir/output.xml' ),
'Output path contains /ilc/user/ which is not what you want', self )
addparam_mock.assert_called_once_with( wf_mock, 'UserOutputData', 'JDL',
'mylfn1;other_lfn;last___lfn', 'List of output data files' )
def test_setoutputdata_invalid_outputpath_2( self ):
wf_mock = Mock()
self.ujo.workflow = wf_mock
with patch('%s.UserJob._addParameter' % MODULE_NAME, new=Mock()) as addparam_mock:
assertDiracFailsWith( self.ujo.setOutputData( [ 'mylfn1', 'other_lfn', 'last___lfn' ],
OutputPath = '//some/dir/ilc/user/somedir/output.xml' ),
'Output path contains /ilc/user/ which is not what you want', self )
addparam_mock.assert_called_once_with( wf_mock, 'UserOutputData', 'JDL',
'mylfn1;other_lfn;last___lfn', 'List of output data files' )
def test_setoutputdata( self ):
wf_mock = Mock()
self.ujo.workflow = wf_mock
with patch('%s.UserJob._addParameter' % MODULE_NAME, new=Mock()) as addparam_mock:
assertDiracSucceeds( self.ujo.setOutputData( [ 'mylfn1', 'other_lfn', 'last___lfn' ], OutputPath =
'//some/dir/somedir/output.xml' ), self )
assertMockCalls( addparam_mock, [
( wf_mock, 'UserOutputData', 'JDL', 'mylfn1;other_lfn;last___lfn', 'List of output data files' ),
( wf_mock, 'UserOutputPath', 'JDL', 'some/dir/somedir/output.xml', 'User specified Output Path' ) ],
self )
def test_setoutputsandbox( self ):
wf_mock = Mock()
self.ujo.workflow = wf_mock
with patch('%s.UserJob._addParameter' % MODULE_NAME, new=Mock()) as addparam_mock:
assertDiracSucceeds( self.ujo.setOutputSandbox( '/my/dir/myfile.txt' ), self )
addparam_mock.assert_called_once_with( wf_mock, 'OutputSandbox', 'JDL',
'/my/dir/myfile.txt', 'Output sandbox file' )
def test_setoutputsandbox_successes(self):
"""Test setting output sandbox."""
assertDiracSucceeds(self.ujo.setOutputSandbox(['myfile.txt', 'myfile.doc']), self)
self.assertEqual(self.ujo.workflow.parameters.find('OutputSandbox').getValue(), 'myfile.txt;myfile.doc')
def test_setoutputsandbox_dictpassed( self ):
wf_mock = Mock()
self.ujo.workflow = wf_mock
with patch('%s.UserJob._addParameter' % MODULE_NAME, new=Mock()) as addparam_mock:
assertDiracFailsWith( self.ujo.setOutputSandbox( { 'mydict' : True } ),
'Expected file string or list of files for output sandbox contents', self )
self.assertFalse( addparam_mock.called )
def test_configs(self):
"""Test setting different config packages."""
assertDiracSucceeds(self.ujo.setILDConfig('123.4'), self)
self.assertEqual(self.ujo.workflow.parameters.find('ILDConfigPackage').getValue(), 'ILDConfig123.4')
assertDiracSucceeds(self.ujo.setCLICConfig('567.8'), self)
self.assertEqual(self.ujo.workflow.parameters.find('ClicConfigPackage').getValue(), 'ClicConfig567.8')
self.assertIn('ildconfig', self.ujo.workflow.parameters.find('SoftwarePackages').getValue())
self.assertIn('clicconfig', self.ujo.workflow.parameters.find('SoftwarePackages').getValue())
def test_submit_split(self):
"""Test submitting with automatic splitting."""
self.ujo._splittingOption = True
self.ujo._split = Mock(return_value=S_OK())
self.ujo.proxyinfo = S_OK({'group': 'ilc_user'})
ilc_mock = Mock()
ilc_mock.submitJob.return_value = S_OK('test_submission_successful')
assertDiracSucceeds(self.ujo.submit(diracinstance=ilc_mock), self)
ilc_mock.submitJob.assert_called_once_with(self.ujo, 'wms')
self.ujo._splittingOption = True
self.ujo._split = Mock(return_value=S_ERROR("Splitting InValid"))
assertDiracFailsWith(self.ujo.submit(), "Splitting InValid", self)
@patch("%s._checkSplitConsistency" % MIXIN_CLASS, new=Mock(return_value=S_OK()))
def test_split_bydata(self):
"""Test splitting by data."""
self.ujo._eventsPerJob = "1"
self.ujo._numberOfJobs = "1"
self.ujo._splittingOption = "byData"
self.ujo._switch['byData'] = Mock(return_value=[("InputData", ["/ilc/user/u/username/data1"], True)])
with patch("%s.UserJob.setParameterSequence" % MODULE_NAME) as mock_parametric, \
patch('%s.LOG' % MIXIN_MODULE, new=self.log_mock):
info_message = "Job splitting successful"
assertDiracSucceeds(self.ujo._split(), self)
self.log_mock.notice.assert_called_with(info_message)
mock_parametric.assert_any_call("InputData", ["/ilc/user/u/username/data1"], True)
@patch("%s.toInt" % MIXIN_MODULE, new=Mock(return_value=1))
@patch("%s.UserJob._checkSplitConsistency" % MODULE_NAME, new=Mock(return_value=S_OK()))
def test_split_byevents(self):
"""Test splitting by events."""
self.ujo._splittingOption = "byEvents"
self.ujo._switch['byEvents'] = Mock(return_value=[('NumberOfEvents', [1, 2], 'NbOfEvts')])
with patch("%s.UserJob.setParameterSequence" % MODULE_NAME) as mock_parametric, \
patch('%s.LOG' % MIXIN_MODULE, new=self.log_mock):
info_message = "Job splitting successful"
assertDiracSucceeds(self.ujo._split(), self)
self.log_mock.notice.assert_called_with(info_message)
mock_parametric.assert_any_call('NumberOfEvents', [1, 2], 'NbOfEvts')
@patch("%s.toInt" % MIXIN_MODULE, new=Mock(return_value=1))
@patch("%s.UserJob._checkSplitConsistency" % MODULE_NAME, new=Mock(return_value=S_OK()))
def test_split_atomicsubmission(self):
"""Test splitting atomic."""
self.ujo._splittingOption = None
info_message = "Job splitting successful"
with patch('%s.LOG' % MIXIN_MODULE, new=self.log_mock):
assertDiracSucceeds(self.ujo._split(), self)
self.log_mock.notice.assert_called_with(info_message)
@patch("%s.toInt" % MIXIN_MODULE, new=Mock(return_value=False))
def test_split_inputparameters_failed(self):
"""Test splitting input parameters with failure."""
assertDiracFailsWith( self.ujo._split(), "Splitting: Invalid values for splitting", self )
@patch("%s.toInt" % MIXIN_MODULE, new=Mock(return_value=1))
@patch("%s._checkSplitConsistency" % MIXIN_CLASS, new=Mock(return_value=S_ERROR('failed')))
def test_split_checkSplitConsistency_failed(self):
"""Test splitting check consistency with failure."""
assertDiracFailsWith(self.ujo._split(), 'failed', self)
@patch("%s.toInt" % MIXIN_MODULE, new=Mock(return_value=1))
@patch("%s._checkSplitConsistency" % MIXIN_CLASS, new=Mock(return_value=S_OK()))
def test_split_sequencer_fails(self):
"""Test splitting when the sequencer fails."""
self.ujo._splittingOption = "bySequence"
self.ujo._switch['bySequence'] = Mock(return_value=[])
self.ujo.setParameterSequence = Mock()
self.ujo._split()
self.ujo.setParameterSequence.assert_not_called()
def test_checkSplitconsistency(self):
"""Test splitting consistency check."""
app1 = Fcc()
app2 = Fcc()
self.ujo.applicationlist = [app1, app2]
self.ujo._switch = {"byEvents": lambda x: x}
self.ujo._splittingOption = "byEvents"
self.assertTrue(self.ujo._checkSplitConsistency())
def test_checkjobconsistency_bad_split_parameter(self):
"""Test splitting consistency check with bad split parameters."""
app1 = Fcc()
app2 = Fcc()
self.ujo.applicationlist = [app1, app2]
self.ujo._switch = {"byEvents": lambda x: x }
self.ujo._splittingOption = "byHand"
self.assertFalse(self.ujo._checkSplitConsistency()['OK'])
self.assertIn('_checkSplitConsistency', self.ujo.errorDict)
def test_checkjobconsistency_no_same_events( self ):
app1 = Fcc()
app2 = Fcc()
app1.numberOfEvents = 1
app2.numberOfEvents = 2
self.ujo.applicationlist = [app1, app2]
self.ujo._switch = {"byEvents": lambda x: x }
self.ujo._splittingOption = "byEvents"
with patch('%s.LOG' % MIXIN_MODULE, new=self.log_mock):
resCheck = self.ujo._checkSplitConsistency()
self.assertFalse(resCheck['OK'])
self.assertIn("have the same number", resCheck['Message'])
def test_checkjobconsistency_negative_events( self ):
app1 = Fcc()
app2 = Fcc()
app1.numberOfEvents = app2.numberOfEvents = -1
self.ujo.applicationlist = [app1, app2]
self.ujo._switch = ["byEvents"]
self.ujo._splittingOption = "byEvents"
self.assertTrue(self.ujo._checkSplitConsistency())
def test_splitbydata( self ):
self.ujo._data = ['data1', 'data2']
app1 = Fcc()
app2 = Fcc()
self.ujo.applicationlist = [app1, app2]
assertEqualsImproved(self.ujo._splitByData(), [("InputData", [['data1'], ['data2']], 'ParametricInputData')], self)
def test_splitbydata_no_data(self):
"""Test splitting without data."""
self.ujo._data = None
self.assertFalse(self.ujo._splitByData())
self.assertIn('_splitByData', self.ujo.errorDict)
def test_splitbydata_incorrectparameter(self):
"""Test splitting with data."""
self.ujo._data = ["/path/to/data1","/path/to/data2"]
self.ujo._numberOfFilesPerJob = 3
self.assertFalse(self.ujo._splitByData())
self.assertIn('_splitByData', self.ujo.errorDict)
def test_splitbyevents_1st_case(self):
"""Test splitting by events."""
app1 = Fcc()
app2 = Fcc()
self.ujo.applicationlist = [app1, app2]
self.ujo._eventsPerJob = 2
self.ujo._numberOfJobs = 3
map_event_job = [2, 2, 2]
assertEqualsImproved(self.ujo._splitByEvents(), [('NumberOfEvents', map_event_job, 'NbOfEvts')], self)
def test_splitbyevents_2nd_case( self ):
app1 = Fcc()
app2 = Fcc()
self.ujo.applicationlist = [app1, app2]
self.ujo._eventsPerJob = 3
self.ujo._totalNumberOfEvents = 5
map_event_job = [3, 2]
assertEqualsImproved(self.ujo._splitByEvents(), [('NumberOfEvents', map_event_job, 'NbOfEvts')], self)
def test_splitbyevents_2nd_case_failed( self ):
app1 = Fcc()
app2 = Fcc()
self.ujo.applicationlist = [app1, app2]
self.ujo._eventsPerJob = 3
self.ujo._totalNumberOfEvents = 2
self.assertFalse(self.ujo._splitByEvents())
def test_splitbyevents_3rd_case(self):
"""Test splitting by events case 3."""
app1 = Fcc()
app2 = Fcc()
self.ujo.applicationlist = [app1, app2]
self.ujo._numberOfJobs = 2
self.ujo._totalNumberOfEvents = 2
map_event_job = [1, 1]
assertEqualsImproved(self.ujo._splitByEvents(), [('NumberOfEvents', map_event_job, 'NbOfEvts')], self)
self.ujo._numberOfJobs = 3
self.ujo._totalNumberOfEvents = 5
map_event_job = [2, 2, 1]
assertEqualsImproved(self.ujo._splitByEvents(), [('NumberOfEvents', map_event_job, 'NbOfEvts')], self)
def test_splitbyevents_3rd_case_failed(self):
"""Test splitting by events case 3 fails."""
app1 = Fcc()
app2 = Fcc()
self.ujo.applicationlist = [app1, app2]
self.ujo._numberOfJobs = 2
self.ujo._totalNumberOfEvents = None
self.assertFalse(self.ujo._splitByEvents())
def test_setsplitevents(self):
"""Test splitting set split events."""
self.ujo.setSplitEvents(42, 42, 126)
assertEqualsImproved(self.ujo._totalNumberOfEvents, 126, self)
assertEqualsImproved(self.ujo._eventsPerJob, 42, self)
assertEqualsImproved(self.ujo._numberOfJobs, 42, self)
assertEqualsImproved(self.ujo._splittingOption, "byEvents", self)
def test_setsplitInputdata(self):
"""Test set split input data."""
input_data = ["/path/to/data1", "/path/to/data2"]
self.ujo.setSplitInputData(input_data)
for data in input_data:
self.assertIn(data, self.ujo._data)
assertEqualsImproved(self.ujo._splittingOption, "byData", self)
def test_setSplitFiles(self):
"""Test set split files over jobs."""
self.ujo.setSplitFilesAcrossJobs('myLFN', 20, 20)
self.assertEqual(self.ujo._data, ['myLFN'])
self.assertEqual(self.ujo._eventsPerFile, 20)
self.assertEqual(self.ujo._eventsPerJob, 20)
def test_splitBySkip(self):
"""Test set split with skip."""
self.ujo._eventsPerFile = 13
self.ujo._eventsPerJob = 5
self.ujo._data = ['lfn_%d' % d for d in [1, 2]]
result = self.ujo._splitBySkip()
self.assertEqual([('InputData', ['lfn_1', 'lfn_1', 'lfn_1', 'lfn_2', 'lfn_2', 'lfn_2'], 'InputData'),
('startFrom', [0, 5, 10, 0, 5, 10], 'startFrom'),
('NumberOfEvents', [5, 5, 3, 5, 5, 3], 'NbOfEvts')],
result)
self.ujo._eventsPerFile = 15
self.ujo._eventsPerJob = 5
self.ujo._data = ['lfn_%d' % d for d in [1, 2]]
result = self.ujo._splitBySkip()
self.assertEqual([('InputData', ['lfn_1', 'lfn_1', 'lfn_1', 'lfn_2', 'lfn_2', 'lfn_2'], 'InputData'),
('startFrom', [0, 5, 10, 0, 5, 10], 'startFrom'),
('NumberOfEvents', [5, 5, 5, 5, 5, 5], 'NbOfEvts')],
result)
def test_setSplittingStartIndex(self):
"""Test setting start index."""
res = self.ujo.setSplittingStartIndex(111)
self.assertTrue(res['OK'])
self.assertEqual(self.ujo._startJobIndex, 111)
self.ujo._startJobIndex = 0
res = self.ujo.setSplittingStartIndex(-111)
self.assertFalse(res['OK'])
self.assertIn('setSplittingStartIndex', self.ujo.errorDict)
self.assertEqual(self.ujo._startJobIndex, 0)
def test_doNotAlter(self):
"""Test setting not altering the output."""
self.ujo.setSplitDoNotAlterOutputFilename()
self.assertIsNotNone(self.ujo.workflow.parameters.find('DoNotAlterOutputData'))
self.assertEqual(self.ujo.workflow.parameters.find('DoNotAlterOutputData').getValue(), "True")
self.ujo.setSplitDoNotAlterOutputFilename(False)
self.assertIsNotNone(self.ujo.workflow.parameters.find('DoNotAlterOutputData'))
self.assertEqual(self.ujo.workflow.parameters.find('DoNotAlterOutputData').getValue(), "False")
def test_setSplitJobIndexList(self):
"""Test the setSplitJobIndexList function."""
res = self.ujo.setSplitJobIndexList(range(0, 7, 3))
self.assertTrue(res['OK'])
self.assertEqual([0, 3, 6], self.ujo._jobIndexList)
res = self.ujo.setSplitJobIndexList(set(range(1, 7, 3)))
self.assertFalse(res['OK'])
self.assertIn('Invalid argument type', res['Message'])
self.assertEqual([0, 3, 6], self.ujo._jobIndexList)
def main():
# Take the input arguments from the argument parser, and check they exist...
args = parse_args()
if not args:
print 'Invalid Arguments'
sys.exit(1)
print args.chain[0]
# softVersions = ["v3r0p3", "3.0-SNAPSHOT", "ILC_DBD", "0116"]
softVersions = ["v3r0p3", "HEAD", "ILC_DBD", "0116"] # Working (recommended)
# softVersions = ["v3r0p3", "2.5", "ILC_DBD", "0116"] # Working
# softVersions = ["v3r0p3", "HEAD", "ILC_DBD", "ILCSoft-01-17-07"] # Working
# softVersions = ["v3r0p3", "HEAD", "ILCSoft-01-17-08", "0116"]
check_events_arguments(args.events, args.split)
detector = args.detector
alias_properties(detector)
outputPath, outputBase, repoName = input_output(args.Input, detector, args.chain, args.digiSteering)
inputSandbox, outputSandbox = setup_sandboxes(args.macFile)
dirac = DiracILC(True, repoName)
# Prepares values for the job loop...
if args.split < 0:
nInputEvents = int(args.events)
nOutputEvents = int(args.events)
if args.split > 0:
nInputEvents = int(args.events)
nOutputEvents = int(args.split)
# Loop that runs through the required number of jobs to be executed...
for startEvent in range(0, nInputEvents, nOutputEvents):
################## Job Initialise ########################################
job = UserJob()
job.setName(outputBase)
job.setJobGroup('JobGroup')
job.setInputSandbox(inputSandbox)
fileNumber = startEvent/nOutputEvents
print "Job ---> ", fileNumber
################## SLIC ##################################################
if 1 in args.chain:
slic = SLIC()
slic.setVersion(softVersions[0])
slic.setSteeringFile(args.macFile)
# slic.setInputFile(lfn)
slic.setOutputFile(outputBase.replace('.slcio', '_' + str(fileNumber) + '_sim.slcio'))
slic.setDetectorModel(detector)
slic.setNumberOfEvents(nOutputEvents)
slic.setStartFrom(startEvent)
#print slic.listAttributes()
result = job.append(slic)
if not result['OK']:
print result['Message']
sys.exit(2)
################## Overlay ###############################################
if 2 in args.chain:
'''
#Add the gghad background overlay.
gghad = OverlayInput()
#gghad.setProdID(1767)
gghad.setEnergy(500.0)
gghad.setBXOverlay('args.bunches')
gghad.setGGToHadInt( 4.1 )
gghad.setNbSigEvtsPerJob(nOutputEvents)
gghad.setMachine('ilc_dbd')
gghad.setDetectorModel('sidloi3')
gghad.setBkgEvtType('aa_lowpt')
result = job.append( gghad )
if not result['OK']:
print result['Message']
sys.exit(2)
#Add the pair background overlay.
pairs = OverlayInput()
pairs.setProdID(2)
pairs.setEnergy(500.0)
pairs.setBXOverlay('args.bunches')
pairs.setGGToHadInt(1.)
pairs.setNbSigEvtsPerJob(nOutputEvents)
pairs.setMachine('ilc_dbd')
pairs.setDetectorModel('sidloi3')
pairs.setBkgEvtType('eepairs')
result = job.append( pairs )
if not result['OK']:
print result['Message']
sys.exit(2)
'''
gghad = OverlayInput()
gghad.setPathToFiles('/ilc/user/j/jstrube/gghadron_lowpt/sidloi3/')
gghad.setBXOverlay(int(args.bunches))
gghad.setGGToHadInt( 4.1 )
gghad.setNbSigEvtsPerJob(nOutputEvents)
gghad.setBkgEvtType('aa_lowpt')
result = job.append( gghad )
if not result['OK']:
print result['Message']
sys.exit(2)
'''
pairs = OverlayInput()
pairs.setPathToFiles('/ilc/user/j/jstrube/GuineaPig/sidloi3/')
pairs.setBXOverlay(int(args.bunches))
pairs.setGGToHadInt(1.)
pairs.setBkgEvtType('eepairs')
pairs.setNbSigEvtsPerJob(nOutputEvents)
result = job.append( pairs )
if not result['OK']:
print result['Message']
sys.exit(2)
'''
################## lcsim (digitization and tracking) #####################
if 3 in args.chain:
lcsim = LCSIM()
lcsim.setVersion(softVersions[1])
lcsim.setSteeringFile(args.digiSteering) # Another version is included in /steeringFiles
if 1 in args.chain:
lcsim.getInputFromApp(slic)
lcsim.setTrackingStrategy('steeringFiles/sidloi3_trackingStrategies_default.xml')
lcsim.setAliasProperties('steeringFiles/alias.properties')
lcsim.setDetectorModel(detector+".zip")
#lcsim.setOutputFile(outputBase.replace('.slcio', '_' + str(fileNumber) + '_digiTracking.slcio'))
lcsim.setOutputDstFile(outputBase.replace('.slcio', '_' + str(fileNumber) + '_DST.slcio')) #NEED TO CHANGE!!!
lcsim.setNumberOfEvents(nOutputEvents)
#print lcsim.listAttributes()
result = job.append(lcsim)
if not result['OK']:
print result['Message']
sys.exit(2)
################## slicPandora ###########################################
if 4 in args.chain:
slicPandora = SLICPandora()
slicPandora.setVersion(softVersions[2])
slicPandora.setDetectorModel(detector)
slicPandora.getInputFromApp(lcsim)
slicPandora.setOutputFile(outputBase.replace('.slcio', '_' + str(fileNumber) + '_pandora.slcio'))
slicPandora.setPandoraSettings('pandoraSettings.xml')
slicPandora.setNumberOfEvents(nOutputEvents)
#print slicPandora.listAttributes()
result = job.append(slicPandora)
if not result['OK']:
print result['Message']
sys.exit(2)
################## Marlin, LCFIPlus Vertexing ############################
if 5 in args.chain:
vertexing = Marlin()
vertexing.setVersion(softVersions[3])
vertexing.setSteeringFile('steeringFiles/sid_dbd_vertexing.xml')
vertexing.setGearFile('steeringFiles/' + detector + '.gear')
vertexing.getInputFromApp(slicPandora)
vertexing.setOutputFile(outputBase.replace('.slcio', '_' + str(fileNumber) + '_vertexing.slcio'))
vertexing.setNumberOfEvents(nOutputEvents)
#print vertexing.listAttributes()
result = job.append(vertexing)
if not result['OK']:
print result['Message']
sys.exit(2)
################## lcsim (DST production) ################################
lcsimDst = LCSIM()
lcsimDst.setVersion(softVersions[1])
lcsimDst.setSteeringFile('steeringFiles/sid_dbd_postPandora.xml')
lcsimDst.getInputFromApp(vertexing)
lcsimDst.setNumberOfEvents(nOutputEvents)
lcsimDst.setAliasProperties('steeringFiles/alias.properties')
lcsimDst.setDetectorModel(detector+".zip")
lcsimDst.setOutputRecFile(outputBase.replace('.slcio', '_' + str(fileNumber) + '_Rec.slcio'))
lcsimDst.setOutputDstFile(outputBase.replace('.slcio', '_' + str(fileNumber) + '_DST.slcio'))
#print lcsimDst.listAttributes()
result = job.append(lcsimDst)
if not result['OK']:
print result['Message']
sys.exit(2)
################## Marlin, LCFIPlus flavortag ############################
if 6 in args.chain:
flavortag = Marlin()
flavortag.setVersion(softVersions[3])
flavortag.setSteeringFile('steeringFiles/sid_dbd_flavortag.xml')
flavortag.setGearFile('steeringFiles/' + detector + '.gear')
flavortag.setInputFile(lcsimDstOutput)
flavortag.setOutputFile(outputBase.replace('.slcio', '_' + '_flavortag.slcio'))
flavortag.setNumberOfEvents(nOutputEvents)
#print flavortag.listAttributes()
result = job.append(flavortag)
if not result['OK']:
print result['Message']
sys.exit(2)
################## Job Finalise ##########################################
# List of banned sites that the job shall not be sent too. These are sites that jobs tend to fail on,
# This list is likely to change.
job.setBannedSites(['LCG.IN2P3-CC.fr', 'LCG.RAL-LCG2.uk', 'LCG.DESY-HH.de', 'LCG.DESYZN.de', 'LCG.KEK.jp',
'OSG.PNNL.us','OSG.UConn.us','OSG.GridUNESP_CENTRAL.br','LCG.SCOTGRIDDURHAM.uk',
'LCG.TECHNIONself.il','LCG.UKI-SOUTHGRID-RALPP.uk','OSG.FNAL_FERMIGRID.us','LCG.UKI-LT2-IC-HEP.uk'])
job.setCPUTime(50000)
job.setPlatform('x86_64-slc5-gcc43-opt')
# Sets the output data file according to if -f is selcted, ships ouput to your /ilc/user/a/aPerson/
# directory on the grid.
outputLevel = max(args.chain)
if outputLevel == 1:
job.setOutputData(outputBase.replace('.slcio', '_' + str(fileNumber) + '_sim.slcio'), outputPath, 'CERN-SRM')
if outputLevel == 3:
#job.setOutputData(outputBase.replace('.slcio', '_' + str(fileNumber) + '_digiTracking.slcio'), outputPath, 'CERN-SRM')
job.setOutputData(outputBase.replace('.slcio', '_' + str(fileNumber) + '_DST.slcio'), outputPath, 'CERN-SRM')
if outputLevel == 4:
job.setOutputData(outputBase.replace('.slcio', '_' + str(fileNumber) + '_pandora.slcio'), outputPath, 'CERN-SRM')
if outputLevel == 5:
job.setOutputData(outputBase.replace('.slcio', '_' + str(fileNumber) + '_DST.slcio'), outputPath, 'CERN-SRM')
if outputLevel == 6:
job.setOutputData(outputBase.replace('.slcio', '_' + str(fileNumber) + '_flavortag.slcio'), outputPath, 'CERN-SRM')
job.setOutputSandbox(outputSandbox)
job.setInputData(args.Input)
if args.dontPromptMe:
job.dontPromptMe()
# Submits Job!!!
job.submit()
return 0;
