def __init__(self, x, y, z, h=0): '''New n-vector normal to the earth's surface. @param x: X component (scalar). @param y: Y component (scalar). @param z: Z component (scalar). @keyword h: Height above surface (meter). @example: >>> from sphericalNvector import Nvector >>> v = Nvector(0.5, 0.5, 0.7071, 1) >>> v.toLatLon() # 45.0°N, 045.0°E, +1.00m ''' Vector3d.__init__(self, x, y, z) if h: self._h = float(h)
def to3llh(self): '''Convert this n-vector to (geodetic) lat-, longitude and height. @return: 3-Tuple (lat, lon, height) in (C{degrees90}, C{degrees180}, C{meter}). ''' return Vector3d.to2ll(self) + (self.h, )
def toVector3d(self): '''Convert this n-vector to a normalized 3-d vector, ignoring the height. @return: Normalized vector (L{Vector3d}). ''' u = self.unit() return Vector3d(u.x, u.y, u.z, name=self.name)
def __init__(self, side_str, device_addr=None, transposition=(0, 1, 2), scaling=(1, 1, 1)): self._accel = Vector3d(transposition, scaling, self._accel_callback) self._gyro = Vector3d(transposition, scaling, self._gyro_callback) self.buf1 = bytearray( 1) # Pre-allocated buffers for reads: allows reads to self.buf2 = bytearray(2) # be done in interrupt handlers self.buf3 = bytearray(3) self.buf6 = bytearray(6) sleep_ms(200) # Ensure PSU and device have settled if isinstance(side_str, str): # Non-pyb targets may use other than X or Y self._mpu_i2c = I2C(side_str) elif hasattr(side_str, 'readfrom'): # Soft or hard I2C instance. See issue #3097 self._mpu_i2c = side_str else: raise ValueError("Invalid I2C instance") if device_addr is None: devices = set(self._mpu_i2c.scan()) mpus = devices.intersection(set(self._mpu_addr)) number_of_mpus = len(mpus) if number_of_mpus == 0: raise MPUException("No MPU's detected") elif number_of_mpus == 1: self.mpu_addr = mpus.pop() else: raise ValueError( "Two MPU's detected: must specify a device address") else: if device_addr not in (0, 1): raise ValueError('Device address must be 0 or 1') self.mpu_addr = self._mpu_addr[device_addr] self.chip_id # Test communication by reading chip_id: throws exception on error # Can communicate with chip. Set it up. self.wake() # wake it up self.passthrough = True # Enable mag access from main I2C bus self.accel_range = 0 # default to highest sensitivity self.gyro_range = 0 # Likewise for gyro
def criterion(tmp, particles): tmp_particle = Particle(r=Vector3d(*tmp)) for particle in particles: # print((tmp_particle.r - particle.r).dot(forces.base_force(tmp_particle, particle))) # if (tmp_particle.r - particle.r).dot(forces.base_force(tmp_particle, particle)) > -0.3: if abs(tmp_particle.r - particle.r) < 0.5 * constants.a_0: return False return True
def to3abh(self): '''Convert this n-vector to (geodetic) lat-, longitude and height. @return: 3-Tuple (lat, lon, height) in (C{radians}, C{radians}, C{meter}). ''' return Vector3d.to2ab(self) + (self.h, )
def __init__(self, device_addr, busnum, transposition, scaling, mag_addr=None): '''Create an InvenSenseMPU interface. Arguments: device_addr (0 or 1): There are two possible I2C slave address for the MPU9x50. This value decides which of the two to use. busnum (integer): Which of the BeagleBone's I2C buses to use. transposition scaling mag_addr: I2C address of the magnetometer (different from the I2C ad dress of the main sensor). ''' self._accel = Vector3d(transposition, scaling, self._accel_callback) self._gyro = Vector3d(transposition, scaling, self._gyro_callback) self.buf1 = bytearray( [0] * 1) # Pre-allocated buffers for reads: allows reads to self.buf2 = bytearray([0] * 2) # be done in interrupt handlers self.buf3 = bytearray([0] * 3) self.buf6 = bytearray([0] * 6) self.timeout = 10 # I2C tieout mS if device_addr is None: raise ValueError("Adafruit_I2C does not support scanning") else: if device_addr not in (0, 1): raise ValueError('Device address must be 0 or 1') self.mpu_addr = self._mpu_addr[device_addr] self._mpu_i2c = Adafruit_I2C(self.mpu_addr, busnum=busnum) if mag_addr is not None: self._mag_i2c = Adafruit_I2C(mag_addr, busnum=busnum) self.chip_id # Test communication by reading chip_id: throws exception on error # Can communicate with chip. Set it up. self.wake() # wake it up self.passthrough = True # Enable mag access from main I2C bus self.accel_range = 0 # default to highest sensitivity self.gyro_range = 0 # Likewise for gyro
def __init__(self, device_addr=None, transposition=(0, 1, 2), scaling=(1, 1, 1), pins=None): self._accel = Vector3d(transposition, scaling, self._accel_callback) self._gyro = Vector3d(transposition, scaling, self._gyro_callback) self.buf1 = bytearray( 1) # Pre-allocated buffers for reads: allows reads to self.buf2 = bytearray(2) # be done in interrupt handlers self.buf3 = bytearray(3) self.buf6 = bytearray(6) sleep_ms(200) # Ensure PSU and device have settled if pins is not None: self._mpu_i2c = I2C(-1, mode=I2C.MASTER, pins=pins, baudrate=100000) else: self._mpu_i2c = I2C(0) if device_addr is None: devices = set(self._mpu_i2c.scan()) mpus = devices.intersection(set(self._mpu_addr)) number_of_mpus = len(mpus) if number_of_mpus == 0: raise MPUException("No MPU's detected") elif number_of_mpus == 1: self.mpu_addr = mpus.pop() else: raise ValueError( "Two MPU's detected: must specify a device address") else: if device_addr not in (0, 1): raise ValueError('Device address must be 0 or 1') self.mpu_addr = self._mpu_addr[device_addr] self.chip_id # Test communication by reading chip_id: throws exception on error # Can communicate with chip. Set it up. self.wake() # wake it up self.passthrough = True # Enable mag access from main I2C bus self.accel_range = 0 # default to highest sensitivity self.gyro_range = 0 # Likewise for gyro
def __init__(self, side_str, device_addr, transposition, scaling): self._accel = Vector3d(transposition, scaling, self._accel_callback) self._gyro = Vector3d(transposition, scaling, self._gyro_callback) self.buf1 = bytearray( [0] * 1) # Pre-allocated buffers for reads: allows reads to self.buf2 = bytearray([0] * 2) # be done in interrupt handlers self.buf3 = bytearray([0] * 3) self.buf6 = bytearray([0] * 6) self.timeout = 10 # I2C tieout mS tim = pyb.millis() # Ensure PSU and device have settled if tim < 200: pyb.delay(200 - tim) if type(side_str) is str: sst = side_str.upper() if sst in {'X', 'Y'}: self._mpu_i2c = pyb.I2C(sst, pyb.I2C.MASTER) else: raise ValueError('I2C side must be X or Y') elif type(side_str) is pyb.I2C: self._mpu_i2c = side_str if device_addr is None: devices = set(self._mpu_i2c.scan()) mpus = devices.intersection(set(self._mpu_addr)) number_of_mpus = len(mpus) if number_of_mpus == 0: raise MPUException("No MPU's detected") elif number_of_mpus == 1: self.mpu_addr = mpus.pop() else: raise ValueError( "Two MPU's detected: must specify a device address") else: if device_addr not in (0, 1): raise ValueError('Device address must be 0 or 1') self.mpu_addr = self._mpu_addr[device_addr] self.chip_id # Test communication by reading chip_id: throws exception on error # Can communicate with chip. Set it up. self.wake() # wake it up self.passthrough = True # Enable mag access from main I2C bus self.accel_range = 0 # default to highest sensitivity self.gyro_range = 0 # Likewise for gyro
def cent_of_mass(self): """ Returns a vector of the geometrical center of atoms. :return: Vector3d """ com = Vector3d() for atom in self.atoms: com += atom.coord return com / len(self)
def unit(self): '''Normalize this vector to unit length. @return: Normalized vector (L{Nvector}). ''' if self._united is None: u = Vector3d.unit(self) # .copy() self._united = u._united = _xattrs(u, self, '_h') return self._united
def __init__(self, side_str, device_addr=None, transposition=(0, 1, 2), scaling=(1, 1, 1)): super(MPU9250, self).__init__(side_str, device_addr, transposition, scaling) self._mag = Vector3d(transposition, scaling, self._mag_callback) self.accel_filter_range = 0 # fast filtered response self.gyro_filter_range = 0 self._mag_stale_count = 0 # MPU9250 count of consecutive reads where old data was returned self.mag_correction = self._magsetup() # 16 bit, 100Hz update.Return correction factors. self._mag_callback() # Seems neccessary to kick the mag off else 1st reading is zero (?)
def toVector3d(self): '''Convert this point to a vector normal to earth's surface. @return: Vector representing this point (L{Vector3d}). ''' if self._v3d is None: x, y, z = self.to3xyz() self._v3d = Vector3d(x, y, z) # XXX .unit() return self._v3d
def copy(self): '''Copy this vector. @return: Copy (L{Nvector}). ''' n = Vector3d.copy(self) if n.h != self.h: n.h = self.h return n
def __init__(self, x, y, z, h=0, ll=None): '''New n-vector normal to the earth's surface. @param x: X component (scalar). @param y: Y component (scalar). @param z: Z component (scalar). @keyword h: Optional height above surface (meter). @keyword ll: Optional, original latlon (I{LatLon}). @example: >>> from sphericalNvector import Nvector >>> v = Nvector(0.5, 0.5, 0.7071, 1) >>> v.toLatLon() # 45.0°N, 045.0°E, +1.00m ''' Vector3d.__init__(self, x, y, z, ll=ll) if h: self._h = scalar(h, None, name='h')
def get_and_plot_density(particles, radii, rotation, center, num=100): cm = Vector3d() particles_ = copy.deepcopy(particles) derotation = np.linalg.inv(rotation) for particle in particles_: particle.r.x -= center[0] particle.r.y -= center[1] particle.r.z -= center[2] tmp = np.dot(np.array([particle.r.x, particle.r.y, particle.r.z]), derotation) particle.r = Vector3d(tmp[0], tmp[1], tmp[2]) cm += particle.r cm = cm * (1 / len(particles_)) for i in range(len(particles)): particles_[i].r.x *= 1 / radii[0] particles_[i].r.y *= 1 / radii[1] particles_[i].r.z *= 1 / radii[2] lengths = sorted([abs(particle.r) for particle in particles_]) density = [] l = [] # particles = sorted(particles, key=lambda particle: abs(particle.r - cm)) for i in range(len(lengths) // num): density.append(num * particles_[0].mass / (4 / 3 * np.pi * (lengths[i * num + num - 1]**3 - lengths[i * num]**3))) # l.append(lengths[i*num] + 0.5*(lengths[i*num + num-1] - lengths[i*num])) l.append(lengths[i * num]) ig, ax1 = plt.subplots(figsize=(4, 4)) ax1.scatter(x=l, y=density, marker='o', c='r', edgecolor='b') ax1.set_title('Scatter: $x$ versus $y$') ax1.set_xlabel('$x$') ax1.set_ylabel('$y$') plt.show() return density, lengths
def _to3LLh(self, LL, height, **kwds): '''(INTERNAL) Helper for C{subclass.toLatLon} and C{.to3llh}. ''' h = self.h if height is None else height r = Vector3d.to2ll(self) # LatLon2Tuple if LL is None: r = r._3Tuple(h) # already ._xnamed else: r = self._xnamed(LL(r.lat, r.lon, height=h, **kwds)) return r
def toStr(self, prec=3, fmt='[%s]', sep=', '): # PYCHOK expected '''Return the string representation of this cartesian. @keyword prec: Optional number of decimals, unstripped (int). @keyword fmt: Optional enclosing backets format (string). @keyword sep: Optional separator to join (string). @return: Cartesian represented as "[x, y, z]" (string). ''' return Vector3d.toStr(self, prec=prec, fmt=fmt, sep=sep)
def create_sphere(radii, num_sumples=2000): cur_num_particles = 0 attempts = 100 particles = [] while True: u = np.random.uniform(0, 2*np.pi) # v = np.random.uniform(0, np.pi) # cosu = np.random.uniform(-1, 1) cosv = np.random.uniform(-1, 1) tmp_z = np.random.uniform(0, 1) v = np.arccos(cosv) mul = tmp_z**(1/3) r1 = radii[0]*mul r2 = radii[1]*mul r3 = radii[2]*mul # mul = tmp_z**(1/2) # r1 = radii[0]*mul # r2 = radii[1]*mul # r3 = radii[2]*mul # lam = 0.1 # k = 0.00001 # r1 = radii[0]*(1-np.exp(tmp_z/lam)**k) # r2 = radii[1]*(1-np.exp(tmp_z/lam)**k) # r3 = radii[2]*(1-np.exp(tmp_z/lam)**k) # k = 1 # mul = -1/np.log(k - k*0.99999) * np.log(k - k*tmp_z) # r1 = radii[0]*mul # r2 = radii[1]*mul # r3 = radii[2]*mul # k = 1 # mul = (-1/(1+np.exp(-10*(tmp_z-0.5)))+1)**(1/3) # r1 = radii[0]*mul # r2 = radii[1]*mul # r3 = radii[2]*mul tmp = [r1 * np.cos(u) * np.sin(v), r2 * np.sin(u) * np.sin(v), r3 * np.cos(v)] if criterion(tmp, particles): # [x, y, z] = np.dot([tmp[0][0][0], tmp[1][0][0], tmp[2][0][0]], rotation) + center [x, y, z] = [tmp[0], tmp[1], tmp[2]] particles.append(Particle(r=Vector3d(x, y, z), color=(0, 0, 0), name=len(particles))) cur_num_particles += 1 if cur_num_particles % 1 == 0: print(cur_num_particles) if cur_num_particles == num_sumples: break return particles
def unit(self): '''Normalize this vector to unit length. @return: Normalised, unit vector (L{Nvector}). ''' if self._united is None: u = Vector3d.unit(self).copy() if u.h != self.h: u.h = self.h self._united = u._united = u return self._united
def to3abh(self, height=None): '''Convert this n-vector to (geodetic) lat-, longitude and height. @keyword height: Optional height, overriding this n-vector's height (C{meter}). @return: A L{PhiLam3Tuple}C{(phi, lambda, height)}. ''' h = self.h if height is None else height return Vector3d.to2ab(self)._3Tuple(h)
def unit(self, ll=None): '''Normalize this vector to unit length. @keyword ll: Optional, original latlon (C{LatLon}). @return: Normalized vector (L{Nvector}). ''' if self._united is None: u = Vector3d.unit(self, ll=ll) # .copy() self._united = u._united = _xattrs(u, self, '_h') return self._united
def __init__(self, line=None, model=0, **kwargs): """ Constructor. Creates an Atom object from string - ATOM/HETATM line from the pdb file. If line is empty creates an empty atom equivalent to: Atom('HETATM 0 XXXX XXX X 0 0.000 0.000 0.000 0.00 0.00') Passing attribute=value to the constructor overwrites default/read values. :param line: str :param model: int """ if line: self.model = model self.hetatm = (line[:6] == "HETATM") self.serial = int(line[6:11]) self.name = line[11:16].strip() self.alt = line[16] self.resname = line[17:21].strip() self.chid = line[21] self.resnum = int(line[22:26]) self.icode = line[26] self.coord = Vector3d(line[30:38], line[38:46], line[46:54]) self.occ = float(line[54:60]) self.bfac = float(line[60:66]) self.tail = line[66:].replace('\n', '') else: self.model = model self.hetatm = True self.serial = 0 self.name = "XXXX" self.alt = "" self.resname = "XXX" self.chid = "X" self.resnum = 0 self.icode = "" self.coord = Vector3d() self.occ = 0.0 self.bfac = 0.0 self.tail = "" for arg in kwargs: if arg in self.__dict__: self.__dict__[arg] = kwargs[arg]
def __init__(self, side_str, device_addr=None, transposition=(0, 1, 2), scaling=(1, 1, 1)): super().__init__(side_str, device_addr, transposition, scaling) self._mag = Vector3d(transposition, scaling, self._mag_callback) self.filter_range = 0 # fast filtered response self._mag_stale_count = 0 # Count of consecutive reads where old data was returned self.mag_triggered = False # Ensure mag is triggered once only until it's read self.mag_correction = self._magsetup() # Returns correction factors. self.mag_wait_func = default_mag_wait
def read(read_path, mode=None): particles = [] with open(read_path, 'r') as inputfile: s_tmp = inputfile.read() for el in s_tmp.split('\n')[2:]: if el != '': if mode is None: rx, ry, rz, r, g, b = el.split() else: с, rx, ry, rz, c = el.split() particles.append( Particle(r=Vector3d(float(rx), float(ry), float(rz)), name=len(particles))) return particles
def __init__(self, position, target, up_dir, projection): """Initialize a camera with its position, target point, and up_dir @position: Point3d @target: Point3d [this is the point towards it is facing @up_dir: Vector3d """ self.position = position self.target = target self.up_dir = up_dir self.facing_dir = Vector3d.new(self.position, self.target) # check if facing_dir and up_dir are perpendicular if self.facing_dir.dot(self.up_dir) != 0.0: raise Exception("facing dir and up dir are not perpendicular") self.__matrix = None self.projection = projection
def insert_ligand(self, receptor, ligand): radius = 0.5 * receptor.dimension + self.separation if ligand.location == 'keep': location = ligand.cent_of_mass() elif ligand.location == 'random': location = Vector3d().random() * radius + receptor.center else: location = receptor.convert_patch( ligand.location) * radius + receptor.center if ligand.conformation == 'random': ligand.random_conformation() ligand.move_to(location)
def cast(self, ch): """ Function that casts a single protein chain onto the lattice. Returns a list of tuples with (x, y, z) coordinates of CA atoms. """ if len(ch.atoms) < 3: raise Exception('Protein chain too short!') prev = None coord = [ Vector3d(round(ch.atoms[0].coord.x / self.grid), round(ch.atoms[0].coord.y / self.grid), round(ch.atoms[0].coord.z / self.grid)) ] for atom in ch.atoms[1:]: # iterate over atoms min_dr = 1e12 min_i = -1 for i, v in enumerate(self.vectors): # iterate over all possible vectors if len(coord) > 2 and self.good[prev, i] == 0: continue new = coord[-1] + v dr = (self.grid * new - atom.coord).mod2() if dr < min_dr: min_dr = dr min_i = i if min_i < 0: raise Exception('Unsolvable geometric problem!') else: coord.append(coord[-1] + self.vectors[min_i]) prev = min_i coord.insert(0, coord[0] + coord[1] - coord[2]) coord.append(coord[-1] + coord[-2] - coord[-3]) return coord
def calculate_asa(atoms, probe, n_sphere_point=960): """ Returns list of accessible surface areas of the atoms, using the probe and atom radius to define the surface. """ sphere_points = generate_sphere_points(n_sphere_point) const = 4.0 * math.pi / len(sphere_points) test_point = Vector3d() areas = [] for i, atom_i in enumerate(atoms): neighbor_indices = find_neighbor_indices(atoms, probe, i) n_neighbor = len(neighbor_indices) j_closest_neighbor = 0 radius = probe + atom_i.radius n_accessible_point = 0 for point in sphere_points: is_accessible = True test_point.x = point[0] * radius + atom_i.pos.x test_point.y = point[1] * radius + atom_i.pos.y test_point.z = point[2] * radius + atom_i.pos.z cycled_indices = range(j_closest_neighbor, n_neighbor) cycled_indices.extend(range(j_closest_neighbor)) for j in cycled_indices: atom_j = atoms[neighbor_indices[j]] r = atom_j.radius + probe diff_sq = pos_distance_sq(atom_j.pos, test_point) if diff_sq < r * r: j_closest_neighbor = j is_accessible = False break if is_accessible: n_accessible_point += 1 area = const * n_accessible_point * radius * radius areas.append(area) return areas
def toStr(self, prec=5, fmt='(%s)', sep=', '): # PYCHOK expected '''Return a string representation of this n-vector. Height component is only included if non-zero. @keyword prec: Optional number of decimals, unstripped (C{int}). @keyword fmt: Optional enclosing backets format (C{str}). @keyword sep: Optional separator between components (C{str}). @return: Comma-separated "x, y, z [, h]" (C{str}). @example: >>> Nvector(0.5, 0.5, 0.7071).toStr() # (0.5, 0.5, 0.7071) >>> Nvector(0.5, 0.5, 0.7071, 1).toStr(-3) # (0.500, 0.500, 0.707, +1.00) ''' t = Vector3d.toStr(self, prec=prec, fmt='%s', sep=sep) if self.h: t = '%s%s%s%+.2f' % (t, sep, self.H, self.h) return fmt % (t, )
def __init__(self, *args, **kwargs): Vector3d.__init__(self, *args, **kwargs) PointBase.__init__(self)