def vision_seat_piston(self):
seat = self.vision_seat()
piston = self.vision_piston()
piston_Not_just_below_seat_ = operations.translate(
piston,
vertical='%s *mm' % (-(self.vision_seat_skirt_height / 2. +
self.vision_seat_shaft_height)))
piston_below_seat = operations.translate(
piston, vertical='%s *mm' % (-(self.vision_seat_skirt_height)))
seat_W_piston = operations.unite(seat, piston_below_seat)
# seat_W_piston_below_dac= operations.translate(seat_W_piston,vertical='%s *mm'
# % (-(self.pavilion_total_triangle_height() +self.girdle_height)))
seat_W_piston_below_dac = operations.translate(
seat_W_piston,
vertical='%s *mm' %
(-(self.pavilion_height() + self.sample_height / 2. +
self.girdle_height)))
seat_W_piston_above_dac = operations.rotate(
operations.rotate(seat_W_piston_below_dac,
transversal=1,
angle='%s *degree' % (180)),
vertical=1,
angle='%s *degree' % -180)
seat_piston_both = operations.unite(seat_W_piston_below_dac,
seat_W_piston_above_dac)
return (seat_piston_both)
def generate_collimator_channels(self):
pyls_beam_vertical, pyls_beam_horizontal = self.generate_channels_list(
)
channels = operations.unite(operations.unite(*pyls_beam_vertical),
*pyls_beam_horizontal)
return (channels)
def horizontally_oddsOReven_blades(self):
pyls_beam_vertical, horizontal_blades = self.generate_blade_list()
horizontal_odd_blades = operations.unite(*horizontal_blades[1::2])
horizontal_even_blades = operations.unite(*horizontal_blades[::2])
return (horizontal_odd_blades, horizontal_even_blades)
def generate_channels_border(self):
pyls_beam_vertical, pyls_beam_horizontal = self.generate_channels_list(
)
channels_border = operations.unite(
operations.unite(
operations.unite(pyls_beam_vertical[0],
pyls_beam_vertical[-1]),
pyls_beam_horizontal[0]), pyls_beam_horizontal[-1])
return channels_border
def gen_collimators(self,
detector_angles=[-45, -135],
multiple_collimator=True,
collimator_Nosupport=True):
"""
Parameters
----------
detector_angles
multiple_collimator
collimator_Nosupport
Returns
-------
"""
if multiple_collimator is True:
rotated_coll = [
operations.rotate(self.gen_one_col(collimator_Nosupport),
beam="1",
angle='%s*deg' % (a))
for a in detector_angles
]
all_coll = operations.unite(*rotated_coll)
else:
rotated_coll = operations.rotate(
self.gen_one_col(collimator_Nosupport),
vertical="1",
angle='%s*deg' % (180 + detector_angles[0])) # transversal ,90
all_coll = rotated_coll
return (all_coll)
def notify(self, parent):
if len(self._shapes) < 2:
raise ValueError("'%s' requires at least two children" % self.tag)
import instrument.geometry.operations as ops
union = ops.unite(*self._shapes)
parent.onUnion(union)
return
def test(self):
"""
instrument.geometry.pml.render
"""
import numpy as np
from instrument.geometry.pml import weave
from instrument.geometry import shapes, operations
pyramid = shapes.pyramid(thickness="20.*mm",
width="20.*mm",
height="110.*mm")
pyramid_along_beam = operations.rotate(pyramid,
transversal="1",
angle="90.*deg")
angles = np.arange(-160, 0., 15.)
pyramids = [
operations.rotate(pyramid_along_beam,
vertical="1",
angle='%s*deg' % a) for a in angles
]
channels = operations.unite(*pyramids)
hollow_cylinder = operations.subtract(
shapes.cylinder(radius="55.*mm", height="50.*mm"),
shapes.cylinder(radius="25.*mm", height="60.*mm"),
)
half_cylinder = operations.subtract(
hollow_cylinder,
operations.translate(
shapes.block(height="110*mm",
width="110*mm",
thickness="110*mm"),
transversal="-55.*mm",
))
all = operations.subtract(half_cylinder, channels)
# use a special renderer
from instrument.geometry.pml.Renderer import Renderer as base
class Renderer(base):
def _renderDocument(self, body):
self.onGeometry(body)
return
def header(self):
return []
def footer(self):
return []
def end(self):
return
text = weave(all,
open('collimator.xml', 'wt'),
print_docs=False,
renderer=Renderer(),
author='')
return
def vertically_oddsOReven_blades(self):
vertical_blades, pyls_beam_horizontal = self.generate_blade_list()
# shiftangle = self.horizontal_pillar_angle_list - self.horizontal_channel_angle * 0.5
vertical_odd_blades = operations.unite(*vertical_blades[1::2])
vertical_even_blades = operations.unite(*vertical_blades[::2])
# channels_shift = [operations.rotate(vertical_odd_blades, vertical="1", angle='%s*deg' % a)
# # "vertical" create the pyramid in horizontal direc
# for a in shiftangle]
# #
# channels_notshift = [operations.rotate(vertical_even_blades, vertical="1", angle='%s*deg' % a)
# # "vertical" create the pyramid in horizontal direc
# for a in self.horizontal_pillar_angle_list]
return(vertical_odd_blades, vertical_even_blades)
def tab_screw(self):
height = self.max_max_coll_width_detector
width = 3.6 * 5
thickness = 6.
source_distance = self.inner_radius + 5
span = self.angle2span(source_distance,
self.horizontal_acceptance_angle)
large_pillar = shapes.block(height='%s *mm' % height,
width='%s *mm' % width,
thickness='%s *mm' % thickness)
small_pillar = shapes.block(height='%s *mm' % span,
width='%s *mm' % (width + 1),
thickness='%s *mm' % (thickness + 1))
pillar = operations.subtract(large_pillar, small_pillar)
length = height - span
holes_position = span / 2 + length / 4
holes = [
operations.translate(operations.rotate(shapes.cylinder(
radius='%s*mm' % 1.6, height='%s *mm' % (thickness + 55)),
transversal=1,
angle='%s *deg' % 90),
vertical='%s *mm' % a)
for a in [holes_position, -holes_position]
]
all_holes = operations.unite(*holes)
pillar_holes = operations.subtract(large_pillar, all_holes)
vertical_rot = operations.rotate(pillar_holes,
vertical=1,
angle='%s *deg' % 90)
beam_rot = operations.rotate(vertical_rot,
beam=1,
angle='%s *deg' % 90)
move_beam = operations.translate(
beam_rot,
beam='%s *mm' % -(self.inner_radius + self.base_thickness / 2))
move_ver = operations.translate(
move_beam,
vertical='%s *mm' %
(-(self.max_coll_height_detector) / 2 + thickness / 2))
return (vertical_rot)
def test(self):
"""
instrument.geometry.pml.render
"""
from instrument.geometry.pml import render
from instrument.geometry import shapes, operations
cyl = shapes.cylinder(radius="1.*cm", height="5.*cm")
sphere = shapes.sphere(radius="2.*cm")
block = shapes.block(width="5*cm", height="4.*cm", thickness="1.*mm")
u = operations.unite(cyl, sphere, block)
t = operations.translate(u, vertical="0.2*cm")
r = operations.rotate(t, vertical=1., angle=90.)
pyramid = shapes.pyramid(width="4.*cm",
height="2.*cm",
thickness="1.*cm")
i = operations.intersect(r, pyramid)
cone = shapes.cone(radius="2.*cm", height="2.*cm")
u = operations.unite(i, cone)
sphere2 = shapes.sphere(radius="3.*cm")
s = operations.subtract(sphere2, u)
text = render(s, print_docs=False)
print('\n'.join(text), file=open('test2.xml.rendered', 'w'))
return
def vision_piston(self):
shaft_height = self.piston_shaft_height - self.piston_chamfer_height
shaft_hollow = self.vision_seat_top_diameter
chamfer_big_cone_height = (self.piston_chamfer_base / 2.) * np.tan(
np.deg2rad(self.piston_chamfer_angle))
subtraction_coneHeight_chamfer = chamfer_big_cone_height - self.piston_chamfer_height
print('chamfer_top_length',
(self.piston_chamfer_base / chamfer_big_cone_height) *
subtraction_coneHeight_chamfer)
champfer_big_cone = operations.translate(
shapes.cone(radius='%s *mm' % (self.piston_chamfer_base / 2.),
height='%s *mm' % (chamfer_big_cone_height)),
vertical='%s *mm' % (-(chamfer_big_cone_height)))
subtraction_cone_chamfer = operations.translate(
shapes.cone(radius='%s *mm' % (500.),
height='%s *mm' % (subtraction_coneHeight_chamfer)),
vertical='%s *mm' % (-(subtraction_coneHeight_chamfer)))
chamfer_atCenter = operations.translate(
operations.subtract(champfer_big_cone, subtraction_cone_chamfer),
vertical='%s *mm' % (subtraction_coneHeight_chamfer))
##### SHAFT #########
shaft_solid = shapes.cylinder(radius='%s *mm' %
(self.piston_chamfer_base / 2.),
height='%s *mm' % (shaft_height))
shaft_in_place = operations.translate(
shaft_solid,
vertical='%s *mm' %
(-(shaft_height / 2. + self.piston_chamfer_height)))
#### CHAMFER+SHAFET ####
chamfer_shaft = operations.unite(chamfer_atCenter, shaft_in_place)
subtraction_cylinder_shaft = shapes.cylinder(radius='%s *mm' %
(shaft_hollow / 2.),
height='%s *mm' % (500))
piston_down_center = operations.subtract(chamfer_shaft,
subtraction_cylinder_shaft)
return (piston_down_center)
def body_bar(self):
bar = shapes.cylinder(radius='%s *mm' % (self.bar_thickness / 2.),
height='%s *mm' % (self.bar_height))
bar_in_place_right = operations.translate(
bar,
beam='%s *mm' %
(-(self.piston_chamfer_base / 2. + self.bar_thickness / 2.)))
bar_in_place_left = operations.translate(
bar,
beam='%s *mm' %
((self.piston_chamfer_base / 2. + self.bar_thickness / 2.)))
bar_in_place = operations.unite(bar_in_place_right, bar_in_place_left)
return (bar_in_place)
def vision_seat(self):
seat_hollow_angle = self.table_angle
seat_larger_cone_height = (self.vision_seat_bottom_diameter/ 2) / \
np.tan(np.deg2rad(self.vision_seat_skirt_angle / 2))
# seat_smaller_cone_height = (self.vision_seat_skirt_height * self.seat_top_diameter) / \
# (self.seat_bottom_diameter - self.seat_top_diameter)
seat_smaller_cone_height = seat_larger_cone_height - self.vision_seat_skirt_height
seat_hollow_large_cone_height_at_top_seat = ((self.vision_seat_hollow_top_diamter) / 2) / \
np.tan(np.deg2rad(seat_hollow_angle / 2))
seat_hollow_large_cone_height = seat_hollow_large_cone_height_at_top_seat + 50
seat_hollow_large_cone_diameter = 2 * seat_hollow_large_cone_height * np.tan(
np.deg2rad(seat_hollow_angle / 2))
# cone has to be translated to center and after translation, the cone is in the negative Y direction
seat_cone_to_subtract = operations.translate(
shapes.cone(radius='%s *mm' % (self.seat_top_diameter / 2. + 500.),
height='%s *mm' % (seat_smaller_cone_height)),
vertical='%s *mm' % (-seat_smaller_cone_height))
seat_larger_cone = operations.translate(shapes.cone(
radius='%s *mm' % (self.vision_seat_bottom_diameter / 2.),
height='%s *mm' % (seat_larger_cone_height)),
vertical='%s *mm' %
(-seat_larger_cone_height))
solid_seat_not_atCenter = operations.subtract(seat_larger_cone,
seat_cone_to_subtract)
solid_seat_at_center = operations.translate(
solid_seat_not_atCenter,
vertical='%s *mm' %
(seat_smaller_cone_height)) # solid seat at center(0,0)
######## HOLLOW TAPPERED CONE #########
seat_hollow_large_cone = operations.translate(
shapes.cone(radius='%s *mm' %
((seat_hollow_large_cone_diameter) / 2.),
height='%s *mm' % (seat_hollow_large_cone_height)),
vertical='%s *mm' % (-(seat_hollow_large_cone_height)))
# invert the tappered hollow
seat_tappered_hollow = operations.translate(
operations.rotate(seat_hollow_large_cone,
transversal=1,
angle='%s *degree' % (-180)),
vertical='%s *mm' % (-seat_hollow_large_cone_height_at_top_seat))
hollow_seat = operations.subtract(solid_seat_at_center,
seat_tappered_hollow)
smaller_saft_to_drill = shapes.cylinder(
radius='%s *mm' % (self.vision_seat_hollow_bottom_diameter / 2.),
height='%s *mm' % (self.vision_seat_shaft_height + 100.))
seat_withSmall_hollow_shaft = operations.subtract(
hollow_seat, smaller_saft_to_drill)
######## CYLINDER SHAFT #############
solid_shaft = shapes.cylinder(
radius='%s *mm' % (self.vision_seat_shaft_diameter / 2.),
height='%s *mm' % (self.vision_seat_shaft_height))
shaft_to_drill = shapes.cylinder(
radius='%s *mm' % (self.vision_seat_hollow_bottom_diameter / 2.),
height='%s *mm' % (self.seat_shaft_height + 100.))
hollow_shaft_atCenter = operations.translate(
operations.subtract(solid_shaft, shaft_to_drill),
vertical='%s *mm' % (-self.vision_seat_shaft_height / 2.))
hollow_shaft_atSkirt = operations.translate(
hollow_shaft_atCenter,
vertical='%s *mm' % (-self.vision_seat_skirt_height))
######## COMBINING SEAT AND SHAFT #############
seat_shaft_down_center = operations.unite(seat_withSmall_hollow_shaft,
hollow_shaft_atSkirt)
return (seat_shaft_down_center)
def gen_one_col(self, collimator_Nosupport=True):
pyr = self.solid_pyramid()
big_cylinder = shapes.cylinder(radius='%s *mm' % (self.vertical_outer_radius),
height='%s *mm' % (self.max_coll_height_detector * 10))
big_box=self.generate_box_toIntersect_big_end()
outside_sphere = shapes.sphere(radius='%s *mm' % self.vertical_outer_radius)
channels=self.generate_collimator_channels()
channels_border=self.generate_channels_border()
conical_colli = operations.intersect(channels, pyr)
conical_channels_border=operations.intersect(channels_border, pyr)
cutoff_cylinder = shapes.cylinder(radius='%s *mm' % (self.inner_radius),
height='%s *mm' % (self.max_coll_height_detector * 90.))
blade_cutoff_cylinder = shapes.cylinder(radius='%s *mm' % (self.vertical_blade_dist_fr_sample_center),
height='%s *mm' % (self.max_coll_height_detector * 10))
cutoff_box = shapes.block(width='%s *mm' % (self.inner_radius*2), thickness='%s *mm' % (self.inner_radius*2),
height='%s *mm' % (self.max_coll_height_detector * 90.))
blade_cutoff_box = shapes.block(width='%s *mm' % (self.vertical_blade_dist_fr_sample_center*2),
thickness='%s *mm' % (self.vertical_blade_dist_fr_sample_center*2),
height='%s *mm' % (self.max_coll_height_detector * 10))
# return (operations.subtract(conical_channels_border, cutoff_cylinder))
if self.collimator_parts is True:
open_collimator = operations.intersect(operations.subtract(conical_channels_border, cutoff_box),
big_box)
collimator_with_blades = operations.intersect(operations.subtract(conical_colli, blade_cutoff_box),
big_box)
else:
open_collimator=operations.intersect(operations.subtract(conical_channels_border, cutoff_cylinder), big_box)
collimator_with_blades = operations.intersect(operations.subtract(conical_colli, blade_cutoff_cylinder), big_box)
collimator=operations.unite(open_collimator, collimator_with_blades)
scale_pyr = 1.1
pyr_ht = (self.horizontal_arc_length_detector / np.deg2rad(self.horizontal_acceptance_angle)) * scale_pyr
thickness = (self.max_coll_height_detector + 1 * self.wall_thickness) * scale_pyr
height = (self.horizontal_arc_length_detector / np.deg2rad(self.horizontal_acceptance_angle)) * scale_pyr
width = (self.max_coll_width_detector + 1 * self.wall_thickness) * scale_pyr
# pyr_ht = self.vertical_outer_radius * np.cos(np.deg2rad(self.horizontal_acceptance_angle/2.)) * scale_pyr
pyr_lateral = shapes.pyramid(
thickness='%s *mm' % (thickness),
# height='%s *mm' % (height),
height='%s *mm' % (height),
width='%s *mm' % (width+900.))
pyr_lateral = operations.rotate(pyr_lateral, transversal=1, angle='%s *degree' % (90))
pyr_depth = shapes.pyramid(
thickness='%s *mm' % (thickness+6900),
# height='%s *mm' % (height),
height='%s *mm' % (height),
width='%s *mm' % (width ))
pyr_depth = operations.rotate(pyr_depth, transversal=1, angle='%s *degree' % (90))
# collimator_support = Collimator_support()
# collimator_support.set_constraints(
# truss_base_thickness=30., trass_final_height_factor=0.45,
# touch_to_halfcircle=6, SNAP_acceptance_angle=False)
#
# supports = collimator_support.support()
supports = self.support()
support_top=operations.intersect(operations.subtract(supports, pyr_lateral), pyr_depth)
# support_top =operations.subtract(self.support(), pyr_lateral)
support_bottom=operations.rotate(operations.rotate(support_top, transversal=1, angle='%s *degree' %(-180)), vertical=1, angle='%s *degree' %180)
supports=operations.subtract(operations.unite(support_top, support_bottom), cutoff_cylinder)
if collimator_Nosupport is True:
return(collimator)
else:
return(operations.unite(collimator,supports))
def generate_channels_border(self):
vertical_blades, horizontal_blades = self.generate_blade_PLUS_border_list()
top_border = horizontal_blades[0]
bottom_border = horizontal_blades[-1]
left_border = vertical_blades[0]
right_border = vertical_blades[-1]
if self.top_border_odds:
top_border_list= self.generate_oneside_discrete_horizontal_channel_top_borders()[1::2]
top_border=operations.unite(*top_border_list)
if self.top_border_evens:
top_border_list = self.generate_oneside_discrete_horizontal_channel_top_borders()[0::2]
top_border = operations.unite(*top_border_list)
if self.bottom_border_odds:
bottom_border_list = self.generate_oneside_discrete_horizontal_channel_bottom_borders()[1::2]
bottom_border = operations.unite(*bottom_border_list)
if self.bottom_border_evens:
bottom_border_list = self.generate_oneside_discrete_horizontal_channel_bottom_borders()[0::2]
bottom_border = operations.unite(*bottom_border_list)
if self.left_border_odds:
left_border_list = self.generate_oneside_discrete_vertical_channel_left_borders()[1::2]
left_border = operations.unite(*left_border_list)
if self.left_border_evens:
left_border_list = self.generate_oneside_discrete_vertical_channel_left_borders()[0::2]
left_border = operations.unite(*left_border_list)
if self.right_border_odds:
right_border_list = self.generate_oneside_discrete_vertical_channel_right_borders()[1::2]
right_border = operations.unite(*right_border_list)
if self.right_border_evens:
right_border_list = self.generate_oneside_discrete_vertical_channel_right_borders()[0::2]
right_border = operations.unite(*right_border_list)
if self.no_right_border:
right_border= shapes.cylinder(radius='%s *mm' % (0),
height='%s *mm' % (0))
if self.no_left_border:
left_border = shapes.cylinder(radius='%s *mm' % (0),
height='%s *mm' % (0))
if self.no_right_border:
right_border = shapes.cylinder(radius='%s *mm' % (0),
height='%s *mm' % (0))
if self.no_top_border:
top_border = shapes.cylinder(radius='%s *mm' % (0),
height='%s *mm' % (0))
if self.no_bottom_border:
bottom_border = shapes.cylinder(radius='%s *mm' % (0),
height='%s *mm' % (0))
channel_border= operations.unite(operations.unite(operations.unite(top_border,bottom_border),
left_border), right_border)
return channel_border
def generate_collimator_channels(self):
vertical_blades_list,horizontal_blades_list=self.generate_blade_list()
horizontal_odd_blades, horizontal_even_blades = self.horizontally_oddsOReven_blades()
horizontal_odd_blades_list, horizontal_even_blades_list = self.horizontally_oddsOReven_blades_list()
vertical_odd_blades, vertical_even_blades = self.vertically_oddsOReven_blades()
vertical_odd_blades_list, vertical_even_blades_list = self.vertically_oddsOReven_blades_list()
vertical_blades = operations.unite(*vertical_blades_list)
horizontal_blades = operations.unite(*horizontal_blades_list)
if self.remove_blades:
if self.vertical_blade_index_to_remove == 1:
del vertical_blades_list[self.vertical_blade_index_to_remove-1::self.vertical_blade_index_to_remove+1]
vertical_blades = operations.unite(*vertical_blades_list)
del horizontal_blades_list[
self.horizontal_blade_index_to_remove-1::self.horizontal_blade_index_to_remove+1]
horizontal_blades = operations.unite(*horizontal_blades_list)
else:
del vertical_blades_list[self.vertical_blade_index_to_remove-1::self.vertical_blade_index_to_remove]
vertical_blades = operations.unite(*vertical_blades_list)
del horizontal_blades_list[self.horizontal_blade_index_to_remove-1::self.horizontal_blade_index_to_remove]
horizontal_blades = operations.unite(*horizontal_blades_list)
if self.vertical_odd_blades:
vertical_blades_list = vertical_odd_blades_list
vertical_blades = vertical_odd_blades
if self.vertical_even_blades:
vertical_blades_list = vertical_even_blades_list
vertical_blades = vertical_even_blades
if self.horizontal_odd_blades:
horizontal_blades_list = horizontal_odd_blades_list
horizontal_blades = horizontal_odd_blades
if self.horizontal_even_blades:
horizontal_blades_list = horizontal_even_blades_list
horizontal_blades = horizontal_even_blades
if self.remove_vertical_blades_manually:
# vertical_blades_L = [x for x in vertical_blades_list if x not in vertical_blades_list[self.vertical_blade_index_list_toRemove]]
for index in sorted(self.vertical_blade_index_list_toRemove, reverse=True):
del vertical_blades_list[index]
# vertical_blades_L = [vertical_blades_list[i] for i in self.vertical_blade_index_list_toRemove]
vertical_blades = operations.unite(*vertical_blades_list)
if self.remove_horizontal_blades_manually:
for index in sorted(self.horizontal_blade_index_list_toRemove, reverse=True):
del horizontal_blades_list[index]
horizontal_blades = operations.unite(*horizontal_blades_list)
channels = operations.unite(vertical_blades, horizontal_blades)
return (channels)
def support(self):
main_cylinder_radius = self.inner_radius * self.truss_height_factor
main_cylinder_diameter = main_cylinder_radius * 2.
height_support_main = main_cylinder_diameter - self.beam_dist_support
base_width_support = self.truss_base_thickness
cyli_radius = main_cylinder_radius * 2
height_support = height_support_main
cyli_dia = cyli_radius * 2.
################################################ cylinder_radius=self.inner_radius
cylinder_radius = cyli_dia / 2.
vertical_cylinder_height = cyli_dia + 100 ## big cylinder height should be greater than the cyli diameter
suppert_end_distance_fr_source = self.inner_radius + base_width_support
thickness_collimator_at_support_end = self.angle2span(
suppert_end_distance_fr_source, self.vertical_acceptance_angle)
height_factor = 1.
height = thickness_collimator_at_support_end * height_factor
cylinder = shapes.cylinder(radius='%s *mm' % (cylinder_radius),
height='%s *mm' % (height * 2 + 10))
cylinder_transversal = operations.rotate(cylinder,
beam=1,
angle='%s *degree' % 90)
vertical_cylinder = shapes.cylinder(
radius='%s *mm' % (cylinder_radius),
height='%s *mm' % (vertical_cylinder_height))
distance_fr_center_height_main = np.sqrt((main_cylinder_radius)**2 -
(height_support / 2)**2)
angular_cut = self.span2angle(height_support,
distance_fr_center_height_main) / 2.
distance_fr_center_height = cylinder_radius * np.cos(
np.deg2rad(angular_cut))
vertical_cylinder_move_dist = abs(cylinder_radius -
distance_fr_center_height)
distance_fr_center_height = np.sqrt((cylinder_radius)**2 -
(height_support / 2)**2)
vertical_cylinder_move_dist = abs(cylinder_radius -
distance_fr_center_height_main)
unwanted_part_of_smallcircle0 = operations.subtract(
cylinder_transversal,
operations.translate(vertical_cylinder,
beam='%s *mm' % -vertical_cylinder_move_dist))
moving_dist_cylinder = 20
# unwanted_part_of_smallcircle0= operations.translate(unwanted_part_of_smallcircle0, beam='%s *mm' %-moving_dist_cylinder)
unwanted_part_of_bigcircle2 = operations.translate(
unwanted_part_of_smallcircle0, beam='%s *mm' % (1))
cylinder_radius = self.inner_radius
cylinder_transversal_1_0 = operations.rotate(shapes.cylinder(
radius='%s *mm' % (cylinder_radius),
height='%s *mm' % ((height * 2))),
beam=1,
angle='%s *degree' % 90)
# return(operations.unite(cylinder_transversal_1_0, operations.translate(vertical_cylinder, beam='%s *mm' % -vertical_cylinder_move_dist)))
mod_cylinder_transversal = operations.subtract(
cylinder_transversal_1_0, unwanted_part_of_smallcircle0)
# return (operations.subtract(cylinder_transversal,operations.subtract(cylinder_transversal,operations.translate(vertical_cylinder, beam='%s *mm' % -vertical_cylinder_move_dist))))
# return (operations.unite(cylinder_transversal_1_0,unwanted_part_of_smallcircle0 ))
# return(mod_cylinder_transversal)
# return (vertical_cylinder)
# return (operations.subtract(vertical_cylinder, cylinder_transversal))
########################################################################################################################################
#########################################################################################################################################
solid_shape = mod_cylinder_transversal
cylinder_transversal = mod_cylinder_transversal ## small inside cylinder
cylinder_2 = shapes.cylinder(
radius='%s *mm' %
(cylinder_radius + 1), ###big cylinder (outside cylinder)
height='%s *mm' % (height * 2))
cylinder_transversal_2_0 = operations.rotate(cylinder_2,
beam=1,
angle='%s *degree' % 90)
cylinder_transversal_2 = operations.subtract(
cylinder_transversal_2_0, unwanted_part_of_bigcircle2)
width_factor = 2.
big_block = shapes.block(
height='%s *mm' % cyli_dia,
width='%s *mm' % (suppert_end_distance_fr_source * width_factor),
thickness='%s *mm' % (height))
big_block_rotate = operations.rotate(big_block,
vertical=1,
angle='%s *degree' % 90)
big_block_2 = shapes.block(
height='%s *mm' % (cyli_dia - 1),
width='%s *mm' %
((suppert_end_distance_fr_source * width_factor) - 2),
thickness='%s *mm' % (height + 1)) #### small blog
big_block_rotate_2 = operations.rotate(big_block_2,
vertical=1,
angle='%s *degree' % 90)
parts = operations.subtract(big_block_rotate, cylinder_transversal)
# return(operations.unite(big_block_rotate, cylinder_transversal))
# return(big_block_rotate)
parts_2 = operations.subtract(big_block_rotate_2,
cylinder_transversal_2)
parts_frame = operations.subtract(parts, parts_2)
# parts_frame=operations.unite(parts_frame, solid_shape)
# return (parts_frame)
# return (operations.subtract(parts_frame,parts_2))
# return operations.unite(cylinder_transversal_1_0,unwanted_part_of_smallcircle0)
# return(operations.unite(cylinder_transversal, cylinder_transversal_2))
blades_in_frames = operations.subtract(self.support_design(),
cylinder_transversal)
parts_frame_blades_pre = operations.unite(parts_frame,
blades_in_frames)
parts_frame_blades_pre = parts_frame
# return (parts_frame_blades_pre)
#############################################################CHANGES#####################################################
#########################################################################################################################
# solid=operations.subtract(vertical_cylinder, unwanted_part_of_bigcircle2)
#
# parts_frame_blades_pre = operations.unite(parts_frame_blades_pre, solid)
side_cut_box = operations.translate(operations.rotate(
shapes.block(height='%s *mm' % cyli_dia,
width='%s *mm' %
(suppert_end_distance_fr_source * width_factor),
thickness='%s *mm' % (height * 2)),
vertical=1,
angle='%s *degree' % 90),
beam='%s *mm' %
-(suppert_end_distance_fr_source))
up_cut_box = operations.translate(
operations.rotate(shapes.block(
height='%s *mm' % cyli_dia,
width='%s *mm' %
((suppert_end_distance_fr_source * width_factor) + 1),
thickness='%s *mm' % (height * 2)),
vertical=1,
angle='%s *degree' % 90),
vertical='%s *mm' % (cyli_dia / 2.)) ########################
down_cut_box = operations.translate(operations.rotate(
shapes.block(height='%s *mm' % cyli_dia,
width='%s *mm' %
((suppert_end_distance_fr_source * width_factor) + 1),
thickness='%s *mm' % (height * 2)),
vertical=1,
angle='%s *degree' % 90),
vertical='%s *mm' %
(-(cyli_dia - 2)))
parts_frame_blades = operations.subtract(
operations.subtract(
operations.subtract(parts_frame_blades_pre, side_cut_box),
up_cut_box), down_cut_box)
parts_frame_blades = operations.unite(parts_frame_blades,
blades_in_frames)
parts_frame_blades = operations.subtract(
operations.subtract(parts_frame_blades, side_cut_box),
down_cut_box)
# return (parts_frame_blades)
thickness_parts = ((suppert_end_distance_fr_source * width_factor) -
(self.inner_radius)) / 2
parts_move_beam = operations.translate(
parts_frame_blades,
beam='%s *mm' %
(-(self.inner_radius) * 2 - base_width_support + 1))
angle = self.vertical_acceptance_angle # 15
# parts_move_up = operations.translate(parts_move_beam, vertical='%s *mm' % (
# self.inner_radius + (
# self.curvature * self.inner_radius * np.tan(np.deg2rad(angle/2.)))))
parts_move_up = operations.translate(
parts_move_beam,
vertical='%s *mm' %
(self.inner_radius +
(self.curvature * (self.inner_radius * 2. + base_width_support) *
np.tan(np.deg2rad(angle / 2.)))))
# return (parts_move_up)
# return(parts_frame)
return (operations.intersect(
parts_move_up,
self.generate_box_toCut_big_end(
width=self.max_coll_height_detector *
self.trass_final_height_factor,
height=(self.inner_radius * 2. + base_width_support + 100.))))
def support_design(self):
main_cylinder_radius = self.inner_radius
main_cylinder_diameter = main_cylinder_radius * 2.
height_support = main_cylinder_diameter - 8.
# print (height_support)
distance_fr_center_height_main = np.sqrt((main_cylinder_radius)**2 -
(height_support / 2)**2)
base_width_support = self.truss_base_thickness
suppert_end_distance_fr_source = self.inner_radius + base_width_support
thickness_collimator_at_support_end = self.angle2span(
suppert_end_distance_fr_source, self.vertical_acceptance_angle)
pillar = shapes.block(
height='%s *mm' % (main_cylinder_diameter + base_width_support +
self.truss_blade_length),
width='%s *mm' % (thickness_collimator_at_support_end),
thickness='%s *mm' % 1)
pillar_beam = operations.rotate(pillar,
transversal=1,
angle="%s *degree" % 90)
small_pillar_beam_tocut = operations.rotate(shapes.block(
height='%s *mm' % (main_cylinder_diameter / 2.),
width='%s *mm' % (thickness_collimator_at_support_end + 5),
thickness='%s *mm' % 5),
transversal=1,
angle="%s *degree" % 90)
pillar_beam = operations.subtract(
pillar_beam,
operations.translate(small_pillar_beam_tocut,
beam='%s*mm' % -(main_cylinder_radius / 2)))
angle = 10
truss_rot_degree = 10
pillar_beam_dia = operations.rotate(pillar_beam,
transversal=1,
angle='%s *degree' %
truss_rot_degree)
# return (pillar_beam_dia)
blade1_needed = operations.translate(operations.subtract(
operations.rotate(shapes.block(
height='%s *mm' % (self.max_coll_height_detector * 90.),
width='%s *mm' % (thickness_collimator_at_support_end),
thickness='%s *mm' % 2),
transversal=1,
angle="%s *degree" % 90),
operations.translate(small_pillar_beam_tocut,
beam='%s*mm' % -(main_cylinder_radius / 2))),
beam='%s *mm' %
(distance_fr_center_height_main))
blade1 = operations.translate(pillar_beam,
beam='%s *mm' %
(distance_fr_center_height_main))
blade1_dia = operations.translate(pillar_beam_dia,
beam='%s *mm' %
(distance_fr_center_height_main))
vertical_blade = operations.rotate(operations.subtract(
operations.rotate(shapes.block(
height='%s *mm' % (self.max_coll_height_detector),
width='%s *mm' % (thickness_collimator_at_support_end),
thickness='%s *mm' % 1),
transversal=1,
angle="%s *degree" % 90),
operations.translate(small_pillar_beam_tocut,
beam='%s*mm' % -(main_cylinder_radius / 2))),
beam=1,
angle='%s *degree' % (90))
vertical_blade = operations.translate(vertical_blade,
beam='%s *mm' %
(self.inner_radius))
vertical_blade = operations.rotate(vertical_blade,
transversal=1,
angle='%s *degree' % (90))
vertical_blade = operations.rotate(vertical_blade,
vertical=1,
angle='%s *degree' % (90))
vertical_blade = operations.translate(vertical_blade,
beam='%s *mm' %
(self.inner_radius))
#
# return (vertical_blade)
# return (operations.unite(blade1, blade1_dia))
pillar_beam2 = operations.translate(
pillar_beam,
vertical="%s *mm" %
-(suppert_end_distance_fr_source * np.sin(np.deg2rad(angle))))
pillar_beam_dia2 = operations.rotate(pillar_beam2,
transversal=1,
angle='%s *degree' %
truss_rot_degree)
blade2 = operations.translate(pillar_beam2,
beam='%s *mm' %
(distance_fr_center_height_main))
blade2_dia = operations.translate(pillar_beam_dia2,
beam='%s *mm' %
(distance_fr_center_height_main))
# return (operations.unite(operations.unite(pillar_beam2, pillar_beam_dia2), pillar_beam))
pillar_beam3 = operations.translate(
pillar_beam2,
vertical="%s *mm" %
-(suppert_end_distance_fr_source * np.sin(np.deg2rad(angle))))
pillar_beam_dia3 = operations.rotate(pillar_beam3,
transversal=1,
angle='%s *degree' %
truss_rot_degree)
blade3 = operations.translate(
pillar_beam3,
beam='%s *mm' %
(distance_fr_center_height_main - self.touch_to_halfcircle))
blade3_dia = operations.translate(pillar_beam_dia3,
beam='%s *mm' %
(distance_fr_center_height_main))
pillar_beam4 = operations.translate(
pillar_beam3,
vertical="%s *mm" %
-(suppert_end_distance_fr_source * np.sin(np.deg2rad(angle))))
pillar_beam_dia4 = operations.rotate(pillar_beam4,
transversal=1,
angle='%s *degree' %
(truss_rot_degree))
blade4 = operations.translate(pillar_beam4,
beam='%s *mm' %
(distance_fr_center_height_main))
blade4_dia = operations.translate(pillar_beam_dia4,
beam='%s *mm' %
(distance_fr_center_height_main))
pillar_beam5 = operations.translate(
pillar_beam4,
vertical="%s *mm" %
-(suppert_end_distance_fr_source * np.sin(np.deg2rad(angle))))
pillar_beam_dia5 = operations.rotate(pillar_beam5,
transversal=1,
angle='%s *degree' %
(truss_rot_degree))
blade5 = operations.translate(pillar_beam5,
beam='%s *mm' %
(distance_fr_center_height_main))
blade5_dia = operations.translate(pillar_beam_dia5,
beam='%s *mm' %
(distance_fr_center_height_main))
pillar_beam6 = operations.translate(
pillar_beam5,
vertical="%s *mm" %
-(suppert_end_distance_fr_source * np.sin(np.deg2rad(angle))))
pillar_beam_dia6 = operations.rotate(pillar_beam6,
transversal=1,
angle='%s *degree' %
(truss_rot_degree))
blade6 = operations.translate(pillar_beam6,
beam='%s *mm' %
(distance_fr_center_height_main))
blade6_dia = operations.translate(pillar_beam_dia6,
beam='%s *mm' %
(distance_fr_center_height_main))
# return (operations.unite(operations.unite(operations.unite(operations.unite(operations.unite(blade1, blade2), blade3), blade4), blade5), blade6))
pillar_beam7 = operations.translate(
pillar_beam6,
vertical="%s *mm" %
-(suppert_end_distance_fr_source * np.sin(np.deg2rad(angle))))
pillar_beam_dia7 = operations.rotate(pillar_beam7,
transversal=1,
angle='%s *degree' %
(truss_rot_degree))
blade7 = operations.translate(pillar_beam7,
beam='%s *mm' %
(distance_fr_center_height_main))
blade7_dia = operations.translate(pillar_beam_dia7,
beam='%s *mm' %
(distance_fr_center_height_main))
pillar_beam8 = operations.translate(
pillar_beam7,
vertical="%s *mm" %
-(suppert_end_distance_fr_source * np.sin(np.deg2rad(angle))))
pillar_beam_dia8 = operations.rotate(pillar_beam8,
transversal=1,
angle='%s *degree' %
(truss_rot_degree))
blade8 = operations.translate(pillar_beam8,
beam='%s *mm' %
(distance_fr_center_height_main))
blade8_dia = operations.translate(pillar_beam_dia8,
beam='%s *mm' %
(distance_fr_center_height_main))
# return (operations.unite(blade1, blade3))
pillar_beam9 = operations.translate(
pillar_beam8,
vertical="%s *mm" %
-(suppert_end_distance_fr_source * np.sin(np.deg2rad(angle))))
pillar_beam_dia9 = operations.rotate(pillar_beam9,
transversal=1,
angle='%s *degree' %
(truss_rot_degree))
blade9 = operations.translate(pillar_beam9,
beam='%s *mm' %
(distance_fr_center_height_main))
blade9_dia = operations.translate(pillar_beam_dia9,
beam='%s *mm' %
(distance_fr_center_height_main))
pillar_beam10 = operations.translate(
pillar_beam9,
vertical="%s *mm" %
-(suppert_end_distance_fr_source * np.sin(np.deg2rad(angle))))
pillar_beam_dia10 = operations.rotate(pillar_beam10,
transversal=1,
angle='%s *degree' %
(truss_rot_degree))
blade10 = operations.translate(pillar_beam10,
beam='%s *mm' %
(distance_fr_center_height_main))
blade10_dia = operations.translate(pillar_beam_dia10,
beam='%s *mm' %
(distance_fr_center_height_main))
pillar_beam_last = operations.translate(
pillar_beam10,
vertical="%s *mm" %
-(suppert_end_distance_fr_source * np.sin(np.deg2rad(angle))))
pillar_beam_dia_last = operations.rotate(blade1,
transversal=1,
angle='%s *degree' % (90))
blade_last = operations.translate(pillar_beam_last,
beam='%s *mm' %
(distance_fr_center_height_main))
blade_last_dia = operations.translate(pillar_beam_dia_last,
beam='%s *mm' %
(distance_fr_center_height_main))
# blade_last_up = operations.rotate(
# operations.rotate(pillar_beam_last, transversal=1, angle='%s *degree' % (-180)), vertical=1,
# angle='%s *degree' % 180)
# return(blade_last)
blades = [
vertical_blade,
blade1_needed,
blade1_dia,
blade2,
blade2_dia,
blade3,
blade3_dia,
blade4,
blade4_dia,
blade5,
blade5_dia,
blade6,
]
# blades = [vertical_blade, blade1_needed, blade1_dia,blade2, blade2_dia, blade3, blade4,
# blade4_dia, blade5,
# blade5_dia, blade6, blade6_dia, blade7, ]
all_blades_down = operations.unite(*blades)
blades_up = operations.rotate(operations.rotate(all_blades_down,
transversal=1,
angle='%s *degree' %
(-180)),
vertical=1,
angle='%s *degree' % 180)
# return (blades_up)
side_cut_box = shapes.block(height='%s *mm' % 10000,
width='%s *mm' % (100),
thickness='%s *mm' %
(self.inner_radius * 2))
blades_up = operations.subtract(blades_up, side_cut_box)
# return (operations.unite(blades_up, self.generate_box_toCut_big_end()))
all_blades = operations.unite(all_blades_down, blades_up)
# more_blades_up=operations.rotate(
# operations.rotate(all_blades, transversal=1, angle='%s *degree' % (-180)), vertical=1,
# angle='%s *degree' % 180)
return (all_blades)
def anvil(self, girdle_length=6.):
crown_top_triangle_height = self.crown_top_triangle_height()
crown_total_triangle_height = self.crown_total_triangle_height(
girdle_length)
pavilion_bottom_triangle_height = self.pavilion_bottom_triangle_height(
)
print('pavilion from center', pavilion_bottom_triangle_height)
pavilion_total_triangle_height = self.pavilion_total_triangle_height(
girdle_length)
upper_orLower_anvil_height_from_center = self.upper_orLower_anvil_height_from_center(
)
crown_top_cone = operations.translate(
shapes.cone(radius='%s *mm' % 500,
height='%s*mm' % (crown_top_triangle_height)),
vertical='%s *mm' % (-crown_top_triangle_height))
crown_total_cone = operations.translate(
shapes.cone(radius='%s*mm' % (girdle_length / 2, ),
height='%s*mm' % crown_total_triangle_height),
vertical='%s *mm' % (-crown_total_triangle_height))
crown = operations.subtract(crown_total_cone, crown_top_cone)
pavilion_bottom_cone = operations.translate(
shapes.cone(radius='%s *mm' % 500.,
height='%s*mm' % (pavilion_bottom_triangle_height)),
vertical='%s *mm' % (-pavilion_bottom_triangle_height))
pavilion_total_cone = operations.translate(
shapes.cone(radius='%s*mm' % (girdle_length / 2),
height='%s*mm' % pavilion_total_triangle_height),
vertical='%s *mm' % (-pavilion_total_triangle_height))
pavilion = operations.rotate(operations.subtract(
pavilion_total_cone, pavilion_bottom_cone),
transversal=1,
angle='%s *degree' % (180))
girdle = shapes.cylinder(radius='%s*mm' % (girdle_length / 2.),
height='%s*mm' % (self.girdle_height))
girdle_inplace = operations.translate(
girdle,
vertical='%s *mm' %
(pavilion_total_triangle_height + self.girdle_height / 2.))
crown_inplace = operations.translate(
crown,
vertical='%s *mm' %
(pavilion_total_triangle_height + self.girdle_height +
crown_total_triangle_height))
upper_diamond_anvil = operations.unite(
operations.unite(crown_inplace, girdle_inplace), pavilion)
lower_diamond_anvil = operations.rotate(operations.rotate(
upper_diamond_anvil, transversal=1, angle='%s *degree' % (-180)),
vertical=1,
angle='%s *degree' % 180)
# return (operations.unite(upper_diamond_anvil, lower_diamond_anvil))
#### the following is for changing the gap between two anvil ##########
upper_diamond_anvil_at_center = operations.translate(
upper_diamond_anvil,
vertical='%s *mm' % (-pavilion_bottom_triangle_height))
upper_diamond_anvil_at_positive_pt_one_from_center = operations.translate(
upper_diamond_anvil_at_center,
vertical='%s *mm' % (self.sample_height / 2.))
lower_diamond_anvil_at_neg_pt_one_from_center = operations.rotate(
operations.rotate(
upper_diamond_anvil_at_positive_pt_one_from_center,
transversal=1,
angle='%s *degree' % (-180)),
vertical=1,
angle='%s *degree' % 180)
return (operations.unite(
upper_diamond_anvil_at_positive_pt_one_from_center,
lower_diamond_anvil_at_neg_pt_one_from_center))
def create (coll_front_end_from_center,max_coll_len=60., Snap_angle=False, vertical_number_channels=20, horizontal_number_channels=20,
detector_angles=[-45,-135],multiple_collimator=False, collimator_Nosupport=True, scad_flag=False,
outputfile=coll_geo_file):
length_of_each_part = max_coll_len
coll_last_height_detector=150.
coll_last_width_detector=60*2.
min_channel_wall_thickness =1
coll_last_front_end_from_center=coll_front_end_from_center+(2.*length_of_each_part)
coll_last_back_end_from_center =coll_last_front_end_from_center+length_of_each_part
coll_first=Collimator_geom()
coll_first_inner_radius = coll_front_end_from_center + (0. * length_of_each_part)
coll_first_outer_radius = coll_first_inner_radius + length_of_each_part
coll_first_height_detector = (coll_last_height_detector / coll_last_back_end_from_center) * coll_first_outer_radius
coll_first_width_detector = (coll_last_width_detector / coll_last_back_end_from_center) * coll_first_outer_radius # half part
coll_first.set_constraints(max_coll_height_detector=coll_first_height_detector,
max_coll_width_detector=coll_first_width_detector,
min_channel_wall_thickness=min_channel_wall_thickness,
max_coll_length=length_of_each_part,
min_channel_size=3,
collimator_front_end_from_center=coll_first_inner_radius,
collimator_parts=False,
no_right_border=False,
no_top_border=False,
horizontal_odd_blades=False,
vertical_odd_blades=False,
)
fist_vertical_number_blades = 3
fist_horizontal_number_blades = 3
coll_first.set_parameters(vertical_number_channels=fist_vertical_number_blades,
horizontal_number_channels=fist_horizontal_number_blades,
channel_length=length_of_each_part)
coll_middle = Collimator_geom()
coll_middle_inner_radius = coll_front_end_from_center + (1. * length_of_each_part)
coll_middle_outer_radius = length_of_each_part + coll_middle_inner_radius
coll_middle_height_detector = (coll_last_height_detector / coll_last_back_end_from_center) * coll_middle_outer_radius
coll_middle_width_detector = (coll_last_width_detector / coll_last_back_end_from_center) * coll_middle_outer_radius
coll_middle.set_constraints(max_coll_height_detector=coll_middle_height_detector,
max_coll_width_detector=coll_middle_width_detector,
min_channel_wall_thickness=min_channel_wall_thickness,
max_coll_length=length_of_each_part,
min_channel_size=3,
collimator_front_end_from_center=coll_middle_inner_radius,
collimator_parts=True,
initial_collimator_horizontal_channel_angle=0.0,
initial_collimator_vertical_channel_angle=0.0,
remove_vertical_blades_manually=True,
vertical_blade_index_list_toRemove=[2, 5],
remove_horizontal_blades_manually=True,
horizontal_blade_index_list_toRemove=[2, 5],
no_right_border=False,
no_top_border=False,
vertical_even_blades=False,
horizontal_even_blades=False)
coll_middle.set_parameters(vertical_number_channels=(fist_vertical_number_blades) * 3,
horizontal_number_channels=(fist_horizontal_number_blades) * 3,
channel_length=length_of_each_part)
col_last = Collimator_geom()
col_last.set_constraints(max_coll_height_detector=coll_last_height_detector,
max_coll_width_detector=coll_last_width_detector,
min_channel_wall_thickness=min_channel_wall_thickness,
max_coll_length=length_of_each_part,
min_channel_size=3.,
collimator_front_end_from_center=coll_last_front_end_from_center,
remove_horizontal_blades_manually=True,
horizontal_blade_index_list_toRemove=[2, 5, 11, 14, 20, 23],
remove_vertical_blades_manually=True,
vertical_blade_index_list_toRemove=[2, 5, 11, 14, 20, 23],
collimator_parts=True,
no_right_border=False,
no_top_border=False,
vertical_odd_blades=False,
horizontal_odd_blades=False)
col_last.set_parameters(vertical_number_channels=fist_vertical_number_blades * 9,
horizontal_number_channels=fist_horizontal_number_blades * 9,
channel_length=length_of_each_part)
coliFirst = coll_first.gen_collimators(detector_angles=detector_angles, multiple_collimator=False,
collimator_Nosupport=True)
coliMiddle = coll_middle.gen_collimators(detector_angles=detector_angles, multiple_collimator=False,
collimator_Nosupport=True)
colilast =col_last.gen_collimators(detector_angles=detector_angles, multiple_collimator=False,collimator_Nosupport=True)
whole = operations.unite(operations.unite(coliFirst, coliMiddle),colilast)
with open (outputfile,'wt') as file_h:
weave(whole,file_h, print_docs = False,renderer=File_inc_Renderer(), author='')
def support_design(self):
angle = 4
truss_rot_degree = 5
main_cylinder_radius = self.inner_radius # inner radius of the collimator
main_cylinder_diameter = main_cylinder_radius * 2.
#
# support_height = main_cylinder_diameter - self.beam_dist_support
#
#
#
# distance_fr_center_support = np.sqrt((main_cylinder_radius) ** 2 - (height_support / 2) ** 2)
base_width_support = self.truss_base_thickness
suppert_end_distance_fr_source = self.inner_radius + base_width_support
collimator_thickness_at_support_end = self.angle2span(
suppert_end_distance_fr_source, self.vertical_acceptance_angle)
length = 1000. ## as big as possible
width = collimator_thickness_at_support_end
pillar = shapes.block(height='%s *mm' % (length),
width='%s *mm' %
(collimator_thickness_at_support_end),
thickness='%s *mm' % 1)
pillar_beam = operations.rotate(pillar,
transversal=1,
angle="%s *degree" % 90)
pillar_beamT = operations.rotate(pillar,
transversal=1,
angle="%s *degree" % 90)
small_pillar_beam_tocut = operations.rotate(shapes.block(
height='%s *mm' % (length),
width='%s *mm' % (width + 5),
thickness='%s *mm' % 5),
transversal=1,
angle="%s *degree" % 90)
pillar_beam = operations.subtract(
pillar_beam,
operations.translate(small_pillar_beam_tocut,
beam='%s*mm' % -(length / 2)))
pillar_beam_dia = operations.rotate(pillar_beam,
transversal=1,
angle='%s *degree' %
truss_rot_degree)
number_blades = 10
vertical_distance = 0
pillar_beams = []
pillar_beams_dia = []
for i in xrange(number_blades):
pillar_beam = operations.translate(pillar_beam,
vertical="%s *mm" %
-(vertical_distance))
vertical_distance = length / 2. * np.sin(np.deg2rad(angle))
# truss_rot_degree = angle*(i/0.2)
truss_rot_degree = 3
pillar_beam_dia = operations.rotate(pillar_beam,
transversal=1,
angle='%s *degree' %
truss_rot_degree)
pillar_beams.append(pillar_beam)
pillar_beams_dia.append(pillar_beam_dia)
united_blades = operations.unite(*pillar_beams)
united_blades_dia = operations.unite(*pillar_beams_dia)
verticle_pillar = operations.translate(pillar,
beam="%s *mm" %
(self.inner_radius))
blades = operations.unite(
operations.unite(united_blades, united_blades_dia),
verticle_pillar)
side_cut_box = shapes.block(height='%s *mm' % 10000,
width='%s *mm' % (100),
thickness='%s *mm' %
(self.inner_radius * 2))
blades_cleanUp = operations.subtract(blades, side_cut_box)
return (blades_cleanUp)
thisdir = os.path.abspath(os.path.dirname(__file__))
libpath = os.path.join(thisdir, '../simlib')
if not libpath in sys.path:
sys.path.insert(0, libpath)
# from collimator_fun_ori_constant_thickness_2_support_mod_3 import Collimator_geom
from collimator_fun_ori_constant_thickness_2_moveBlades import Collimator_geom
from clampcell_geo import Clampcell
clampcell = Clampcell(total_height=False)
outer_body = clampcell.outer_body()
inner_sleeve = clampcell.inner_sleeve()
sample = clampcell.sample()
sample_assemblyCad = operations.unite(operations.unite(outer_body, sample),
inner_sleeve)
detector_angles = [-45, -135]
###########################################################
#############################################################333
##########################################################3
min_dis = 30.
coll = Collimator_geom()
coll.set_constraints()
coll.set_parameters(number_channels=4., channel_length=min_dis)
changle_horizontal = coll.horizontal_channel_angle
chan_open_horizontal = coll.angle2span(min_dis, changle_horizontal)
