def test_lattice2(self):
self.lattice = impact.read_lattice(StringIO(self.LATTICE2))
# header line 1
self.assertEqual(self.lattice.nprocessors, 2)
# header line 2
self.assertEqual(self.lattice.ndimensions, 6)
self.assertEqual(sum(self.lattice.nparticles), 3000)
self.assertEqual(self.lattice.integrator, 1)
self.assertEqual(self.lattice.errorStudy, 0)
self.assertEqual(self.lattice.outputMode, 3)
# header line 3
self.assertItemsEqual(self.lattice.meshSize, [ 33, 33, 65 ])
self.assertEqual(self.lattice.meshMode, 4)
for idx, value in enumerate([ 0.16, 0.18 ]):
self.assertAlmostEqual(self.lattice.pipeSize[idx], value)
self.assertAlmostEqual(self.lattice.periodSize, 0.44)
# header line 4
self.assertEqual(self.lattice.inputMode, 3)
self.assertEqual(self.lattice.restart, 0)
self.assertEqual(self.lattice.subcycle, 0)
self.assertEqual(self.lattice.nstates, 2)
# header line 5
for idx, value in enumerate([ 1000, 2000 ]):
self.assertEqual(self.lattice.nparticles[idx], value)
# header line 6
for idx, value in enumerate([ 0.01, 0.02 ]):
self.assertAlmostEqual(self.lattice.current[idx], value)
# header line 7
for idx, value in enumerate([1.48e-10, 2.28e-10 ]):
self.assertEqual(self.lattice.charge[idx], value)
# header line 8
self.assertAlmostEqual(self.lattice.distSigma[0], 0.00276)
self.assertAlmostEqual(self.lattice.distLambda[0], 4.68274e-05)
self.assertAlmostEqual(self.lattice.distMu[0], 0.11)
self.assertAlmostEqual(self.lattice.mismatch[0], 1.1)
self.assertAlmostEqual(self.lattice.emismatch[0], 1.4)
self.assertAlmostEqual(self.lattice.offset[0], 0.07)
self.assertAlmostEqual(self.lattice.eoffset[0], 0.08)
# header line 9
self.assertAlmostEqual(self.lattice.distSigma[1], 0.00387)
self.assertAlmostEqual(self.lattice.distLambda[1], 5.92732e-05)
self.assertAlmostEqual(self.lattice.distMu[1], 0.21)
self.assertAlmostEqual(self.lattice.mismatch[1], 1.2)
self.assertAlmostEqual(self.lattice.emismatch[1], 1.5)
self.assertAlmostEqual(self.lattice.offset[1], 0.08)
self.assertAlmostEqual(self.lattice.eoffset[1], 0.07)
# header line 10
self.assertAlmostEqual(self.lattice.distSigma[2], 0.07674)
self.assertAlmostEqual(self.lattice.distLambda[2], 8.09374e-06)
self.assertAlmostEqual(self.lattice.distMu[2], 0.31)
self.assertAlmostEqual(self.lattice.mismatch[2], 1.3)
self.assertAlmostEqual(self.lattice.emismatch[2], 1.6)
self.assertAlmostEqual(self.lattice.offset[2], 0.09)
self.assertAlmostEqual(self.lattice.eoffset[2], 0.06)
# header line 11
self.assertAlmostEqual(self.lattice.initialCurrent, 0.05)
self.assertAlmostEqual(self.lattice.initialEnergy, 400000.0)
self.assertAlmostEqual(self.lattice.particleMass, 936.0)
self.assertAlmostEqual(self.lattice.initialCharge, 0.24325653)
self.assertAlmostEqual(self.lattice.scalingFreq, 6500000.0)
self.assertAlmostEqual(self.lattice.initialPhase, 0.0)
self.assertAlmostEqual(self.lattice.beamPercent, 99.9)
# lattice elements
elements = self.lattice.elements
# value element
self.assertEqual(elements[0].name, "DRIFT")
self.assertEqual(elements[0].etype, "DRIFT")
self.assertAlmostEqual(elements[0].length, 0.0761235)
self.assertAlmostEqual(elements[0].position, 0.6558303)
# solenoid element
self.assertEqual(elements[1].name, "LS1_CA01:SOL1_D1131")
self.assertEqual(elements[1].etype, "SOL")
self.assertAlmostEqual(elements[1].length, 0.1)
self.assertAlmostEqual(elements[1].position, 0.74333034)
self.assertEquals(len(elements[1].fields), 1)
self.assertEquals(elements[1].fields[0].name, "B")
self.assertEqual(elements[1].fields[0].unit, "T")
self.assertEqual(elements[1].fields[0].index, 4)
# horiz. corrector element
self.assertEqual(elements[2].name, "LS1_CA01:DCH_D1131")
self.assertEqual(elements[2].etype, "HCOR")
self.assertAlmostEqual(elements[2].length, 0.0)
self.assertAlmostEqual(elements[2].position, 0.74333034)
self.assertEquals(len(elements[2].fields), 1)
self.assertEquals(elements[2].fields[0].name, "ANG")
self.assertEqual(elements[2].fields[0].unit, "rad")
self.assertEqual(elements[2].fields[0].index, 6)
# vert. corrector element
self.assertEqual(elements[3].name, "LS1_CA01:DCV_D1131")
self.assertEqual(elements[3].etype, "VCOR")
self.assertAlmostEqual(elements[3].length, 0.0)
self.assertAlmostEqual(elements[3].position, 0.74333034)
self.assertEquals(len(elements[3].fields), 1)
self.assertEquals(elements[3].fields[0].name, "ANG")
self.assertEqual(elements[3].fields[0].unit, "rad")
self.assertEqual(elements[3].fields[0].index, 8)
# solenoid element
self.assertEqual(elements[4].name, "LS1_CA01:SOL1_D1131")
self.assertEqual(elements[4].etype, "SOL")
self.assertAlmostEqual(elements[4].length, 0.1)
self.assertAlmostEqual(elements[4].position, 0.8433303)
self.assertEquals(len(elements[4].fields), 1)
self.assertEquals(elements[4].fields[0].name, "B")
self.assertEqual(elements[4].fields[0].unit, "T")
self.assertEqual(elements[4].fields[0].index, 4)
def test_lattice1(self):
self.lattice = impact.read_lattice(StringIO(self.LATTICE1))
# header line 1
self.assertEqual(self.lattice.nprocessors, 4)
# header line 2
self.assertEqual(self.lattice.ndimensions, 6)
self.assertEqual(self.lattice.nparticles, 1000)
self.assertEqual(self.lattice.integrator, 2)
self.assertEqual(self.lattice.errorStudy, 0)
self.assertEqual(self.lattice.outputMode, 1)
# header line 3
self.assertItemsEqual(self.lattice.meshSize, [ 65, 65, 129 ])
self.assertEqual(self.lattice.meshMode, 4)
for idx, value in enumerate([ 0.14, 0.14 ]):
self.assertAlmostEqual(self.lattice.pipeSize[idx], value)
self.assertAlmostEqual(self.lattice.periodSize, 0.1025446)
# header line 4
self.assertEqual(self.lattice.inputMode, 3)
self.assertEqual(self.lattice.restart, 0)
self.assertEqual(self.lattice.subcycle, 0)
self.assertEqual(self.lattice.nstates, 1)
# header line 5
self.assertEqual(self.lattice.nparticles, 1000)
# header line 6
self.assertEqual(self.lattice.current, 0.0)
# header line 7
self.assertEqual(self.lattice.charge, 1.48852718947e-10)
# header line 8
self.assertAlmostEqual(self.lattice.distSigma[0], 0.0022734189)
self.assertAlmostEqual(self.lattice.distLambda[0], 8.8312578e-05)
self.assertAlmostEqual(self.lattice.distMu[0], 0.0)
self.assertAlmostEqual(self.lattice.mismatch[0], 1.0)
self.assertAlmostEqual(self.lattice.emismatch[0], 1.0)
self.assertAlmostEqual(self.lattice.offset[0], 0.0)
self.assertAlmostEqual(self.lattice.eoffset[0], 0.0)
# header line 9
self.assertAlmostEqual(self.lattice.distSigma[1], 0.0022734189)
self.assertAlmostEqual(self.lattice.distLambda[1], 8.8312578e-05)
self.assertAlmostEqual(self.lattice.distMu[1], 0.0)
self.assertAlmostEqual(self.lattice.mismatch[1], 1.0)
self.assertAlmostEqual(self.lattice.emismatch[1], 1.0)
self.assertAlmostEqual(self.lattice.offset[1], 0.0)
self.assertAlmostEqual(self.lattice.eoffset[1], 0.0)
# header line 10
self.assertAlmostEqual(self.lattice.distSigma[2], 0.076704772)
self.assertAlmostEqual(self.lattice.distLambda[2], 3.4741445e-06)
self.assertAlmostEqual(self.lattice.distMu[2], 0.0)
self.assertAlmostEqual(self.lattice.mismatch[2], 1.0)
self.assertAlmostEqual(self.lattice.emismatch[2], 1.0)
self.assertAlmostEqual(self.lattice.offset[2], 0.0)
self.assertAlmostEqual(self.lattice.eoffset[2], 0.0)
# header line 11
self.assertAlmostEqual(self.lattice.initialCurrent, 0.0)
self.assertAlmostEqual(self.lattice.initialEnergy, 500000.0)
self.assertAlmostEqual(self.lattice.particleMass, 931494320.0)
self.assertAlmostEqual(self.lattice.initialCharge, 0.138655462185)
self.assertAlmostEqual(self.lattice.scalingFreq, 80500000.0)
self.assertAlmostEqual(self.lattice.initialPhase, 0.0)
self.assertAlmostEqual(self.lattice.beamPercent, 99.9)
# lattice elements
elements = self.lattice.elements
# value element
self.assertEqual(elements[0].name, "DRIFT")
self.assertEqual(elements[0].etype, "VALVE")
self.assertAlmostEqual(elements[0].length, 0.072)
self.assertAlmostEqual(elements[0].position, 0.072)
# dift element
self.assertEqual(elements[1].name, "DRIFT")
self.assertEqual(elements[1].etype, "DRIFT")
self.assertAlmostEqual(elements[1].length, 0.1350635)
self.assertAlmostEqual(elements[1].position, 0.19094025)
# cavity element
self.assertEqual(elements[2].name, "LS1_CA01:CAV1_D1127")
self.assertEqual(elements[2].etype, "CAV")
self.assertAlmostEqual(elements[2].length, 0.24)
self.assertAlmostEqual(elements[2].position, 0.4470635)
self.assertEquals(len(elements[2].fields), 2)
self.assertIn("AMP", [ f.name for f in elements[2].fields ])
self.assertIn("PHA", [ f.name for f in elements[2].fields ])
for f in elements[2].fields:
if f.name == "AMP":
self.assertEqual(f.unit, "V")
self.assertEqual(f.index, 4)
elif f.name == "PHA":
self.assertEqual(f.unit, "deg")
self.assertEqual(f.index, 6)
def _form_upload_post(self, send_status):
"""Process the request and create new Lattice resource.
:param send_status: callback method to signal completion
"""
data = self.application.data
ctx = yield self._create_upload_context()
content_type = self.handler.request.headers["Content-Type"]
if not content_type.startswith("multipart/form-data;"):
send_status(415)
return
ctx.lattice.particle_type = self.handler.get_argument("particle_type", "")
if len(ctx.lattice.particle_type) == 0:
ctx.errors.particle_type = "Particle Type is required"
else:
for p in ctx.particle_types:
if p["type"] == ctx.lattice.particle_type:
particle_type = ObjectDict(p)
break
else:
ctx.errors.particle_type = "Particle Type '{}' is invalid" \
.format(ctx.lattice.particle_type)
ctx.lattice.name = self.handler.get_argument("name", "")
if len(ctx.lattice.name) == 0:
ctx.errors.name = "Name is required"
ctx.lattice.branch = self.handler.get_argument("branch", "")
if len(ctx.lattice.branch) == 0:
ctx.errors.branch = "Branch is required"
if self.handler.get_argument("autoversion", "off") == "on":
ctx.lattice_autoversion = True
else:
ctx.lattice_autoversion = False
ctx.lattice.version = self.handler.get_argument("version", "")
if not ctx.lattice_autoversion:
if len(ctx.lattice.version) == 0:
ctx.errors.version = "Version is required"
else:
try:
ctx.lattice.version = int(ctx.lattice.version)
except ValueError:
ctx.lattice.version = self._INITIAL_VERSION
ctx.errors.version = "Version must be an integer"
if ctx.lattice.version <= 0:
ctx.errors.version = "Version must be greater than zero"
ctx.lattice.description = self.handler.get_argument("description", "")
ctx.lattice.status_type = self.handler.get_argument("status_type", "")
ctx.lattice.created_by = self.handler.current_user
ctx.lattice.created_date = datetime.now()
ctx.lattice._id = ObjectId()
request_files = self.handler.request.files
if "lattice_file" not in request_files:
ctx.errors.lattice_file = "Lattice File is required"
elif len(request_files["lattice_file"]) == 0:
ctx.errors.lattice_file = "Lattice File is required"
if ctx.errors:
send_status(400, ctx)
return
# check for another lattice with name, branch and version
if ctx.lattice_autoversion:
lattice = yield data.find_lattice_by_name(ctx.lattice.name,
ctx.lattice.branch)
else:
lattice = yield data.find_lattice_by_name(ctx.lattice.name,
ctx.lattice.branch, ctx.lattice.version)
if ctx.lattice_autoversion:
if lattice:
ctx.lattice.version = lattice.version + 1
else:
ctx.lattice.version = self._INITIAL_VERSION
else:
if lattice:
ctx.errors.version = "Version already exists"
if ctx.errors:
send_status(400, ctx)
return
lattice_file = request_files["lattice_file"][0]
try:
lattice = read_lattice(StringIO(lattice_file.body))
except Exception as e:
LOGGER.warning("Error reading lattice: %s", e)
ctx.errors.lattice_file = "Lattice File invalid format"
if ctx.errors:
send_status(400, ctx)
return
ctx.lattice.properties = []
ctx.lattice.properties.append(dict(
name="ParticleMass",
value=lattice.particleMass,
unit="MeV/c^2"
))
ctx.lattice.properties.append(dict(
name="ParticleCount",
value=lattice.nparticles
))
ctx.lattice.properties.append(dict(
name="ParticleCurrent",
value=lattice.current,
unit="A"
))
ctx.lattice.properties.append(dict(
name="PositionMismatch",
value=lattice.mismatch
))
ctx.lattice.properties.append(dict(
name="EnergyMismatch",
value=lattice.emismatch
))
ctx.lattice.properties.append(dict(
name="PositionOffset",
value=lattice.offset
))
ctx.lattice.properties.append(dict(
name="EnergyOffset",
value=lattice.eoffset
))
ctx.lattice.properties.append(dict(
name="DistSigma",
value=lattice.distSigma
))
ctx.lattice.properties.append(dict(
name="DistLambda",
value=lattice.distLambda
))
ctx.lattice.properties.append(dict(
name="DistMu",
value=lattice.distMu
))
ctx.lattice.properties.append(dict(
name="OutputMode",
value=lattice.outputMode
))
ctx.lattice.properties.append(dict(
name="IntegratorType",
value=lattice.integrator
))
nucleons = particle_type.protons + particle_type.neutrons
# lattice charge states
if isinstance(lattice.charge, (tuple, list)):
lattice_charge = []
for charge in lattice.charge:
lattice_charge.append(int(charge * lattice.particleMass * nucleons))
else:
lattice_charge = int(lattice.charge * lattice.particleMass * nucleons)
ctx.lattice.properties.append(dict(
name="ParticleCharge",
value=lattice_charge
))
ctx.lattice.files = []
file_content = {}
file_id = _create_file_id()
ctx.lattice.files.append(ObjectDict(
id=file_id,
name="LatticeFile",
size=len(lattice_file.body),
filename=lattice_file.filename,
location=_create_file_location(lattice_file)
))
file_content[file_id] = lattice_file.body
for data_file in request_files.get("data_file", []):
# find a unique file ID
while True:
file_id=_create_file_id()
if file_id not in file_content:
break
ctx.lattice.files.append(ObjectDict(
id=file_id,
name="DataFile",
size=len(data_file.body),
filename=data_file.filename,
location=_create_file_location(data_file)
))
file_content[file_id] = data_file.body
# check that all the data files specified by the
# lattice have been submitted as attachments
for filename in lattice.files:
for f in ctx.lattice.files:
if f.filename == filename:
break
else:
ctx.errors.data_file = "Missing data file: " + filename
send_status(400, ctx)
return
attachment_path = self.settings.get("attachment_path", "")
if len(attachment_path) == 0:
LOGGER.warn("setting 'attachment_path' not found")
ctx.errors._global = "Attachment directory not specified"
send_status(500, ctx)
return
if not os.path.isdir(attachment_path):
LOGGER.error("attachment path '%s' not found", attachment_path)
ctx.errors._global = "Attachment directory not found"
send_status(500, ctx)
return
try:
yield data.validate_lattice(ctx.lattice)
except Exception as e:
LOGGER.error("lattice validation error: %s", e)
ctx.errors._global = "Lattice validation error"
send_status(500, ctx)
return
lattice_elements = []
for idx, element in enumerate(lattice.elements):
lattice_element = ObjectDict()
lattice_element.lattice_id = ctx.lattice._id
lattice_element.order = idx+1
lattice_element.name = element.name
lattice_element.type = element.etype
lattice_element.length = element.length
lattice_element.position = element.position
lattice_element.properties = []
lattice_element.properties.append(dict(
name="ITYPE",
value=element.itype
))
lattice_element.properties.append(dict(
name="STEPS",
value=element.steps
))
for field in element.fields:
lattice_element.properties.append(dict(
name = field.name,
unit = field.unit,
value = element.getfield(field.name)
))
try:
yield data.validate_lattice_element(lattice_element)
except Exception as e:
LOGGER.error("lattice element validation error: %s", e)
ctx.errors._global = "Lattice element validation error"
send_status(500, ctx)
return
lattice_elements.append(lattice_element)
try:
lattice_id = yield data.insert_lattice(ctx.lattice, validate=False)
except Exception as e:
LOGGER.error("lattice database insert error: %s", e)
ctx.errors._global = "Lattice database insert error"
send_status(500, ctx)
return
try:
for lattice_element in lattice_elements:
lattice_element.lattice_id = lattice_id
data.insert_lattice_element(lattice_element, validate=False)
except Exception as e:
LOGGER.error("lattice element database insert error: %s", e)
ctx.errors._global = "Lattice element database insert error"
# Rollback?
send_status(500, ctx)
return
try:
for f in ctx.lattice.files:
_write_file_content(attachment_path, f.location, file_content[f.id])
except Exception as e:
LOGGER.exception("lattice file write error: %s", e)
ctx.errors._global = "Lattice file write error"
#Rollback?
send_status(500, ctx)
return
send_status(201, ctx)
return
