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)